diff --git a/Modules/CppRestSdk/include/mitkIRESTManager.h b/Modules/CppRestSdk/include/mitkIRESTManager.h
index 58069abef7..7e218c8353 100644
--- a/Modules/CppRestSdk/include/mitkIRESTManager.h
+++ b/Modules/CppRestSdk/include/mitkIRESTManager.h
@@ -1,95 +1,95 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef mitkIRESTManager_h
 #define mitkIRESTManager_h
 
 #include "cpprest/json.h"
 #include "cpprest/uri.h"
 
 #include <MitkCoreExports.h>
 #include <mitkServiceInterface.h>
 
 #include <MitkCppRestSdkExports.h>
 #include <mitkRESTClient.h>
 #include <mitkIRESTObserver.h>
 
 
 namespace mitk
 {
   class RESTServer;
   class MITKCPPRESTSDK_EXPORT IRESTManager
   {
   public:
     virtual ~IRESTManager();
 
     /**
      * @brief request type for client requests by calling SendRequest
      */
     enum class RequestType
     {
       Get,
       Post,
       Put
     };
 
     /**
      * @brief Executes a HTTP request in the mitkRESTClient class
      *
      * @param uri defines the URI the request is send to
      * @param type the RequestType of the HTTP request (optional)
      * @param body the body for the request (optional)
      * @return task to wait for
      */
     virtual pplx::task<web::json::value> SendRequest(const web::uri &uri,
                                              const RequestType &type = RequestType::Get,
                                              const web::json::value *body = nullptr,
                                              const utility::string_t &filePath = L"") = 0;
 
     /**
      * @brief starts listening for requests if there isn't another observer listening and the port is free
      *
      * @param uri defines the URI for which incoming requests should be send to the observer
      * @param observer the observer which handles the incoming requests
      */
     virtual void ReceiveRequest(const web::uri &uri, IRESTObserver *observer) = 0;
 
     /**
      * @brief Handles incoming requests by notifying the observer which should receive it
      *
      * @param uri defines the URI of the request
      * @param body the body of the request
      * @return the data which is modified by the notified observer
      */
-    virtual web::json::value Handle(const web::uri &uri, web::json::value &body) = 0;
+    virtual web::json::value Handle(const web::uri &uri, const web::json::value &body) = 0;
 
     /**
      * @brief Handles the deletion of an observer for all or a specific uri
      *
      * @param observer the observer which shouldn't receive requests anymore
      * @param uri the uri for which the observer doesn't handle requests anymore (optional)
      */
     virtual void HandleDeleteObserver(IRESTObserver *observer, const web::uri &uri = L"") = 0;
 
     virtual const std::map<int, RESTServer *>& GetServerMap() = 0;
     virtual const std::map<std::pair<int, utility::string_t>, IRESTObserver *>& GetObservers() = 0;
 
   };
 } // namespace mitk
 
 MITK_DECLARE_SERVICE_INTERFACE(mitk::IRESTManager, "org.mitk.IRESTManager")
 
 #endif
diff --git a/Modules/CppRestSdk/include/mitkIRESTObserver.h b/Modules/CppRestSdk/include/mitkIRESTObserver.h
index 098bc279b4..7576090e4a 100644
--- a/Modules/CppRestSdk/include/mitkIRESTObserver.h
+++ b/Modules/CppRestSdk/include/mitkIRESTObserver.h
@@ -1,49 +1,49 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef mitkIRESTObserver_h
 #define mitkIRESTObserver_h
 
 #include "cpprest/json.h"
 #include "cpprest/uri.h"
 #include <MitkCppRestSdkExports.h>
 
 namespace mitk
 {
   class MITKCPPRESTSDK_EXPORT IRESTObserver
   {
   public:
     /**
      * @brief Deletes an observer and calls HandleDeleteObserver() in RESTManager class
      *
      * @see HandleDeleteObserver()
      */
     virtual ~IRESTObserver();
 
     /**
      * @brief Called if there's an incoming request for the observer, observer implements how to handle request
      *
      * @param data the data of the incoming request
      * @return the modified data
      */
-    virtual web::json::value Notify(web::json::value &data, const web::uri &uri) = 0;
+    virtual web::json::value Notify(const web::json::value &data, const web::uri &uri) = 0;
 
 
   private:
   };
 }
 
 #endif // !mitkIRESTObserver
diff --git a/Modules/CppRestSdk/include/mitkRESTManager.h b/Modules/CppRestSdk/include/mitkRESTManager.h
index 1edee36754..dca7f6c13f 100644
--- a/Modules/CppRestSdk/include/mitkRESTManager.h
+++ b/Modules/CppRestSdk/include/mitkRESTManager.h
@@ -1,121 +1,120 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef mitkRESTManager_h
 #define mitkRESTManager_h
 
 #ifdef _MSC_VER
 #pragma warning(push)
 #pragma warning(disable : 4251)
 #endif
 
 #include <mitkIRESTManager.h>
 #include <mitkRESTServer.h>
 
 
 
 namespace mitk
 {
   class MITKCPPRESTSDK_EXPORT RESTManager : public IRESTManager
   {
 
   public:
     RESTManager();
     ~RESTManager() override;
 
     /**
      * @brief Executes a HTTP request in the mitkRESTClient class
      *
      * @param uri defines the URI the request is send to
      * @param type the RequestType of the HTTP request (optional)
      * @param body the body for the request (optional)
      * @param filePath the file path to store the request to
      * @return task to wait for
      */
     pplx::task<web::json::value> SendRequest(const web::uri &uri,
                                              const RequestType &type = RequestType::Get,
                                              const web::json::value *body= nullptr,
                                              const utility::string_t &filePath = L"") override;
     
     /**
      * @brief starts listening for requests if there isn't another observer listening and the port is free
      *
      * @param uri defines the URI for which incoming requests should be send to the observer
      * @param observer the observer which handles the incoming requests
      */
     void ReceiveRequest(const web::uri &uri, IRESTObserver *observer) override;
 
     /**
      * @brief Handles incoming requests by notifying the observer which should receive it
      *
      * @param uri defines the URI of the request
      * @param body the body of the request
      * @return the data which is modified by the notified observer
      */
-    //TODO body const
-    web::json::value Handle(const web::uri &uri, web::json::value &body) override;
+    web::json::value Handle(const web::uri &uri, const web::json::value &body) override;
 
     /**
      * @brief Handles the deletion of an observer for all or a specific uri
      *
      * @param observer the observer which shouldn't receive requests anymore
      * @param uri the uri for which the observer doesn't handle requests anymore (optional)
      */
     virtual void HandleDeleteObserver(IRESTObserver *observer, const web::uri &uri) override;
 
     /**
     * @brief internal use only
     */
     //TODO alternative: aus interface rausnehmen und dynamic casten
     virtual const std::map<int, RESTServer *>& GetServerMap() override;
     virtual const std::map<std::pair<int, utility::string_t>, IRESTObserver *>& GetObservers() override;
 
     protected:
     /**
      * @brief adds an observer if a port is free, called by ReceiveRequest method
      *
      * @param uri the uri which builds the key for the observer map
      * @param observer the observer which is added
      */
     void AddObserver(const web::uri &uri, IRESTObserver *observer);
 
     /**
      * @brief handles server management if there is already a server under a port, called by ReceiveRequest method
      *
      * @param uri the uri which which is requested to be added
      * @param observer the observer which proceeds the request
      */
     void ServerUnderPort(const web::uri &uri, IRESTObserver *observer);
 
     /**
      * @brief deletes an observer, called by HandleDeleteObserver method
      *
      * @param it the iterator comparing the observers in HandleDeleteObserver method
      * @param the uri for which the observer doesn't want to receive requests anymore
      * @return bool if there is another observer under the port
      */
     bool DeleteObserver(std::map < std::pair<int, utility::string_t>, IRESTObserver *>::iterator &it, const web::uri &uri);
 //TODO Member immer private, zugriff über getter/setter
     std::map<int, RESTServer *> m_ServerMap;                     // Map with port server pairs
     std::map<std::pair<int, utility::string_t>, IRESTObserver *> m_Observers; // Map with all observers
   };
 } // namespace mitk
 
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif
 
 #endif // !mitkRESTManager_h
diff --git a/Modules/CppRestSdk/src/mitkRESTManager.cpp b/Modules/CppRestSdk/src/mitkRESTManager.cpp
index d3f014611b..34683eafa3 100644
--- a/Modules/CppRestSdk/src/mitkRESTManager.cpp
+++ b/Modules/CppRestSdk/src/mitkRESTManager.cpp
@@ -1,212 +1,212 @@
 #include "mitkRESTManager.h"
 #include <mitkCommon.h>
 #include <mitkRESTUtil.h>
 
 mitk::RESTManager::RESTManager() {}
 
 mitk::RESTManager::~RESTManager() {}
 
 pplx::task<web::json::value> mitk::RESTManager::SendRequest(const web::uri &uri,
                                                             const RequestType &type,
                                                             const web::json::value *content,
                                                             const utility::string_t &filePath)
 {
   pplx::task<web::json::value> answer;
   auto client = new RESTClient();
   // according to the RequestType, different HTTP requests are made
   switch (type)
   {
     case RequestType::Get:
     
       if (filePath.empty())
       {
         // no file path specified, starts a normal get request returning the normal json result
         answer = client->Get(uri);
       }
       else
       {
         // file path ist specified, the result of the get request ist stored in this file
         // and an empty json object is returned
         answer = client->Get(uri, filePath);
       }
       break;
     
     case RequestType::Post:
     
       //TODO fixen wert vorne bei vergleich
       if (content == nullptr)
       {
         // warning because normally you won't create an empty ressource
         MITK_WARN << "Content for put is empty, this will create an empty ressource";
       }
       answer = client->Post(uri, content);
       break;
     
     case RequestType::Put:
     
       if (content == nullptr)
       {
         // warning because normally you won't empty a ressource
         MITK_WARN << "Content for put is empty, this will empty the ressource";
       }
       answer = client->Put(uri, content);
       break;
     //TODO: default hinzufügen
   }
 
   return answer;
 }
 
 void mitk::RESTManager::ReceiveRequest(const web::uri &uri, mitk::IRESTObserver *observer)
 {
   // New instance of RESTServer in m_ServerMap, key is port of the request
   int port = uri.port();
 
   // Checking if port is free to add a new Server
   if (m_ServerMap.count(port) == 0)
   {
     this->AddObserver(uri, observer);
     // creating server instance
     auto server = new RESTServer(uri.authority());
     // add reference to server instance to map
     m_ServerMap[port] = server;
     // start Server
     server->OpenListener();
 
     MITK_INFO << "new server " << mitk::RESTUtil::convertToUtf8(uri.authority().to_string()) << " at port " << port;
   }
   // If there is already a server under this port
   else
   {
     //TODO umbenennen
     this->ServerUnderPort(uri, observer);
   }
 }
 
-web::json::value mitk::RESTManager::Handle(const web::uri &uri, web::json::value &body)
+web::json::value mitk::RESTManager::Handle(const web::uri &uri, const web::json::value &body)
 {
   // Checking if there is an observer for the port and path
   std::pair<int, utility::string_t> key(uri.port(), uri.path());
   if (m_Observers.count(key) != 0)
   {
     //TODO Ausgaben minimieren
     MITK_INFO << "Manager: Data send to observer";
     return m_Observers[key]->Notify(body, uri);
   }
   // No observer under this port, return null which results in status code 404 (s. RESTServer)
   else
   {
     MITK_WARN << "No Observer can handle the data";
     return NULL;
   }
 }
 
 void mitk::RESTManager::HandleDeleteObserver(IRESTObserver *observer, const web::uri &uri = L"")
 {
   for (auto it = m_Observers.begin(); it != m_Observers.end();)
   {
     mitk::IRESTObserver *obsMap = it->second;
     // Check wether observer is at this place in map
     if (obsMap == observer)
     {
       // Check wether it is the right uri to be deleted
       if (uri.is_empty() || it->first.second == uri.path())
       {
         int port = it->first.first;
         bool noObserverForPort = this->DeleteObserver(it, uri);
         if (noObserverForPort)
         {
           //  there isn't an observer at this port, delete m_ServerMap entry for this port
           // close listener
           m_ServerMap[port]->CloseListener();
           delete m_ServerMap[port];
           // delete server from map
           m_ServerMap.erase(port);
         }
       }
       else
       {
         ++it;
       }
     }
     else
     {
       ++it;
     }
   }
 }
 
 const std::map<int, mitk::RESTServer *> &mitk::RESTManager::GetServerMap()
 {
   return m_ServerMap;
 }
 
 const std::map<std::pair<int, utility::string_t>, mitk::IRESTObserver *> &mitk::RESTManager::GetObservers()
 {
   return m_Observers;
 }
 
 void mitk::RESTManager::AddObserver(const web::uri &uri, IRESTObserver *observer)
 {
   // new observer has to be added
   std::pair<int, utility::string_t> key(uri.port(), uri.path());
   m_Observers[key] = observer;
 
   // testing if entry has been added to observer map
   MITK_INFO << "[" << uri.port() << ", " << mitk::RESTUtil::convertToUtf8(uri.path())
             << "] : Number of elements in map: " << m_Observers.count(key);
 }
 
 void mitk::RESTManager::ServerUnderPort(const web::uri &uri, IRESTObserver *observer)
 {
   // Same host, means new observer but not a new server instance
   if (m_ServerMap[uri.port()]->GetUri() == uri.authority())
   {
     // new observer has to be added
     std::pair<int, utility::string_t> key(uri.port(), uri.path());
     // only add a new observer if there isn't already an observer for this uri
     if (m_Observers.count(key) == 0)
     {
       this->AddObserver(uri, observer);
 
       // info output
       MITK_INFO << "started listening, no new server instance has been created";
     }
     else
     {
       MITK_ERROR << "Threre is already a observer handeling this data";
     }
   }
   // Error, since another server can't be added under this port
   else
   {
     MITK_ERROR << "There is already another server listening under this port";
   }
 }
 
 bool mitk::RESTManager::DeleteObserver(std::map<std::pair<int, utility::string_t>, IRESTObserver *>::iterator &it,
                                        const web::uri &uri)
 {
   // if yes
   // 1. store port and path in a temporary variable
   // (path is only needed to create a key for info output)
   int port = it->first.first;
   utility::string_t path = it->first.second;
   std::pair<int, utility::string_t> key(port, path);
   MITK_INFO << "Number of elements at key [ " << port << ", " << mitk::RESTUtil::convertToUtf8(key.second)
             << "]: " << m_Observers.count(key);
   // 2. delete map entry
   it = m_Observers.erase(it);
   MITK_INFO << "Number of elements at key [ " << port << ", " << mitk::RESTUtil::convertToUtf8(key.second)
             << "]: " << m_Observers.count(key);
   // 3. check, if there is another observer under this port in observer map (with bool flag)
   for (auto o : m_Observers)
   {
     if (o.first.first == port)
     {
       // there still exists an observer for this port
       return false;
     }
   }
   return true;
 }
diff --git a/Modules/CppRestSdk/test/mitkRESTClientTest.cpp b/Modules/CppRestSdk/test/mitkRESTClientTest.cpp
index dcc7cb002f..a6d689f70f 100644
--- a/Modules/CppRestSdk/test/mitkRESTClientTest.cpp
+++ b/Modules/CppRestSdk/test/mitkRESTClientTest.cpp
@@ -1,281 +1,282 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 // Testing
 #include "mitkTestFixture.h"
 #include "mitkTestingMacros.h"
 
 // MITK includes
 #include "mitkRESTClient.h"
 
 // VTK includes
 #include <vtkDebugLeaks.h>
 
 #include "mitkIRESTManager.h"
 #include <usGetModuleContext.h>
 #include <usModule.h>
 #include <usModuleContext.h>
 #include <usModuleRegistry.h>
 #include <usServiceReference.h>
 #include <usServiceTracker.h>
 
 class mitkRESTClientTestSuite : public mitk::TestFixture, mitk::IRESTObserver
 {
   CPPUNIT_TEST_SUITE(mitkRESTClientTestSuite);
 
   MITK_TEST(GetRequestValidURI_ReturnsExpectedJSON);
   MITK_TEST(MultipleGetRequestValidURI_AllTasksFinish);
   MITK_TEST(PutRequestValidURI_ReturnsExpectedJSON);
   MITK_TEST(PostRequestValidURI_ReturnsExpectedJSON);
   MITK_TEST(GetRequestInvalidURI_ThrowsException);
   MITK_TEST(PutRequestInvalidURI_ThrowsException);
   MITK_TEST(PostRequestInvalidURI_ThrowsException);
   CPPUNIT_TEST_SUITE_END();
 
 public:
   mitk::IRESTManager *m_Service;
 
-  web::json::value Notify(web::json::value &data, const web::uri &uri) override
+  web::json::value Notify(const web::json::value &data, const web::uri &uri) override
   {
     MITK_INFO << "Observer: Data in observer";
-    data[L"userId"] = web::json::value(1);
-    data[L"id"] = web::json::value(1);
-    data[L"title"] = web::json::value(U("this is a title"));
-    data[L"body"] = web::json::value(U("this is a body"));
-    return data;
+    web::json::value returnData = data;
+    returnData[L"userId"] = web::json::value(1);
+    returnData[L"id"] = web::json::value(1);
+    returnData[L"title"] = web::json::value(U("this is a title"));
+    returnData[L"body"] = web::json::value(U("this is a body"));
+    return returnData;
   }
 
   /**
    * @brief Setup Always call this method before each Test-case to ensure correct and new intialization of the used
    * members for a new test case. (If the members are not used in a test, the method does not need to be called).
    */
   void setUp() override
   {
     us::ServiceReference<mitk::IRESTManager> serviceRef =
       us::GetModuleContext()->GetServiceReference<mitk::IRESTManager>();
     if (serviceRef)
     {
       m_Service = us::GetModuleContext()->GetService(serviceRef);
     }
      if (m_Service)
     {
       m_Service->ReceiveRequest(L"http://localhost:8080/test", this);
     }
   }
 
   void tearDown() override
   {
      if (m_Service)
     {
       m_Service->HandleDeleteObserver(this);
     }
   }
 
   void GetRequestValidURI_ReturnsExpectedJSON()
   {
     web::json::value *result = new web::json::value();
     web::json::value data;
     //TODO: data als memebrvariable/ in setup/ in methode
     data[L"userId"] = web::json::value(1);
     data[L"id"] = web::json::value(1);
     data[L"title"] = web::json::value(U("this is a title"));
     data[L"body"] = web::json::value(U("this is a body"));
     if (m_Service)
     {
       m_Service->SendRequest(L"http://localhost:8080/test")
         .then([=](pplx::task<web::json::value> resultTask) {
           try
           {
             *result = resultTask.get();
           }
           catch (const mitk::Exception &exception)
           {
             MITK_ERROR << exception.what();
             return;
           }
         })
         .wait();
     }
     CPPUNIT_ASSERT_MESSAGE("Result is the expected JSON value", *result == data);
   }
 
   void MultipleGetRequestValidURI_AllTasksFinish()
   {
     int *count = new int(0);
     if (m_Service)
     {
       // Create multiple tasks e.g. as shown below
       //TODO: vector konstruktoren anschauen / emplace_back
       std::vector<pplx::task<void>> tasks;
       for (int i = 0; i < 20; ++i)
       {
         pplx::task<void> singleTask =
           m_Service->SendRequest(L"http://localhost:8080/test")
             .then([=](pplx::task<web::json::value> resultTask) {
               // Do something when a single task is done
               try
               {
                 resultTask.get();
                 *count +=1;
               }
               catch (const mitk::Exception &exception)
               {
                 MITK_ERROR << exception.what();
                 return;
               }
             });
         tasks.push_back(singleTask);
       }
       // Create a joinTask which includes all tasks you've created
       auto joinTask = pplx::when_all(begin(tasks), end(tasks));
       // Run asynchonously
       joinTask.then([=](pplx::task<void> resultTask) {
         // Do something when all tasks are finished
         try
         {
           resultTask.get();
           *count += 1;
         }
         catch (const mitk::Exception &exception)
         {
           MITK_ERROR << exception.what();
           return;
         }
       }).wait();
      }
     CPPUNIT_ASSERT_MESSAGE("Multiple Requests", *count ==21);
   }
 
   void PutRequestValidURI_ReturnsExpectedJSON()
   {
     // optional: link might get invalid or content is changed
     web::json::value *result = new web::json::value();
     web::json::value data;
     if (m_Service)
     {
       data[L"userId"] = web::json::value(1);
       data[L"id"] = web::json::value(1);
       data[L"title"] = web::json::value(U("this is a changed title"));
       data[L"body"] = web::json::value(U("and the body is changed as well"));
       m_Service
         ->SendRequest(L"https://jsonplaceholder.typicode.com/posts/1", mitk::IRESTManager::RequestType::Put, &data)
         .then([=](pplx::task<web::json::value> resultTask) {
           try
           {
             *result = resultTask.get();
           }
           catch (const mitk::Exception &exception)
           {
             MITK_ERROR << exception.what();
             return;
           }
         })
         .wait();
     }
     CPPUNIT_ASSERT_MESSAGE(
       "Result is the expected JSON value, check if the link is still valid since this is an optional test",
       *result == data);
   }
 
   void PostRequestValidURI_ReturnsExpectedJSON()
   {
     // optional: link might get invalid or content is changed
     web::json::value *result = new web::json::value();
     web::json::value data;
     if (m_Service)
     {
       data[L"userId"] = web::json::value(1);
       data[L"title"] = web::json::value(U("this is a new title"));
       data[L"body"] = web::json::value(U("this is a new body"));
       m_Service->SendRequest(L"https://jsonplaceholder.typicode.com/posts", mitk::IRESTManager::RequestType::Post, &data)
         .then([=](pplx::task<web::json::value> resultTask) {
           try
           {
             *result = resultTask.get();
           }
           catch (const mitk::Exception &exception)
           {
             MITK_ERROR << exception.what();
             return;
           }
         })
         .wait();
     }
     data[L"id"] = web::json::value(101);
     CPPUNIT_ASSERT_MESSAGE(
       "Result is the expected JSON value, check if the link is still valid since this is an optional test",
       *result == data);
   }
 
   void GetException()
   {
     //Method which makes a get request to an invalid uri
     web::json::value *result = new web::json::value();
     if (m_Service)
     {
       m_Service->SendRequest(L"http://localhost:1234/invalid")
         .then([=](pplx::task<web::json::value> resultTask) { *result = resultTask.get(); })
         .wait();
     }
   }
   void GetRequestInvalidURI_ThrowsException() { CPPUNIT_ASSERT_THROW(GetException(), mitk::Exception); }
 
   void PutException() 
   {
     //Method which makes a put request to an invalid uri
     web::json::value *result = new web::json::value();
     web::json::value data;
     if (m_Service)
     {
       data[L"userId"] = web::json::value(1);
       data[L"id"] = web::json::value(1);
       data[L"title"] = web::json::value(U("this is a changed title"));
       data[L"body"] = web::json::value(U("and the body is changed as well"));
       m_Service->SendRequest(L"http://localhost:1234/invalid", mitk::IRESTManager::RequestType::Put, &data)
         .then([=](pplx::task<web::json::value> resultTask) {
             *result = resultTask.get();})
         .wait();
         }
   }
   void PutRequestInvalidURI_ThrowsException()
   {
     CPPUNIT_ASSERT_THROW(PutException(), mitk::Exception);
   }
 
   void PostException()
   {
     //Method which makes a post request to an invalid uri
     web::json::value *result = new web::json::value();
     web::json::value data;
     if (m_Service)
     {
       data[L"userId"] = web::json::value(1);
       data[L"title"] = web::json::value(U("this is a new title"));
       data[L"body"] = web::json::value(U("this is a new body"));
       m_Service->SendRequest(L"http://localhost:1234/invalid", mitk::IRESTManager::RequestType::Post, &data)
         .then([=](pplx::task<web::json::value> resultTask) {
             *result = resultTask.get();
         })
         .wait();
     }
   }
   void PostRequestInvalidURI_ThrowsException()
   {
     CPPUNIT_ASSERT_THROW(PostException(), mitk::Exception);
   }
 };
 
 MITK_TEST_SUITE_REGISTRATION(mitkRESTClient)
\ No newline at end of file
diff --git a/Modules/CppRestSdk/test/mitkRESTServerTest.cpp b/Modules/CppRestSdk/test/mitkRESTServerTest.cpp
index 8ad5284460..bb3507f131 100644
--- a/Modules/CppRestSdk/test/mitkRESTServerTest.cpp
+++ b/Modules/CppRestSdk/test/mitkRESTServerTest.cpp
@@ -1,262 +1,263 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 // Testing
 #include "mitkTestFixture.h"
 #include "mitkTestingMacros.h"
 
 // MITK includes
 #include "mitkRESTServer.h"
 
 // VTK includes
 #include <vtkDebugLeaks.h>
 
 class mitkRESTServerTestSuite : public mitk::TestFixture, mitk::IRESTObserver
 {
   CPPUNIT_TEST_SUITE(mitkRESTServerTestSuite);
 
   MITK_TEST(OpenListener_Succeed);
   MITK_TEST(TwoListenerSameHostSamePort_OnlyOneOpened);
   MITK_TEST(CloseListener_Succeed);
   MITK_TEST(OpenMultipleListenerCloseOne_Succeed);
   MITK_TEST(OpenMultipleListenerCloseAll_Succeed);
   MITK_TEST(OpenListenerGetRequestSamePath_ReturnExpectedJSON);
   MITK_TEST(CloseListener_NoRequestPossible);
   MITK_TEST(OpenListenerGetRequestDifferentPath_ReturnNotFound);
   MITK_TEST(OpenListenerCloseAndReopen_Succeed);
   CPPUNIT_TEST_SUITE_END();
 
 public:
   mitk::IRESTManager *m_Service;
   web::json::value m_Data;
 
   //TODO: bei Notify uri parameter zuerst
   //TODO: data als const ref
-  web::json::value Notify(web::json::value &data, const web::uri &uri) override
+  web::json::value Notify(const web::json::value &data, const web::uri &uri) override
   {
     MITK_INFO << "Observer: Data in observer";
-    data[L"userId"] = web::json::value(1);
-    data[L"id"] = web::json::value(1);
-    data[L"title"] = web::json::value(U("this is a title"));
-    data[L"body"] = web::json::value(U("this is a body"));
-    return data;
+    web::json::value returnData = data;
+    returnData[L"userId"] = web::json::value(1);
+    returnData[L"id"] = web::json::value(1);
+    returnData[L"title"] = web::json::value(U("this is a title"));
+    returnData[L"body"] = web::json::value(U("this is a body"));
+    return returnData;
   }
 
   /**
    * @brief Setup Always call this method before each Test-case to ensure correct and new intialization of the used
    * members for a new test case. (If the members are not used in a test, the method does not need to be called).
    */
   void setUp() override
   {
     m_Data[L"userId"] = web::json::value(1);
     m_Data[L"id"] = web::json::value(1);
     m_Data[L"title"] = web::json::value(U("this is a title"));
     m_Data[L"body"] = web::json::value(U("this is a body"));
     us::ServiceReference<mitk::IRESTManager> serviceRef =
       us::GetModuleContext()->GetServiceReference<mitk::IRESTManager>();
     if (serviceRef)
     {
       m_Service = us::GetModuleContext()->GetService(serviceRef);
     }
     //TODO: if(m_Service) überprüfen, exception wenn nicht
   }
 
   void tearDown() override { m_Service->HandleDeleteObserver(this); }
 
   void OpenListener_Succeed()
   {
     if (m_Service)
     {
       m_Service->ReceiveRequest(L"http://localhost:8080/test", this);
     }
     CPPUNIT_ASSERT_MESSAGE("Open one listener, observer map size is one", m_Service->GetObservers().size() == 1);
     CPPUNIT_ASSERT_MESSAGE("Open one listener, server map size is one", m_Service->GetServerMap().size() == 1);
   }
 
   void TwoListenerSameHostSamePort_OnlyOneOpened()
   {
     if (m_Service)
     {
       m_Service->ReceiveRequest(L"http://localhost:8080/test", this);
       m_Service->ReceiveRequest(L"http://localhost:8080/example", this);
     }
     CPPUNIT_ASSERT_MESSAGE("Open two listener with a different path,same host, same port, observer map size is two",
                            m_Service->GetObservers().size() == 2);
     CPPUNIT_ASSERT_MESSAGE("Open two listener with a different path,same host, same port, server map size is one",
                            m_Service->GetServerMap().size() == 1);
   }
 
   void CloseListener_Succeed()
   {
     if (m_Service)
     {
       m_Service->ReceiveRequest(L"http://localhost:8080/test", this);
     }
     CPPUNIT_ASSERT_MESSAGE("Open one listener, observer map size is one", m_Service->GetObservers().size() == 1);
     CPPUNIT_ASSERT_MESSAGE("Open one listener, server map size is one", m_Service->GetServerMap().size() == 1);
     if (m_Service)
     {
       m_Service->HandleDeleteObserver(this);
     }
     CPPUNIT_ASSERT_MESSAGE("Closed listener, observer map is empty", m_Service->GetObservers().size() == 0);
     CPPUNIT_ASSERT_MESSAGE("Closed listener, server map is empty", m_Service->GetServerMap().size() == 0);
   }
 
   void OpenMultipleListenerCloseOne_Succeed()
   {
     if (m_Service)
     {
       m_Service->ReceiveRequest(L"http://localhost:8080/test", this);
       m_Service->ReceiveRequest(L"http://localhost:8090/example", this);
     }
     CPPUNIT_ASSERT_MESSAGE("Open two listener, observer map size is two", m_Service->GetObservers().size() == 2);
     CPPUNIT_ASSERT_MESSAGE("Open two listener, server map size is two", m_Service->GetServerMap().size() == 2);
     if (m_Service)
     {
       m_Service->HandleDeleteObserver(this, L"http://localhost:8080/test");
     }
     CPPUNIT_ASSERT_MESSAGE("Closed one of two listeners, observer map is size is one",
                            m_Service->GetObservers().size() == 1);
     CPPUNIT_ASSERT_MESSAGE("Closed one of two listener, server map size is one",
                            m_Service->GetServerMap().size() == 1);
   }
 
   void OpenMultipleListenerCloseAll_Succeed()
   {
     if (m_Service)
     {
       m_Service->ReceiveRequest(L"http://localhost:8080/test", this);
       m_Service->ReceiveRequest(L"http://localhost:8090/example", this);
     }
     CPPUNIT_ASSERT_MESSAGE("Open two listener, observer map size is two", m_Service->GetObservers().size() == 2);
     CPPUNIT_ASSERT_MESSAGE("Open two listener, server map size is two", m_Service->GetServerMap().size() == 2);
     if (m_Service)
     {
       m_Service->HandleDeleteObserver(this);
     }
     CPPUNIT_ASSERT_MESSAGE("Closed all listeners, observer map is empty", m_Service->GetObservers().size() == 0);
     CPPUNIT_ASSERT_MESSAGE("Closed all listeners, server map is empty", m_Service->GetServerMap().size() == 0);
   }
 
   void OpenListenerGetRequestSamePath_ReturnExpectedJSON()
   {
     if (m_Service)
     {
       m_Service->ReceiveRequest(L"http://localhost:8080/test", this);
     }
     web::json::value *result = new web::json::value();
     web::json::value data;
     data[L"userId"] = web::json::value(1);
     data[L"id"] = web::json::value(1);
     data[L"title"] = web::json::value(U("this is a title"));
     data[L"body"] = web::json::value(U("this is a body"));
 
     if (m_Service)
     {
       m_Service->SendRequest(L"http://localhost:8080/test")
         .then([=](pplx::task<web::json::value> resultTask) {
           try
           {
             *result = resultTask.get();
           }
           catch (const mitk::Exception &exception)
           {
             MITK_ERROR << exception.what();
             return;
           }
         })
         .wait();
     }
     CPPUNIT_ASSERT_MESSAGE("Opened listener and send request to same uri, returned expected JSON", *result == data);
   }
 
   void RequestToClosedListener()
   {
     web::json::value *result = new web::json::value();
     if (m_Service)
     {
       m_Service->SendRequest(L"http://localhost:8080/test")
         .then([=](pplx::task<web::json::value> resultTask) { *result = resultTask.get(); })
         .wait();
     }
   }
   void CloseListener_NoRequestPossible()
   {
     if (m_Service)
     {
       m_Service->ReceiveRequest(L"http://localhost:8080/test", this);
     }
     CPPUNIT_ASSERT_MESSAGE("Open one listener, observer map size is one", m_Service->GetObservers().size() == 1);
     CPPUNIT_ASSERT_MESSAGE("Open one listener, server map size is one", m_Service->GetServerMap().size() == 1);
     if (m_Service)
     {
       m_Service->HandleDeleteObserver(this);
     }
     CPPUNIT_ASSERT_MESSAGE("Closed listener, observer map is empty", m_Service->GetObservers().size() == 0);
     CPPUNIT_ASSERT_MESSAGE("Closed listener, server map is empty", m_Service->GetServerMap().size() == 0);
     
     CPPUNIT_ASSERT_THROW(RequestToClosedListener(), mitk::Exception);
   }
 
   void RequestToDifferentPathNotFound()
   {
     if (m_Service)
     {
       m_Service->ReceiveRequest(L"http://localhost:8080/test", this);
     }
     web::json::value *result = new web::json::value();
     web::json::value data;
     data[L"userId"] = web::json::value(1);
     data[L"id"] = web::json::value(1);
     data[L"title"] = web::json::value(U("this is a title"));
     data[L"body"] = web::json::value(U("this is a body"));
 
     if (m_Service)
     {
       m_Service->SendRequest(L"http://localhost:8080/example")
         .then([=](pplx::task<web::json::value> resultTask) { *result = resultTask.get(); })
         .wait();
     }
   }
   void OpenListenerGetRequestDifferentPath_ReturnNotFound()
   {
     CPPUNIT_ASSERT_THROW(RequestToDifferentPathNotFound(), mitk::Exception);
   }
 
   void OpenListenerCloseAndReopen_Succeed() 
   {
     if (m_Service)
     {
       m_Service->ReceiveRequest(L"http://localhost:8080/test", this);
     }
     CPPUNIT_ASSERT_MESSAGE("Open one listener, observer map size is one", m_Service->GetObservers().size() == 1);
     CPPUNIT_ASSERT_MESSAGE("Open one listener, server map size is one", m_Service->GetServerMap().size() == 1);
     if (m_Service)
     {
       m_Service->HandleDeleteObserver(this);
     }
     CPPUNIT_ASSERT_MESSAGE("Closed listener, observer map is empty", m_Service->GetObservers().size() == 0);
     CPPUNIT_ASSERT_MESSAGE("Closed listener, server map is empty", m_Service->GetServerMap().size() == 0);
     if (m_Service)
     {
       m_Service->ReceiveRequest(L"http://localhost:8080/test", this);
     }
     CPPUNIT_ASSERT_MESSAGE("Reopened listener, observer map size is one", m_Service->GetObservers().size() == 1);
     CPPUNIT_ASSERT_MESSAGE("Reopened listener, server map size is one", m_Service->GetServerMap().size() == 1);
   }
 };
 
 MITK_TEST_SUITE_REGISTRATION(mitkRESTServer)
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.thread/src/internal/QmitkThreadView.cpp b/Plugins/org.mitk.gui.qt.thread/src/internal/QmitkThreadView.cpp
index 53011b8c78..899fc6cc62 100644
--- a/Plugins/org.mitk.gui.qt.thread/src/internal/QmitkThreadView.cpp
+++ b/Plugins/org.mitk.gui.qt.thread/src/internal/QmitkThreadView.cpp
@@ -1,146 +1,146 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "QmitkThreadView.h"
 
 #include <QThread>
 
 #include <ui_QmitkThreadView.h>
 #include <mitkIRESTManager.h>
 #include <usModule.h>
 #include <usServiceTracker.h>
 #include <usModuleRegistry.h>
 #include <usGetModuleContext.h>
 
 const std::string QmitkThreadView::VIEW_ID = "org.mitk.views.threadview";
 
 QmitkThreadView::QmitkThreadView()
   : m_Ui(new Ui::QmitkThreadView)
 {
 }
 
-web::json::value QmitkThreadView::Notify(web::json::value &data, const web::uri &uri)
+web::json::value QmitkThreadView::Notify(const web::json::value &data, const web::uri &uri)
 {
   MITK_INFO << "Observer: Data in observer";
   return data.at(U("key 1"));
 }
 
 QmitkThreadView::~QmitkThreadView()
 {
   delete m_Ui;
 }
 
 void QmitkThreadView::CreateQtPartControl(QWidget* parent)
 {
   m_Ui->setupUi(parent);
 
   connect(m_Ui->stopAllPushButton, &QPushButton::clicked, this, &QmitkThreadView::OnStopAllButtonClicked);
   
   connect(m_Ui->testListenCheckBox, &QCheckBox::clicked, this, &QmitkThreadView::OnTestListenCheckBoxClicked);
   connect(m_Ui->exampleListenCheckBox, &QCheckBox::clicked, this, &QmitkThreadView::OnExampleListenCheckBoxClicked);
   connect(m_Ui->port8090CheckBox, &QCheckBox::clicked, this, &QmitkThreadView::OnPort8090ListenCheckBoxClicked);
 
   connect(m_Ui->stopAllPushButton, &QPushButton::clicked, this, &QmitkThreadView::OnStopAllButtonClicked);
 }
 
 void QmitkThreadView::SetFocus()
 {
 }
 
 
 void QmitkThreadView::StartListening(web::uri uri)
 {
   us::ModuleContext *context = us::ModuleRegistry::GetModule(1)->GetModuleContext();
 
   auto managerRef = context->GetServiceReference<mitk::IRESTManager>();
   if (managerRef)
   {
     auto managerService = context->GetService(managerRef);
     if (managerService)
     {
       managerService->ReceiveRequest(uri, this);
     }
   }
 }
 
 void QmitkThreadView::StopListening(web::uri uri) 
 {
   us::ModuleContext *context = us::ModuleRegistry::GetModule(1)->GetModuleContext();
 
   auto managerRef = context->GetServiceReference<mitk::IRESTManager>();
   if (managerRef)
   {
     auto managerService = context->GetService(managerRef);
     if (managerService)
     {
       managerService->HandleDeleteObserver(this,uri);
     }
   }
 }
 
 void QmitkThreadView::OnStopAllButtonClicked()
 {
   us::ModuleContext *context = us::ModuleRegistry::GetModule(1)->GetModuleContext();
 
   auto managerRef = context->GetServiceReference<mitk::IRESTManager>();
   if (managerRef)
   {
     auto managerService = context->GetService(managerRef);
     if (managerService)
     {
       managerService->HandleDeleteObserver(this);
     }
   }
   m_Ui->testListenCheckBox->setChecked(false);
   m_Ui->exampleListenCheckBox->setChecked(false);
   m_Ui->port8090CheckBox->setChecked(false);
 }
 
 void QmitkThreadView::OnTestListenCheckBoxClicked()
 {
   if (m_Ui->testListenCheckBox->isChecked())
   {
     StartListening(L"http://localhost:8080/test");
   }
   else
   {
     StopListening(L"http://localhost:8080/test");
   }
 }
 
 void QmitkThreadView::OnExampleListenCheckBoxClicked() 
 {
   if (m_Ui->exampleListenCheckBox->isChecked())
   {
     StartListening(L"http://localhost:8080/example");
   }
   else
   {
     StopListening(L"http://localhost:8080/example");
   }
 }
 
 void QmitkThreadView::OnPort8090ListenCheckBoxClicked() 
 {
   if (m_Ui->port8090CheckBox->isChecked())
   {
     StartListening(L"http://localhost:8090");
   }
   else
   {
     StopListening(L"http://localhost:8090");
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.thread/src/internal/QmitkThreadView.h b/Plugins/org.mitk.gui.qt.thread/src/internal/QmitkThreadView.h
index 9136b3a5e4..3f55117ec6 100644
--- a/Plugins/org.mitk.gui.qt.thread/src/internal/QmitkThreadView.h
+++ b/Plugins/org.mitk.gui.qt.thread/src/internal/QmitkThreadView.h
@@ -1,60 +1,60 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef QmitkThreadView_h
 #define QmitkThreadView_h
 
 #include <QmitkAbstractView.h>
 #include <mitkIRESTObserver.h>
 #include "cpprest/uri.h"
 
 namespace Ui
 {
   class QmitkThreadView;
 }
 
 namespace mitk
 {
   class RESTManager;
 }
 
 class QmitkThreadView : public QmitkAbstractView, public mitk::IRESTObserver
 {
   Q_OBJECT
 
 public:
   static const std::string VIEW_ID;
 
   QmitkThreadView();
   ~QmitkThreadView() override;
 
   void CreateQtPartControl(QWidget *parent) override;
-  web::json::value Notify(web::json::value &data, const web::uri &uri) override;
+  web::json::value Notify(const web::json::value &data, const web::uri &uri) override;
 
 private slots:
   void OnStopAllButtonClicked();
   void OnTestListenCheckBoxClicked();
   void OnExampleListenCheckBoxClicked();
   void OnPort8090ListenCheckBoxClicked();
 
 private:
   void SetFocus() override;
   void StartListening(web::uri);
   void StopListening(web::uri);
   Ui::QmitkThreadView *m_Ui;
 };
 
 #endif