diff --git a/Modules/DICOMweb/src/mitkDICOMweb.cpp b/Modules/DICOMweb/src/mitkDICOMweb.cpp
index a7ec34f47a..47e2399c53 100644
--- a/Modules/DICOMweb/src/mitkDICOMweb.cpp
+++ b/Modules/DICOMweb/src/mitkDICOMweb.cpp
@@ -1,218 +1,218 @@
 /*===================================================================
 
 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 "mitkDICOMweb.h"
 
 mitk::DICOMweb::DICOMweb() {}
 
 mitk::DICOMweb::DICOMweb(utility::string_t baseURI) : m_BaseURI(baseURI)
 {
   MITK_INFO << "base uri: " << mitk::RESTUtil::convertToUtf8(m_BaseURI);
   InitializeRESTManager();
 }
 
 utility::string_t mitk::DICOMweb::CreateQIDOUri(mitk::RESTUtil::ParamMap map)
 {
   MitkUriBuilder queryBuilder(m_BaseURI + U("rs/instances"));
 
   for (auto const &element : map)
   {
     queryBuilder.append_query(element.first, element.second);
   }
 
   return queryBuilder.to_string();
 }
 
 utility::string_t mitk::DICOMweb::CreateWADOUri(utility::string_t studyUID,
                                           utility::string_t seriesUID,
                                           utility::string_t instanceUID)
 {
   MitkUriBuilder builder(m_BaseURI + U("wado"));
   builder.append_query(U("requestType"), U("WADO"));
   builder.append_query(U("studyUID"), studyUID);
   builder.append_query(U("seriesUID"), seriesUID);
   builder.append_query(U("objectUID"), instanceUID);
   builder.append_query(U("contentType"), U("application/dicom"));
 
   return builder.to_string();
 }
 
 utility::string_t mitk::DICOMweb::CreateSTOWUri(utility::string_t studyUID)
 {
   MitkUriBuilder builder(m_BaseURI + U("rs/studies"));
   builder.append_path(studyUID);
   return builder.to_string();
 }
 
 pplx::task<void> mitk::DICOMweb::SendSTOW(utility::string_t filePath, utility::string_t studyUID)
 {
   auto uri = CreateSTOWUri(studyUID);
 
   // this is the working stow-rs request which supports just one dicom file packed into a multipart message
   std::ifstream input(filePath, std::ios::binary);
   if (!input)
   {
     MITK_WARN << "could not read file to POST";
     return pplx::task<void>();
   }
 
   std::vector<unsigned char> result;
   std::vector<unsigned char> buffer;
 
   // Stop eating new lines in binary mode!!!
   input.unsetf(std::ios::skipws);
   
   input.seekg(0, std::ios::end);
   const std::streampos fileSize = input.tellg();
   input.seekg(0, std::ios::beg);
 
   MITK_INFO << fileSize << " bytes will be sent.";
   buffer.reserve(fileSize); // file size
   std::copy(
     std::istream_iterator<unsigned char>(input), std::istream_iterator<unsigned char>(), std::back_inserter(buffer));
 
   // in future more than one file should also be supported..
   std::string head = "";
   head += "\r\n--boundary";
   head += "\r\nContent-Type: " + mitk::RESTUtil::convertToUtf8(U("application/dicom")) + "\r\n\r\n";
 
   std::vector<unsigned char> bodyVector(head.begin(), head.end());
 
   std::string tail = "";
   tail += "\r\n--boundary--";
 
   result.insert(result.end(), bodyVector.begin(), bodyVector.end());
   result.insert(result.end(), buffer.begin(), buffer.end());
   result.insert(result.end(), tail.begin(), tail.end());
 
   mitk::RESTUtil::ParamMap headers;
   headers.insert(mitk::RESTUtil::ParamMap::value_type(
     U("Content-Type"), U("multipart/related; type=\"application/dicom\"; boundary=boundary")));
 
   try
   {
     return m_RESTManager->SendRequest(uri, mitk::IRESTManager::RequestType::Post, &result, headers)
       .then([=](web::json::value result) {
         MITK_INFO << "after send";
-        MITK_INFO << mitk::RESTUtil::convertToUtf8(result.to_string());
+        MITK_INFO << mitk::RESTUtil::convertToUtf8(result.serialize());
         result.is_null();
       });
   }
   catch (std::exception &e)
   {
     MITK_WARN << e.what();
   }
 
   return pplx::task<void>();
 }
 
 pplx::task<void> mitk::DICOMweb::SendWADO(utility::string_t filePath,
                                     utility::string_t studyUID,
                                     utility::string_t seriesUID,
                                     utility::string_t instanceUID)
 {
   auto uri = CreateWADOUri(studyUID, seriesUID, instanceUID);
 
   // don't want return something
   auto content = web::json::value();
   return m_RESTManager->SendRequest(uri, mitk::IRESTManager::RequestType::Get, &content, {}, filePath)
     .then([=](web::json::value result) {
       result.is_null();
 
     });
 }
 
 pplx::task<std::string> mitk::DICOMweb::SendWADO(utility::string_t folderPath,
                                            utility::string_t studyUID,
                                            utility::string_t seriesUID)
 {
   mitk::RESTUtil::ParamMap seriesInstances;
   seriesInstances.insert(mitk::RESTUtil::ParamMap::value_type(U("StudyInstanceUID"), studyUID));
   seriesInstances.insert(mitk::RESTUtil::ParamMap::value_type(U("SeriesInstanceUID"), seriesUID));
 
   return SendQIDO(seriesInstances).then([=](web::json::value jsonResult) -> pplx::task<std::string> {
     auto jsonListResult = jsonResult;
     auto resultArray = jsonListResult.as_array();
 
     auto firstFileName = std::string();
 
     std::vector<pplx::task<void>> tasks;
 
     for (unsigned short i = 0; i < resultArray.size(); i++)
     {
       try
       {
         auto firstResult = resultArray[i];
         auto sopInstanceUIDKey = firstResult.at(U("00080018"));
         auto sopInstanceObject = sopInstanceUIDKey.as_object();
         auto valueKey = sopInstanceObject.at(U("Value"));
         auto valueArray = valueKey.as_array();
         auto sopInstanceUID = valueArray[0].as_string();
 
         auto fileName = utility::string_t(sopInstanceUID).append(U(".dcm"));
 
         // save first file name as result to load series
         if (i == 0)
         {
           firstFileName = utility::conversions::to_utf8string(fileName);
         }
 
         auto filePath = utility::string_t(folderPath).append(fileName);
         auto task = SendWADO(filePath, studyUID, seriesUID, sopInstanceUID);
         tasks.push_back(task);
       }
       catch (const web::json::json_exception &e)
       {
         MITK_ERROR << e.what();
       }
     }
 
     auto joinTask = pplx::when_all(begin(tasks), end(tasks));
 
     auto returnTask = joinTask.then([=](void) -> std::string {
       auto folderPathUtf8 = utility::conversions::to_utf8string(folderPath);
       auto result = folderPathUtf8 + firstFileName;
 
       return result;
     });
 
     return returnTask;
   });
 }
 
 pplx::task<web::json::value> mitk::DICOMweb::SendQIDO(mitk::RESTUtil::ParamMap map)
 {
   auto uri = CreateQIDOUri(map);
 
   mitk::RESTUtil::ParamMap headers;
   headers.insert(mitk::RESTUtil::ParamMap::value_type(U("Accept"), U("application/json")));
   auto content = web::json::value();
   return m_RESTManager->SendRequest(uri, mitk::IRESTManager::RequestType::Get, &content, headers);
 }
 
 void mitk::DICOMweb::InitializeRESTManager()
 {
   auto *context = us::GetModuleContext();
   auto managerRef = context->GetServiceReference<mitk::IRESTManager>();
   if (managerRef)
   {
     auto managerService = context->GetService(managerRef);
     if (managerService)
     {
       m_RESTManager = managerService;
     }
   }
 }