diff --git a/Modules/CppRestSdk/documentation/mitkCppRestSdk.dox b/Modules/CppRestSdk/documentation/mitkCppRestSdk.dox new file mode 100644 index 0000000000..73a5fc37e0 --- /dev/null +++ b/Modules/CppRestSdk/documentation/mitkCppRestSdk.dox @@ -0,0 +1,194 @@ +/** + +\page CppRestSdkModule The MITK CppRestSdk Module + +\tableofcontents + +\section CppRestSdk_brief Description +The MITK CppRestSdk Module is able to manage REST requests. The two main classes to use are the RESTManager and the RESTManageQt (in the CppRestSdkQt Module). +These are MicroServices which can be accessed via +\code{.cpp} +auto *context = us::GetModuleContext(); + auto managerRef = context->GetServiceReference(); + if (managerRef) + { + auto managerService = context->GetService(managerRef); + if (managerService) + { + //call the function you need from the service + } + } +\endcode + +\subsection CppRestSdk_Technical Technical background + + The module uses the library CppRestSdk for REST mechanisms as well as JSON convertion and asynchronic prorgamming + +\section Use_CppRestSdk How to use the CppRestSdk Module + +You can use the CppRestSdk from two different perspectives in MITK: + +
    +
  1. The Server view (receive Requests from clients) +
  2. The Client view (send Requests to servers) +
+ +The following sections will give you an introduction on how to use which of those roles: + +\subsection Server_Use Use from a Server perspective +To act as a server, you need to implement the IRESTObserver, which has a Notify() method that has to be implemented. +In this Notify() method you specify how you want to react to incoming requests and with which data you want to respond to the requests. + +You can then start listening for requests from clients as shown below: + +\code{.cpp} +auto *context = us::GetModuleContext(); + auto managerRef = context->GetServiceReference(); + if (managerRef) + { + auto managerService = context->GetService(managerRef); + if (managerService) + { + managerService->ReceiveRequests(uri /*specify your uri which you want to receive requests for*/, this); + } + } +\endcode + +If a client sends a request, the Notify method is called and a response is sent. By now, only Get-requests from clients are supported. + +If you want to stop listening for requests you can do this by calling + +\code{.cpp} +auto *context = us::GetModuleContext(); + auto managerRef = context->GetServiceReference(); + if (managerRef) + { + auto managerService = context->GetService(managerRef); + if (managerService) + { + managerService->HandleDeleteObserver(this, uri); + } + } +\endcode + +You don't have to specify a uri in the HandleDeleteObserver method, if you only call managerService->HandleDeleteObserver(this);, all uris you receive requests for are deleted and you aren't listening to any requests anymore. + +\subsection Client_Use Use from a Client perspective + +The following example shows how to send requests from a client perspective: + +\code{.cpp} + //Get the microservice + auto *context = us::ModuleRegistry::GetModule(1)->GetModuleContext(); + auto managerRef = context->GetServiceReference(); + if (managerRef) + { + auto managerService = context->GetService(managerRef); + if (managerService) + { + //Call the send request method which starts the actual request + managerService + ->SendRequest(L"https://jsonplaceholder.typicode.com/posts/1") + .then([=](pplx::task resultTask)/*It is important to use task-based continuation*/ { + try + { + //Get the result of the request + //This will throw an exception if the ascendent task threw an exception (e.g. invalid URI) + web::json::value result = resultTask.get(); + //Do something with the result (e.g. convert it to a QString to update an UI element) + utility::string_t stringT = result.to_string(); + std::string stringStd(stringT.begin(), stringT.end()); + QString stringQ = QString::fromStdString(stringStd); + //Note: if you want to update your UI, do this by using signals and slots. + //The UI can't be updated from a Thread different to the Qt main thread + emit UpdateLabel(stringQ); + } + catch (const mitk::Exception &exception) + { + //Exceptions from ascendent tasks are catched here + MITK_ERROR << exception.what(); + return; + } + }); + } + } +\endcode + +The steps you need to make are the following: +
    +
  1. Get the microservice. You can get the microservice via the module context. If you want to use the microservice within a plug-in, you need to get the module context from the us::ModuleRegistry. +
  2. Call the SendRequest method. This will start the request itself and is performed asynchronously. As soon as the response is sent by the server, the .then(...) block is executed. +
  3. Choose parameters for .then(...) block. For exception handling, it is important to choose pplx::task . This is a task-based continuation. + For more information, visit https://docs.microsoft.com/en-us/cpp/parallel/concrt/exception-handling-in-the-concurrency-runtime?view=vs-2017. +
  4. Get the result of the request. You can get the JSON-value of the result by callint .get(). At this point, an exception is thrown if something in the previous tasks threw an exception. +
  5. Do something with the result. + \note If you want to modify GUI elements within the .then(...) block, you need to do this by using signals and slots because GUI elements can only be modified by th Qt Main Thread. + For more information, visit https://doc.qt.io/Qt-5/thread-basics.html#gui-thread-and-worker-thread +
  6. Exception handling. Here you can define the behaviour if an exception is thrown, exceptions from ascendent tasks are also catched here. +
+ +Code, which is followed by this codeblock shown above will be performed asynchronously while waiting for the result. +Besides Get-Requests, you can also perform Put or Post requests by specifying a RequestType in the SendRequest method. + +The following example shows, how you can perform multiple tasks, encapsulated to one joined task. The steps are based on the example for one request and only the specific steps for encapsulation are described. + +\code{.cpp} + //Get the microservice + //Get microservice + auto *context = us::ModuleRegistry::GetModule(1)->GetModuleContext(); + auto managerRef = context->GetServiceReference(); + if (managerRef) + { + auto managerService = context->GetService(managerRef); + if (managerService) + { + //Create multiple tasks e.g. as shown below + std::vector> tasks; + for (int i = 0; i < 20; i++) + { + pplx::task singleTask = managerService->SendRequest(L"https://jsonplaceholder.typicode.com/posts/1") + .then([=](pplx::task resultTask) { + //Do something when a single task is done + try + { + resultTask.get(); + emit UpdateProgressBar(); + } + catch (const mitk::Exception &exception) + { + MITK_ERROR << exception.what(); + return; + } + }); + tasks.emplace_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 resultTask) { + //Do something when all tasks are finished + try + { + resultTask.get(); + emit UpdateLabel("All tasks finished"); + } + catch (const mitk::Exception &exception) + { + MITK_ERROR << exception.what(); + return; + } + }); + } +\endcode + +The steps you need to make are the following: +
    +
  1. Get the microservice. See example above. +
  2. Create multiple tasks. In this example, 20 identical tasks are created and are saved into a vector. In general, it is possible to place any tasks in that vector. +
  3. Do something when a single task is done. Here, an action is performed if a single tasks is finished. In this example, a progress bar is loaded by a specific number of percent. +
  4. Create a joinTask. Here, all small tasks are encapsulated in one big task. +
  5. Run joinTask asynchonously. The then(...) of the joinTask is performed when all single tasks are finished. +
  6. Do something when all tasks are finished. The handling of the end of a joinTask is equivalent to the end of a single tasks. +
+ +*/ \ No newline at end of file