orthanc-authorization: Resources/Orthanc/Plugins/OrthancPluginCppWrapper.cpp comparison

comparison Resources/Orthanc/Plugins/OrthancPluginCppWrapper.cpp @ 69:af44dce56328

new 'auth/user-profile' Rest API route

author	Alain Mazy <am@osimis.io>
date	Mon, 20 Feb 2023 11:56:14 +0100
parents	1a13c4fbc9a1
children	30fb3ce960d9

comparison

equal deleted inserted replaced

-:1a13c4fbc9a1
+:af44dce56328
 /**
 * Orthanc - A Lightweight, RESTful DICOM Store
 * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics
 * Department, University Hospital of Liege, Belgium
-* Copyright (C) 2017-2023 Osimis S.A., Belgium
+* Copyright (C) 2017-2022 Osimis S.A., Belgium
+* Copyright (C) 2021-2022 Sebastien Jodogne, ICTEAM UCLouvain, Belgium
 *
 * This program is free software: you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 {
 return CheckHttp(OrthancPluginRestApiGet(GetGlobalContext(), &buffer_, uri.c_str()));
 }
 }
+// helper class to convert std::map of headers to the plugin SDK C structure
+class PluginHttpHeaders
+{
+std::vector<const char*> headersKeys_;
+std::vector<const char*> headersValues_;
+public:
+PluginHttpHeaders(const std::map<std::string, std::string>& httpHeaders)
+{
+for (std::map<std::string, std::string>::const_iterator
+it = httpHeaders.begin(); it != httpHeaders.end(); it++)
+{
+headersKeys_.push_back(it->first.c_str());
+headersValues_.push_back(it->second.c_str());
+}
+}
+const char* const* GetKeys()
+{
+return (headersKeys_.empty() ? NULL : &headersKeys_[0]);
+}
+const char* const* GetValues()
+{
+return (headersValues_.empty() ? NULL : &headersValues_[0]);
+}
+uint32_t GetSize()
+{
+return static_cast<uint32_t>(headersKeys_.size());
+}
+};
 bool MemoryBuffer::RestApiGet(const std::string& uri,
 const std::map<std::string, std::string>& httpHeaders,
 bool applyPlugins)
 {
 Clear();
-std::vector<const char*> headersKeys;
+PluginHttpHeaders headers(httpHeaders);
-std::vector<const char*> headersValues;
-for (std::map<std::string, std::string>::const_iterator
-it = httpHeaders.begin(); it != httpHeaders.end(); it++)
-{
-headersKeys.push_back(it->first.c_str());
-headersValues.push_back(it->second.c_str());
-}
 return CheckHttp(OrthancPluginRestApiGet2(
-GetGlobalContext(), &buffer_, uri.c_str(), httpHeaders.size(),
+GetGlobalContext(), &buffer_, uri.c_str(),
-(headersKeys.empty() ? NULL : &headersKeys[0]),
+headers.GetSize(),
-(headersValues.empty() ? NULL : &headersValues[0]), applyPlugins));
+headers.GetKeys(),
+headers.GetValues(), applyPlugins));
 }
 bool MemoryBuffer::RestApiPost(const std::string& uri,
 const void* body,
 size_t bodySize,
 {
 return CheckHttp(OrthancPluginRestApiPost(GetGlobalContext(), &buffer_, uri.c_str(), b, bodySize));
 }
 }
+#if HAS_ORTHANC_PLUGIN_GENERIC_CALL_REST_API == 1
+bool MemoryBuffer::RestApiPost(const std::string& uri,
+const void* body,
+size_t bodySize,
+const std::map<std::string, std::string>& httpHeaders,
+bool applyPlugins)
+{
+MemoryBuffer answerHeaders;
+uint16_t httpStatus;
+PluginHttpHeaders headers(httpHeaders);
+return CheckHttp(OrthancPluginCallRestApi(GetGlobalContext(),
+&buffer_,
+*answerHeaders,
+&httpStatus,
+OrthancPluginHttpMethod_Post,
+uri.c_str(),
+headers.GetSize(), headers.GetKeys(), headers.GetValues(),
+body, bodySize,
+applyPlugins));
+}
+bool MemoryBuffer::RestApiPost(const std::string& uri,
+const Json::Value& body,
+const std::map<std::string, std::string>& httpHeaders,
+bool applyPlugins)
+{
+std::string s;
+WriteFastJson(s, body);
+return RestApiPost(uri, s.c_str(), s.size(), httpHeaders, applyPlugins);
+}
+#endif
 bool MemoryBuffer::RestApiPut(const std::string& uri,
 const void* body,
 size_t bodySize,
 bool applyPlugins)
 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat);
 }
 }
+void OrthancString::ToJsonWithoutComments(Json::Value& target) const
+{
+if (str_ == NULL)
+{
+LogError("Cannot convert an empty memory buffer to JSON");
+ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError);
+}
+if (!ReadJsonWithoutComments(target, str_))
+{
+LogError("Cannot convert some memory buffer to JSON");
+ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat);
+}
+}
 void MemoryBuffer::DicomToJson(Json::Value& target,
 OrthancPluginDicomToJsonFormat format,
 OrthancPluginDicomToJsonFlags flags,
 uint32_t maxStringLength)
 {
 const std::string& body,
 const std::string& username,
 const std::string& password)
 {
 Clear();
+if (body.size() > 0xffffffffu)
+{
+LogError("Cannot handle body size > 4GB");
+ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError);
+}
 return CheckHttp(OrthancPluginHttpPost(GetGlobalContext(), &buffer_, url.c_str(),
 body.c_str(), body.size(),
 username.empty() ? NULL : username.c_str(),
 password.empty() ? NULL : password.c_str()));
 }
 const std::string& body,
 const std::string& username,
 const std::string& password)
 {
 Clear();
+if (body.size() > 0xffffffffu)
+{
+LogError("Cannot handle body size > 4GB");
+ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError);
+}
 return CheckHttp(OrthancPluginHttpPut(GetGlobalContext(), &buffer_, url.c_str(),
 body.empty() ? NULL : body.c_str(),
 body.size(),
 username.empty() ? NULL : username.c_str(),
 password.empty() ? NULL : password.c_str()));
 {
 LogError("Cannot access the Orthanc configuration");
 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError);
 }
-str.ToJson(configuration_);
+str.ToJsonWithoutComments(configuration_);
 if (configuration_.type() != Json::objectValue)
 {
 LogError("Unable to read the Orthanc configuration");
 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError);
 }
 return true;
 }
 }
+#if HAS_ORTHANC_PLUGIN_GENERIC_CALL_REST_API == 1
+bool RestApiPost(Json::Value& result,
+const std::string& uri,
+const Json::Value& body,
+const std::map<std::string, std::string>& httpHeaders,
+bool applyPlugins)
+{
+MemoryBuffer answer;
+if (!answer.RestApiPost(uri, body, httpHeaders, applyPlugins))
+{
+return false;
+}
+else
+{
+if (!answer.IsEmpty())
+{
+answer.ToJson(result);
+}
+return true;
+}
+}
+#endif
 bool RestApiPost(Json::Value& result,
 const std::string& uri,
 const Json::Value& body,
 bool applyPlugins)
 boost::lexical_cast<std::string>(minor) + "." +
 boost::lexical_cast<std::string>(revision) +
 " is required)");
 }
+bool CheckMinimalVersion(const char* version,
-bool CheckMinimalOrthancVersion(unsigned int major,
+unsigned int major,
 unsigned int minor,
 unsigned int revision)
 {
-if (!HasGlobalContext())
+if (!strcmp(version, "mainline"))
-{
-LogError("Bad Orthanc context in the plugin");
-return false;
-}
-if (!strcmp(GetGlobalContext()->orthancVersion, "mainline"))
 {
 // Assume compatibility with the mainline
 return true;
 }
-// Parse the version of the Orthanc core
+// Parse the version
 int aa, bb, cc;
 if (
 #ifdef _MSC_VER
 sscanf_s
 #else
 sscanf
 #endif
-(GetGlobalContext()->orthancVersion, "%4d.%4d.%4d", &aa, &bb, &cc) != 3 ||
+(version, "%4d.%4d.%4d", &aa, &bb, &cc) != 3 ||
 aa < 0 ||
 bb < 0 ||
 cc < 0)
 {
 return false;
 if (a < major)
 {
 return false;
 }
 // Check the minor version number
 assert(a == major);
 if (b > minor)
 {
 }
 else
 {
 return false;
 }
+}
+bool CheckMinimalOrthancVersion(unsigned int major,
+unsigned int minor,
+unsigned int revision)
+{
+if (!HasGlobalContext())
+{
+LogError("Bad Orthanc context in the plugin");
+return false;
+}
+return CheckMinimalVersion(GetGlobalContext()->orthancVersion,
+major, minor, revision);
 }
 #if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 5, 0)
 const char* AutodetectMimeType(const std::string& path)
 }
 bool OrthancPeers::DoGet(MemoryBuffer& target,
 size_t index,
-const std::string& uri) const
+const std::string& uri,
+const std::map<std::string, std::string>& headers) const
 {
 if (index >= index_.size())
 {
 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_ParameterOutOfRange);
 }
 OrthancPlugins::MemoryBuffer answer;
 uint16_t status;
+PluginHttpHeaders pluginHeaders(headers);
 OrthancPluginErrorCode code = OrthancPluginCallPeerApi
 (GetGlobalContext(), *answer, NULL, &status, peers_,
 static_cast<uint32_t>(index), OrthancPluginHttpMethod_Get, uri.c_str(),
-0, NULL, NULL, NULL, 0, timeout_);
+pluginHeaders.GetSize(), pluginHeaders.GetKeys(), pluginHeaders.GetValues(), NULL, 0, timeout_);
 if (code == OrthancPluginErrorCode_Success)
 {
 target.Swap(answer);
 return (status == 200);
 }
 bool OrthancPeers::DoGet(MemoryBuffer& target,
 const std::string& name,
-const std::string& uri) const
+const std::string& uri,
+const std::map<std::string, std::string>& headers) const
 {
 size_t index;
 return (LookupName(index, name) &&
-DoGet(target, index, uri));
+DoGet(target, index, uri, headers));
 }
 bool OrthancPeers::DoGet(Json::Value& target,
 size_t index,
-const std::string& uri) const
+const std::string& uri,
+const std::map<std::string, std::string>& headers) const
 {
 MemoryBuffer buffer;
-if (DoGet(buffer, index, uri))
+if (DoGet(buffer, index, uri, headers))
 {
 buffer.ToJson(target);
 return true;
 }
 else
 }
 bool OrthancPeers::DoGet(Json::Value& target,
 const std::string& name,
-const std::string& uri) const
+const std::string& uri,
+const std::map<std::string, std::string>& headers) const
 {
 MemoryBuffer buffer;
-if (DoGet(buffer, name, uri))
+if (DoGet(buffer, name, uri, headers))
 {
 buffer.ToJson(target);
 return true;
 }
 else
 bool OrthancPeers::DoPost(MemoryBuffer& target,
 const std::string& name,
 const std::string& uri,
-const std::string& body) const
+const std::string& body,
+const std::map<std::string, std::string>& headers) const
 {
 size_t index;
 return (LookupName(index, name) &&
-DoPost(target, index, uri, body));
+DoPost(target, index, uri, body, headers));
 }
 bool OrthancPeers::DoPost(Json::Value& target,
 size_t index,
 const std::string& uri,
-const std::string& body) const
+const std::string& body,
+const std::map<std::string, std::string>& headers) const
 {
 MemoryBuffer buffer;
-if (DoPost(buffer, index, uri, body))
+if (DoPost(buffer, index, uri, body, headers))
 {
 buffer.ToJson(target);
 return true;
 }
 else
 bool OrthancPeers::DoPost(Json::Value& target,
 const std::string& name,
 const std::string& uri,
-const std::string& body) const
+const std::string& body,
+const std::map<std::string, std::string>& headers) const
 {
 MemoryBuffer buffer;
-if (DoPost(buffer, name, uri, body))
+if (DoPost(buffer, name, uri, body, headers))
 {
 buffer.ToJson(target);
 return true;
 }
 else
 bool OrthancPeers::DoPost(MemoryBuffer& target,
 size_t index,
 const std::string& uri,
-const std::string& body) const
+const std::string& body,
+const std::map<std::string, std::string>& headers) const
 {
 if (index >= index_.size())
 {
 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_ParameterOutOfRange);
+}
+if (body.size() > 0xffffffffu)
+{
+LogError("Cannot handle body size > 4GB");
+ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError);
 }
 OrthancPlugins::MemoryBuffer answer;
 uint16_t status;
+PluginHttpHeaders pluginHeaders(headers);
 OrthancPluginErrorCode code = OrthancPluginCallPeerApi
 (GetGlobalContext(), *answer, NULL, &status, peers_,
 static_cast<uint32_t>(index), OrthancPluginHttpMethod_Post, uri.c_str(),
-0, NULL, NULL, body.empty() ? NULL : body.c_str(), body.size(), timeout_);
+pluginHeaders.GetSize(), pluginHeaders.GetKeys(), pluginHeaders.GetValues(), body.empty() ? NULL : body.c_str(), body.size(), timeout_);
 if (code == OrthancPluginErrorCode_Success)
 {
 target.Swap(answer);
 return (status == 200);
 }
 bool OrthancPeers::DoPut(size_t index,
 const std::string& uri,
-const std::string& body) const
+const std::string& body,
+const std::map<std::string, std::string>& headers) const
 {
 if (index >= index_.size())
 {
 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_ParameterOutOfRange);
+}
+if (body.size() > 0xffffffffu)
+{
+LogError("Cannot handle body size > 4GB");
+ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError);
 }
 OrthancPlugins::MemoryBuffer answer;
 uint16_t status;
+PluginHttpHeaders pluginHeaders(headers);
 OrthancPluginErrorCode code = OrthancPluginCallPeerApi
 (GetGlobalContext(), *answer, NULL, &status, peers_,
 static_cast<uint32_t>(index), OrthancPluginHttpMethod_Put, uri.c_str(),
-0, NULL, NULL, body.empty() ? NULL : body.c_str(), body.size(), timeout_);
+pluginHeaders.GetSize(), pluginHeaders.GetKeys(), pluginHeaders.GetValues(), body.empty() ? NULL : body.c_str(), body.size(), timeout_);
 if (code == OrthancPluginErrorCode_Success)
 {
 return (status == 200);
 }
 }
 bool OrthancPeers::DoPut(const std::string& name,
 const std::string& uri,
-const std::string& body) const
+const std::string& body,
+const std::map<std::string, std::string>& headers) const
 {
 size_t index;
 return (LookupName(index, name) &&
-DoPut(index, uri, body));
+DoPut(index, uri, body, headers));
 }
 bool OrthancPeers::DoDelete(size_t index,
-const std::string& uri) const
+const std::string& uri,
+const std::map<std::string, std::string>& headers) const
 {
 if (index >= index_.size())
 {
 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_ParameterOutOfRange);
 }
 OrthancPlugins::MemoryBuffer answer;
 uint16_t status;
+PluginHttpHeaders pluginHeaders(headers);
 OrthancPluginErrorCode code = OrthancPluginCallPeerApi
 (GetGlobalContext(), *answer, NULL, &status, peers_,
 static_cast<uint32_t>(index), OrthancPluginHttpMethod_Delete, uri.c_str(),
-0, NULL, NULL, NULL, 0, timeout_);
+pluginHeaders.GetSize(), pluginHeaders.GetKeys(), pluginHeaders.GetValues(), NULL, 0, timeout_);
 if (code == OrthancPluginErrorCode_Success)
 {
 return (status == 200);
 }
 }
 }
 bool OrthancPeers::DoDelete(const std::string& name,
-const std::string& uri) const
+const std::string& uri,
+const std::map<std::string, std::string>& headers) const
 {
 size_t index;
 return (LookupName(index, name) &&
-DoDelete(index, uri));
+DoDelete(index, uri, headers));
 }
 #endif
 return 0;
 }
 }
+#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 11, 3)
+static OrthancPluginErrorCode CopyStringToMemoryBuffer(OrthancPluginMemoryBuffer* target,
+const std::string& source)
+{
+if (OrthancPluginCreateMemoryBuffer(globalContext_, target, source.size()) != OrthancPluginErrorCode_Success)
+{
+return OrthancPluginErrorCode_NotEnoughMemory;
+}
+else
+{
+if (!source.empty())
+{
+memcpy(target->data, source.c_str(), source.size());
+}
+return OrthancPluginErrorCode_Success;
+}
+}
+#endif
+#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 11, 3)
+OrthancPluginErrorCode OrthancJob::CallbackGetContent(OrthancPluginMemoryBuffer* target,
+void* job)
+{
+assert(job != NULL);
+OrthancJob& that = *reinterpret_cast<OrthancJob*>(job);
+return CopyStringToMemoryBuffer(target, that.content_);
+}
+#else
 const char* OrthancJob::CallbackGetContent(void* job)
 {
 assert(job != NULL);
 try
 catch (...)
 {
 return 0;
 }
 }
+#endif
+#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 11, 3)
+int32_t OrthancJob::CallbackGetSerialized(OrthancPluginMemoryBuffer* target,
+void* job)
+{
+assert(job != NULL);
+OrthancJob& that = *reinterpret_cast<OrthancJob*>(job);
+if (that.hasSerialized_)
+{
+if (CopyStringToMemoryBuffer(target, that.serialized_) == OrthancPluginErrorCode_Success)
+{
+return 1;
+}
+else
+{
+return -1;
+}
+}
+else
+{
+return 0;
+}
+}
+#else
 const char* OrthancJob::CallbackGetSerialized(void* job)
 {
 assert(job != NULL);
 try
 catch (...)
 {
 return 0;
 }
 }
+#endif
 OrthancPluginJobStepStatus OrthancJob::CallbackStep(void* job)
 {
 assert(job != NULL);
 if (job == NULL)
 {
 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_NullPointer);
 }
-OrthancPluginJob* orthanc = OrthancPluginCreateJob(
+OrthancPluginJob* orthanc =
-GetGlobalContext(), job, CallbackFinalize, job->jobType_.c_str(),
+#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 11, 3)
-CallbackGetProgress, CallbackGetContent, CallbackGetSerialized,
+OrthancPluginCreateJob2
-CallbackStep, CallbackStop, CallbackReset);
+#else
+OrthancPluginCreateJob
+#endif
+(GetGlobalContext(), job, CallbackFinalize, job->jobType_.c_str(),
+CallbackGetProgress, CallbackGetContent, CallbackGetSerialized,
+CallbackStep, CallbackStop, CallbackReset);
 if (orthanc == NULL)
 {
 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_Plugin);
 }
 {
 return static_cast<OrthancPluginErrorCode>(e.GetErrorCode());
 }
 catch (...)
 {
-return OrthancPluginErrorCode_InternalError;
+return OrthancPluginErrorCode_Plugin;
 }
 }
 }
 };
 }
 void HttpClient::ClearCredentials()
 {
-username_.empty();
+username_.clear();
-password_.empty();
+password_.clear();
 }
 void HttpClient::SetCertificate(const std::string& certificateFile,
 const std::string& keyFile,
 {
 HeadersWrapper headers(headers_);
 MemoryBuffer answerBodyBuffer, answerHeadersBuffer;
+if (body.size() > 0xffffffffu)
+{
+LogError("Cannot handle body size > 4GB");
+ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError);
+}
 OrthancPluginErrorCode error = OrthancPluginHttpClient(
 GetGlobalContext(),
 *answerBodyBuffer,
 *answerHeadersBuffer,
 &httpStatus,
 result->toFree_ = true;
 return result.release();
 }
 }
 #endif
+#if HAS_ORTHANC_PLUGIN_WEBDAV == 1
+static std::vector<std::string> WebDavConvertPath(uint32_t pathSize,
+const char* const*  pathItems)
+{
+std::vector<std::string> result(pathSize);
+for (uint32_t i = 0; i < pathSize; i++)
+{
+result[i] = pathItems[i];
+}
+return result;
+}
+#endif
+#if HAS_ORTHANC_PLUGIN_WEBDAV == 1
+static OrthancPluginErrorCode WebDavIsExistingFolder(uint8_t*            isExisting,
+uint32_t            pathSize,
+const char* const*  pathItems,
+void*               payload)
+{
+IWebDavCollection& that = *reinterpret_cast<IWebDavCollection*>(payload);
+try
+{
+*isExisting = (that.IsExistingFolder(WebDavConvertPath(pathSize, pathItems)) ? 1 : 0);
+return OrthancPluginErrorCode_Success;
+}
+catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e)
+{
+return static_cast<OrthancPluginErrorCode>(e.GetErrorCode());
+}
+catch (...)
+{
+return OrthancPluginErrorCode_Plugin;
+}
+}
+#endif
+#if HAS_ORTHANC_PLUGIN_WEBDAV == 1
+static OrthancPluginErrorCode WebDavListFolder(uint8_t*                        isExisting,
+OrthancPluginWebDavCollection*  collection,
+OrthancPluginWebDavAddFile      addFile,
+OrthancPluginWebDavAddFolder    addFolder,
+uint32_t                        pathSize,
+const char* const*              pathItems,
+void*                           payload)
+{
+IWebDavCollection& that = *reinterpret_cast<IWebDavCollection*>(payload);
+try
+{
+std::list<IWebDavCollection::FileInfo> files;
+std::list<IWebDavCollection::FolderInfo> subfolders;
+if (!that.ListFolder(files, subfolders, WebDavConvertPath(pathSize, pathItems)))
+{
+*isExisting = 0;
+}
+else
+{
+*isExisting = 1;
+for (std::list<IWebDavCollection::FileInfo>::const_iterator
+it = files.begin(); it != files.end(); ++it)
+{
+OrthancPluginErrorCode code = addFile(
+collection, it->GetName().c_str(), it->GetContentSize(),
+it->GetMimeType().c_str(), it->GetDateTime().c_str());
+if (code != OrthancPluginErrorCode_Success)
+{
+return code;
+}
+}
+for (std::list<IWebDavCollection::FolderInfo>::const_iterator it =
+subfolders.begin(); it != subfolders.end(); ++it)
+{
+OrthancPluginErrorCode code = addFolder(
+collection, it->GetName().c_str(), it->GetDateTime().c_str());
+if (code != OrthancPluginErrorCode_Success)
+{
+return code;
+}
+}
+}
+return OrthancPluginErrorCode_Success;
+}
+catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e)
+{
+return static_cast<OrthancPluginErrorCode>(e.GetErrorCode());
+}
+catch (...)
+{
+return OrthancPluginErrorCode_Plugin;
+}
+}
+#endif
+#if HAS_ORTHANC_PLUGIN_WEBDAV == 1
+static OrthancPluginErrorCode WebDavRetrieveFile(OrthancPluginWebDavCollection*   collection,
+OrthancPluginWebDavRetrieveFile  retrieveFile,
+uint32_t                         pathSize,
+const char* const*               pathItems,
+void*                            payload)
+{
+IWebDavCollection& that = *reinterpret_cast<IWebDavCollection*>(payload);
+try
+{
+std::string content, mime, dateTime;
+if (that.GetFile(content, mime, dateTime, WebDavConvertPath(pathSize, pathItems)))
+{
+return retrieveFile(collection, content.empty() ? NULL : content.c_str(),
+content.size(), mime.c_str(), dateTime.c_str());
+}
+else
+{
+// Inexisting file
+return OrthancPluginErrorCode_Success;
+}
+}
+catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e)
+{
+return static_cast<OrthancPluginErrorCode>(e.GetErrorCode());
+}
+catch (...)
+{
+return OrthancPluginErrorCode_InternalError;
+}
+}
+#endif
+#if HAS_ORTHANC_PLUGIN_WEBDAV == 1
+static OrthancPluginErrorCode WebDavStoreFileCallback(uint8_t*            isReadOnly, /* out */
+uint32_t            pathSize,
+const char* const*  pathItems,
+const void*         data,
+uint64_t            size,
+void*               payload)
+{
+IWebDavCollection& that = *reinterpret_cast<IWebDavCollection*>(payload);
+try
+{
+if (static_cast<uint64_t>(static_cast<size_t>(size)) != size)
+{
+ORTHANC_PLUGINS_THROW_EXCEPTION(NotEnoughMemory);
+}
+*isReadOnly = (that.StoreFile(WebDavConvertPath(pathSize, pathItems), data,
+static_cast<size_t>(size)) ? 1 : 0);
+return OrthancPluginErrorCode_Success;
+}
+catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e)
+{
+return static_cast<OrthancPluginErrorCode>(e.GetErrorCode());
+}
+catch (...)
+{
+return OrthancPluginErrorCode_InternalError;
+}
+}
+#endif
+#if HAS_ORTHANC_PLUGIN_WEBDAV == 1
+static OrthancPluginErrorCode WebDavCreateFolderCallback(uint8_t*            isReadOnly, /* out */
+uint32_t            pathSize,
+const char* const*  pathItems,
+void*               payload)
+{
+IWebDavCollection& that = *reinterpret_cast<IWebDavCollection*>(payload);
+try
+{
+*isReadOnly = (that.CreateFolder(WebDavConvertPath(pathSize, pathItems)) ? 1 : 0);
+return OrthancPluginErrorCode_Success;
+}
+catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e)
+{
+return static_cast<OrthancPluginErrorCode>(e.GetErrorCode());
+}
+catch (...)
+{
+return OrthancPluginErrorCode_InternalError;
+}
+}
+#endif
+#if HAS_ORTHANC_PLUGIN_WEBDAV == 1
+static OrthancPluginErrorCode WebDavDeleteItemCallback(uint8_t*            isReadOnly, /* out */
+uint32_t            pathSize,
+const char* const*  pathItems,
+void*               payload)
+{
+IWebDavCollection& that = *reinterpret_cast<IWebDavCollection*>(payload);
+try
+{
+*isReadOnly = (that.DeleteItem(WebDavConvertPath(pathSize, pathItems)) ? 1 : 0);
+return OrthancPluginErrorCode_Success;
+}
+catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e)
+{
+return static_cast<OrthancPluginErrorCode>(e.GetErrorCode());
+}
+catch (...)
+{
+return OrthancPluginErrorCode_InternalError;
+}
+}
+#endif
+#if HAS_ORTHANC_PLUGIN_WEBDAV == 1
+void IWebDavCollection::Register(const std::string& uri,
+IWebDavCollection& collection)
+{
+OrthancPluginErrorCode code = OrthancPluginRegisterWebDavCollection(
+GetGlobalContext(), uri.c_str(), WebDavIsExistingFolder, WebDavListFolder, WebDavRetrieveFile,
+WebDavStoreFileCallback, WebDavCreateFolderCallback, WebDavDeleteItemCallback, &collection);
+if (code != OrthancPluginErrorCode_Success)
+{
+ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(code);
+}
+}
+#endif
+void GetHttpHeaders(std::map<std::string, std::string>& result, const OrthancPluginHttpRequest* request)
+{
+result.clear();
+for (uint32_t i = 0; i < request->headersCount; ++i)
+{
+result[request->headersKeys[i]] = request->headersValues[i];
+}
+}
 }

Mercurial > hg > orthanc-authorization

comparison Resources/Orthanc/Plugins/OrthancPluginCppWrapper.cpp @ 69:af44dce56328