Mercurial > hg > orthanc

comparison OrthancServer/Sources/ServerEnumerations.cpp @ 4044:d25f4c0fa160 framework

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
splitting code into OrthancFramework and OrthancServer
author Sebastien Jodogne <s.jodogne@gmail.com>
date Wed, 10 Jun 2020 20:30:34 +0200
parents OrthancServer/ServerEnumerations.cpp@5d2348b39392
children 05b8fd21089c
comparison
equal deleted inserted replaced
4043:6c6239aec462 4044:d25f4c0fa160
1 /**
2 * Orthanc - A Lightweight, RESTful DICOM Store
3 * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics
4 * Department, University Hospital of Liege, Belgium
5 * Copyright (C) 2017-2020 Osimis S.A., Belgium
6 *
7 * This program is free software: you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License as
9 * published by the Free Software Foundation, either version 3 of the
10 * License, or (at your option) any later version.
11 *
12 * In addition, as a special exception, the copyright holders of this
13 * program give permission to link the code of its release with the
14 * OpenSSL project's "OpenSSL" library (or with modified versions of it
15 * that use the same license as the "OpenSSL" library), and distribute
16 * the linked executables. You must obey the GNU General Public License
17 * in all respects for all of the code used other than "OpenSSL". If you
18 * modify file(s) with this exception, you may extend this exception to
19 * your version of the file(s), but you are not obligated to do so. If
20 * you do not wish to do so, delete this exception statement from your
21 * version. If you delete this exception statement from all source files
22 * in the program, then also delete it here.
23 *
24 * This program is distributed in the hope that it will be useful, but
25 * WITHOUT ANY WARRANTY; without even the implied warranty of
26 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
27 * General Public License for more details.
28 *
29 * You should have received a copy of the GNU General Public License
30 * along with this program. If not, see <http://www.gnu.org/licenses/>.
31 **/
32
33
34 #include "PrecompiledHeadersServer.h"
35 #include "ServerEnumerations.h"
36
37 #include "../Core/OrthancException.h"
38 #include "../Core/EnumerationDictionary.h"
39 #include "../Core/Logging.h"
40 #include "../Core/Toolbox.h"
41
42 #include <boost/thread.hpp>
43
44 namespace Orthanc
45 {
46 typedef std::map<FileContentType, std::string> MimeTypes;
47
48 static boost::mutex enumerationsMutex_;
49 static EnumerationDictionary<MetadataType> dictMetadataType_;
50 static EnumerationDictionary<FileContentType> dictContentType_;
51 static MimeTypes mimeTypes_;
52
53 void InitializeServerEnumerations()
54 {
55 boost::mutex::scoped_lock lock(enumerationsMutex_);
56
57 dictMetadataType_.Clear();
58 dictContentType_.Clear();
59
60 dictMetadataType_.Add(MetadataType_Instance_IndexInSeries, "IndexInSeries");
61 dictMetadataType_.Add(MetadataType_Instance_ReceptionDate, "ReceptionDate");
62 dictMetadataType_.Add(MetadataType_Instance_RemoteAet, "RemoteAET");
63 dictMetadataType_.Add(MetadataType_Series_ExpectedNumberOfInstances, "ExpectedNumberOfInstances");
64 dictMetadataType_.Add(MetadataType_ModifiedFrom, "ModifiedFrom");
65 dictMetadataType_.Add(MetadataType_AnonymizedFrom, "AnonymizedFrom");
66 dictMetadataType_.Add(MetadataType_LastUpdate, "LastUpdate");
67 dictMetadataType_.Add(MetadataType_Instance_Origin, "Origin");
68 dictMetadataType_.Add(MetadataType_Instance_TransferSyntax, "TransferSyntax");
69 dictMetadataType_.Add(MetadataType_Instance_SopClassUid, "SopClassUid");
70 dictMetadataType_.Add(MetadataType_Instance_RemoteIp, "RemoteIP");
71 dictMetadataType_.Add(MetadataType_Instance_CalledAet, "CalledAET");
72 dictMetadataType_.Add(MetadataType_Instance_HttpUsername, "HttpUsername");
73
74 dictContentType_.Add(FileContentType_Dicom, "dicom");
75 dictContentType_.Add(FileContentType_DicomAsJson, "dicom-as-json");
76 }
77
78 void RegisterUserMetadata(int metadata,
79 const std::string& name)
80 {
81 boost::mutex::scoped_lock lock(enumerationsMutex_);
82
83 MetadataType type = static_cast<MetadataType>(metadata);
84
85 if (metadata < 0 ||
86 !IsUserMetadata(type))
87 {
88 LOG(ERROR) << "A user content type must have index between "
89 << static_cast<int>(MetadataType_StartUser) << " and "
90 << static_cast<int>(MetadataType_EndUser) << ", but \""
91 << name << "\" has index " << metadata;
92
93 throw OrthancException(ErrorCode_ParameterOutOfRange);
94 }
95
96 if (dictMetadataType_.Contains(type))
97 {
98 LOG(ERROR) << "Cannot associate user content type \""
99 << name << "\" with index " << metadata
100 << ", as this index is already used";
101
102 throw OrthancException(ErrorCode_ParameterOutOfRange);
103 }
104
105 dictMetadataType_.Add(type, name);
106 }
107
108 std::string EnumerationToString(MetadataType type)
109 {
110 // This function MUST return a "std::string" and not "const
111 // char*", as the result is not a static string
112 boost::mutex::scoped_lock lock(enumerationsMutex_);
113 return dictMetadataType_.Translate(type);
114 }
115
116 MetadataType StringToMetadata(const std::string& str)
117 {
118 boost::mutex::scoped_lock lock(enumerationsMutex_);
119 return dictMetadataType_.Translate(str);
120 }
121
122 void RegisterUserContentType(int contentType,
123 const std::string& name,
124 const std::string& mime)
125 {
126 boost::mutex::scoped_lock lock(enumerationsMutex_);
127
128 FileContentType type = static_cast<FileContentType>(contentType);
129
130 if (contentType < 0 ||
131 !IsUserContentType(type))
132 {
133 LOG(ERROR) << "A user content type must have index between "
134 << static_cast<int>(FileContentType_StartUser) << " and "
135 << static_cast<int>(FileContentType_EndUser) << ", but \""
136 << name << "\" has index " << contentType;
137
138 throw OrthancException(ErrorCode_ParameterOutOfRange);
139 }
140
141 if (dictContentType_.Contains(type))
142 {
143 LOG(ERROR) << "Cannot associate user content type \""
144 << name << "\" with index " << contentType
145 << ", as this index is already used";
146
147 throw OrthancException(ErrorCode_ParameterOutOfRange);
148 }
149
150 dictContentType_.Add(type, name);
151 mimeTypes_[type] = mime;
152 }
153
154 std::string EnumerationToString(FileContentType type)
155 {
156 // This function MUST return a "std::string" and not "const
157 // char*", as the result is not a static string
158 boost::mutex::scoped_lock lock(enumerationsMutex_);
159 return dictContentType_.Translate(type);
160 }
161
162 std::string GetFileContentMime(FileContentType type)
163 {
164 if (type >= FileContentType_StartUser &&
165 type <= FileContentType_EndUser)
166 {
167 boost::mutex::scoped_lock lock(enumerationsMutex_);
168
169 MimeTypes::const_iterator it = mimeTypes_.find(type);
170 if (it != mimeTypes_.end())
171 {
172 return it->second;
173 }
174 }
175
176 switch (type)
177 {
178 case FileContentType_Dicom:
179 return EnumerationToString(MimeType_Dicom);
180
181 case FileContentType_DicomAsJson:
182 return MIME_JSON_UTF8;
183
184 default:
185 return EnumerationToString(MimeType_Binary);
186 }
187 }
188
189 FileContentType StringToContentType(const std::string& str)
190 {
191 boost::mutex::scoped_lock lock(enumerationsMutex_);
192 return dictContentType_.Translate(str);
193 }
194
195
196 FindStorageAccessMode StringToFindStorageAccessMode(const std::string& value)
197 {
198 if (value == "Always")
199 {
200 return FindStorageAccessMode_DiskOnLookupAndAnswer;
201 }
202 else if (value == "Never")
203 {
204 return FindStorageAccessMode_DatabaseOnly;
205 }
206 else if (value == "Answers")
207 {
208 return FindStorageAccessMode_DiskOnAnswer;
209 }
210 else
211 {
212 throw OrthancException(ErrorCode_ParameterOutOfRange,
213 "Configuration option \"StorageAccessOnFind\" "
214 "should be \"Always\", \"Never\" or \"Answers\": " + value);
215 }
216 }
217
218
219 BuiltinDecoderTranscoderOrder StringToBuiltinDecoderTranscoderOrder(const std::string& value)
220 {
221 if (value == "Before")
222 {
223 return BuiltinDecoderTranscoderOrder_Before;
224 }
225 else if (value == "After")
226 {
227 return BuiltinDecoderTranscoderOrder_After;
228 }
229 else if (value == "Disabled")
230 {
231 return BuiltinDecoderTranscoderOrder_Disabled;
232 }
233 else
234 {
235 throw OrthancException(ErrorCode_ParameterOutOfRange,
236 "Configuration option \"BuiltinDecoderTranscoderOrder\" "
237 "should be \"After\", \"Before\" or \"Disabled\": " + value);
238 }
239 }
240
241
242 std::string GetBasePath(ResourceType type,
243 const std::string& publicId)
244 {
245 switch (type)
246 {
247 case ResourceType_Patient:
248 return "/patients/" + publicId;
249
250 case ResourceType_Study:
251 return "/studies/" + publicId;
252
253 case ResourceType_Series:
254 return "/series/" + publicId;
255
256 case ResourceType_Instance:
257 return "/instances/" + publicId;
258
259 default:
260 throw OrthancException(ErrorCode_ParameterOutOfRange);
261 }
262 }
263
264 const char* EnumerationToString(SeriesStatus status)
265 {
266 switch (status)
267 {
268 case SeriesStatus_Complete:
269 return "Complete";
270
271 case SeriesStatus_Missing:
272 return "Missing";
273
274 case SeriesStatus_Inconsistent:
275 return "Inconsistent";
276
277 case SeriesStatus_Unknown:
278 return "Unknown";
279
280 default:
281 throw OrthancException(ErrorCode_ParameterOutOfRange);
282 }
283 }
284
285 const char* EnumerationToString(StoreStatus status)
286 {
287 switch (status)
288 {
289 case StoreStatus_Success:
290 return "Success";
291
292 case StoreStatus_AlreadyStored:
293 return "AlreadyStored";
294
295 case StoreStatus_Failure:
296 return "Failure";
297
298 case StoreStatus_FilteredOut:
299 return "FilteredOut";
300
301 default:
302 throw OrthancException(ErrorCode_ParameterOutOfRange);
303 }
304 }
305
306
307 const char* EnumerationToString(ChangeType type)
308 {
309 switch (type)
310 {
311 case ChangeType_CompletedSeries:
312 return "CompletedSeries";
313
314 case ChangeType_NewInstance:
315 return "NewInstance";
316
317 case ChangeType_NewPatient:
318 return "NewPatient";
319
320 case ChangeType_NewSeries:
321 return "NewSeries";
322
323 case ChangeType_NewStudy:
324 return "NewStudy";
325
326 case ChangeType_AnonymizedStudy:
327 return "AnonymizedStudy";
328
329 case ChangeType_AnonymizedSeries:
330 return "AnonymizedSeries";
331
332 case ChangeType_ModifiedStudy:
333 return "ModifiedStudy";
334
335 case ChangeType_ModifiedSeries:
336 return "ModifiedSeries";
337
338 case ChangeType_AnonymizedPatient:
339 return "AnonymizedPatient";
340
341 case ChangeType_ModifiedPatient:
342 return "ModifiedPatient";
343
344 case ChangeType_StablePatient:
345 return "StablePatient";
346
347 case ChangeType_StableStudy:
348 return "StableStudy";
349
350 case ChangeType_StableSeries:
351 return "StableSeries";
352
353 case ChangeType_Deleted:
354 return "Deleted";
355
356 case ChangeType_NewChildInstance:
357 return "NewChildInstance";
358
359 case ChangeType_UpdatedAttachment:
360 return "UpdatedAttachment";
361
362 case ChangeType_UpdatedMetadata:
363 return "UpdatedMetadata";
364
365 default:
366 throw OrthancException(ErrorCode_ParameterOutOfRange);
367 }
368 }
369
370
371 bool IsUserMetadata(MetadataType metadata)
372 {
373 return (metadata >= MetadataType_StartUser &&
374 metadata <= MetadataType_EndUser);
375 }
376 }