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

comparison OrthancServer/Sources/OrthancRestApi/OrthancRestResources.cpp @ 5851:6a4e47163b3c find-refactoring

cleaning OrthancRestResources.cpp

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Tue, 29 Oct 2024 15:21:15 +0000
parents	1980354c8113
children

comparison

equal deleted inserted replaced

-:1980354c8113
+:6a4e47163b3c
 static const char* const ARG_WHOLE = "whole";
 namespace Orthanc
 {
+static ResourceType GetResourceTypeFromUri(const RestApiCall& call)
+{
+assert(!call.GetFullUri().empty());
+const std::string resourceType = call.GetFullUri() [0];
+return StringToResourceType(resourceType.c_str());
+}
 static std::string GetDocumentationSampleResource(ResourceType type)
 {
 switch (type)
 {
 case Orthanc::ResourceType_Instance:
 }
 static void GetResourceStatistics(RestApiGetCall& call)
 {
-if (call.IsDocumentation())
+const ResourceType level = GetResourceTypeFromUri(call);
-{
-ResourceType t = StringToResourceType(call.GetFullUri()[0].c_str());
+if (call.IsDocumentation())
-std::string r = GetResourceTypeText(t, false /* plural */, false /* upper case */);
+{
-call.GetDocumentation()
+std::string r = GetResourceTypeText(level, false /* plural */, false /* upper case */);
-.SetTag(GetResourceTypeText(t, true /* plural */, true /* upper case */))
+call.GetDocumentation()
+.SetTag(GetResourceTypeText(level, true /* plural */, true /* upper case */))
 .SetSummary("Get " + r + " statistics")
 .SetDescription("Get statistics about the given " + r)
 .SetUriArgument("id", "Orthanc identifier of the " + r + " of interest")
 .SetAnswerField("DiskSize", RestApiCallDocumentation::Type_String,
 "Size of the " + r + " on the disk in bytes, expressed as a string for 64bit compatibility with JSON")
 "Size on the disk of the DICOM instances associated with the " + r + ", expressed in megabytes (MB)")
 .SetAnswerField("DicomUncompressedSize", RestApiCallDocumentation::Type_String,
 "Size on the disk of the uncompressed DICOM instances associated with the " + r + ", expressed in bytes")
 .SetAnswerField("DicomUncompressedSizeMB", RestApiCallDocumentation::Type_Number,
 "Size on the disk of the uncompressed DICOM instances associated with the " + r + ", expressed in megabytes (MB)")
-.SetHttpGetSample(GetDocumentationSampleResource(t) + "/statistics", true);
+.SetHttpGetSample(GetDocumentationSampleResource(level) + "/statistics", true);
-switch (t)
+switch (level)
 {
 // Do NOT add "break" below this point!
 case ResourceType_Patient:
 call.GetDocumentation().SetAnswerField("CountStudies", RestApiCallDocumentation::Type_Number,
 "Number of child studies within this " + r);
 // Handling of metadata -----------------------------------------------------
-static ResourceType GetResourceTypeFromUri(const RestApiCall& call)
-{
-assert(!call.GetFullUri().empty());
-const std::string resourceType = call.GetFullUri() [0];
-return StringToResourceType(resourceType.c_str());
-}
-static void CheckValidResourceType(const RestApiCall& call)
-{
-GetResourceTypeFromUri(call);
-}
 static void ListMetadata(RestApiGetCall& call)
 {
-if (call.IsDocumentation())
+const ResourceType level = GetResourceTypeFromUri(call);
-{
-ResourceType t = StringToResourceType(call.GetFullUri()[0].c_str());
+if (call.IsDocumentation())
-std::string r = GetResourceTypeText(t, false /* plural */, false /* upper case */);
+{
-call.GetDocumentation()
+std::string r = GetResourceTypeText(level, false /* plural */, false /* upper case */);
-.SetTag(GetResourceTypeText(t, true /* plural */, true /* upper case */))
+call.GetDocumentation()
+.SetTag(GetResourceTypeText(level, true /* plural */, true /* upper case */))
 .SetSummary("List metadata")
 .SetDescription("Get the list of metadata that are associated with the given " + r)
 .SetUriArgument("id", "Orthanc identifier of the " + r + " of interest")
 .SetHttpGetArgument("expand", RestApiCallDocumentation::Type_String,
 "If present, also retrieve the value of the individual metadata", false)
 .SetHttpGetArgument("numeric", RestApiCallDocumentation::Type_String,
 "If present, use the numeric identifier of the metadata instead of its symbolic name", false)
 .AddAnswerType(MimeType_Json, "JSON array containing the names of the available metadata, "
 "or JSON associative array mapping metadata to their values (if `expand` argument is provided)")
-.SetHttpGetSample(GetDocumentationSampleResource(t) + "/metadata", true);
+.SetHttpGetSample(GetDocumentationSampleResource(level) + "/metadata", true);
 return;
 }
 assert(!call.GetFullUri().empty());
 const std::string publicId = call.GetUriComponent("id", "");
-ResourceType level = StringToResourceType(call.GetFullUri() [0].c_str());
 typedef std::map<MetadataType, std::string>  Metadata;
 Metadata metadata;
 OrthancRestApi::GetIndex(call).GetAllMetadata(metadata, publicId, level);
 }
 static void GetMetadata(RestApiGetCall& call)
 {
-if (call.IsDocumentation())
+const ResourceType level = GetResourceTypeFromUri(call);
-{
-ResourceType t = StringToResourceType(call.GetFullUri()[0].c_str());
+if (call.IsDocumentation())
-std::string r = GetResourceTypeText(t, false /* plural */, false /* upper case */);
+{
-call.GetDocumentation()
+std::string r = GetResourceTypeText(level, false /* plural */, false /* upper case */);
-.SetTag(GetResourceTypeText(t, true /* plural */, true /* upper case */))
+call.GetDocumentation()
+.SetTag(GetResourceTypeText(level, true /* plural */, true /* upper case */))
 .SetSummary("Get metadata")
 .SetDescription("Get the value of a metadata that is associated with the given " + r)
 .SetUriArgument("id", "Orthanc identifier of the " + r + " of interest")
 .SetUriArgument("name", "The name of the metadata, or its index (cf. `UserMetadata` configuration option)")
 .AddAnswerType(MimeType_PlainText, "Value of the metadata")
 return;
 }
 assert(!call.GetFullUri().empty());
 const std::string publicId = call.GetUriComponent("id", "");
-const ResourceType level = StringToResourceType(call.GetFullUri() [0].c_str());
 std::string name = call.GetUriComponent("name", "");
 MetadataType metadata = StringToMetadata(name);
 std::string value;
 }
 static void DeleteMetadata(RestApiDeleteCall& call)
 {
-if (call.IsDocumentation())
+const ResourceType level = GetResourceTypeFromUri(call);
-{
-ResourceType t = StringToResourceType(call.GetFullUri()[0].c_str());
+if (call.IsDocumentation())
-std::string r = GetResourceTypeText(t, false /* plural */, false /* upper case */);
+{
-call.GetDocumentation()
+std::string r = GetResourceTypeText(level, false /* plural */, false /* upper case */);
-.SetTag(GetResourceTypeText(t, true /* plural */, true /* upper case */))
+call.GetDocumentation()
+.SetTag(GetResourceTypeText(level, true /* plural */, true /* upper case */))
 .SetSummary("Delete metadata")
 .SetDescription("Delete some metadata associated with the given DICOM " + r +
 ". This call will fail if trying to delete a system metadata (i.e. whose index is < 1024).")
 .SetUriArgument("id", "Orthanc identifier of the " + r + " of interest")
 .SetUriArgument("name", "The name of the metadata, or its index (cf. `UserMetadata` configuration option)")
 .SetHttpHeader("If-Match", "Revision of the metadata, to check if its content has not changed and can "
 "be deleted. This header is mandatory if `CheckRevisions` option is `true`.");
 return;
 }
-CheckValidResourceType(call);
 const std::string publicId = call.GetUriComponent("id", "");
 std::string name = call.GetUriComponent("name", "");
 MetadataType metadata = StringToMetadata(name);
 }
 static void SetMetadata(RestApiPutCall& call)
 {
-if (call.IsDocumentation())
+const ResourceType level = GetResourceTypeFromUri(call);
-{
-ResourceType t = StringToResourceType(call.GetFullUri()[0].c_str());
+if (call.IsDocumentation())
-std::string r = GetResourceTypeText(t, false /* plural */, false /* upper case */);
+{
-call.GetDocumentation()
+std::string r = GetResourceTypeText(level, false /* plural */, false /* upper case */);
-.SetTag(GetResourceTypeText(t, true /* plural */, true /* upper case */))
+call.GetDocumentation()
+.SetTag(GetResourceTypeText(level, true /* plural */, true /* upper case */))
 .SetSummary("Set metadata")
 .SetDescription("Set the value of some metadata in the given DICOM " + r +
 ". This call will fail if trying to modify a system metadata (i.e. whose index is < 1024).")
 .SetUriArgument("id", "Orthanc identifier of the " + r + " of interest")
 .SetUriArgument("name", "The name of the metadata, or its index (cf. `UserMetadata` configuration option)")
 .AddRequestType(MimeType_PlainText, "String value of the metadata")
 .SetHttpHeader("If-Match", "Revision of the metadata, if this is not the first time this metadata is set.");
 return;
 }
-CheckValidResourceType(call);
 std::string publicId = call.GetUriComponent("id", "");
 std::string name = call.GetUriComponent("name", "");
 MetadataType metadata = StringToMetadata(name);
 std::string value;
 // Handling of labels -------------------------------------------------------
 static void ListLabels(RestApiGetCall& call)
 {
-if (call.IsDocumentation())
+const ResourceType level = GetResourceTypeFromUri(call);
-{
-ResourceType t = StringToResourceType(call.GetFullUri()[0].c_str());
+if (call.IsDocumentation())
-std::string r = GetResourceTypeText(t, false /* plural */, false /* upper case */);
+{
-call.GetDocumentation()
+std::string r = GetResourceTypeText(level, false /* plural */, false /* upper case */);
-.SetTag(GetResourceTypeText(t, true /* plural */, true /* upper case */))
+call.GetDocumentation()
+.SetTag(GetResourceTypeText(level, true /* plural */, true /* upper case */))
 .SetSummary("List labels")
 .SetDescription("Get the labels that are associated with the given " + r + " (new in Orthanc 1.12.0)")
 .SetUriArgument("id", "Orthanc identifier of the " + r + " of interest")
 .AddAnswerType(MimeType_Json, "JSON array containing the names of the labels")
-.SetHttpGetSample(GetDocumentationSampleResource(t) + "/labels", true);
+.SetHttpGetSample(GetDocumentationSampleResource(level) + "/labels", true);
 return;
 }
-assert(!call.GetFullUri().empty());
 const std::string publicId = call.GetUriComponent("id", "");
-ResourceType level = StringToResourceType(call.GetFullUri() [0].c_str());
 std::set<std::string> labels;
 OrthancRestApi::GetIndex(call).ListLabels(labels, publicId, level);
 Json::Value result = Json::arrayValue;
 }
 static void GetLabel(RestApiGetCall& call)
 {
-if (call.IsDocumentation())
+const ResourceType level = GetResourceTypeFromUri(call);
-{
-ResourceType t = StringToResourceType(call.GetFullUri()[0].c_str());
+if (call.IsDocumentation())
-std::string r = GetResourceTypeText(t, false /* plural */, false /* upper case */);
+{
-call.GetDocumentation()
+std::string r = GetResourceTypeText(level, false /* plural */, false /* upper case */);
-.SetTag(GetResourceTypeText(t, true /* plural */, true /* upper case */))
+call.GetDocumentation()
+.SetTag(GetResourceTypeText(level, true /* plural */, true /* upper case */))
 .SetSummary("Test label")
 .SetDescription("Test whether the " + r + " is associated with the given label")
 .SetUriArgument("id", "Orthanc identifier of the " + r + " of interest")
 .SetUriArgument("label", "The label of interest")
 .AddAnswerType(MimeType_PlainText, "Empty string is returned in the case of presence, error 404 in the case of absence");
 return;
 }
-CheckValidResourceType(call);
-assert(!call.GetFullUri().empty());
 const std::string publicId = call.GetUriComponent("id", "");
-const ResourceType level = StringToResourceType(call.GetFullUri() [0].c_str());
 std::string label = call.GetUriComponent("label", "");
 std::set<std::string> labels;
 OrthancRestApi::GetIndex(call).ListLabels(labels, publicId, level);
 }
 static void AddLabel(RestApiPutCall& call)
 {
-if (call.IsDocumentation())
+const ResourceType level = GetResourceTypeFromUri(call);
-{
-ResourceType t = StringToResourceType(call.GetFullUri()[0].c_str());
+if (call.IsDocumentation())
-std::string r = GetResourceTypeText(t, false /* plural */, false /* upper case */);
+{
-call.GetDocumentation()
+std::string r = GetResourceTypeText(level, false /* plural */, false /* upper case */);
-.SetTag(GetResourceTypeText(t, true /* plural */, true /* upper case */))
+call.GetDocumentation()
+.SetTag(GetResourceTypeText(level, true /* plural */, true /* upper case */))
 .SetSummary("Add label")
 .SetDescription("Associate a label with a " + r)
 .SetUriArgument("id", "Orthanc identifier of the " + r + " of interest")
 .SetUriArgument("label", "The label to be added");
 return;
 }
-CheckValidResourceType(call);
 std::string publicId = call.GetUriComponent("id", "");
-const ResourceType level = StringToResourceType(call.GetFullUri() [0].c_str());
 std::string label = call.GetUriComponent("label", "");
 OrthancRestApi::GetIndex(call).ModifyLabel(publicId, level, label, StatelessDatabaseOperations::LabelOperation_Add);
 call.GetOutput().AnswerBuffer("", MimeType_PlainText);
 }
 static void RemoveLabel(RestApiDeleteCall& call)
 {
-if (call.IsDocumentation())
+const ResourceType level = GetResourceTypeFromUri(call);
-{
-ResourceType t = StringToResourceType(call.GetFullUri()[0].c_str());
+if (call.IsDocumentation())
-std::string r = GetResourceTypeText(t, false /* plural */, false /* upper case */);
+{
-call.GetDocumentation()
+std::string r = GetResourceTypeText(level, false /* plural */, false /* upper case */);
-.SetTag(GetResourceTypeText(t, true /* plural */, true /* upper case */))
+call.GetDocumentation()
+.SetTag(GetResourceTypeText(level, true /* plural */, true /* upper case */))
 .SetSummary("Remove label")
 .SetDescription("Remove a label associated with a " + r)
 .SetUriArgument("id", "Orthanc identifier of the " + r + " of interest")
 .SetUriArgument("label", "The label to be removed");
 return;
 }
-CheckValidResourceType(call);
 std::string publicId = call.GetUriComponent("id", "");
-const ResourceType level = StringToResourceType(call.GetFullUri() [0].c_str());
 std::string label = call.GetUriComponent("label", "");
 OrthancRestApi::GetIndex(call).ModifyLabel(publicId, level, label, StatelessDatabaseOperations::LabelOperation_Remove);
 call.GetOutput().AnswerBuffer("", MimeType_PlainText);
 // Handling of attached files -----------------------------------------------
 static void ListAttachments(RestApiGetCall& call)
 {
-if (call.IsDocumentation())
+const ResourceType level = GetResourceTypeFromUri(call);
-{
-ResourceType t = StringToResourceType(call.GetFullUri()[0].c_str());
+if (call.IsDocumentation())
-std::string r = GetResourceTypeText(t, false /* plural */, false /* upper case */);
+{
-call.GetDocumentation()
+std::string r = GetResourceTypeText(level, false /* plural */, false /* upper case */);
-.SetTag(GetResourceTypeText(t, true /* plural */, true /* upper case */))
+call.GetDocumentation()
+.SetTag(GetResourceTypeText(level, true /* plural */, true /* upper case */))
 .SetSummary("List attachments")
 .SetDescription("Get the list of attachments that are associated with the given " + r)
 .SetUriArgument("id", "Orthanc identifier of the " + r + " of interest")
 .SetHttpGetArgument("full", RestApiCallDocumentation::Type_String,
 "If present, retrieve the attachments list and their numerical ids", false)
 .AddAnswerType(MimeType_Json, "JSON array containing the names of the attachments")
-.SetHttpGetSample(GetDocumentationSampleResource(t) + "/attachments", true);
+.SetHttpGetSample(GetDocumentationSampleResource(level) + "/attachments", true);
 return;
 }
-const std::string resourceType = call.GetFullUri() [0];
 const std::string publicId = call.GetUriComponent("id", "");
 std::set<FileContentType> attachments;
-OrthancRestApi::GetIndex(call).ListAvailableAttachments(attachments, publicId, StringToResourceType(resourceType.c_str()));
+OrthancRestApi::GetIndex(call).ListAvailableAttachments(attachments, publicId, level);
 Json::Value result;
 if (call.HasArgument("full"))
 {
 result = Json::objectValue;
 for (std::set<FileContentType>::const_iterator
 it = attachments.begin(); it != attachments.end(); ++it)
 {
 std::string key = EnumerationToString(*it);
 result[key] = static_cast<uint16_t>(*it);
 }
 }
 else
 {
 result = Json::arrayValue;
 for (std::set<FileContentType>::const_iterator
 it = attachments.begin(); it != attachments.end(); ++it)
 {
 result.append(EnumerationToString(*it));
 }
 }
 static bool GetAttachmentInfo(FileInfo& info,
 ResourceType level,
 RestApiGetCall& call)
 {
-CheckValidResourceType(call);
 const std::string publicId = call.GetUriComponent("id", "");
 const std::string name = call.GetUriComponent("name", "");
 FileContentType contentType = StringToContentType(name);
 int64_t revision;
 }
 static void GetAttachmentOperations(RestApiGetCall& call)
 {
-const ResourceType t = GetResourceTypeFromUri(call);
+const ResourceType level = GetResourceTypeFromUri(call);
 if (call.IsDocumentation())
 {
-ResourceType t = StringToResourceType(call.GetFullUri()[0].c_str());
+std::string r = GetResourceTypeText(level, false /* plural */, false /* upper case */);
-std::string r = GetResourceTypeText(t, false /* plural */, false /* upper case */);
 AddAttachmentDocumentation(call, r);
 call.GetDocumentation()
 .SetTag("Other")
 .SetSummary("List operations on attachments")
 .SetDescription("Get the list of the operations that are available for attachments associated with the given " + r)
 .SetHttpGetSample("https://orthanc.uclouvain.be/demo/instances/6582b1c0-292ad5ab-ba0f088f-f7a1766f-9a29a54f/attachments/dicom", true);
 return;
 }
 FileInfo info;
-if (GetAttachmentInfo(info, t, call))
+if (GetAttachmentInfo(info, level, call))
 {
 Json::Value operations = Json::arrayValue;
 operations.append("compress");
 operations.append("compressed-data");
 template <int uncompress>
 static void GetAttachmentData(RestApiGetCall& call)
 {
-const ResourceType t = GetResourceTypeFromUri(call);
+const ResourceType level = GetResourceTypeFromUri(call);
 if (call.IsDocumentation())
 {
-std::string r = GetResourceTypeText(t, false /* plural */, false /* upper case */);
+std::string r = GetResourceTypeText(level, false /* plural */, false /* upper case */);
 call.GetDocumentation()
-.SetTag(GetResourceTypeText(t, true /* plural */, true /* upper case */))
+.SetTag(GetResourceTypeText(level, true /* plural */, true /* upper case */))
 .SetSummary("Get attachment" + std::string(uncompress ? "" : " (no decompression)"))
 .SetDescription("Get the (binary) content of one attachment associated with the given " + r +
 std::string(uncompress ? "" : ". The attachment will not be decompressed if `StorageCompression` is `true`."))
 .SetUriArgument("id", "Orthanc identifier of the " + r + " of interest")
 .SetUriArgument("name", "The name of the attachment, or its index (cf. `UserContentType` configuration option)")
 return;
 }
 ServerContext& context = OrthancRestApi::GetContext(call);
-CheckValidResourceType(call);
 std::string publicId = call.GetUriComponent("id", "");
 FileContentType type = StringToContentType(call.GetUriComponent("name", ""));
 FileInfo info;
-if (GetAttachmentInfo(info, t, call))
+if (GetAttachmentInfo(info, level, call))
 {
 // NB: "SetAttachmentETag()" is already invoked by "GetAttachmentInfo()"
 if (uncompress)
 {
-context.AnswerAttachment(call.GetOutput(), t, publicId, type);
+context.AnswerAttachment(call.GetOutput(), level, publicId, type);
 }
 else
 {
 // Return the raw data (possibly compressed), as stored on the filesystem
 std::string content;
 std::string attachmentId;
 int64_t revision;
-context.ReadAttachment(content, revision, attachmentId, t, publicId, type, false, true /* skipCache when you absolutely need the compressed data */);
+context.ReadAttachment(content, revision, attachmentId, level, publicId, type, false, true /* skipCache when you absolutely need the compressed data */);
 int64_t userRevision;
 std::string userMD5;
 if (GetRevisionHeader(userRevision, userMD5, call, "If-None-Match") &&
 revision == userRevision &&
 }
 static void GetAttachmentSize(RestApiGetCall& call)
 {
-const ResourceType t = GetResourceTypeFromUri(call);
+const ResourceType level = GetResourceTypeFromUri(call);
 if (call.IsDocumentation())
 {
-std::string r = GetResourceTypeText(t, false /* plural */, false /* upper case */);
+std::string r = GetResourceTypeText(level, false /* plural */, false /* upper case */);
 AddAttachmentDocumentation(call, r);
 call.GetDocumentation()
-.SetTag(GetResourceTypeText(t, true /* plural */, true /* upper case */))
+.SetTag(GetResourceTypeText(level, true /* plural */, true /* upper case */))
 .SetSummary("Get size of attachment")
 .SetDescription("Get the size of one attachment associated with the given " + r)
 .AddAnswerType(MimeType_PlainText, "The size of the attachment");
 return;
 }
 FileInfo info;
-if (GetAttachmentInfo(info, t, call))
+if (GetAttachmentInfo(info, level, call))
 {
 call.GetOutput().AnswerBuffer(boost::lexical_cast<std::string>(info.GetUncompressedSize()), MimeType_PlainText);
 }
 }
 static void GetAttachmentInfo(RestApiGetCall& call)
 {
-const ResourceType t = GetResourceTypeFromUri(call);
+const ResourceType level = GetResourceTypeFromUri(call);
 if (call.IsDocumentation())
 {
-std::string r = GetResourceTypeText(t, false /* plural */, false /* upper case */);
+std::string r = GetResourceTypeText(level, false /* plural */, false /* upper case */);
 AddAttachmentDocumentation(call, r);
 call.GetDocumentation()
-.SetTag(GetResourceTypeText(t, true /* plural */, true /* upper case */))
+.SetTag(GetResourceTypeText(level, true /* plural */, true /* upper case */))
 .SetSummary("Get info about the attachment")
 .SetDescription("Get all the information about the attachment associated with the given " + r)
 .AddAnswerType(MimeType_Json, "JSON object containing the information about the attachment")
 .SetHttpGetSample("https://orthanc.uclouvain.be/demo/instances/7c92ce8e-bbf67ed2-ffa3b8c1-a3b35d94-7ff3ae26/attachments/dicom/info", true);
 return;
 }
 FileInfo info;
-if (GetAttachmentInfo(info, t, call))
+if (GetAttachmentInfo(info, level, call))
 {
 Json::Value result = Json::objectValue;
 result["Uuid"] = info.GetUuid();
 result["ContentType"] = info.GetContentType();
 result["UncompressedSize"] = Json::Value::UInt64(info.GetUncompressedSize());
 }
 }
 static void GetAttachmentCompressedSize(RestApiGetCall& call)
 {
-const ResourceType t = GetResourceTypeFromUri(call);
+const ResourceType level = GetResourceTypeFromUri(call);
 if (call.IsDocumentation())
 {
-std::string r = GetResourceTypeText(t, false /* plural */, false /* upper case */);
+std::string r = GetResourceTypeText(level, false /* plural */, false /* upper case */);
 AddAttachmentDocumentation(call, r);
 call.GetDocumentation()
-.SetTag(GetResourceTypeText(t, true /* plural */, true /* upper case */))
+.SetTag(GetResourceTypeText(level, true /* plural */, true /* upper case */))
 .SetSummary("Get size of attachment on disk")
 .SetDescription("Get the size of one attachment associated with the given " + r + ", as stored on the disk. "
 "This is different from `.../size` iff `EnableStorage` is `true`.")
 .AddAnswerType(MimeType_PlainText, "The size of the attachment, as stored on the disk");
 return;
 }
 FileInfo info;
-if (GetAttachmentInfo(info, t, call))
+if (GetAttachmentInfo(info, level, call))
 {
 call.GetOutput().AnswerBuffer(boost::lexical_cast<std::string>(info.GetCompressedSize()), MimeType_PlainText);
 }
 }
 static void GetAttachmentMD5(RestApiGetCall& call)
 {
-const ResourceType t = GetResourceTypeFromUri(call);
+const ResourceType level = GetResourceTypeFromUri(call);
 if (call.IsDocumentation())
 {
-std::string r = GetResourceTypeText(t, false /* plural */, false /* upper case */);
+std::string r = GetResourceTypeText(level, false /* plural */, false /* upper case */);
 AddAttachmentDocumentation(call, r);
 call.GetDocumentation()
-.SetTag(GetResourceTypeText(t, true /* plural */, true /* upper case */))
+.SetTag(GetResourceTypeText(level, true /* plural */, true /* upper case */))
 .SetSummary("Get MD5 of attachment")
 .SetDescription("Get the MD5 hash of one attachment associated with the given " + r)
 .AddAnswerType(MimeType_PlainText, "The MD5 of the attachment");
 return;
 }
 FileInfo info;
-if (GetAttachmentInfo(info, t, call) &&
+if (GetAttachmentInfo(info, level, call) &&
 info.GetUncompressedMD5() != "")
 {
 call.GetOutput().AnswerBuffer(boost::lexical_cast<std::string>(info.GetUncompressedMD5()), MimeType_PlainText);
 }
 }
 static void GetAttachmentCompressedMD5(RestApiGetCall& call)
 {
-const ResourceType t = GetResourceTypeFromUri(call);
+const ResourceType level = GetResourceTypeFromUri(call);
 if (call.IsDocumentation())
 {
-std::string r = GetResourceTypeText(t, false /* plural */, false /* upper case */);
+std::string r = GetResourceTypeText(level, false /* plural */, false /* upper case */);
 AddAttachmentDocumentation(call, r);
 call.GetDocumentation()
-.SetTag(GetResourceTypeText(t, true /* plural */, true /* upper case */))
+.SetTag(GetResourceTypeText(level, true /* plural */, true /* upper case */))
 .SetSummary("Get MD5 of attachment on disk")
 .SetDescription("Get the MD5 hash of one attachment associated with the given " + r + ", as stored on the disk. "
 "This is different from `.../md5` iff `EnableStorage` is `true`.")
 .AddAnswerType(MimeType_PlainText, "The MD5 of the attachment, as stored on the disk");
 return;
 }
 FileInfo info;
-if (GetAttachmentInfo(info, t, call) &&
+if (GetAttachmentInfo(info, level, call) &&
 info.GetCompressedMD5() != "")
 {
 call.GetOutput().AnswerBuffer(boost::lexical_cast<std::string>(info.GetCompressedMD5()), MimeType_PlainText);
 }
 }
 static void VerifyAttachment(RestApiPostCall& call)
 {
-const ResourceType t = GetResourceTypeFromUri(call);
+const ResourceType level = GetResourceTypeFromUri(call);
 if (call.IsDocumentation())
 {
-std::string r = GetResourceTypeText(t, false /* plural */, false /* upper case */);
+std::string r = GetResourceTypeText(level, false /* plural */, false /* upper case */);
 call.GetDocumentation()
-.SetTag(GetResourceTypeText(t, true /* plural */, true /* upper case */))
+.SetTag(GetResourceTypeText(level, true /* plural */, true /* upper case */))
 .SetSummary("Verify attachment")
 .SetDescription("Verify that the attachment is not corrupted, by validating its MD5 hash")
 .SetUriArgument("id", "Orthanc identifier of the " + r + " of interest")
 .SetUriArgument("name", "The name of the attachment, or its index (cf. `UserContentType` configuration option)")
 .AddAnswerType(MimeType_Json, "On success, a valid JSON object is returned");
 return;
 }
 ServerContext& context = OrthancRestApi::GetContext(call);
-CheckValidResourceType(call);
 std::string publicId = call.GetUriComponent("id", "");
 std::string name = call.GetUriComponent("name", "");
 FileContentType contentType = StringToContentType(name);
 FileInfo info;
 int64_t revision;  // Ignored
-if (!OrthancRestApi::GetIndex(call).LookupAttachment(info, revision, t, publicId, contentType) ||
+if (!OrthancRestApi::GetIndex(call).LookupAttachment(info, revision, level, publicId, contentType) ||
 info.GetCompressedMD5() == "" ||
 info.GetUncompressedMD5() == "")
 {
 // Inexistent resource, or no MD5 available
 return;
 // First check whether the compressed data is correctly stored in the disk
 std::string data;
 std::string attachmentId;
-context.ReadAttachment(data, revision, attachmentId, t, publicId, StringToContentType(name), false, true /* skipCache when you absolutely need the compressed data */);
+context.ReadAttachment(data, revision, attachmentId, level, publicId, StringToContentType(name), false, true /* skipCache when you absolutely need the compressed data */);
 std::string actualMD5;
 Toolbox::ComputeMD5(actualMD5, data);
 if (actualMD5 == info.GetCompressedMD5())
 {
 ok = true;
 }
 else
 {
-context.ReadAttachment(data, revision, attachmentId, t, publicId, StringToContentType(name), true, true /* skipCache when you absolutely need the compressed data */);
+context.ReadAttachment(data, revision, attachmentId, level, publicId, StringToContentType(name), true, true /* skipCache when you absolutely need the compressed data */);
 Toolbox::ComputeMD5(actualMD5, data);
 ok = (actualMD5 == info.GetUncompressedMD5());
 }
 }
 }
 static void UploadAttachment(RestApiPutCall& call)
 {
-if (call.IsDocumentation())
+const ResourceType level = GetResourceTypeFromUri(call);
-{
-ResourceType t = StringToResourceType(call.GetFullUri()[0].c_str());
+if (call.IsDocumentation())
-std::string r = GetResourceTypeText(t, false /* plural */, false /* upper case */);
+{
-call.GetDocumentation()
+std::string r = GetResourceTypeText(level, false /* plural */, false /* upper case */);
-.SetTag(GetResourceTypeText(t, true /* plural */, true /* upper case */))
+call.GetDocumentation()
+.SetTag(GetResourceTypeText(level, true /* plural */, true /* upper case */))
 .SetSummary("Set attachment")
 .SetDescription("Attach a file to the given DICOM " + r +
 ". This call will fail if trying to modify a system attachment (i.e. whose index is < 1024).")
 .SetUriArgument("id", "Orthanc identifier of the " + r + " of interest")
 .SetUriArgument("name", "The name of the attachment, or its index (cf. `UserContentType` configuration option)")
 .SetHttpHeader("If-Match", "Revision of the attachment, if this is not the first time this attachment is set.");
 return;
 }
 ServerContext& context = OrthancRestApi::GetContext(call);
-CheckValidResourceType(call);
 std::string publicId = call.GetUriComponent("id", "");
 std::string name = call.GetUriComponent("name", "");
 FileContentType contentType = StringToContentType(name);
 }
 static void DeleteAttachment(RestApiDeleteCall& call)
 {
-if (call.IsDocumentation())
+const ResourceType level = GetResourceTypeFromUri(call);
-{
-ResourceType t = StringToResourceType(call.GetFullUri()[0].c_str());
+if (call.IsDocumentation())
-std::string r = GetResourceTypeText(t, false /* plural */, false /* upper case */);
+{
-call.GetDocumentation()
+std::string r = GetResourceTypeText(level, false /* plural */, false /* upper case */);
-.SetTag(GetResourceTypeText(t, true /* plural */, true /* upper case */))
+call.GetDocumentation()
+.SetTag(GetResourceTypeText(level, true /* plural */, true /* upper case */))
 .SetSummary("Delete attachment")
 .SetDescription("Delete an attachment associated with the given DICOM " + r +
 ". This call will fail if trying to delete a system attachment (i.e. whose index is < 1024).")
 .SetUriArgument("id", "Orthanc identifier of the " + r + " of interest")
 .SetUriArgument("name", "The name of the attachment, or its index (cf. `UserContentType` configuration option)")
 .SetHttpHeader("If-Match", "Revision of the attachment, to check if its content has not changed and can "
 "be deleted. This header is mandatory if `CheckRevisions` option is `true`.");
 return;
 }
-CheckValidResourceType(call);
 std::string publicId = call.GetUriComponent("id", "");
 std::string name = call.GetUriComponent("name", "");
 FileContentType contentType = StringToContentType(name);
 bool allowed;
 template <enum CompressionType compression>
 static void ChangeAttachmentCompression(RestApiPostCall& call)
 {
-const ResourceType t = GetResourceTypeFromUri(call);
+const ResourceType level = GetResourceTypeFromUri(call);
 if (call.IsDocumentation())
 {
-std::string r = GetResourceTypeText(t, false /* plural */, false /* upper case */);
+std::string r = GetResourceTypeText(level, false /* plural */, false /* upper case */);
 call.GetDocumentation()
-.SetTag(GetResourceTypeText(t, true /* plural */, true /* upper case */))
+.SetTag(GetResourceTypeText(level, true /* plural */, true /* upper case */))
 .SetSummary(compression == CompressionType_None ? "Uncompress attachment" : "Compress attachment")
 .SetDescription("Change the compression scheme that is used to store an attachment.")
 .SetUriArgument("id", "Orthanc identifier of the " + r + " of interest")
 .SetUriArgument("name", "The name of the attachment, or its index (cf. `UserContentType` configuration option)");
 return;
 }
-CheckValidResourceType(call);
 std::string publicId = call.GetUriComponent("id", "");
 std::string name = call.GetUriComponent("name", "");
 FileContentType contentType = StringToContentType(name);
-OrthancRestApi::GetContext(call).ChangeAttachmentCompression(t, publicId, contentType, compression);
+OrthancRestApi::GetContext(call).ChangeAttachmentCompression(level, publicId, contentType, compression);
 call.GetOutput().AnswerBuffer("{}", MimeType_Json);
 }
 static void IsAttachmentCompressed(RestApiGetCall& call)
 {
-const ResourceType t = GetResourceTypeFromUri(call);
+const ResourceType level = GetResourceTypeFromUri(call);
 if (call.IsDocumentation())
 {
-std::string r = GetResourceTypeText(t, false /* plural */, false /* upper case */);
+std::string r = GetResourceTypeText(level, false /* plural */, false /* upper case */);
 AddAttachmentDocumentation(call, r);
 call.GetDocumentation()
-.SetTag(GetResourceTypeText(t, true /* plural */, true /* upper case */))
+.SetTag(GetResourceTypeText(level, true /* plural */, true /* upper case */))
 .SetSummary("Is attachment compressed?")
 .SetDescription("Test whether the attachment has been stored as a compressed file on the disk.")
 .AddAnswerType(MimeType_PlainText, "`0` if the attachment was stored uncompressed, `1` if it was compressed");
 return;
 }
 FileInfo info;
-if (GetAttachmentInfo(info, t, call))
+if (GetAttachmentInfo(info, level, call))
 {
 std::string answer = (info.GetCompressionType() == CompressionType_None) ? "0" : "1";
 call.GetOutput().AnswerBuffer(answer, MimeType_PlainText);
 }
 }
 }
 static void GetSharedTags(RestApiGetCall& call)
 {
+const ResourceType level = GetResourceTypeFromUri(call);
 if (call.IsDocumentation())
 {
 OrthancRestApi::DocumentDicomFormat(call, DicomToJsonFormat_Full);
-ResourceType t = StringToResourceType(call.GetFullUri()[0].c_str());
+std::string r = GetResourceTypeText(level, false /* plural */, false /* upper case */);
-std::string r = GetResourceTypeText(t, false /* plural */, false /* upper case */);
+call.GetDocumentation()
-call.GetDocumentation()
+.SetTag(GetResourceTypeText(level, true /* plural */, true /* upper case */))
-.SetTag(GetResourceTypeText(t, true /* plural */, true /* upper case */))
 .SetSummary("Get shared tags")
 .SetDescription("Extract the DICOM tags whose value is constant across all the child instances of "
 "the DICOM " + r + " whose Orthanc identifier is provided in the URL")
 .SetUriArgument("id", "Orthanc identifier of the " + r + " of interest")
 .AddAnswerType(MimeType_Json, "JSON object containing the values of the DICOM tags")
-.SetTruncatedJsonHttpGetSample(GetDocumentationSampleResource(t) + "/shared-tags", 5);
+.SetTruncatedJsonHttpGetSample(GetDocumentationSampleResource(level) + "/shared-tags", 5);
 return;
 }
 ServerContext& context = OrthancRestApi::GetContext(call);
 std::string publicId = call.GetUriComponent("id", "");
 }
 static void GetChildInstancesTags(RestApiGetCall& call)
 {
+const ResourceType level = GetResourceTypeFromUri(call);
 if (call.IsDocumentation())
 {
 OrthancRestApi::DocumentDicomFormat(call, DicomToJsonFormat_Full);
-ResourceType t = StringToResourceType(call.GetFullUri()[0].c_str());
+std::string r = GetResourceTypeText(level, false /* plural */, false /* upper case */);
-std::string r = GetResourceTypeText(t, false /* plural */, false /* upper case */);
+call.GetDocumentation()
-call.GetDocumentation()
+.SetTag(GetResourceTypeText(level, true /* plural */, true /* upper case */))
-.SetTag(GetResourceTypeText(t, true /* plural */, true /* upper case */))
 .SetSummary("Get tags of instances")
 .SetDescription("Get the tags of all the child instances of the DICOM " + r +
 " whose Orthanc identifier is provided in the URL")
 .SetUriArgument("id", "Orthanc identifier of the " + r + " of interest")
 .SetHttpGetArgument(IGNORE_LENGTH, RestApiCallDocumentation::Type_JsonListOfStrings,
 "Also include the DICOM tags that are provided in this list, even if their associated value is long", false)
 .AddAnswerType(MimeType_Json, "JSON object associating the Orthanc identifiers of the instances, with the values of their DICOM tags")
-.SetTruncatedJsonHttpGetSample(GetDocumentationSampleResource(t) + "/instances-tags", 5);
+.SetTruncatedJsonHttpGetSample(GetDocumentationSampleResource(level) + "/instances-tags", 5);
 return;
 }
 ServerContext& context = OrthancRestApi::GetContext(call);
 std::string publicId = call.GetUriComponent("id", "");

Mercurial > hg > orthanc

comparison OrthancServer/Sources/OrthancRestApi/OrthancRestResources.cpp @ 5851:6a4e47163b3c find-refactoring