orthanc: OrthancServer/Sources/OrthancRestApi/OrthancRestResources.cpp comparison

comparison OrthancServer/Sources/OrthancRestApi/OrthancRestResources.cpp @ 5809:023a99146dd0 attach-custom-data tip

merged find-refactoring -> attach-custom-data

author	Alain Mazy <am@orthanc.team>
date	Tue, 24 Sep 2024 12:53:43 +0200
parents	8279eaab0d1d 25df40a274fd
children

comparison

equal deleted inserted replaced

-:63c025cf6958
+:023a99146dd0
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 **/
 #include "../PrecompiledHeadersServer.h"
+#include "../ResourceFinder.h"
 #include "OrthancRestApi.h"
 #include "../../../OrthancFramework/Sources/Compression/GzipCompressor.h"
 #include "../../../OrthancFramework/Sources/DicomFormat/DicomImageInformation.h"
 #include "../../../OrthancFramework/Sources/DicomParsing/DicomWebJsonVisitor.h"
 }
 }
 }
+static bool ExpandResource(Json::Value& target,
+ServerContext& context,
+ResourceType level,
+const std::string& identifier,
+DicomToJsonFormat format,
+bool retrieveMetadata)
+{
+ResourceFinder finder(level, true /* expand */);
+finder.SetOrthancId(level, identifier);
+finder.SetRetrieveMetadata(retrieveMetadata);
+return finder.ExecuteOneResource(target, context, format, retrieveMetadata);
+}
 // List all the patients, studies, series or instances ----------------------
-static void AnswerListOfResources(RestApiOutput& output,
+static void AnswerListOfResources1(RestApiOutput& output,
 ServerContext& context,
 const std::list<std::string>& resources,
 const std::map<std::string, std::string>& instancesIds, // optional: the id of an instance for each found resource.
 const std::map<std::string, boost::shared_ptr<DicomMap> >& resourcesMainDicomTags,  // optional: all tags read from DB for a resource (current level and upper levels)
 const std::map<std::string, boost::shared_ptr<Json::Value> >& resourcesDicomAsJson, // optional: the dicom-as-json for each resource
 output.AnswerJson(answer);
 }
-static void AnswerListOfResources(RestApiOutput& output,
+static void AnswerListOfResources2(RestApiOutput& output,
 ServerContext& context,
 const std::list<std::string>& resources,
 ResourceType level,
 bool expand,
 DicomToJsonFormat format,
 {
 std::map<std::string, std::string> unusedInstancesIds;
 std::map<std::string, boost::shared_ptr<DicomMap> > unusedResourcesMainDicomTags;
 std::map<std::string, boost::shared_ptr<Json::Value> > unusedResourcesDicomAsJson;
-AnswerListOfResources(output, context, resources, unusedInstancesIds, unusedResourcesMainDicomTags, unusedResourcesDicomAsJson, level, expand, format, requestedTags, allowStorageAccess);
+AnswerListOfResources1(output, context, resources, unusedInstancesIds, unusedResourcesMainDicomTags, unusedResourcesDicomAsJson, level, expand, format, requestedTags, allowStorageAccess);
 }
 template <enum ResourceType resourceType>
 static void ListResources(RestApiGetCall& call)
 }
 ServerIndex& index = OrthancRestApi::GetIndex(call);
 ServerContext& context = OrthancRestApi::GetContext(call);
-std::list<std::string> result;
+if (true)
+{
-std::set<DicomTag> requestedTags;
+/**
-OrthancRestApi::GetRequestedTags(requestedTags, call);
+* EXPERIMENTAL VERSION
+**/
-if (call.HasArgument("limit") ||
-call.HasArgument("since"))
+// TODO-FIND: include the FindRequest options parsing in a method (parse from get-arguments and from post payload)
-{
+// TODO-FIND: support other values for expand like expand=MainDicomTags,Labels,Parent,SeriesStatus
-if (!call.HasArgument("limit"))
+const bool expand = (call.HasArgument("expand") &&
-{
+call.GetBooleanArgument("expand", true));
-throw OrthancException(ErrorCode_BadRequest,
-"Missing \"limit\" argument for GET request against: " +
+std::set<DicomTag> requestedTags;
-call.FlattenUri());
+OrthancRestApi::GetRequestedTags(requestedTags, call);
-}
+ResourceFinder finder(resourceType, expand);
-if (!call.HasArgument("since"))
+finder.AddRequestedTags(requestedTags);
-{
-throw OrthancException(ErrorCode_BadRequest,
+if (call.HasArgument("limit") ||
-"Missing \"since\" argument for GET request against: " +
+call.HasArgument("since"))
-call.FlattenUri());
+{
-}
+if (!call.HasArgument("limit"))
+{
-size_t since = boost::lexical_cast<size_t>(call.GetArgument("since", ""));
+throw OrthancException(ErrorCode_BadRequest,
-size_t limit = boost::lexical_cast<size_t>(call.GetArgument("limit", ""));
+"Missing \"limit\" argument for GET request against: " +
-index.GetAllUuids(result, resourceType, since, limit);
+call.FlattenUri());
+}
+if (!call.HasArgument("since"))
+{
+throw OrthancException(ErrorCode_BadRequest,
+"Missing \"since\" argument for GET request against: " +
+call.FlattenUri());
+}
+uint64_t since = boost::lexical_cast<uint64_t>(call.GetArgument("since", ""));
+uint64_t limit = boost::lexical_cast<uint64_t>(call.GetArgument("limit", ""));
+finder.SetLimitsSince(since);
+finder.SetLimitsCount(limit);
+}
+Json::Value answer;
+finder.Execute(answer, context, OrthancRestApi::GetDicomFormat(call, DicomToJsonFormat_Human), false /* no "Metadata" field */);
+call.GetOutput().AnswerJson(answer);
 }
 else
 {
-index.GetAllUuids(result, resourceType);
+/**
-}
+* VERSION IN ORTHANC <= 1.12.4
+**/
-AnswerListOfResources(call.GetOutput(), context, result, resourceType, call.HasArgument("expand") && call.GetBooleanArgument("expand", true),
-OrthancRestApi::GetDicomFormat(call, DicomToJsonFormat_Human),
+std::list<std::string> result;
-requestedTags,
-true /* allowStorageAccess */);
+std::set<DicomTag> requestedTags;
+OrthancRestApi::GetRequestedTags(requestedTags, call);
+if (call.HasArgument("limit") ||
+call.HasArgument("since"))
+{
+if (!call.HasArgument("limit"))
+{
+throw OrthancException(ErrorCode_BadRequest,
+"Missing \"limit\" argument for GET request against: " +
+call.FlattenUri());
+}
+if (!call.HasArgument("since"))
+{
+throw OrthancException(ErrorCode_BadRequest,
+"Missing \"since\" argument for GET request against: " +
+call.FlattenUri());
+}
+size_t since = boost::lexical_cast<size_t>(call.GetArgument("since", ""));
+size_t limit = boost::lexical_cast<size_t>(call.GetArgument("limit", ""));
+index.GetAllUuids(result, resourceType, since, limit);
+}
+else
+{
+index.GetAllUuids(result, resourceType);
+}
+AnswerListOfResources2(call.GetOutput(), context, result, resourceType, call.HasArgument("expand") && call.GetBooleanArgument("expand", true),
+OrthancRestApi::GetDicomFormat(call, DicomToJsonFormat_Human),
+requestedTags,
+true /* allowStorageAccess */);
+}
 }
 template <enum ResourceType resourceType>
 const DicomToJsonFormat format = OrthancRestApi::GetDicomFormat(call, DicomToJsonFormat_Human);
 std::set<DicomTag> requestedTags;
 OrthancRestApi::GetRequestedTags(requestedTags, call);
-Json::Value json;
+if (true)
-if (OrthancRestApi::GetContext(call).ExpandResource(
+{
-json, call.GetUriComponent("id", ""), resourceType, format, requestedTags, true /* allowStorageAccess */))
+/**
-{
+* EXPERIMENTAL VERSION
-call.GetOutput().AnswerJson(json);
+**/
+ResourceFinder finder(resourceType, true /* expand */);
+finder.AddRequestedTags(requestedTags);
+finder.SetOrthancId(resourceType, call.GetUriComponent("id", ""));
+Json::Value json;
+if (finder.ExecuteOneResource(json, OrthancRestApi::GetContext(call), format, false /* no "Metadata" field */))
+{
+call.GetOutput().AnswerJson(json);
+}
+}
+else
+{
+/**
+* VERSION IN ORTHANC <= 1.12.4
+**/
+Json::Value json;
+if (OrthancRestApi::GetContext(call).ExpandResource(
+json, call.GetUriComponent("id", ""), resourceType, format, requestedTags, true /* allowStorageAccess */))
+{
+call.GetOutput().AnswerJson(json);
+}
 }
 }
 template <enum ResourceType resourceType>
 static void DeleteSingleResource(RestApiDeleteCall& call)
 ServerContext& context,
 ResourceType level,
 bool expand,
 const std::set<DicomTag>& requestedTags) const
 {
-AnswerListOfResources(output, context, resources_, instancesIds_, resourcesMainDicomTags_, resourcesDicomAsJson_, level, expand, format_, requestedTags, IsStorageAccessAllowedForAnswers(findStorageAccessMode_));
+AnswerListOfResources1(output, context, resources_, instancesIds_, resourcesMainDicomTags_, resourcesDicomAsJson_, level, expand, format_, requestedTags, IsStorageAccessAllowedForAnswers(findStorageAccessMode_));
 }
 };
 }
 request[KEY_LABELS_CONSTRAINT].type() != Json::stringValue)
 {
 throw OrthancException(ErrorCode_BadRequest,
 "Field \"" + std::string(KEY_LABELS_CONSTRAINT) + "\" must be an array of strings");
 }
+else if (true)
+{
+/**
+* EXPERIMENTAL VERSION
+**/
+bool expand = false;
+if (request.isMember(KEY_EXPAND))
+{
+expand = request[KEY_EXPAND].asBool();
+}
+const ResourceType level = StringToResourceType(request[KEY_LEVEL].asCString());
+ResourceFinder finder(level, expand);
+finder.SetDatabaseLimits(context.GetDatabaseLimits(level));
+const DicomToJsonFormat format = OrthancRestApi::GetDicomFormat(request, DicomToJsonFormat_Human);
+if (request.isMember(KEY_LIMIT))
+{
+int64_t tmp = request[KEY_LIMIT].asInt64();
+if (tmp < 0)
+{
+throw OrthancException(ErrorCode_ParameterOutOfRange,
+"Field \"" + std::string(KEY_LIMIT) + "\" must be a positive integer");
+}
+else if (tmp != 0)  // This is for compatibility with Orthanc 1.12.4
+{
+finder.SetLimitsCount(static_cast<uint64_t>(tmp));
+}
+}
+if (request.isMember(KEY_SINCE))
+{
+int64_t tmp = request[KEY_SINCE].asInt64();
+if (tmp < 0)
+{
+throw OrthancException(ErrorCode_ParameterOutOfRange,
+"Field \"" + std::string(KEY_SINCE) + "\" must be a positive integer");
+}
+else
+{
+finder.SetLimitsSince(static_cast<uint64_t>(tmp));
+}
+}
+{
+bool caseSensitive = false;
+if (request.isMember(KEY_CASE_SENSITIVE))
+{
+caseSensitive = request[KEY_CASE_SENSITIVE].asBool();
+}
+DatabaseLookup query;
+Json::Value::Members members = request[KEY_QUERY].getMemberNames();
+for (size_t i = 0; i < members.size(); i++)
+{
+if (request[KEY_QUERY][members[i]].type() != Json::stringValue)
+{
+throw OrthancException(ErrorCode_BadRequest,
+"Tag \"" + members[i] + "\" must be associated with a string");
+}
+const std::string value = request[KEY_QUERY][members[i]].asString();
+if (!value.empty())
+{
+// An empty string corresponds to an universal constraint,
+// so we ignore it. This mimics the behavior of class
+// "OrthancFindRequestHandler"
+query.AddRestConstraint(FromDcmtkBridge::ParseTag(members[i]),
+value, caseSensitive, true);
+}
+}
+finder.SetDatabaseLookup(query);
+}
+if (request.isMember(KEY_REQUESTED_TAGS))
+{
+std::set<DicomTag> requestedTags;
+FromDcmtkBridge::ParseListOfTags(requestedTags, request[KEY_REQUESTED_TAGS]);
+finder.AddRequestedTags(requestedTags);
+}
+if (request.isMember(KEY_LABELS))  // New in Orthanc 1.12.0
+{
+for (Json::Value::ArrayIndex i = 0; i < request[KEY_LABELS].size(); i++)
+{
+if (request[KEY_LABELS][i].type() != Json::stringValue)
+{
+throw OrthancException(ErrorCode_BadRequest, "Field \"" + std::string(KEY_LABELS) + "\" must contain strings");
+}
+else
+{
+finder.AddLabel(request[KEY_LABELS][i].asString());
+}
+}
+}
+finder.SetLabelsConstraint(LabelsConstraint_All);
+if (request.isMember(KEY_LABELS_CONSTRAINT))
+{
+const std::string& s = request[KEY_LABELS_CONSTRAINT].asString();
+if (s == "All")
+{
+finder.SetLabelsConstraint(LabelsConstraint_All);
+}
+else if (s == "Any")
+{
+finder.SetLabelsConstraint(LabelsConstraint_Any);
+}
+else if (s == "None")
+{
+finder.SetLabelsConstraint(LabelsConstraint_None);
+}
+else
+{
+throw OrthancException(ErrorCode_BadRequest, "Field \"" + std::string(KEY_LABELS_CONSTRAINT) + "\" must be \"All\", \"Any\", or \"None\"");
+}
+}
+Json::Value answer;
+finder.Execute(answer, context, format, false /* no "Metadata" field */);
+call.GetOutput().AnswerJson(answer);
+}
 else
 {
+/**
+* VERSION IN ORTHANC <= 1.12.4
+**/
 bool expand = false;
 if (request.isMember(KEY_EXPAND))
 {
 expand = request[KEY_EXPAND].asBool();
 }
 }
 ServerIndex& index = OrthancRestApi::GetIndex(call);
 ServerContext& context = OrthancRestApi::GetContext(call);
+const bool expand = (!call.HasArgument("expand") ||
+// this "expand" is the only one to have a false default value to keep backward compatibility
+call.GetBooleanArgument("expand", false));
+const DicomToJsonFormat format = OrthancRestApi::GetDicomFormat(call, DicomToJsonFormat_Human);
 std::set<DicomTag> requestedTags;
 OrthancRestApi::GetRequestedTags(requestedTags, call);
-std::list<std::string> a, b, c;
+if (true)
-a.push_back(call.GetUriComponent("id", ""));
+{
+/**
-ResourceType type = start;
+* EXPERIMENTAL VERSION
-while (type != end)
+**/
-{
-b.clear();
+ResourceFinder finder(end, expand);
+finder.SetOrthancId(start, call.GetUriComponent("id", ""));
-for (std::list<std::string>::const_iterator
+finder.AddRequestedTags(requestedTags);
-it = a.begin(); it != a.end(); ++it)
-{
+Json::Value answer;
-index.GetChildren(c, *it);
+finder.Execute(answer, context, format, false /* no "Metadata" field */);
-b.splice(b.begin(), c);
+call.GetOutput().AnswerJson(answer);
 }
+else
-type = GetChildResourceType(type);
+{
+/**
-a.clear();
+* VERSION IN ORTHANC <= 1.12.4
-a.splice(a.begin(), b);
+**/
-}
+std::list<std::string> a, b, c;
+a.push_back(call.GetUriComponent("id", ""));
-AnswerListOfResources(call.GetOutput(), context, a, type, !call.HasArgument("expand") || call.GetBooleanArgument("expand", false),  // this "expand" is the only one to have a false default value to keep backward compatibility
-OrthancRestApi::GetDicomFormat(call, DicomToJsonFormat_Human),
+ResourceType type = start;
-requestedTags,
+while (type != end)
-true /* allowStorageAccess */);
+{
+b.clear();
+for (std::list<std::string>::const_iterator
+it = a.begin(); it != a.end(); ++it)
+{
+index.GetChildren(c, *it);
+b.splice(b.begin(), c);
+}
+type = GetChildResourceType(type);
+a.clear();
+a.splice(a.begin(), b);
+}
+AnswerListOfResources2(call.GetOutput(), context, a, type, expand, format, requestedTags, true /* allowStorageAccess */);
+}
 }
 static void GetChildInstancesTags(RestApiGetCall& call)
 {
 assert(currentType == end);
 const DicomToJsonFormat format = OrthancRestApi::GetDicomFormat(call, DicomToJsonFormat_Human);
 Json::Value resource;
-if (OrthancRestApi::GetContext(call).ExpandResource(resource, current, end, format, requestedTags, true /* allowStorageAccess */))
-{
+if (true)
-call.GetOutput().AnswerJson(resource);
+{
+/**
+* EXPERIMENTAL VERSION
+**/
+if (ExpandResource(resource, OrthancRestApi::GetContext(call), currentType, current, format, false))
+{
+call.GetOutput().AnswerJson(resource);
+}
+}
+else
+{
+/**
+* VERSION IN ORTHANC <= 1.12.4
+**/
+if (OrthancRestApi::GetContext(call).ExpandResource(resource, current, end, format, requestedTags, true /* allowStorageAccess */))
+{
+call.GetOutput().AnswerJson(resource);
+}
 }
 }
 static void ExtractPdf(RestApiGetCall& call)
 }
 for (std::set<std::string>::const_iterator
 it = interest.begin(); it != interest.end(); ++it)
 {
-Json::Value item;
+if (true)
-std::set<DicomTag> emptyRequestedTags;  // not supported for bulk content
-if (OrthancRestApi::GetContext(call).ExpandResource(item, *it, level, format, emptyRequestedTags, true /* allowStorageAccess */))
 {
-if (metadata)
+/**
+* EXPERIMENTAL VERSION
+**/
+Json::Value item;
+if (ExpandResource(item, OrthancRestApi::GetContext(call), level, *it, format, metadata))
 {
-AddMetadata(item[METADATA], index, *it, level);
+answer.append(item);
 }
+}
-answer.append(item);
+else
+{
+/**
+* VERSION IN ORTHANC <= 1.12.4
+**/
+Json::Value item;
+std::set<DicomTag> emptyRequestedTags;  // not supported for bulk content
+if (OrthancRestApi::GetContext(call).ExpandResource(item, *it, level, format, emptyRequestedTags, true /* allowStorageAccess */))
+{
+if (metadata)
+{
+AddMetadata(item[METADATA], index, *it, level);
+}
+answer.append(item);
+}
 }
 }
 }
 else
 {
 {
 ResourceType level;
 Json::Value item;
 std::set<DicomTag> emptyRequestedTags;  // not supported for bulk content
-if (index.LookupResourceType(level, *it) &&
+if (true)
-OrthancRestApi::GetContext(call).ExpandResource(item, *it, level, format, emptyRequestedTags, true /* allowStorageAccess */))
 {
-if (metadata)
+/**
+* EXPERIMENTAL VERSION
+**/
+if (index.LookupResourceType(level, *it) &&
+ExpandResource(item, OrthancRestApi::GetContext(call), level, *it, format, metadata))
 {
-AddMetadata(item[METADATA], index, *it, level);
+answer.append(item);
 }
-answer.append(item);
 }
 else
 {
-CLOG(INFO, HTTP) << "Unknown resource during a bulk content retrieval: " << *it;
+/**
+* VERSION IN ORTHANC <= 1.12.4
+**/
+if (index.LookupResourceType(level, *it) &&
+OrthancRestApi::GetContext(call).ExpandResource(item, *it, level, format, emptyRequestedTags, true /* allowStorageAccess */))
+{
+if (metadata)
+{
+AddMetadata(item[METADATA], index, *it, level);
+}
+answer.append(item);
+}
+else
+{
+CLOG(INFO, HTTP) << "Unknown resource during a bulk content retrieval: " << *it;
+}
 }
 }
 }
 call.GetOutput().AnswerJson(answer);
 Register("/instances", ListResources<ResourceType_Instance>);
 Register("/patients", ListResources<ResourceType_Patient>);
 Register("/series", ListResources<ResourceType_Series>);
 Register("/studies", ListResources<ResourceType_Study>);
-Register("/instances/{id}", DeleteSingleResource<ResourceType_Instance>);
+if (!context_.IsReadOnly())
+{
+Register("/instances/{id}", DeleteSingleResource<ResourceType_Instance>);
+Register("/patients/{id}", DeleteSingleResource<ResourceType_Patient>);
+Register("/series/{id}", DeleteSingleResource<ResourceType_Series>);
+Register("/studies/{id}", DeleteSingleResource<ResourceType_Study>);
+Register("/tools/bulk-delete", BulkDelete);
+}
+else
+{
+LOG(WARNING) << "READ-ONLY SYSTEM: DELETE routes are not available";
+}
 Register("/instances/{id}", GetSingleResource<ResourceType_Instance>);
-Register("/patients/{id}", DeleteSingleResource<ResourceType_Patient>);
 Register("/patients/{id}", GetSingleResource<ResourceType_Patient>);
-Register("/series/{id}", DeleteSingleResource<ResourceType_Series>);
 Register("/series/{id}", GetSingleResource<ResourceType_Series>);
-Register("/studies/{id}", DeleteSingleResource<ResourceType_Study>);
 Register("/studies/{id}", GetSingleResource<ResourceType_Study>);
 Register("/instances/{id}/statistics", GetResourceStatistics);
 Register("/patients/{id}/statistics", GetResourceStatistics);
 Register("/studies/{id}/statistics", GetResourceStatistics);
 Register("/instances/{id}/matlab", GetMatlabImage);
 Register("/instances/{id}/header", GetInstanceHeader);
 Register("/instances/{id}/numpy", GetNumpyInstance);  // New in Orthanc 1.10.0
 Register("/patients/{id}/protected", IsProtectedPatient);
-Register("/patients/{id}/protected", SetPatientProtection);
+if (!context_.IsReadOnly())
+{
+Register("/patients/{id}/protected", SetPatientProtection);
+}
+else
+{
+LOG(WARNING) << "READ-ONLY SYSTEM: PUT /patients/{id}/protected route is not available";
+}
 std::vector<std::string> resourceTypes;
 resourceTypes.push_back("patients");
 resourceTypes.push_back("studies");
 resourceTypes.push_back("series");
 Register("/" + resourceTypes[i] + "/{id}/metadata/{name}", SetMetadata);
 // New in Orthanc 1.12.0
 Register("/" + resourceTypes[i] + "/{id}/labels", ListLabels);
 Register("/" + resourceTypes[i] + "/{id}/labels/{label}", GetLabel);
-Register("/" + resourceTypes[i] + "/{id}/labels/{label}", RemoveLabel);
-Register("/" + resourceTypes[i] + "/{id}/labels/{label}", AddLabel);
+if (!context_.IsReadOnly())
+{
+Register("/" + resourceTypes[i] + "/{id}/labels/{label}", RemoveLabel);
+Register("/" + resourceTypes[i] + "/{id}/labels/{label}", AddLabel);
+}
 Register("/" + resourceTypes[i] + "/{id}/attachments", ListAttachments);
-Register("/" + resourceTypes[i] + "/{id}/attachments/{name}", DeleteAttachment);
 Register("/" + resourceTypes[i] + "/{id}/attachments/{name}", GetAttachmentOperations);
-Register("/" + resourceTypes[i] + "/{id}/attachments/{name}", UploadAttachment);
-Register("/" + resourceTypes[i] + "/{id}/attachments/{name}/compress", ChangeAttachmentCompression<CompressionType_ZlibWithSize>);
 Register("/" + resourceTypes[i] + "/{id}/attachments/{name}/compressed-data", GetAttachmentData<0>);
 Register("/" + resourceTypes[i] + "/{id}/attachments/{name}/compressed-md5", GetAttachmentCompressedMD5);
 Register("/" + resourceTypes[i] + "/{id}/attachments/{name}/compressed-size", GetAttachmentCompressedSize);
 Register("/" + resourceTypes[i] + "/{id}/attachments/{name}/data", GetAttachmentData<1>);
 Register("/" + resourceTypes[i] + "/{id}/attachments/{name}/is-compressed", IsAttachmentCompressed);
 Register("/" + resourceTypes[i] + "/{id}/attachments/{name}/md5", GetAttachmentMD5);
 Register("/" + resourceTypes[i] + "/{id}/attachments/{name}/size", GetAttachmentSize);
-Register("/" + resourceTypes[i] + "/{id}/attachments/{name}/uncompress", ChangeAttachmentCompression<CompressionType_None>);
 Register("/" + resourceTypes[i] + "/{id}/attachments/{name}/info", GetAttachmentInfo);
 Register("/" + resourceTypes[i] + "/{id}/attachments/{name}/verify-md5", VerifyAttachment);
-}
+if (!context_.IsReadOnly())
-Register("/tools/invalidate-tags", InvalidateTags);
+{
+Register("/" + resourceTypes[i] + "/{id}/attachments/{name}", DeleteAttachment);
+Register("/" + resourceTypes[i] + "/{id}/attachments/{name}", UploadAttachment);
+Register("/" + resourceTypes[i] + "/{id}/attachments/{name}/compress", ChangeAttachmentCompression<CompressionType_ZlibWithSize>);
+Register("/" + resourceTypes[i] + "/{id}/attachments/{name}/uncompress", ChangeAttachmentCompression<CompressionType_None>);
+}
+}
+if (context_.IsReadOnly())
+{
+LOG(WARNING) << "READ-ONLY SYSTEM: deactivating PUT, POST and DELETE attachments routes";
+LOG(WARNING) << "READ-ONLY SYSTEM: deactivating PUT and DELETE labels routes";
+}
+if (!context_.IsReadOnly())
+{
+Register("/tools/invalidate-tags", InvalidateTags);
+}
 Register("/tools/lookup", Lookup);
 Register("/tools/find", Find);
 Register("/patients/{id}/studies", GetChildResources<ResourceType_Patient, ResourceType_Study>);
 Register("/patients/{id}/series", GetChildResources<ResourceType_Patient, ResourceType_Series>);
 Register("/instances/{id}/content/*", GetRawContent);
 Register("/series/{id}/ordered-slices", OrderSlices);
 Register("/series/{id}/numpy", GetNumpySeries);  // New in Orthanc 1.10.0
-Register("/patients/{id}/reconstruct", ReconstructResource<ResourceType_Patient>);
+if (!context_.IsReadOnly())
-Register("/studies/{id}/reconstruct", ReconstructResource<ResourceType_Study>);
+{
-Register("/series/{id}/reconstruct", ReconstructResource<ResourceType_Series>);
+Register("/patients/{id}/reconstruct", ReconstructResource<ResourceType_Patient>);
-Register("/instances/{id}/reconstruct", ReconstructResource<ResourceType_Instance>);
+Register("/studies/{id}/reconstruct", ReconstructResource<ResourceType_Study>);
-Register("/tools/reconstruct", ReconstructAllResources);
+Register("/series/{id}/reconstruct", ReconstructResource<ResourceType_Series>);
+Register("/instances/{id}/reconstruct", ReconstructResource<ResourceType_Instance>);
+Register("/tools/reconstruct", ReconstructAllResources);
+}
+else
+{
+LOG(WARNING) << "READ-ONLY SYSTEM: deactivating /reconstruct routes";
+}
 Register("/tools/bulk-content", BulkContent);
-Register("/tools/bulk-delete", BulkDelete);
+}
-}
 }

Mercurial > hg > orthanc

comparison OrthancServer/Sources/OrthancRestApi/OrthancRestResources.cpp @ 5809:023a99146dd0 attach-custom-data tip