diff --git a/Modules/CppRestSdk/include/mitkIRESTManager.h b/Modules/CppRestSdk/include/mitkIRESTManager.h
index c1eb34d68b..c65e2ad471 100644
--- a/Modules/CppRestSdk/include/mitkIRESTManager.h
+++ b/Modules/CppRestSdk/include/mitkIRESTManager.h
@@ -1,29 +1,30 @@
 #ifndef mitkIRESTManager_h
 #define mitkIRESTManager_h
 
 #include "cpprest/uri.h"
 #include <MitkCoreExports.h>
 #include <mitkServiceInterface.h>
 #include <mitkIRESTObserver.h>
 
 namespace mitk
 {
   class IRESTManager
   {
   public:
     virtual ~IRESTManager();
 
     enum RequestType
     {
       get,
       post,
       put
     };
     virtual void sendRequest(RequestType type) = 0;
     virtual void receiveRequest(web::uri uri, IRESTObserver *observer) = 0;
+    virtual bool handle(web::uri) = 0;
   };
 } // namespace mitk
 
 MITK_DECLARE_SERVICE_INTERFACE(mitk::IRESTManager, "org.mitk.IRESTManager")
 
 #endif
diff --git a/Modules/CppRestSdk/include/mitkRESTManager.h b/Modules/CppRestSdk/include/mitkRESTManager.h
index 9964edbd4b..1c1dca6635 100644
--- a/Modules/CppRestSdk/include/mitkRESTManager.h
+++ b/Modules/CppRestSdk/include/mitkRESTManager.h
@@ -1,28 +1,30 @@
 #ifndef mitkRESTManager_h
 #define mitkRESTManager_h
 
 #include <mitkIRESTManager.h>
 #include <mitkRESTClientMicroService.h>
 #include <mitkRESTServerMicroService.h>
 #include <mitkIRESTObserver.h>
 
 namespace mitk
 {
   class RESTManager : public IRESTManager
   {
   public:
     RESTManager();
     ~RESTManager() override;
 
     //calls RESTClient
     void sendRequest(RequestType type) override;
     //calls RESTServer
     void receiveRequest(web::uri uri, IRESTObserver *observer) override;
 
+    bool handle(web::uri) override;
+
   private:
     std::map<int, RESTClientMicroService*> m_ClientMap; // Map with port client pairs
     std::map<int, RESTServerMicroService*> m_ServerMap; // Map with port server pairs
     std::map<web::uri, IRESTObserver *> m_Observer; //Map with all observers
   };
 } // namespace mitk
 #endif // !mitkRESTManager_h
diff --git a/Modules/CppRestSdk/include/mitkRESTServerMicroService.h b/Modules/CppRestSdk/include/mitkRESTServerMicroService.h
index b332706af8..08b539911b 100644
--- a/Modules/CppRestSdk/include/mitkRESTServerMicroService.h
+++ b/Modules/CppRestSdk/include/mitkRESTServerMicroService.h
@@ -1,39 +1,41 @@
 #ifndef mitkRESTServerMicroService_h
 #define mitkRESTServerMicroService_h
 
 #include "cpprest/asyncrt_utils.h"
 #include "cpprest/containerstream.h"
 #include "cpprest/filestream.h"
 #include "cpprest/http_listener.h"
 #include "cpprest/json.h"
 #include "cpprest/producerconsumerstream.h"
 #include "cpprest/uri.h"
 
 #include "MitkCppRestSdkExports.h"
-
+#include <mitkIRESTManager.h>
+#include <usGetModuleContext.h>
+#include <usModule.h>
+#include <usServiceTracker.h>
 typedef web::http::experimental::listener::http_listener MitkListener;
 typedef web::http::http_request MitkRequest;
 typedef web::http::http_response MitkResponse;
 typedef web::http::methods MitkRESTMethods;
 typedef web::http::status_codes MitkRestStatusCodes;
 typedef web::json::json_exception MitkJsonException;
 
-
 namespace mitk
 {
   class RESTServerMicroService
   {
   public:
     RESTServerMicroService(web::uri uri);
     ~RESTServerMicroService();
     web::uri GetUri();
 
   private:
     pplx::task<void> openListener();
     pplx::task<void> closeListener();
     void HandleGet(MitkRequest request);
     MitkListener m_Listener;
     web::uri m_Uri;
   };
 } // namespace mitk
-#endif 
\ No newline at end of file
+#endif
\ No newline at end of file
diff --git a/Modules/CppRestSdk/src/mitkCppRestSdkActivator.cpp b/Modules/CppRestSdk/src/mitkCppRestSdkActivator.cpp
index fa6c5a3a27..26c4370805 100644
--- a/Modules/CppRestSdk/src/mitkCppRestSdkActivator.cpp
+++ b/Modules/CppRestSdk/src/mitkCppRestSdkActivator.cpp
@@ -1,33 +1,33 @@
 #include "mitkCppRestSdkActivator.h"
 
 #include <usGetModuleContext.h>
 #include<usModule.h> 
 #include<usModuleActivator.h> 
 #include<usModuleContext.h> 
 #include<usModuleEvent.h> 
 #include<usModuleInitialization.h> 
 #include<usModuleResource.h> 
 #include<usModuleResourceStream.h> 
 #include<usModuleSettings.h> 
 #include<usServiceTracker.h>
 
-#include <mitkRESTTest.h>
+
 
 
 void MitkCppRestSdkActivator::Load(us::ModuleContext *context)
 {
   //Registration of the RESTManagerMicroservice
   m_RESTManager.reset(new mitk::RESTManager);
   context->RegisterService<mitk::IRESTManager>(m_RESTManager.get());
 
   //Test use of the RESTManagerMicroservice, later done in Module
-  mitk::RestTest test;
-  test.TestRESTServer();
+ 
+  m_Test.TestRESTServer();
 }
 
 void MitkCppRestSdkActivator::Unload(us::ModuleContext *) 
 {
 
 }
 
 US_EXPORT_MODULE_ACTIVATOR(MitkCppRestSdkActivator)
diff --git a/Modules/CppRestSdk/src/mitkCppRestSdkActivator.h b/Modules/CppRestSdk/src/mitkCppRestSdkActivator.h
index 767c675fab..c2521ebb76 100644
--- a/Modules/CppRestSdk/src/mitkCppRestSdkActivator.h
+++ b/Modules/CppRestSdk/src/mitkCppRestSdkActivator.h
@@ -1,21 +1,23 @@
 #ifndef MITKCPPRESTSDKACTIVATOR_H_
 #define MITKCPPRESTSDKACTIVATOR_H_
 
 #include <mitkRESTManager.h>
 
 #include <usModuleActivator.h>
 #include <usModuleEvent.h> 
 #include <usServiceRegistration.h> 
 #include <usServiceTracker.h>
+#include <mitkRESTTest.h>
 
 class MitkCppRestSdkActivator : public us::ModuleActivator
 {
 public:
   void Load(us::ModuleContext *context) override;
   void Unload(us::ModuleContext *) override;
 
 private:
   std::unique_ptr<mitk::RESTManager> m_RESTManager;
+  mitk::RestTest m_Test;
 
 };
 #endif
diff --git a/Modules/CppRestSdk/src/mitkRESTManager.cpp b/Modules/CppRestSdk/src/mitkRESTManager.cpp
index 9f038b7c16..ab19dc623d 100644
--- a/Modules/CppRestSdk/src/mitkRESTManager.cpp
+++ b/Modules/CppRestSdk/src/mitkRESTManager.cpp
@@ -1,69 +1,89 @@
 #include "mitkRESTManager.h"
 #include <mitkCommon.h>
 
 mitk::RESTManager::RESTManager() {}
 
 mitk::RESTManager::~RESTManager() {}
 
 void mitk::RESTManager::sendRequest(RequestType type) 
 {
   switch (type)
   {
     case get:
       //Call get in mitkRESTClientMicroService
       break;
     case post:
       //Call post in mitkRESTClientMicroService
       break;
     case put:
       //Call put in mitkRESTClientMicroService
       break;
   }
 }
 
 void mitk::RESTManager::receiveRequest(web::uri uri, mitk::IRESTObserver *observer)
 {
   //New instance of RESTServerMicroservice 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)
   {
     //new observer has to be added
     m_Observer[uri] = observer;
 
-    //testing if entry has been added to map
+    //testing if entry has been added to observer map
     utility::string_t uristringt = uri.to_string();
     std::string uristring(uristringt.begin(), uristringt.end());
     MITK_INFO << uristring << " : Number of elements in map: " << m_Observer.count(uri);
 
     //creating server instance
     RESTServerMicroService *server = new RESTServerMicroService(uri.authority());
     //add reference to server instance to map
     m_ServerMap[port] = server;
 
     //info output
     utility::string_t host = uri.authority().to_string();
     std::string hoststring(host.begin(), host.end());
     MITK_INFO << "new server" << hoststring<<" at port" << port;
   }
+  //If there is already a server under this port
   else
   {
+    //Same host, means new observer but not a new server instance
     if (m_ServerMap[port]->GetUri() == uri.authority())
     {
       //new observer has to be added
       m_Observer[uri] = observer;
 
       // testing if entry has been added to map
       utility::string_t uristringt = uri.to_string();
       std::string uristring(uristringt.begin(), uristringt.end());
       MITK_INFO << uristring << " : Number of elements in map: " << m_Observer.count(uri);
 
       //info output
       MITK_INFO << "started listening, no new server instance has been created";
     }
+    //Error, since another server can't be added under this port
     else
     {
       MITK_ERROR << "there is already another server listening under this port";
     }
   }
 }
+
+//TODO replace boolean as return value by actual data
+bool mitk::RESTManager::handle(web::uri uri)
+{
+  if (m_Observer.count(uri) == 1)
+  {
+    //TODO replace by data
+    bool worked = m_Observer[uri]->notify();
+    return worked;
+  }
+  else
+  {
+    MITK_WARN << "No Observer can handle the data";
+    return false;
+  }
+}
diff --git a/Modules/CppRestSdk/src/mitkRESTServerMicroService.cpp b/Modules/CppRestSdk/src/mitkRESTServerMicroService.cpp
index b8e844c6ee..bed6ba9e17 100644
--- a/Modules/CppRestSdk/src/mitkRESTServerMicroService.cpp
+++ b/Modules/CppRestSdk/src/mitkRESTServerMicroService.cpp
@@ -1,48 +1,68 @@
 #include "mitkRESTServerMicroService.h"
 #include <mitkCommon.h>
+#include <usGetModuleContext.h>
+#include <usModule.h>
 
 mitk::RESTServerMicroService::RESTServerMicroService(web::uri uri) : m_Listener(uri)
 {
   m_Uri = uri;
   m_Listener.support(MitkRESTMethods::GET, std::bind(&RESTServerMicroService::HandleGet, this, std::placeholders::_1));
   openListener();
 }
 
 mitk::RESTServerMicroService::~RESTServerMicroService()
 {
   closeListener();
 }
 
 pplx::task<void> mitk::RESTServerMicroService::openListener()
 {
   return m_Listener.open();
 }
 
 pplx::task<void> mitk::RESTServerMicroService::closeListener()
 {
   return m_Listener.close();
 }
 
 web::uri mitk::RESTServerMicroService::GetUri() 
 {
   return m_Uri;
 }
 
 void mitk::RESTServerMicroService::HandleGet(MitkRequest request)
 {
   int port = m_Listener.uri().port();
-
+ //getting exact request uri has to be a parameter in handle function
   web::uri_builder build(m_Listener.uri());
   build.append(request.absolute_uri());
   utility::string_t uri = build.to_uri().to_string();
 
   std::string uriString(uri.begin(), uri.end());
   web::json::value content;
-
+  //example content, has to be replace by getting actual modified data by handle
   content[L"key 1"] = web::json::value::string(U("this is a first test"));
   request.set_body(content);
   auto answer = request.extract_json().get();
   MITK_INFO << "Test for Server at port " << port << " Exact request uri: " << uriString;
+  
+  //TODO replace worked by data object
+  bool worked;
+  us::ModuleContext *context = us::GetModuleContext();
+  auto managerRef = context->GetServiceReference<IRESTManager>();
+  if (managerRef)
+  {
+    auto managerService = context->GetService(managerRef);
+    if (managerService)
+    {
+      worked = managerService->handle(build.to_uri());
+    }
+  }
+  if (worked)
+  {
+    //TODO return modified data
+    MITK_INFO << "Pipeline worked";
+  }
 
   request.reply(MitkRestStatusCodes::OK, answer);
 }
\ No newline at end of file
diff --git a/Modules/CppRestSdk/src/mitkRESTTest.cpp b/Modules/CppRestSdk/src/mitkRESTTest.cpp
index c74c73bd4e..e39e4c8b89 100644
--- a/Modules/CppRestSdk/src/mitkRESTTest.cpp
+++ b/Modules/CppRestSdk/src/mitkRESTTest.cpp
@@ -1,29 +1,30 @@
 #include "mitkRESTTest.h"
 #include <usGetModuleContext.h>
 #include <usModule.h>
 #include <mitkCommon.h>
 
 mitk::RestTest::RestTest() {}
 
 mitk::RestTest::~RestTest() {}
 
 void mitk::RestTest::TestRESTServer()
 {
   us::ModuleContext *context = us::GetModuleContext();
   auto managerRef = context->GetServiceReference<IRESTManager>();
   if (managerRef)
   {
     auto managerService = context->GetService(managerRef);
     if (managerService)
     {
-      managerService->receiveRequest(L"http://localhost:8080/test", this);
+      managerService->receiveRequest(L"http://localhost:8080/test/", this);
       managerService->receiveRequest(L"http://localhost:8080/example", this);
       managerService->receiveRequest(L"http://localhost:8090", this);
     }
   }
 }
 
+//TODO get Data, return modified Data
 bool mitk::RestTest::notify() 
 {
   return true;
 }