Mercurial > hg > orthanc-databases
comparison Framework/Plugins/OrthancCppDatabasePlugin.h @ 200:30b210616f4f
cont
author | Sebastien Jodogne <s.jodogne@gmail.com> |
---|---|
date | Thu, 18 Mar 2021 15:21:17 +0100 |
parents | 8cae98f73d53 |
children | 42990b2dd51b |
comparison
equal
deleted
inserted
replaced
199:8cae98f73d53 | 200:30b210616f4f |
---|---|
41 | 41 |
42 #include <OrthancException.h> | 42 #include <OrthancException.h> |
43 | 43 |
44 | 44 |
45 | 45 |
46 #define ORTHANC_PLUGINS_DATABASE_CATCH \ | 46 #define ORTHANC_PLUGINS_DATABASE_CATCH \ |
47 catch (::Orthanc::OrthancException& e) \ | 47 catch (::Orthanc::OrthancException& e) \ |
48 { \ | 48 { \ |
49 return static_cast<OrthancPluginErrorCode>(e.GetErrorCode()); \ | 49 return static_cast<OrthancPluginErrorCode>(e.GetErrorCode()); \ |
50 } \ | 50 } \ |
51 catch (::std::runtime_error& e) \ | 51 catch (::std::runtime_error& e) \ |
52 { \ | 52 { \ |
53 LogError(backend, e); \ | 53 LogError(backend, e); \ |
54 return OrthancPluginErrorCode_DatabasePlugin; \ | 54 return OrthancPluginErrorCode_DatabasePlugin; \ |
55 } \ | 55 } \ |
56 catch (...) \ | 56 catch (...) \ |
57 { \ | 57 { \ |
58 OrthancPluginLogError(backend->GetContext(), "Native exception"); \ | 58 OrthancPluginLogError(backend->GetContext(), "Native exception"); \ |
59 return OrthancPluginErrorCode_DatabasePlugin; \ | 59 return OrthancPluginErrorCode_DatabasePlugin; \ |
60 } | 60 } |
61 | 61 |
62 | 62 |
63 #include <stdexcept> | 63 #include <stdexcept> |
64 #include <list> | 64 #include <list> |
67 namespace OrthancPlugins | 67 namespace OrthancPlugins |
68 { | 68 { |
69 /** | 69 /** |
70 * @ingroup Callbacks | 70 * @ingroup Callbacks |
71 **/ | 71 **/ |
72 class DatabaseBackendOutput : public boost::noncopyable | 72 |
73 class IDatabaseBackendOutput : public boost::noncopyable | |
74 { | |
75 public: | |
76 virtual ~IDatabaseBackendOutput() | |
77 { | |
78 } | |
79 | |
80 virtual void SignalDeletedAttachment(const std::string& uuid, | |
81 int32_t contentType, | |
82 uint64_t uncompressedSize, | |
83 const std::string& uncompressedHash, | |
84 int32_t compressionType, | |
85 uint64_t compressedSize, | |
86 const std::string& compressedHash) = 0; | |
87 | |
88 virtual void SignalDeletedResource(const std::string& publicId, | |
89 OrthancPluginResourceType resourceType) = 0; | |
90 | |
91 virtual void SignalRemainingAncestor(const std::string& ancestorId, | |
92 OrthancPluginResourceType ancestorType) = 0; | |
93 | |
94 virtual void AnswerAttachment(const std::string& uuid, | |
95 int32_t contentType, | |
96 uint64_t uncompressedSize, | |
97 const std::string& uncompressedHash, | |
98 int32_t compressionType, | |
99 uint64_t compressedSize, | |
100 const std::string& compressedHash) = 0; | |
101 | |
102 virtual void AnswerChange(int64_t seq, | |
103 int32_t changeType, | |
104 OrthancPluginResourceType resourceType, | |
105 const std::string& publicId, | |
106 const std::string& date) = 0; | |
107 | |
108 virtual void AnswerDicomTag(uint16_t group, | |
109 uint16_t element, | |
110 const std::string& value) = 0; | |
111 | |
112 virtual void AnswerExportedResource(int64_t seq, | |
113 OrthancPluginResourceType resourceType, | |
114 const std::string& publicId, | |
115 const std::string& modality, | |
116 const std::string& date, | |
117 const std::string& patientId, | |
118 const std::string& studyInstanceUid, | |
119 const std::string& seriesInstanceUid, | |
120 const std::string& sopInstanceUid) = 0; | |
121 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1 | |
122 virtual void AnswerMatchingResource(const std::string& resourceId) = 0; | |
123 #endif | |
124 | |
125 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1 | |
126 virtual void AnswerMatchingResource(const std::string& resourceId, | |
127 const std::string& someInstanceId) = 0; | |
128 #endif | |
129 }; | |
130 | |
131 | |
132 /** | |
133 * @ingroup Callbacks | |
134 **/ | |
135 class IDatabaseBackend : public boost::noncopyable | |
136 { | |
137 private: | |
138 OrthancPluginContext* context_; | |
139 std::unique_ptr<IDatabaseBackendOutput> output_; | |
140 | |
141 public: | |
142 // "context" can be NULL iff. running the unit tests | |
143 IDatabaseBackend() : | |
144 context_(NULL) | |
145 { | |
146 } | |
147 | |
148 IDatabaseBackendOutput& GetOutput() | |
149 { | |
150 if (output_.get() == NULL) | |
151 { | |
152 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); | |
153 } | |
154 else | |
155 { | |
156 return *output_; | |
157 } | |
158 } | |
159 | |
160 OrthancPluginContext* GetContext() const | |
161 { | |
162 return context_; | |
163 } | |
164 | |
165 // This takes the ownership of the "output" | |
166 void RegisterOutput(OrthancPluginContext* context, | |
167 IDatabaseBackendOutput* output) | |
168 { | |
169 context_ = context; | |
170 output_.reset(output); | |
171 } | |
172 | |
173 virtual void Open() = 0; | |
174 | |
175 virtual void Close() = 0; | |
176 | |
177 virtual void AddAttachment(int64_t id, | |
178 const OrthancPluginAttachment& attachment) = 0; | |
179 | |
180 virtual void AttachChild(int64_t parent, | |
181 int64_t child) = 0; | |
182 | |
183 virtual void ClearChanges() = 0; | |
184 | |
185 virtual void ClearExportedResources() = 0; | |
186 | |
187 virtual int64_t CreateResource(const char* publicId, | |
188 OrthancPluginResourceType type) = 0; | |
189 | |
190 virtual void DeleteAttachment(int64_t id, | |
191 int32_t attachment) = 0; | |
192 | |
193 virtual void DeleteMetadata(int64_t id, | |
194 int32_t metadataType) = 0; | |
195 | |
196 virtual void DeleteResource(int64_t id) = 0; | |
197 | |
198 virtual void GetAllInternalIds(std::list<int64_t>& target, | |
199 OrthancPluginResourceType resourceType) = 0; | |
200 | |
201 virtual void GetAllPublicIds(std::list<std::string>& target, | |
202 OrthancPluginResourceType resourceType) = 0; | |
203 | |
204 virtual void GetAllPublicIds(std::list<std::string>& target, | |
205 OrthancPluginResourceType resourceType, | |
206 uint64_t since, | |
207 uint64_t limit) = 0; | |
208 | |
209 /* Use GetOutput().AnswerChange() */ | |
210 virtual void GetChanges(bool& done /*out*/, | |
211 int64_t since, | |
212 uint32_t maxResults) = 0; | |
213 | |
214 virtual void GetChildrenInternalId(std::list<int64_t>& target /*out*/, | |
215 int64_t id) = 0; | |
216 | |
217 virtual void GetChildrenPublicId(std::list<std::string>& target /*out*/, | |
218 int64_t id) = 0; | |
219 | |
220 /* Use GetOutput().AnswerExportedResource() */ | |
221 virtual void GetExportedResources(bool& done /*out*/, | |
222 int64_t since, | |
223 uint32_t maxResults) = 0; | |
224 | |
225 /* Use GetOutput().AnswerChange() */ | |
226 virtual void GetLastChange() = 0; | |
227 | |
228 /* Use GetOutput().AnswerExportedResource() */ | |
229 virtual void GetLastExportedResource() = 0; | |
230 | |
231 /* Use GetOutput().AnswerDicomTag() */ | |
232 virtual void GetMainDicomTags(int64_t id) = 0; | |
233 | |
234 virtual std::string GetPublicId(int64_t resourceId) = 0; | |
235 | |
236 virtual uint64_t GetResourceCount(OrthancPluginResourceType resourceType) = 0; | |
237 | |
238 virtual OrthancPluginResourceType GetResourceType(int64_t resourceId) = 0; | |
239 | |
240 virtual uint64_t GetTotalCompressedSize() = 0; | |
241 | |
242 virtual uint64_t GetTotalUncompressedSize() = 0; | |
243 | |
244 virtual bool IsExistingResource(int64_t internalId) = 0; | |
245 | |
246 virtual bool IsProtectedPatient(int64_t internalId) = 0; | |
247 | |
248 virtual void ListAvailableMetadata(std::list<int32_t>& target /*out*/, | |
249 int64_t id) = 0; | |
250 | |
251 virtual void ListAvailableAttachments(std::list<int32_t>& target /*out*/, | |
252 int64_t id) = 0; | |
253 | |
254 virtual void LogChange(const OrthancPluginChange& change) = 0; | |
255 | |
256 virtual void LogExportedResource(const OrthancPluginExportedResource& resource) = 0; | |
257 | |
258 /* Use GetOutput().AnswerAttachment() */ | |
259 virtual bool LookupAttachment(int64_t id, | |
260 int32_t contentType) = 0; | |
261 | |
262 virtual bool LookupGlobalProperty(std::string& target /*out*/, | |
263 int32_t property) = 0; | |
264 | |
265 virtual void LookupIdentifier(std::list<int64_t>& target /*out*/, | |
266 OrthancPluginResourceType resourceType, | |
267 uint16_t group, | |
268 uint16_t element, | |
269 OrthancPluginIdentifierConstraint constraint, | |
270 const char* value) = 0; | |
271 | |
272 virtual void LookupIdentifierRange(std::list<int64_t>& target /*out*/, | |
273 OrthancPluginResourceType resourceType, | |
274 uint16_t group, | |
275 uint16_t element, | |
276 const char* start, | |
277 const char* end) = 0; | |
278 | |
279 virtual bool LookupMetadata(std::string& target /*out*/, | |
280 int64_t id, | |
281 int32_t metadataType) = 0; | |
282 | |
283 virtual bool LookupParent(int64_t& parentId /*out*/, | |
284 int64_t resourceId) = 0; | |
285 | |
286 virtual bool LookupResource(int64_t& id /*out*/, | |
287 OrthancPluginResourceType& type /*out*/, | |
288 const char* publicId) = 0; | |
289 | |
290 virtual bool SelectPatientToRecycle(int64_t& internalId /*out*/) = 0; | |
291 | |
292 virtual bool SelectPatientToRecycle(int64_t& internalId /*out*/, | |
293 int64_t patientIdToAvoid) = 0; | |
294 | |
295 virtual void SetGlobalProperty(int32_t property, | |
296 const char* value) = 0; | |
297 | |
298 virtual void SetMainDicomTag(int64_t id, | |
299 uint16_t group, | |
300 uint16_t element, | |
301 const char* value) = 0; | |
302 | |
303 virtual void SetIdentifierTag(int64_t id, | |
304 uint16_t group, | |
305 uint16_t element, | |
306 const char* value) = 0; | |
307 | |
308 virtual void SetMetadata(int64_t id, | |
309 int32_t metadataType, | |
310 const char* value) = 0; | |
311 | |
312 virtual void SetProtectedPatient(int64_t internalId, | |
313 bool isProtected) = 0; | |
314 | |
315 virtual void StartTransaction() = 0; | |
316 | |
317 virtual void RollbackTransaction() = 0; | |
318 | |
319 virtual void CommitTransaction() = 0; | |
320 | |
321 virtual uint32_t GetDatabaseVersion() = 0; | |
322 | |
323 /** | |
324 * Upgrade the database to the specified version of the database | |
325 * schema. The upgrade script is allowed to make calls to | |
326 * OrthancPluginReconstructMainDicomTags(). | |
327 **/ | |
328 virtual void UpgradeDatabase(uint32_t targetVersion, | |
329 OrthancPluginStorageArea* storageArea) = 0; | |
330 | |
331 virtual void ClearMainDicomTags(int64_t internalId) = 0; | |
332 | |
333 virtual bool HasCreateInstance() const | |
334 { | |
335 return false; | |
336 } | |
337 | |
338 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1 | |
339 virtual void LookupResources(const std::vector<Orthanc::DatabaseConstraint>& lookup, | |
340 OrthancPluginResourceType queryLevel, | |
341 uint32_t limit, | |
342 bool requestSomeInstance) = 0; | |
343 #endif | |
344 | |
345 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1 | |
346 virtual void CreateInstance(OrthancPluginCreateInstanceResult& result, | |
347 const char* hashPatient, | |
348 const char* hashStudy, | |
349 const char* hashSeries, | |
350 const char* hashInstance) | |
351 { | |
352 throw std::runtime_error("Not implemented"); | |
353 } | |
354 #endif | |
355 | |
356 | |
357 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1 | |
358 virtual void SetResourcesContent( | |
359 uint32_t countIdentifierTags, | |
360 const OrthancPluginResourcesContentTags* identifierTags, | |
361 uint32_t countMainDicomTags, | |
362 const OrthancPluginResourcesContentTags* mainDicomTags, | |
363 uint32_t countMetadata, | |
364 const OrthancPluginResourcesContentMetadata* metadata) = 0; | |
365 #endif | |
366 | |
367 | |
368 virtual void GetChildrenMetadata(std::list<std::string>& target, | |
369 int64_t resourceId, | |
370 int32_t metadata) = 0; | |
371 | |
372 virtual int64_t GetLastChangeIndex() = 0; | |
373 | |
374 virtual void TagMostRecentPatient(int64_t patientId) = 0; | |
375 | |
376 #if defined(ORTHANC_PLUGINS_VERSION_IS_ABOVE) // Macro introduced in 1.3.1 | |
377 # if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 5, 4) | |
378 // NB: "parentPublicId" must be cleared if the resource has no parent | |
379 virtual bool LookupResourceAndParent(int64_t& id, | |
380 OrthancPluginResourceType& type, | |
381 std::string& parentPublicId, | |
382 const char* publicId) = 0; | |
383 # endif | |
384 #endif | |
385 | |
386 #if defined(ORTHANC_PLUGINS_VERSION_IS_ABOVE) // Macro introduced in 1.3.1 | |
387 # if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 5, 4) | |
388 virtual void GetAllMetadata(std::map<int32_t, std::string>& result, | |
389 int64_t id) = 0; | |
390 # endif | |
391 #endif | |
392 }; | |
393 | |
394 | |
395 | |
396 class DatabaseBackendOutputV2 : public IDatabaseBackendOutput | |
73 { | 397 { |
74 public: | 398 public: |
75 enum AllowedAnswers | 399 enum AllowedAnswers |
76 { | 400 { |
77 AllowedAnswers_All, | 401 AllowedAnswers_All, |
89 OrthancPluginContext* context_; | 413 OrthancPluginContext* context_; |
90 OrthancPluginDatabaseContext* database_; | 414 OrthancPluginDatabaseContext* database_; |
91 AllowedAnswers allowedAnswers_; | 415 AllowedAnswers allowedAnswers_; |
92 | 416 |
93 public: | 417 public: |
94 DatabaseBackendOutput(OrthancPluginContext* context, | 418 DatabaseBackendOutputV2(OrthancPluginContext* context, |
95 OrthancPluginDatabaseContext* database) : | 419 OrthancPluginDatabaseContext* database) : |
96 context_(context), | 420 context_(context), |
97 database_(database), | 421 database_(database), |
98 allowedAnswers_(AllowedAnswers_All /* for unit tests */) | 422 allowedAnswers_(AllowedAnswers_All /* for unit tests */) |
99 { | 423 { |
100 } | 424 } |
107 OrthancPluginDatabaseContext* GetDatabase() const | 431 OrthancPluginDatabaseContext* GetDatabase() const |
108 { | 432 { |
109 return database_; | 433 return database_; |
110 } | 434 } |
111 | 435 |
112 void SignalDeletedAttachment(const std::string& uuid, | 436 virtual void SignalDeletedAttachment(const std::string& uuid, |
113 int32_t contentType, | 437 int32_t contentType, |
114 uint64_t uncompressedSize, | 438 uint64_t uncompressedSize, |
115 const std::string& uncompressedHash, | 439 const std::string& uncompressedHash, |
116 int32_t compressionType, | 440 int32_t compressionType, |
117 uint64_t compressedSize, | 441 uint64_t compressedSize, |
118 const std::string& compressedHash) | 442 const std::string& compressedHash) ORTHANC_OVERRIDE |
119 { | 443 { |
120 OrthancPluginAttachment attachment; | 444 OrthancPluginAttachment attachment; |
121 attachment.uuid = uuid.c_str(); | 445 attachment.uuid = uuid.c_str(); |
122 attachment.contentType = contentType; | 446 attachment.contentType = contentType; |
123 attachment.uncompressedSize = uncompressedSize; | 447 attachment.uncompressedSize = uncompressedSize; |
127 attachment.compressedHash = compressedHash.c_str(); | 451 attachment.compressedHash = compressedHash.c_str(); |
128 | 452 |
129 OrthancPluginDatabaseSignalDeletedAttachment(context_, database_, &attachment); | 453 OrthancPluginDatabaseSignalDeletedAttachment(context_, database_, &attachment); |
130 } | 454 } |
131 | 455 |
132 void SignalDeletedResource(const std::string& publicId, | 456 virtual void SignalDeletedResource(const std::string& publicId, |
133 OrthancPluginResourceType resourceType) | 457 OrthancPluginResourceType resourceType) ORTHANC_OVERRIDE |
134 { | 458 { |
135 OrthancPluginDatabaseSignalDeletedResource(context_, database_, publicId.c_str(), resourceType); | 459 OrthancPluginDatabaseSignalDeletedResource(context_, database_, publicId.c_str(), resourceType); |
136 } | 460 } |
137 | 461 |
138 void SignalRemainingAncestor(const std::string& ancestorId, | 462 virtual void SignalRemainingAncestor(const std::string& ancestorId, |
139 OrthancPluginResourceType ancestorType) | 463 OrthancPluginResourceType ancestorType) ORTHANC_OVERRIDE |
140 { | 464 { |
141 OrthancPluginDatabaseSignalRemainingAncestor(context_, database_, ancestorId.c_str(), ancestorType); | 465 OrthancPluginDatabaseSignalRemainingAncestor(context_, database_, ancestorId.c_str(), ancestorType); |
142 } | 466 } |
143 | 467 |
144 void AnswerAttachment(const std::string& uuid, | 468 virtual void AnswerAttachment(const std::string& uuid, |
145 int32_t contentType, | 469 int32_t contentType, |
146 uint64_t uncompressedSize, | 470 uint64_t uncompressedSize, |
147 const std::string& uncompressedHash, | 471 const std::string& uncompressedHash, |
148 int32_t compressionType, | 472 int32_t compressionType, |
149 uint64_t compressedSize, | 473 uint64_t compressedSize, |
150 const std::string& compressedHash) | 474 const std::string& compressedHash) ORTHANC_OVERRIDE |
151 { | 475 { |
152 if (allowedAnswers_ != AllowedAnswers_All && | 476 if (allowedAnswers_ != AllowedAnswers_All && |
153 allowedAnswers_ != AllowedAnswers_Attachment) | 477 allowedAnswers_ != AllowedAnswers_Attachment) |
154 { | 478 { |
155 throw std::runtime_error("Cannot answer with an attachment in the current state"); | 479 throw std::runtime_error("Cannot answer with an attachment in the current state"); |
165 attachment.compressedHash = compressedHash.c_str(); | 489 attachment.compressedHash = compressedHash.c_str(); |
166 | 490 |
167 OrthancPluginDatabaseAnswerAttachment(context_, database_, &attachment); | 491 OrthancPluginDatabaseAnswerAttachment(context_, database_, &attachment); |
168 } | 492 } |
169 | 493 |
170 void AnswerChange(int64_t seq, | 494 virtual void AnswerChange(int64_t seq, |
171 int32_t changeType, | 495 int32_t changeType, |
172 OrthancPluginResourceType resourceType, | 496 OrthancPluginResourceType resourceType, |
173 const std::string& publicId, | 497 const std::string& publicId, |
174 const std::string& date) | 498 const std::string& date) ORTHANC_OVERRIDE |
175 { | 499 { |
176 if (allowedAnswers_ != AllowedAnswers_All && | 500 if (allowedAnswers_ != AllowedAnswers_All && |
177 allowedAnswers_ != AllowedAnswers_Change) | 501 allowedAnswers_ != AllowedAnswers_Change) |
178 { | 502 { |
179 throw std::runtime_error("Cannot answer with a change in the current state"); | 503 throw std::runtime_error("Cannot answer with a change in the current state"); |
187 change.date = date.c_str(); | 511 change.date = date.c_str(); |
188 | 512 |
189 OrthancPluginDatabaseAnswerChange(context_, database_, &change); | 513 OrthancPluginDatabaseAnswerChange(context_, database_, &change); |
190 } | 514 } |
191 | 515 |
192 void AnswerDicomTag(uint16_t group, | 516 virtual void AnswerDicomTag(uint16_t group, |
193 uint16_t element, | 517 uint16_t element, |
194 const std::string& value) | 518 const std::string& value) ORTHANC_OVERRIDE |
195 { | 519 { |
196 if (allowedAnswers_ != AllowedAnswers_All && | 520 if (allowedAnswers_ != AllowedAnswers_All && |
197 allowedAnswers_ != AllowedAnswers_DicomTag) | 521 allowedAnswers_ != AllowedAnswers_DicomTag) |
198 { | 522 { |
199 throw std::runtime_error("Cannot answer with a DICOM tag in the current state"); | 523 throw std::runtime_error("Cannot answer with a DICOM tag in the current state"); |
205 tag.value = value.c_str(); | 529 tag.value = value.c_str(); |
206 | 530 |
207 OrthancPluginDatabaseAnswerDicomTag(context_, database_, &tag); | 531 OrthancPluginDatabaseAnswerDicomTag(context_, database_, &tag); |
208 } | 532 } |
209 | 533 |
210 void AnswerExportedResource(int64_t seq, | 534 virtual void AnswerExportedResource(int64_t seq, |
211 OrthancPluginResourceType resourceType, | 535 OrthancPluginResourceType resourceType, |
212 const std::string& publicId, | 536 const std::string& publicId, |
213 const std::string& modality, | 537 const std::string& modality, |
214 const std::string& date, | 538 const std::string& date, |
215 const std::string& patientId, | 539 const std::string& patientId, |
216 const std::string& studyInstanceUid, | 540 const std::string& studyInstanceUid, |
217 const std::string& seriesInstanceUid, | 541 const std::string& seriesInstanceUid, |
218 const std::string& sopInstanceUid) | 542 const std::string& sopInstanceUid) ORTHANC_OVERRIDE |
219 { | 543 { |
220 if (allowedAnswers_ != AllowedAnswers_All && | 544 if (allowedAnswers_ != AllowedAnswers_All && |
221 allowedAnswers_ != AllowedAnswers_ExportedResource) | 545 allowedAnswers_ != AllowedAnswers_ExportedResource) |
222 { | 546 { |
223 throw std::runtime_error("Cannot answer with an exported resource in the current state"); | 547 throw std::runtime_error("Cannot answer with an exported resource in the current state"); |
237 OrthancPluginDatabaseAnswerExportedResource(context_, database_, &exported); | 561 OrthancPluginDatabaseAnswerExportedResource(context_, database_, &exported); |
238 } | 562 } |
239 | 563 |
240 | 564 |
241 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1 | 565 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1 |
242 void AnswerMatchingResource(const std::string& resourceId) | 566 virtual void AnswerMatchingResource(const std::string& resourceId) ORTHANC_OVERRIDE |
243 { | 567 { |
244 if (allowedAnswers_ != AllowedAnswers_All && | 568 if (allowedAnswers_ != AllowedAnswers_All && |
245 allowedAnswers_ != AllowedAnswers_MatchingResource) | 569 allowedAnswers_ != AllowedAnswers_MatchingResource) |
246 { | 570 { |
247 throw std::runtime_error("Cannot answer with an exported resource in the current state"); | 571 throw std::runtime_error("Cannot answer with an exported resource in the current state"); |
255 } | 579 } |
256 #endif | 580 #endif |
257 | 581 |
258 | 582 |
259 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1 | 583 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1 |
260 void AnswerMatchingResource(const std::string& resourceId, | 584 virtual void AnswerMatchingResource(const std::string& resourceId, |
261 const std::string& someInstanceId) | 585 const std::string& someInstanceId) ORTHANC_OVERRIDE |
262 { | 586 { |
263 if (allowedAnswers_ != AllowedAnswers_All && | 587 if (allowedAnswers_ != AllowedAnswers_All && |
264 allowedAnswers_ != AllowedAnswers_MatchingResource) | 588 allowedAnswers_ != AllowedAnswers_MatchingResource) |
265 { | 589 { |
266 throw std::runtime_error("Cannot answer with an exported resource in the current state"); | 590 throw std::runtime_error("Cannot answer with an exported resource in the current state"); |
272 | 596 |
273 OrthancPluginDatabaseAnswerMatchingResource(context_, database_, &match); | 597 OrthancPluginDatabaseAnswerMatchingResource(context_, database_, &match); |
274 } | 598 } |
275 #endif | 599 #endif |
276 }; | 600 }; |
277 | |
278 | |
279 /** | |
280 * @ingroup Callbacks | |
281 **/ | |
282 class IDatabaseBackend : public boost::noncopyable | |
283 { | |
284 private: | |
285 OrthancPluginContext* context_; | |
286 DatabaseBackendOutput* output_; | |
287 | |
288 void Finalize() | |
289 { | |
290 if (output_ != NULL) | |
291 { | |
292 delete output_; | |
293 output_ = NULL; | |
294 } | |
295 } | |
296 | |
297 public: | |
298 // "context" can be NULL iff. running the unit tests | |
299 IDatabaseBackend() : | |
300 context_(NULL), | |
301 output_(NULL) | |
302 { | |
303 } | |
304 | |
305 virtual ~IDatabaseBackend() | |
306 { | |
307 Finalize(); | |
308 } | |
309 | |
310 DatabaseBackendOutput& GetOutput() | |
311 { | |
312 return *output_; | |
313 } | |
314 | |
315 OrthancPluginContext* GetContext() const | |
316 { | |
317 return context_; | |
318 } | |
319 | |
320 // This takes the ownership | |
321 void RegisterOutput(OrthancPluginContext* context, | |
322 DatabaseBackendOutput* output) | |
323 { | |
324 Finalize(); | |
325 context_ = context; | |
326 output_ = output; | |
327 } | |
328 | |
329 virtual void Open() = 0; | |
330 | |
331 virtual void Close() = 0; | |
332 | |
333 virtual void AddAttachment(int64_t id, | |
334 const OrthancPluginAttachment& attachment) = 0; | |
335 | |
336 virtual void AttachChild(int64_t parent, | |
337 int64_t child) = 0; | |
338 | |
339 virtual void ClearChanges() = 0; | |
340 | |
341 virtual void ClearExportedResources() = 0; | |
342 | |
343 virtual int64_t CreateResource(const char* publicId, | |
344 OrthancPluginResourceType type) = 0; | |
345 | |
346 virtual void DeleteAttachment(int64_t id, | |
347 int32_t attachment) = 0; | |
348 | |
349 virtual void DeleteMetadata(int64_t id, | |
350 int32_t metadataType) = 0; | |
351 | |
352 virtual void DeleteResource(int64_t id) = 0; | |
353 | |
354 virtual void GetAllInternalIds(std::list<int64_t>& target, | |
355 OrthancPluginResourceType resourceType) = 0; | |
356 | |
357 virtual void GetAllPublicIds(std::list<std::string>& target, | |
358 OrthancPluginResourceType resourceType) = 0; | |
359 | |
360 virtual void GetAllPublicIds(std::list<std::string>& target, | |
361 OrthancPluginResourceType resourceType, | |
362 uint64_t since, | |
363 uint64_t limit) = 0; | |
364 | |
365 /* Use GetOutput().AnswerChange() */ | |
366 virtual void GetChanges(bool& done /*out*/, | |
367 int64_t since, | |
368 uint32_t maxResults) = 0; | |
369 | |
370 virtual void GetChildrenInternalId(std::list<int64_t>& target /*out*/, | |
371 int64_t id) = 0; | |
372 | |
373 virtual void GetChildrenPublicId(std::list<std::string>& target /*out*/, | |
374 int64_t id) = 0; | |
375 | |
376 /* Use GetOutput().AnswerExportedResource() */ | |
377 virtual void GetExportedResources(bool& done /*out*/, | |
378 int64_t since, | |
379 uint32_t maxResults) = 0; | |
380 | |
381 /* Use GetOutput().AnswerChange() */ | |
382 virtual void GetLastChange() = 0; | |
383 | |
384 /* Use GetOutput().AnswerExportedResource() */ | |
385 virtual void GetLastExportedResource() = 0; | |
386 | |
387 /* Use GetOutput().AnswerDicomTag() */ | |
388 virtual void GetMainDicomTags(int64_t id) = 0; | |
389 | |
390 virtual std::string GetPublicId(int64_t resourceId) = 0; | |
391 | |
392 virtual uint64_t GetResourceCount(OrthancPluginResourceType resourceType) = 0; | |
393 | |
394 virtual OrthancPluginResourceType GetResourceType(int64_t resourceId) = 0; | |
395 | |
396 virtual uint64_t GetTotalCompressedSize() = 0; | |
397 | |
398 virtual uint64_t GetTotalUncompressedSize() = 0; | |
399 | |
400 virtual bool IsExistingResource(int64_t internalId) = 0; | |
401 | |
402 virtual bool IsProtectedPatient(int64_t internalId) = 0; | |
403 | |
404 virtual void ListAvailableMetadata(std::list<int32_t>& target /*out*/, | |
405 int64_t id) = 0; | |
406 | |
407 virtual void ListAvailableAttachments(std::list<int32_t>& target /*out*/, | |
408 int64_t id) = 0; | |
409 | |
410 virtual void LogChange(const OrthancPluginChange& change) = 0; | |
411 | |
412 virtual void LogExportedResource(const OrthancPluginExportedResource& resource) = 0; | |
413 | |
414 /* Use GetOutput().AnswerAttachment() */ | |
415 virtual bool LookupAttachment(int64_t id, | |
416 int32_t contentType) = 0; | |
417 | |
418 virtual bool LookupGlobalProperty(std::string& target /*out*/, | |
419 int32_t property) = 0; | |
420 | |
421 virtual void LookupIdentifier(std::list<int64_t>& target /*out*/, | |
422 OrthancPluginResourceType resourceType, | |
423 uint16_t group, | |
424 uint16_t element, | |
425 OrthancPluginIdentifierConstraint constraint, | |
426 const char* value) = 0; | |
427 | |
428 virtual void LookupIdentifierRange(std::list<int64_t>& target /*out*/, | |
429 OrthancPluginResourceType resourceType, | |
430 uint16_t group, | |
431 uint16_t element, | |
432 const char* start, | |
433 const char* end) = 0; | |
434 | |
435 virtual bool LookupMetadata(std::string& target /*out*/, | |
436 int64_t id, | |
437 int32_t metadataType) = 0; | |
438 | |
439 virtual bool LookupParent(int64_t& parentId /*out*/, | |
440 int64_t resourceId) = 0; | |
441 | |
442 virtual bool LookupResource(int64_t& id /*out*/, | |
443 OrthancPluginResourceType& type /*out*/, | |
444 const char* publicId) = 0; | |
445 | |
446 virtual bool SelectPatientToRecycle(int64_t& internalId /*out*/) = 0; | |
447 | |
448 virtual bool SelectPatientToRecycle(int64_t& internalId /*out*/, | |
449 int64_t patientIdToAvoid) = 0; | |
450 | |
451 virtual void SetGlobalProperty(int32_t property, | |
452 const char* value) = 0; | |
453 | |
454 virtual void SetMainDicomTag(int64_t id, | |
455 uint16_t group, | |
456 uint16_t element, | |
457 const char* value) = 0; | |
458 | |
459 virtual void SetIdentifierTag(int64_t id, | |
460 uint16_t group, | |
461 uint16_t element, | |
462 const char* value) = 0; | |
463 | |
464 virtual void SetMetadata(int64_t id, | |
465 int32_t metadataType, | |
466 const char* value) = 0; | |
467 | |
468 virtual void SetProtectedPatient(int64_t internalId, | |
469 bool isProtected) = 0; | |
470 | |
471 virtual void StartTransaction() = 0; | |
472 | |
473 virtual void RollbackTransaction() = 0; | |
474 | |
475 virtual void CommitTransaction() = 0; | |
476 | |
477 virtual uint32_t GetDatabaseVersion() = 0; | |
478 | |
479 /** | |
480 * Upgrade the database to the specified version of the database | |
481 * schema. The upgrade script is allowed to make calls to | |
482 * OrthancPluginReconstructMainDicomTags(). | |
483 **/ | |
484 virtual void UpgradeDatabase(uint32_t targetVersion, | |
485 OrthancPluginStorageArea* storageArea) = 0; | |
486 | |
487 virtual void ClearMainDicomTags(int64_t internalId) = 0; | |
488 | |
489 virtual bool HasCreateInstance() const | |
490 { | |
491 return false; | |
492 } | |
493 | |
494 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1 | |
495 virtual void LookupResources(const std::vector<Orthanc::DatabaseConstraint>& lookup, | |
496 OrthancPluginResourceType queryLevel, | |
497 uint32_t limit, | |
498 bool requestSomeInstance) = 0; | |
499 #endif | |
500 | |
501 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1 | |
502 virtual void CreateInstance(OrthancPluginCreateInstanceResult& result, | |
503 const char* hashPatient, | |
504 const char* hashStudy, | |
505 const char* hashSeries, | |
506 const char* hashInstance) | |
507 { | |
508 throw std::runtime_error("Not implemented"); | |
509 } | |
510 #endif | |
511 | |
512 | |
513 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1 | |
514 virtual void SetResourcesContent( | |
515 uint32_t countIdentifierTags, | |
516 const OrthancPluginResourcesContentTags* identifierTags, | |
517 uint32_t countMainDicomTags, | |
518 const OrthancPluginResourcesContentTags* mainDicomTags, | |
519 uint32_t countMetadata, | |
520 const OrthancPluginResourcesContentMetadata* metadata) = 0; | |
521 #endif | |
522 | |
523 | |
524 virtual void GetChildrenMetadata(std::list<std::string>& target, | |
525 int64_t resourceId, | |
526 int32_t metadata) = 0; | |
527 | |
528 virtual int64_t GetLastChangeIndex() = 0; | |
529 | |
530 virtual void TagMostRecentPatient(int64_t patientId) = 0; | |
531 | |
532 #if defined(ORTHANC_PLUGINS_VERSION_IS_ABOVE) // Macro introduced in 1.3.1 | |
533 # if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 5, 4) | |
534 // NB: "parentPublicId" must be cleared if the resource has no parent | |
535 virtual bool LookupResourceAndParent(int64_t& id, | |
536 OrthancPluginResourceType& type, | |
537 std::string& parentPublicId, | |
538 const char* publicId) = 0; | |
539 # endif | |
540 #endif | |
541 | |
542 #if defined(ORTHANC_PLUGINS_VERSION_IS_ABOVE) // Macro introduced in 1.3.1 | |
543 # if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 5, 4) | |
544 virtual void GetAllMetadata(std::map<int32_t, std::string>& result, | |
545 int64_t id) = 0; | |
546 # endif | |
547 #endif | |
548 }; | |
549 | |
550 | 601 |
551 | 602 |
552 /** | 603 /** |
553 * @brief Bridge between C and C++ database engines. | 604 * @brief Bridge between C and C++ database engines. |
554 * | 605 * |
556 * custom database engines, and the high-level IDatabaseBackend C++ | 607 * custom database engines, and the high-level IDatabaseBackend C++ |
557 * interface. | 608 * interface. |
558 * | 609 * |
559 * @ingroup Callbacks | 610 * @ingroup Callbacks |
560 **/ | 611 **/ |
561 class DatabaseBackendAdapter | 612 class DatabaseBackendAdapterV2 |
562 { | 613 { |
563 private: | 614 private: |
564 // This class cannot be instantiated | 615 // This class cannot be instantiated |
565 DatabaseBackendAdapter() | 616 DatabaseBackendAdapterV2() |
566 { | 617 { |
567 } | 618 } |
568 | 619 |
569 static void LogError(IDatabaseBackend* backend, | 620 static void LogError(IDatabaseBackend* backend, |
570 const std::runtime_error& e) | 621 const std::runtime_error& e) |
577 static OrthancPluginErrorCode AddAttachment(void* payload, | 628 static OrthancPluginErrorCode AddAttachment(void* payload, |
578 int64_t id, | 629 int64_t id, |
579 const OrthancPluginAttachment* attachment) | 630 const OrthancPluginAttachment* attachment) |
580 { | 631 { |
581 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 632 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
582 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 633 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
634 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
583 | 635 |
584 try | 636 try |
585 { | 637 { |
586 backend->AddAttachment(id, *attachment); | 638 backend->AddAttachment(id, *attachment); |
587 return OrthancPluginErrorCode_Success; | 639 return OrthancPluginErrorCode_Success; |
588 } | 640 } |
589 ORTHANC_PLUGINS_DATABASE_CATCH | 641 ORTHANC_PLUGINS_DATABASE_CATCH; |
590 } | 642 } |
591 | 643 |
592 | 644 |
593 static OrthancPluginErrorCode AttachChild(void* payload, | 645 static OrthancPluginErrorCode AttachChild(void* payload, |
594 int64_t parent, | 646 int64_t parent, |
595 int64_t child) | 647 int64_t child) |
596 { | 648 { |
597 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 649 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
598 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 650 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
651 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
599 | 652 |
600 try | 653 try |
601 { | 654 { |
602 backend->AttachChild(parent, child); | 655 backend->AttachChild(parent, child); |
603 return OrthancPluginErrorCode_Success; | 656 return OrthancPluginErrorCode_Success; |
604 } | 657 } |
605 ORTHANC_PLUGINS_DATABASE_CATCH | 658 ORTHANC_PLUGINS_DATABASE_CATCH; |
606 } | 659 } |
607 | 660 |
608 | 661 |
609 static OrthancPluginErrorCode ClearChanges(void* payload) | 662 static OrthancPluginErrorCode ClearChanges(void* payload) |
610 { | 663 { |
611 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 664 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
612 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 665 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
666 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
613 | 667 |
614 try | 668 try |
615 { | 669 { |
616 backend->ClearChanges(); | 670 backend->ClearChanges(); |
617 return OrthancPluginErrorCode_Success; | 671 return OrthancPluginErrorCode_Success; |
618 } | 672 } |
619 ORTHANC_PLUGINS_DATABASE_CATCH | 673 ORTHANC_PLUGINS_DATABASE_CATCH; |
620 } | 674 } |
621 | 675 |
622 | 676 |
623 static OrthancPluginErrorCode ClearExportedResources(void* payload) | 677 static OrthancPluginErrorCode ClearExportedResources(void* payload) |
624 { | 678 { |
625 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 679 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
626 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 680 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
681 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
627 | 682 |
628 try | 683 try |
629 { | 684 { |
630 backend->ClearExportedResources(); | 685 backend->ClearExportedResources(); |
631 return OrthancPluginErrorCode_Success; | 686 return OrthancPluginErrorCode_Success; |
632 } | 687 } |
633 ORTHANC_PLUGINS_DATABASE_CATCH | 688 ORTHANC_PLUGINS_DATABASE_CATCH; |
634 } | 689 } |
635 | 690 |
636 | 691 |
637 static OrthancPluginErrorCode CreateResource(int64_t* id, | 692 static OrthancPluginErrorCode CreateResource(int64_t* id, |
638 void* payload, | 693 void* payload, |
639 const char* publicId, | 694 const char* publicId, |
640 OrthancPluginResourceType resourceType) | 695 OrthancPluginResourceType resourceType) |
641 { | 696 { |
642 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 697 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
643 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 698 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
699 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
644 | 700 |
645 try | 701 try |
646 { | 702 { |
647 *id = backend->CreateResource(publicId, resourceType); | 703 *id = backend->CreateResource(publicId, resourceType); |
648 return OrthancPluginErrorCode_Success; | 704 return OrthancPluginErrorCode_Success; |
649 } | 705 } |
650 ORTHANC_PLUGINS_DATABASE_CATCH | 706 ORTHANC_PLUGINS_DATABASE_CATCH; |
651 } | 707 } |
652 | 708 |
653 | 709 |
654 static OrthancPluginErrorCode DeleteAttachment(void* payload, | 710 static OrthancPluginErrorCode DeleteAttachment(void* payload, |
655 int64_t id, | 711 int64_t id, |
656 int32_t contentType) | 712 int32_t contentType) |
657 { | 713 { |
658 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 714 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
659 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 715 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
716 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
660 | 717 |
661 try | 718 try |
662 { | 719 { |
663 backend->DeleteAttachment(id, contentType); | 720 backend->DeleteAttachment(id, contentType); |
664 return OrthancPluginErrorCode_Success; | 721 return OrthancPluginErrorCode_Success; |
665 } | 722 } |
666 ORTHANC_PLUGINS_DATABASE_CATCH | 723 ORTHANC_PLUGINS_DATABASE_CATCH; |
667 } | 724 } |
668 | 725 |
669 | 726 |
670 static OrthancPluginErrorCode DeleteMetadata(void* payload, | 727 static OrthancPluginErrorCode DeleteMetadata(void* payload, |
671 int64_t id, | 728 int64_t id, |
672 int32_t metadataType) | 729 int32_t metadataType) |
673 { | 730 { |
674 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 731 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
675 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 732 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
733 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
676 | 734 |
677 try | 735 try |
678 { | 736 { |
679 backend->DeleteMetadata(id, metadataType); | 737 backend->DeleteMetadata(id, metadataType); |
680 return OrthancPluginErrorCode_Success; | 738 return OrthancPluginErrorCode_Success; |
681 } | 739 } |
682 ORTHANC_PLUGINS_DATABASE_CATCH | 740 ORTHANC_PLUGINS_DATABASE_CATCH; |
683 } | 741 } |
684 | 742 |
685 | 743 |
686 static OrthancPluginErrorCode DeleteResource(void* payload, | 744 static OrthancPluginErrorCode DeleteResource(void* payload, |
687 int64_t id) | 745 int64_t id) |
688 { | 746 { |
689 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 747 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
690 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 748 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
749 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
691 | 750 |
692 try | 751 try |
693 { | 752 { |
694 backend->DeleteResource(id); | 753 backend->DeleteResource(id); |
695 return OrthancPluginErrorCode_Success; | 754 return OrthancPluginErrorCode_Success; |
696 } | 755 } |
697 ORTHANC_PLUGINS_DATABASE_CATCH | 756 ORTHANC_PLUGINS_DATABASE_CATCH; |
698 } | 757 } |
699 | 758 |
700 | 759 |
701 static OrthancPluginErrorCode GetAllInternalIds(OrthancPluginDatabaseContext* context, | 760 static OrthancPluginErrorCode GetAllInternalIds(OrthancPluginDatabaseContext* context, |
702 void* payload, | 761 void* payload, |
703 OrthancPluginResourceType resourceType) | 762 OrthancPluginResourceType resourceType) |
704 { | 763 { |
705 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 764 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
706 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 765 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
766 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
707 | 767 |
708 try | 768 try |
709 { | 769 { |
710 std::list<int64_t> target; | 770 std::list<int64_t> target; |
711 backend->GetAllInternalIds(target, resourceType); | 771 backend->GetAllInternalIds(target, resourceType); |
712 | 772 |
713 for (std::list<int64_t>::const_iterator | 773 for (std::list<int64_t>::const_iterator |
714 it = target.begin(); it != target.end(); ++it) | 774 it = target.begin(); it != target.end(); ++it) |
715 { | 775 { |
716 OrthancPluginDatabaseAnswerInt64(backend->GetContext(), | 776 OrthancPluginDatabaseAnswerInt64(backend->GetContext(), |
717 backend->GetOutput().GetDatabase(), *it); | 777 output.GetDatabase(), *it); |
718 } | 778 } |
719 | 779 |
720 return OrthancPluginErrorCode_Success; | 780 return OrthancPluginErrorCode_Success; |
721 } | 781 } |
722 ORTHANC_PLUGINS_DATABASE_CATCH | 782 ORTHANC_PLUGINS_DATABASE_CATCH; |
723 } | 783 } |
724 | 784 |
725 | 785 |
726 static OrthancPluginErrorCode GetAllPublicIds(OrthancPluginDatabaseContext* context, | 786 static OrthancPluginErrorCode GetAllPublicIds(OrthancPluginDatabaseContext* context, |
727 void* payload, | 787 void* payload, |
728 OrthancPluginResourceType resourceType) | 788 OrthancPluginResourceType resourceType) |
729 { | 789 { |
730 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 790 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
731 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 791 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
792 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
732 | 793 |
733 try | 794 try |
734 { | 795 { |
735 std::list<std::string> ids; | 796 std::list<std::string> ids; |
736 backend->GetAllPublicIds(ids, resourceType); | 797 backend->GetAllPublicIds(ids, resourceType); |
737 | 798 |
738 for (std::list<std::string>::const_iterator | 799 for (std::list<std::string>::const_iterator |
739 it = ids.begin(); it != ids.end(); ++it) | 800 it = ids.begin(); it != ids.end(); ++it) |
740 { | 801 { |
741 OrthancPluginDatabaseAnswerString(backend->GetContext(), | 802 OrthancPluginDatabaseAnswerString(backend->GetContext(), |
742 backend->GetOutput().GetDatabase(), | 803 output.GetDatabase(), |
743 it->c_str()); | 804 it->c_str()); |
744 } | 805 } |
745 | 806 |
746 return OrthancPluginErrorCode_Success; | 807 return OrthancPluginErrorCode_Success; |
747 } | 808 } |
748 ORTHANC_PLUGINS_DATABASE_CATCH | 809 ORTHANC_PLUGINS_DATABASE_CATCH; |
749 } | 810 } |
750 | 811 |
751 | 812 |
752 static OrthancPluginErrorCode GetAllPublicIdsWithLimit(OrthancPluginDatabaseContext* context, | 813 static OrthancPluginErrorCode GetAllPublicIdsWithLimit(OrthancPluginDatabaseContext* context, |
753 void* payload, | 814 void* payload, |
754 OrthancPluginResourceType resourceType, | 815 OrthancPluginResourceType resourceType, |
755 uint64_t since, | 816 uint64_t since, |
756 uint64_t limit) | 817 uint64_t limit) |
757 { | 818 { |
758 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 819 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
759 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 820 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
821 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
760 | 822 |
761 try | 823 try |
762 { | 824 { |
763 std::list<std::string> ids; | 825 std::list<std::string> ids; |
764 backend->GetAllPublicIds(ids, resourceType, since, limit); | 826 backend->GetAllPublicIds(ids, resourceType, since, limit); |
765 | 827 |
766 for (std::list<std::string>::const_iterator | 828 for (std::list<std::string>::const_iterator |
767 it = ids.begin(); it != ids.end(); ++it) | 829 it = ids.begin(); it != ids.end(); ++it) |
768 { | 830 { |
769 OrthancPluginDatabaseAnswerString(backend->GetContext(), | 831 OrthancPluginDatabaseAnswerString(backend->GetContext(), |
770 backend->GetOutput().GetDatabase(), | 832 output.GetDatabase(), |
771 it->c_str()); | 833 it->c_str()); |
772 } | 834 } |
773 | 835 |
774 return OrthancPluginErrorCode_Success; | 836 return OrthancPluginErrorCode_Success; |
775 } | 837 } |
776 ORTHANC_PLUGINS_DATABASE_CATCH | 838 ORTHANC_PLUGINS_DATABASE_CATCH; |
777 } | 839 } |
778 | 840 |
779 | 841 |
780 static OrthancPluginErrorCode GetChanges(OrthancPluginDatabaseContext* context, | 842 static OrthancPluginErrorCode GetChanges(OrthancPluginDatabaseContext* context, |
781 void* payload, | 843 void* payload, |
782 int64_t since, | 844 int64_t since, |
783 uint32_t maxResult) | 845 uint32_t maxResult) |
784 { | 846 { |
785 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 847 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
786 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_Change); | 848 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
849 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_Change); | |
787 | 850 |
788 try | 851 try |
789 { | 852 { |
790 bool done; | 853 bool done; |
791 backend->GetChanges(done, since, maxResult); | 854 backend->GetChanges(done, since, maxResult); |
792 | 855 |
793 if (done) | 856 if (done) |
794 { | 857 { |
795 OrthancPluginDatabaseAnswerChangesDone(backend->GetContext(), | 858 OrthancPluginDatabaseAnswerChangesDone(backend->GetContext(), |
796 backend->GetOutput().GetDatabase()); | 859 output.GetDatabase()); |
797 } | 860 } |
798 | 861 |
799 return OrthancPluginErrorCode_Success; | 862 return OrthancPluginErrorCode_Success; |
800 } | 863 } |
801 ORTHANC_PLUGINS_DATABASE_CATCH | 864 ORTHANC_PLUGINS_DATABASE_CATCH; |
802 } | 865 } |
803 | 866 |
804 | 867 |
805 static OrthancPluginErrorCode GetChildrenInternalId(OrthancPluginDatabaseContext* context, | 868 static OrthancPluginErrorCode GetChildrenInternalId(OrthancPluginDatabaseContext* context, |
806 void* payload, | 869 void* payload, |
807 int64_t id) | 870 int64_t id) |
808 { | 871 { |
809 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 872 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
810 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 873 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
874 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
811 | 875 |
812 try | 876 try |
813 { | 877 { |
814 std::list<int64_t> target; | 878 std::list<int64_t> target; |
815 backend->GetChildrenInternalId(target, id); | 879 backend->GetChildrenInternalId(target, id); |
816 | 880 |
817 for (std::list<int64_t>::const_iterator | 881 for (std::list<int64_t>::const_iterator |
818 it = target.begin(); it != target.end(); ++it) | 882 it = target.begin(); it != target.end(); ++it) |
819 { | 883 { |
820 OrthancPluginDatabaseAnswerInt64(backend->GetContext(), | 884 OrthancPluginDatabaseAnswerInt64(backend->GetContext(), |
821 backend->GetOutput().GetDatabase(), *it); | 885 output.GetDatabase(), *it); |
822 } | 886 } |
823 | 887 |
824 return OrthancPluginErrorCode_Success; | 888 return OrthancPluginErrorCode_Success; |
825 } | 889 } |
826 ORTHANC_PLUGINS_DATABASE_CATCH | 890 ORTHANC_PLUGINS_DATABASE_CATCH; |
827 } | 891 } |
828 | 892 |
829 | 893 |
830 static OrthancPluginErrorCode GetChildrenPublicId(OrthancPluginDatabaseContext* context, | 894 static OrthancPluginErrorCode GetChildrenPublicId(OrthancPluginDatabaseContext* context, |
831 void* payload, | 895 void* payload, |
832 int64_t id) | 896 int64_t id) |
833 { | 897 { |
834 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 898 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
835 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 899 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
900 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
836 | 901 |
837 try | 902 try |
838 { | 903 { |
839 std::list<std::string> ids; | 904 std::list<std::string> ids; |
840 backend->GetChildrenPublicId(ids, id); | 905 backend->GetChildrenPublicId(ids, id); |
841 | 906 |
842 for (std::list<std::string>::const_iterator | 907 for (std::list<std::string>::const_iterator |
843 it = ids.begin(); it != ids.end(); ++it) | 908 it = ids.begin(); it != ids.end(); ++it) |
844 { | 909 { |
845 OrthancPluginDatabaseAnswerString(backend->GetContext(), | 910 OrthancPluginDatabaseAnswerString(backend->GetContext(), |
846 backend->GetOutput().GetDatabase(), | 911 output.GetDatabase(), |
847 it->c_str()); | 912 it->c_str()); |
848 } | 913 } |
849 | 914 |
850 return OrthancPluginErrorCode_Success; | 915 return OrthancPluginErrorCode_Success; |
851 } | 916 } |
852 ORTHANC_PLUGINS_DATABASE_CATCH | 917 ORTHANC_PLUGINS_DATABASE_CATCH; |
853 } | 918 } |
854 | 919 |
855 | 920 |
856 static OrthancPluginErrorCode GetExportedResources(OrthancPluginDatabaseContext* context, | 921 static OrthancPluginErrorCode GetExportedResources(OrthancPluginDatabaseContext* context, |
857 void* payload, | 922 void* payload, |
858 int64_t since, | 923 int64_t since, |
859 uint32_t maxResult) | 924 uint32_t maxResult) |
860 { | 925 { |
861 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 926 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
862 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_ExportedResource); | 927 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
928 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_ExportedResource); | |
863 | 929 |
864 try | 930 try |
865 { | 931 { |
866 bool done; | 932 bool done; |
867 backend->GetExportedResources(done, since, maxResult); | 933 backend->GetExportedResources(done, since, maxResult); |
868 | 934 |
869 if (done) | 935 if (done) |
870 { | 936 { |
871 OrthancPluginDatabaseAnswerExportedResourcesDone(backend->GetContext(), | 937 OrthancPluginDatabaseAnswerExportedResourcesDone(backend->GetContext(), |
872 backend->GetOutput().GetDatabase()); | 938 output.GetDatabase()); |
873 } | 939 } |
874 return OrthancPluginErrorCode_Success; | 940 return OrthancPluginErrorCode_Success; |
875 } | 941 } |
876 ORTHANC_PLUGINS_DATABASE_CATCH | 942 ORTHANC_PLUGINS_DATABASE_CATCH; |
877 } | 943 } |
878 | 944 |
879 | 945 |
880 static OrthancPluginErrorCode GetLastChange(OrthancPluginDatabaseContext* context, | 946 static OrthancPluginErrorCode GetLastChange(OrthancPluginDatabaseContext* context, |
881 void* payload) | 947 void* payload) |
882 { | 948 { |
883 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 949 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
884 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_Change); | 950 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
951 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_Change); | |
885 | 952 |
886 try | 953 try |
887 { | 954 { |
888 backend->GetLastChange(); | 955 backend->GetLastChange(); |
889 return OrthancPluginErrorCode_Success; | 956 return OrthancPluginErrorCode_Success; |
890 } | 957 } |
891 ORTHANC_PLUGINS_DATABASE_CATCH | 958 ORTHANC_PLUGINS_DATABASE_CATCH; |
892 } | 959 } |
893 | 960 |
894 | 961 |
895 static OrthancPluginErrorCode GetLastExportedResource(OrthancPluginDatabaseContext* context, | 962 static OrthancPluginErrorCode GetLastExportedResource(OrthancPluginDatabaseContext* context, |
896 void* payload) | 963 void* payload) |
897 { | 964 { |
898 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 965 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
899 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_ExportedResource); | 966 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
967 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_ExportedResource); | |
900 | 968 |
901 try | 969 try |
902 { | 970 { |
903 backend->GetLastExportedResource(); | 971 backend->GetLastExportedResource(); |
904 return OrthancPluginErrorCode_Success; | 972 return OrthancPluginErrorCode_Success; |
905 } | 973 } |
906 ORTHANC_PLUGINS_DATABASE_CATCH | 974 ORTHANC_PLUGINS_DATABASE_CATCH; |
907 } | 975 } |
908 | 976 |
909 | 977 |
910 static OrthancPluginErrorCode GetMainDicomTags(OrthancPluginDatabaseContext* context, | 978 static OrthancPluginErrorCode GetMainDicomTags(OrthancPluginDatabaseContext* context, |
911 void* payload, | 979 void* payload, |
912 int64_t id) | 980 int64_t id) |
913 { | 981 { |
914 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 982 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
915 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_DicomTag); | 983 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
984 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_DicomTag); | |
916 | 985 |
917 try | 986 try |
918 { | 987 { |
919 backend->GetMainDicomTags(id); | 988 backend->GetMainDicomTags(id); |
920 return OrthancPluginErrorCode_Success; | 989 return OrthancPluginErrorCode_Success; |
921 } | 990 } |
922 ORTHANC_PLUGINS_DATABASE_CATCH | 991 ORTHANC_PLUGINS_DATABASE_CATCH; |
923 } | 992 } |
924 | 993 |
925 | 994 |
926 static OrthancPluginErrorCode GetPublicId(OrthancPluginDatabaseContext* context, | 995 static OrthancPluginErrorCode GetPublicId(OrthancPluginDatabaseContext* context, |
927 void* payload, | 996 void* payload, |
928 int64_t id) | 997 int64_t id) |
929 { | 998 { |
930 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 999 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
931 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 1000 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
1001 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
932 | 1002 |
933 try | 1003 try |
934 { | 1004 { |
935 std::string s = backend->GetPublicId(id); | 1005 std::string s = backend->GetPublicId(id); |
936 OrthancPluginDatabaseAnswerString(backend->GetContext(), | 1006 OrthancPluginDatabaseAnswerString(backend->GetContext(), |
937 backend->GetOutput().GetDatabase(), | 1007 output.GetDatabase(), |
938 s.c_str()); | 1008 s.c_str()); |
939 | 1009 |
940 return OrthancPluginErrorCode_Success; | 1010 return OrthancPluginErrorCode_Success; |
941 } | 1011 } |
942 ORTHANC_PLUGINS_DATABASE_CATCH | 1012 ORTHANC_PLUGINS_DATABASE_CATCH; |
943 } | 1013 } |
944 | 1014 |
945 | 1015 |
946 static OrthancPluginErrorCode GetResourceCount(uint64_t* target, | 1016 static OrthancPluginErrorCode GetResourceCount(uint64_t* target, |
947 void* payload, | 1017 void* payload, |
948 OrthancPluginResourceType resourceType) | 1018 OrthancPluginResourceType resourceType) |
949 { | 1019 { |
950 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1020 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
951 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 1021 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
1022 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
952 | 1023 |
953 try | 1024 try |
954 { | 1025 { |
955 *target = backend->GetResourceCount(resourceType); | 1026 *target = backend->GetResourceCount(resourceType); |
956 return OrthancPluginErrorCode_Success; | 1027 return OrthancPluginErrorCode_Success; |
957 } | 1028 } |
958 ORTHANC_PLUGINS_DATABASE_CATCH | 1029 ORTHANC_PLUGINS_DATABASE_CATCH; |
959 } | 1030 } |
960 | 1031 |
961 | 1032 |
962 static OrthancPluginErrorCode GetResourceType(OrthancPluginResourceType* resourceType, | 1033 static OrthancPluginErrorCode GetResourceType(OrthancPluginResourceType* resourceType, |
963 void* payload, | 1034 void* payload, |
964 int64_t id) | 1035 int64_t id) |
965 { | 1036 { |
966 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1037 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
967 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 1038 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
1039 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
968 | 1040 |
969 try | 1041 try |
970 { | 1042 { |
971 *resourceType = backend->GetResourceType(id); | 1043 *resourceType = backend->GetResourceType(id); |
972 return OrthancPluginErrorCode_Success; | 1044 return OrthancPluginErrorCode_Success; |
973 } | 1045 } |
974 ORTHANC_PLUGINS_DATABASE_CATCH | 1046 ORTHANC_PLUGINS_DATABASE_CATCH; |
975 } | 1047 } |
976 | 1048 |
977 | 1049 |
978 static OrthancPluginErrorCode GetTotalCompressedSize(uint64_t* target, | 1050 static OrthancPluginErrorCode GetTotalCompressedSize(uint64_t* target, |
979 void* payload) | 1051 void* payload) |
980 { | 1052 { |
981 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1053 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
982 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 1054 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
1055 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
983 | 1056 |
984 try | 1057 try |
985 { | 1058 { |
986 *target = backend->GetTotalCompressedSize(); | 1059 *target = backend->GetTotalCompressedSize(); |
987 return OrthancPluginErrorCode_Success; | 1060 return OrthancPluginErrorCode_Success; |
988 } | 1061 } |
989 ORTHANC_PLUGINS_DATABASE_CATCH | 1062 ORTHANC_PLUGINS_DATABASE_CATCH; |
990 } | 1063 } |
991 | 1064 |
992 | 1065 |
993 static OrthancPluginErrorCode GetTotalUncompressedSize(uint64_t* target, | 1066 static OrthancPluginErrorCode GetTotalUncompressedSize(uint64_t* target, |
994 void* payload) | 1067 void* payload) |
995 { | 1068 { |
996 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1069 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
997 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 1070 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
1071 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
998 | 1072 |
999 try | 1073 try |
1000 { | 1074 { |
1001 *target = backend->GetTotalUncompressedSize(); | 1075 *target = backend->GetTotalUncompressedSize(); |
1002 return OrthancPluginErrorCode_Success; | 1076 return OrthancPluginErrorCode_Success; |
1003 } | 1077 } |
1004 ORTHANC_PLUGINS_DATABASE_CATCH | 1078 ORTHANC_PLUGINS_DATABASE_CATCH; |
1005 } | 1079 } |
1006 | 1080 |
1007 | 1081 |
1008 static OrthancPluginErrorCode IsExistingResource(int32_t* existing, | 1082 static OrthancPluginErrorCode IsExistingResource(int32_t* existing, |
1009 void* payload, | 1083 void* payload, |
1010 int64_t id) | 1084 int64_t id) |
1011 { | 1085 { |
1012 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1086 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
1013 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 1087 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
1088 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
1014 | 1089 |
1015 try | 1090 try |
1016 { | 1091 { |
1017 *existing = backend->IsExistingResource(id); | 1092 *existing = backend->IsExistingResource(id); |
1018 return OrthancPluginErrorCode_Success; | 1093 return OrthancPluginErrorCode_Success; |
1019 } | 1094 } |
1020 ORTHANC_PLUGINS_DATABASE_CATCH | 1095 ORTHANC_PLUGINS_DATABASE_CATCH; |
1021 } | 1096 } |
1022 | 1097 |
1023 | 1098 |
1024 static OrthancPluginErrorCode IsProtectedPatient(int32_t* isProtected, | 1099 static OrthancPluginErrorCode IsProtectedPatient(int32_t* isProtected, |
1025 void* payload, | 1100 void* payload, |
1026 int64_t id) | 1101 int64_t id) |
1027 { | 1102 { |
1028 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1103 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
1029 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 1104 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
1105 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
1030 | 1106 |
1031 try | 1107 try |
1032 { | 1108 { |
1033 *isProtected = backend->IsProtectedPatient(id); | 1109 *isProtected = backend->IsProtectedPatient(id); |
1034 return OrthancPluginErrorCode_Success; | 1110 return OrthancPluginErrorCode_Success; |
1035 } | 1111 } |
1036 ORTHANC_PLUGINS_DATABASE_CATCH | 1112 ORTHANC_PLUGINS_DATABASE_CATCH; |
1037 } | 1113 } |
1038 | 1114 |
1039 | 1115 |
1040 static OrthancPluginErrorCode ListAvailableMetadata(OrthancPluginDatabaseContext* context, | 1116 static OrthancPluginErrorCode ListAvailableMetadata(OrthancPluginDatabaseContext* context, |
1041 void* payload, | 1117 void* payload, |
1042 int64_t id) | 1118 int64_t id) |
1043 { | 1119 { |
1044 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1120 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
1045 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 1121 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
1122 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
1046 | 1123 |
1047 try | 1124 try |
1048 { | 1125 { |
1049 std::list<int32_t> target; | 1126 std::list<int32_t> target; |
1050 backend->ListAvailableMetadata(target, id); | 1127 backend->ListAvailableMetadata(target, id); |
1051 | 1128 |
1052 for (std::list<int32_t>::const_iterator | 1129 for (std::list<int32_t>::const_iterator |
1053 it = target.begin(); it != target.end(); ++it) | 1130 it = target.begin(); it != target.end(); ++it) |
1054 { | 1131 { |
1055 OrthancPluginDatabaseAnswerInt32(backend->GetContext(), | 1132 OrthancPluginDatabaseAnswerInt32(backend->GetContext(), |
1056 backend->GetOutput().GetDatabase(), | 1133 output.GetDatabase(), |
1057 *it); | 1134 *it); |
1058 } | 1135 } |
1059 | 1136 |
1060 return OrthancPluginErrorCode_Success; | 1137 return OrthancPluginErrorCode_Success; |
1061 } | 1138 } |
1062 ORTHANC_PLUGINS_DATABASE_CATCH | 1139 ORTHANC_PLUGINS_DATABASE_CATCH; |
1063 } | 1140 } |
1064 | 1141 |
1065 | 1142 |
1066 static OrthancPluginErrorCode ListAvailableAttachments(OrthancPluginDatabaseContext* context, | 1143 static OrthancPluginErrorCode ListAvailableAttachments(OrthancPluginDatabaseContext* context, |
1067 void* payload, | 1144 void* payload, |
1068 int64_t id) | 1145 int64_t id) |
1069 { | 1146 { |
1070 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1147 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
1071 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 1148 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
1149 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
1072 | 1150 |
1073 try | 1151 try |
1074 { | 1152 { |
1075 std::list<int32_t> target; | 1153 std::list<int32_t> target; |
1076 backend->ListAvailableAttachments(target, id); | 1154 backend->ListAvailableAttachments(target, id); |
1077 | 1155 |
1078 for (std::list<int32_t>::const_iterator | 1156 for (std::list<int32_t>::const_iterator |
1079 it = target.begin(); it != target.end(); ++it) | 1157 it = target.begin(); it != target.end(); ++it) |
1080 { | 1158 { |
1081 OrthancPluginDatabaseAnswerInt32(backend->GetContext(), | 1159 OrthancPluginDatabaseAnswerInt32(backend->GetContext(), |
1082 backend->GetOutput().GetDatabase(), | 1160 output.GetDatabase(), |
1083 *it); | 1161 *it); |
1084 } | 1162 } |
1085 | 1163 |
1086 return OrthancPluginErrorCode_Success; | 1164 return OrthancPluginErrorCode_Success; |
1087 } | 1165 } |
1088 ORTHANC_PLUGINS_DATABASE_CATCH | 1166 ORTHANC_PLUGINS_DATABASE_CATCH; |
1089 } | 1167 } |
1090 | 1168 |
1091 | 1169 |
1092 static OrthancPluginErrorCode LogChange(void* payload, | 1170 static OrthancPluginErrorCode LogChange(void* payload, |
1093 const OrthancPluginChange* change) | 1171 const OrthancPluginChange* change) |
1094 { | 1172 { |
1095 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1173 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
1096 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 1174 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
1175 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
1097 | 1176 |
1098 try | 1177 try |
1099 { | 1178 { |
1100 backend->LogChange(*change); | 1179 backend->LogChange(*change); |
1101 return OrthancPluginErrorCode_Success; | 1180 return OrthancPluginErrorCode_Success; |
1102 } | 1181 } |
1103 ORTHANC_PLUGINS_DATABASE_CATCH | 1182 ORTHANC_PLUGINS_DATABASE_CATCH; |
1104 } | 1183 } |
1105 | 1184 |
1106 | 1185 |
1107 static OrthancPluginErrorCode LogExportedResource(void* payload, | 1186 static OrthancPluginErrorCode LogExportedResource(void* payload, |
1108 const OrthancPluginExportedResource* exported) | 1187 const OrthancPluginExportedResource* exported) |
1109 { | 1188 { |
1110 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1189 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
1111 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 1190 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
1191 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
1112 | 1192 |
1113 try | 1193 try |
1114 { | 1194 { |
1115 backend->LogExportedResource(*exported); | 1195 backend->LogExportedResource(*exported); |
1116 return OrthancPluginErrorCode_Success; | 1196 return OrthancPluginErrorCode_Success; |
1117 } | 1197 } |
1118 ORTHANC_PLUGINS_DATABASE_CATCH | 1198 ORTHANC_PLUGINS_DATABASE_CATCH; |
1119 } | 1199 } |
1120 | 1200 |
1121 | 1201 |
1122 static OrthancPluginErrorCode LookupAttachment(OrthancPluginDatabaseContext* context, | 1202 static OrthancPluginErrorCode LookupAttachment(OrthancPluginDatabaseContext* context, |
1123 void* payload, | 1203 void* payload, |
1124 int64_t id, | 1204 int64_t id, |
1125 int32_t contentType) | 1205 int32_t contentType) |
1126 { | 1206 { |
1127 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1207 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
1128 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_Attachment); | 1208 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
1209 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_Attachment); | |
1129 | 1210 |
1130 try | 1211 try |
1131 { | 1212 { |
1132 backend->LookupAttachment(id, contentType); | 1213 backend->LookupAttachment(id, contentType); |
1133 return OrthancPluginErrorCode_Success; | 1214 return OrthancPluginErrorCode_Success; |
1134 } | 1215 } |
1135 ORTHANC_PLUGINS_DATABASE_CATCH | 1216 ORTHANC_PLUGINS_DATABASE_CATCH; |
1136 } | 1217 } |
1137 | 1218 |
1138 | 1219 |
1139 static OrthancPluginErrorCode LookupGlobalProperty(OrthancPluginDatabaseContext* context, | 1220 static OrthancPluginErrorCode LookupGlobalProperty(OrthancPluginDatabaseContext* context, |
1140 void* payload, | 1221 void* payload, |
1141 int32_t property) | 1222 int32_t property) |
1142 { | 1223 { |
1143 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1224 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
1144 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 1225 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
1226 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
1145 | 1227 |
1146 try | 1228 try |
1147 { | 1229 { |
1148 std::string s; | 1230 std::string s; |
1149 if (backend->LookupGlobalProperty(s, property)) | 1231 if (backend->LookupGlobalProperty(s, property)) |
1150 { | 1232 { |
1151 OrthancPluginDatabaseAnswerString(backend->GetContext(), | 1233 OrthancPluginDatabaseAnswerString(backend->GetContext(), |
1152 backend->GetOutput().GetDatabase(), | 1234 output.GetDatabase(), |
1153 s.c_str()); | 1235 s.c_str()); |
1154 } | 1236 } |
1155 | 1237 |
1156 return OrthancPluginErrorCode_Success; | 1238 return OrthancPluginErrorCode_Success; |
1157 } | 1239 } |
1158 ORTHANC_PLUGINS_DATABASE_CATCH | 1240 ORTHANC_PLUGINS_DATABASE_CATCH; |
1159 } | 1241 } |
1160 | 1242 |
1161 | 1243 |
1162 static OrthancPluginErrorCode LookupIdentifier3(OrthancPluginDatabaseContext* context, | 1244 static OrthancPluginErrorCode LookupIdentifier3(OrthancPluginDatabaseContext* context, |
1163 void* payload, | 1245 void* payload, |
1164 OrthancPluginResourceType resourceType, | 1246 OrthancPluginResourceType resourceType, |
1165 const OrthancPluginDicomTag* tag, | 1247 const OrthancPluginDicomTag* tag, |
1166 OrthancPluginIdentifierConstraint constraint) | 1248 OrthancPluginIdentifierConstraint constraint) |
1167 { | 1249 { |
1168 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1250 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
1169 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 1251 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
1252 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
1170 | 1253 |
1171 try | 1254 try |
1172 { | 1255 { |
1173 std::list<int64_t> target; | 1256 std::list<int64_t> target; |
1174 backend->LookupIdentifier(target, resourceType, tag->group, tag->element, constraint, tag->value); | 1257 backend->LookupIdentifier(target, resourceType, tag->group, tag->element, constraint, tag->value); |
1175 | 1258 |
1176 for (std::list<int64_t>::const_iterator | 1259 for (std::list<int64_t>::const_iterator |
1177 it = target.begin(); it != target.end(); ++it) | 1260 it = target.begin(); it != target.end(); ++it) |
1178 { | 1261 { |
1179 OrthancPluginDatabaseAnswerInt64(backend->GetContext(), | 1262 OrthancPluginDatabaseAnswerInt64(backend->GetContext(), |
1180 backend->GetOutput().GetDatabase(), *it); | 1263 output.GetDatabase(), *it); |
1181 } | 1264 } |
1182 | 1265 |
1183 return OrthancPluginErrorCode_Success; | 1266 return OrthancPluginErrorCode_Success; |
1184 } | 1267 } |
1185 ORTHANC_PLUGINS_DATABASE_CATCH | 1268 ORTHANC_PLUGINS_DATABASE_CATCH; |
1186 } | 1269 } |
1187 | 1270 |
1188 | 1271 |
1189 static OrthancPluginErrorCode LookupIdentifierRange(OrthancPluginDatabaseContext* context, | 1272 static OrthancPluginErrorCode LookupIdentifierRange(OrthancPluginDatabaseContext* context, |
1190 void* payload, | 1273 void* payload, |
1193 uint16_t element, | 1276 uint16_t element, |
1194 const char* start, | 1277 const char* start, |
1195 const char* end) | 1278 const char* end) |
1196 { | 1279 { |
1197 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1280 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
1198 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 1281 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
1282 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
1199 | 1283 |
1200 try | 1284 try |
1201 { | 1285 { |
1202 std::list<int64_t> target; | 1286 std::list<int64_t> target; |
1203 backend->LookupIdentifierRange(target, resourceType, group, element, start, end); | 1287 backend->LookupIdentifierRange(target, resourceType, group, element, start, end); |
1204 | 1288 |
1205 for (std::list<int64_t>::const_iterator | 1289 for (std::list<int64_t>::const_iterator |
1206 it = target.begin(); it != target.end(); ++it) | 1290 it = target.begin(); it != target.end(); ++it) |
1207 { | 1291 { |
1208 OrthancPluginDatabaseAnswerInt64(backend->GetContext(), | 1292 OrthancPluginDatabaseAnswerInt64(backend->GetContext(), |
1209 backend->GetOutput().GetDatabase(), *it); | 1293 output.GetDatabase(), *it); |
1210 } | 1294 } |
1211 | 1295 |
1212 return OrthancPluginErrorCode_Success; | 1296 return OrthancPluginErrorCode_Success; |
1213 } | 1297 } |
1214 ORTHANC_PLUGINS_DATABASE_CATCH | 1298 ORTHANC_PLUGINS_DATABASE_CATCH; |
1215 } | 1299 } |
1216 | 1300 |
1217 | 1301 |
1218 static OrthancPluginErrorCode LookupMetadata(OrthancPluginDatabaseContext* context, | 1302 static OrthancPluginErrorCode LookupMetadata(OrthancPluginDatabaseContext* context, |
1219 void* payload, | 1303 void* payload, |
1220 int64_t id, | 1304 int64_t id, |
1221 int32_t metadata) | 1305 int32_t metadata) |
1222 { | 1306 { |
1223 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1307 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
1224 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 1308 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
1309 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
1225 | 1310 |
1226 try | 1311 try |
1227 { | 1312 { |
1228 std::string s; | 1313 std::string s; |
1229 if (backend->LookupMetadata(s, id, metadata)) | 1314 if (backend->LookupMetadata(s, id, metadata)) |
1230 { | 1315 { |
1231 OrthancPluginDatabaseAnswerString(backend->GetContext(), | 1316 OrthancPluginDatabaseAnswerString(backend->GetContext(), |
1232 backend->GetOutput().GetDatabase(), s.c_str()); | 1317 output.GetDatabase(), s.c_str()); |
1233 } | 1318 } |
1234 | 1319 |
1235 return OrthancPluginErrorCode_Success; | 1320 return OrthancPluginErrorCode_Success; |
1236 } | 1321 } |
1237 ORTHANC_PLUGINS_DATABASE_CATCH | 1322 ORTHANC_PLUGINS_DATABASE_CATCH; |
1238 } | 1323 } |
1239 | 1324 |
1240 | 1325 |
1241 static OrthancPluginErrorCode LookupParent(OrthancPluginDatabaseContext* context, | 1326 static OrthancPluginErrorCode LookupParent(OrthancPluginDatabaseContext* context, |
1242 void* payload, | 1327 void* payload, |
1243 int64_t id) | 1328 int64_t id) |
1244 { | 1329 { |
1245 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1330 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
1246 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 1331 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
1332 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
1247 | 1333 |
1248 try | 1334 try |
1249 { | 1335 { |
1250 int64_t parent; | 1336 int64_t parent; |
1251 if (backend->LookupParent(parent, id)) | 1337 if (backend->LookupParent(parent, id)) |
1252 { | 1338 { |
1253 OrthancPluginDatabaseAnswerInt64(backend->GetContext(), | 1339 OrthancPluginDatabaseAnswerInt64(backend->GetContext(), |
1254 backend->GetOutput().GetDatabase(), parent); | 1340 output.GetDatabase(), parent); |
1255 } | 1341 } |
1256 | 1342 |
1257 return OrthancPluginErrorCode_Success; | 1343 return OrthancPluginErrorCode_Success; |
1258 } | 1344 } |
1259 ORTHANC_PLUGINS_DATABASE_CATCH | 1345 ORTHANC_PLUGINS_DATABASE_CATCH; |
1260 } | 1346 } |
1261 | 1347 |
1262 | 1348 |
1263 static OrthancPluginErrorCode LookupResource(OrthancPluginDatabaseContext* context, | 1349 static OrthancPluginErrorCode LookupResource(OrthancPluginDatabaseContext* context, |
1264 void* payload, | 1350 void* payload, |
1265 const char* publicId) | 1351 const char* publicId) |
1266 { | 1352 { |
1267 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1353 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
1268 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 1354 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
1355 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
1269 | 1356 |
1270 try | 1357 try |
1271 { | 1358 { |
1272 int64_t id; | 1359 int64_t id; |
1273 OrthancPluginResourceType type; | 1360 OrthancPluginResourceType type; |
1274 if (backend->LookupResource(id, type, publicId)) | 1361 if (backend->LookupResource(id, type, publicId)) |
1275 { | 1362 { |
1276 OrthancPluginDatabaseAnswerResource(backend->GetContext(), | 1363 OrthancPluginDatabaseAnswerResource(backend->GetContext(), |
1277 backend->GetOutput().GetDatabase(), | 1364 output.GetDatabase(), |
1278 id, type); | 1365 id, type); |
1279 } | 1366 } |
1280 | 1367 |
1281 return OrthancPluginErrorCode_Success; | 1368 return OrthancPluginErrorCode_Success; |
1282 } | 1369 } |
1283 ORTHANC_PLUGINS_DATABASE_CATCH | 1370 ORTHANC_PLUGINS_DATABASE_CATCH; |
1284 } | 1371 } |
1285 | 1372 |
1286 | 1373 |
1287 static OrthancPluginErrorCode SelectPatientToRecycle(OrthancPluginDatabaseContext* context, | 1374 static OrthancPluginErrorCode SelectPatientToRecycle(OrthancPluginDatabaseContext* context, |
1288 void* payload) | 1375 void* payload) |
1289 { | 1376 { |
1290 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1377 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
1291 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 1378 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
1379 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
1292 | 1380 |
1293 try | 1381 try |
1294 { | 1382 { |
1295 int64_t id; | 1383 int64_t id; |
1296 if (backend->SelectPatientToRecycle(id)) | 1384 if (backend->SelectPatientToRecycle(id)) |
1297 { | 1385 { |
1298 OrthancPluginDatabaseAnswerInt64(backend->GetContext(), | 1386 OrthancPluginDatabaseAnswerInt64(backend->GetContext(), |
1299 backend->GetOutput().GetDatabase(), id); | 1387 output.GetDatabase(), id); |
1300 } | 1388 } |
1301 | 1389 |
1302 return OrthancPluginErrorCode_Success; | 1390 return OrthancPluginErrorCode_Success; |
1303 } | 1391 } |
1304 ORTHANC_PLUGINS_DATABASE_CATCH | 1392 ORTHANC_PLUGINS_DATABASE_CATCH; |
1305 } | 1393 } |
1306 | 1394 |
1307 | 1395 |
1308 static OrthancPluginErrorCode SelectPatientToRecycle2(OrthancPluginDatabaseContext* context, | 1396 static OrthancPluginErrorCode SelectPatientToRecycle2(OrthancPluginDatabaseContext* context, |
1309 void* payload, | 1397 void* payload, |
1310 int64_t patientIdToAvoid) | 1398 int64_t patientIdToAvoid) |
1311 { | 1399 { |
1312 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1400 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
1313 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 1401 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
1402 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
1314 | 1403 |
1315 try | 1404 try |
1316 { | 1405 { |
1317 int64_t id; | 1406 int64_t id; |
1318 if (backend->SelectPatientToRecycle(id, patientIdToAvoid)) | 1407 if (backend->SelectPatientToRecycle(id, patientIdToAvoid)) |
1319 { | 1408 { |
1320 OrthancPluginDatabaseAnswerInt64(backend->GetContext(), | 1409 OrthancPluginDatabaseAnswerInt64(backend->GetContext(), |
1321 backend->GetOutput().GetDatabase(), id); | 1410 output.GetDatabase(), id); |
1322 } | 1411 } |
1323 | 1412 |
1324 return OrthancPluginErrorCode_Success; | 1413 return OrthancPluginErrorCode_Success; |
1325 } | 1414 } |
1326 ORTHANC_PLUGINS_DATABASE_CATCH | 1415 ORTHANC_PLUGINS_DATABASE_CATCH; |
1327 } | 1416 } |
1328 | 1417 |
1329 | 1418 |
1330 static OrthancPluginErrorCode SetGlobalProperty(void* payload, | 1419 static OrthancPluginErrorCode SetGlobalProperty(void* payload, |
1331 int32_t property, | 1420 int32_t property, |
1332 const char* value) | 1421 const char* value) |
1333 { | 1422 { |
1334 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1423 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
1335 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 1424 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
1425 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
1336 | 1426 |
1337 try | 1427 try |
1338 { | 1428 { |
1339 backend->SetGlobalProperty(property, value); | 1429 backend->SetGlobalProperty(property, value); |
1340 return OrthancPluginErrorCode_Success; | 1430 return OrthancPluginErrorCode_Success; |
1341 } | 1431 } |
1342 ORTHANC_PLUGINS_DATABASE_CATCH | 1432 ORTHANC_PLUGINS_DATABASE_CATCH; |
1343 } | 1433 } |
1344 | 1434 |
1345 | 1435 |
1346 static OrthancPluginErrorCode SetMainDicomTag(void* payload, | 1436 static OrthancPluginErrorCode SetMainDicomTag(void* payload, |
1347 int64_t id, | 1437 int64_t id, |
1348 const OrthancPluginDicomTag* tag) | 1438 const OrthancPluginDicomTag* tag) |
1349 { | 1439 { |
1350 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1440 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
1351 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 1441 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
1442 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
1352 | 1443 |
1353 try | 1444 try |
1354 { | 1445 { |
1355 backend->SetMainDicomTag(id, tag->group, tag->element, tag->value); | 1446 backend->SetMainDicomTag(id, tag->group, tag->element, tag->value); |
1356 return OrthancPluginErrorCode_Success; | 1447 return OrthancPluginErrorCode_Success; |
1357 } | 1448 } |
1358 ORTHANC_PLUGINS_DATABASE_CATCH | 1449 ORTHANC_PLUGINS_DATABASE_CATCH; |
1359 } | 1450 } |
1360 | 1451 |
1361 | 1452 |
1362 static OrthancPluginErrorCode SetIdentifierTag(void* payload, | 1453 static OrthancPluginErrorCode SetIdentifierTag(void* payload, |
1363 int64_t id, | 1454 int64_t id, |
1364 const OrthancPluginDicomTag* tag) | 1455 const OrthancPluginDicomTag* tag) |
1365 { | 1456 { |
1366 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1457 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
1367 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 1458 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
1459 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
1368 | 1460 |
1369 try | 1461 try |
1370 { | 1462 { |
1371 backend->SetIdentifierTag(id, tag->group, tag->element, tag->value); | 1463 backend->SetIdentifierTag(id, tag->group, tag->element, tag->value); |
1372 return OrthancPluginErrorCode_Success; | 1464 return OrthancPluginErrorCode_Success; |
1373 } | 1465 } |
1374 ORTHANC_PLUGINS_DATABASE_CATCH | 1466 ORTHANC_PLUGINS_DATABASE_CATCH; |
1375 } | 1467 } |
1376 | 1468 |
1377 | 1469 |
1378 static OrthancPluginErrorCode SetMetadata(void* payload, | 1470 static OrthancPluginErrorCode SetMetadata(void* payload, |
1379 int64_t id, | 1471 int64_t id, |
1380 int32_t metadata, | 1472 int32_t metadata, |
1381 const char* value) | 1473 const char* value) |
1382 { | 1474 { |
1383 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1475 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
1384 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 1476 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
1477 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
1385 | 1478 |
1386 try | 1479 try |
1387 { | 1480 { |
1388 backend->SetMetadata(id, metadata, value); | 1481 backend->SetMetadata(id, metadata, value); |
1389 return OrthancPluginErrorCode_Success; | 1482 return OrthancPluginErrorCode_Success; |
1390 } | 1483 } |
1391 ORTHANC_PLUGINS_DATABASE_CATCH | 1484 ORTHANC_PLUGINS_DATABASE_CATCH; |
1392 } | 1485 } |
1393 | 1486 |
1394 | 1487 |
1395 static OrthancPluginErrorCode SetProtectedPatient(void* payload, | 1488 static OrthancPluginErrorCode SetProtectedPatient(void* payload, |
1396 int64_t id, | 1489 int64_t id, |
1397 int32_t isProtected) | 1490 int32_t isProtected) |
1398 { | 1491 { |
1399 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1492 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
1400 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 1493 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
1494 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
1401 | 1495 |
1402 try | 1496 try |
1403 { | 1497 { |
1404 backend->SetProtectedPatient(id, (isProtected != 0)); | 1498 backend->SetProtectedPatient(id, (isProtected != 0)); |
1405 return OrthancPluginErrorCode_Success; | 1499 return OrthancPluginErrorCode_Success; |
1406 } | 1500 } |
1407 ORTHANC_PLUGINS_DATABASE_CATCH | 1501 ORTHANC_PLUGINS_DATABASE_CATCH; |
1408 } | 1502 } |
1409 | 1503 |
1410 | 1504 |
1411 static OrthancPluginErrorCode StartTransaction(void* payload) | 1505 static OrthancPluginErrorCode StartTransaction(void* payload) |
1412 { | 1506 { |
1413 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1507 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
1414 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 1508 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
1509 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
1415 | 1510 |
1416 try | 1511 try |
1417 { | 1512 { |
1418 backend->StartTransaction(); | 1513 backend->StartTransaction(); |
1419 return OrthancPluginErrorCode_Success; | 1514 return OrthancPluginErrorCode_Success; |
1420 } | 1515 } |
1421 ORTHANC_PLUGINS_DATABASE_CATCH | 1516 ORTHANC_PLUGINS_DATABASE_CATCH; |
1422 } | 1517 } |
1423 | 1518 |
1424 | 1519 |
1425 static OrthancPluginErrorCode RollbackTransaction(void* payload) | 1520 static OrthancPluginErrorCode RollbackTransaction(void* payload) |
1426 { | 1521 { |
1427 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1522 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
1428 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 1523 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
1524 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
1429 | 1525 |
1430 try | 1526 try |
1431 { | 1527 { |
1432 backend->RollbackTransaction(); | 1528 backend->RollbackTransaction(); |
1433 return OrthancPluginErrorCode_Success; | 1529 return OrthancPluginErrorCode_Success; |
1434 } | 1530 } |
1435 ORTHANC_PLUGINS_DATABASE_CATCH | 1531 ORTHANC_PLUGINS_DATABASE_CATCH; |
1436 } | 1532 } |
1437 | 1533 |
1438 | 1534 |
1439 static OrthancPluginErrorCode CommitTransaction(void* payload) | 1535 static OrthancPluginErrorCode CommitTransaction(void* payload) |
1440 { | 1536 { |
1441 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1537 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
1442 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 1538 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
1539 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
1443 | 1540 |
1444 try | 1541 try |
1445 { | 1542 { |
1446 backend->CommitTransaction(); | 1543 backend->CommitTransaction(); |
1447 return OrthancPluginErrorCode_Success; | 1544 return OrthancPluginErrorCode_Success; |
1448 } | 1545 } |
1449 ORTHANC_PLUGINS_DATABASE_CATCH | 1546 ORTHANC_PLUGINS_DATABASE_CATCH; |
1450 } | 1547 } |
1451 | 1548 |
1452 | 1549 |
1453 static OrthancPluginErrorCode Open(void* payload) | 1550 static OrthancPluginErrorCode Open(void* payload) |
1454 { | 1551 { |
1455 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1552 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
1456 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 1553 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
1554 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
1457 | 1555 |
1458 try | 1556 try |
1459 { | 1557 { |
1460 backend->Open(); | 1558 backend->Open(); |
1461 return OrthancPluginErrorCode_Success; | 1559 return OrthancPluginErrorCode_Success; |
1462 } | 1560 } |
1463 ORTHANC_PLUGINS_DATABASE_CATCH | 1561 ORTHANC_PLUGINS_DATABASE_CATCH; |
1464 } | 1562 } |
1465 | 1563 |
1466 | 1564 |
1467 static OrthancPluginErrorCode Close(void* payload) | 1565 static OrthancPluginErrorCode Close(void* payload) |
1468 { | 1566 { |
1469 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1567 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
1470 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 1568 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
1569 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
1471 | 1570 |
1472 try | 1571 try |
1473 { | 1572 { |
1474 backend->Close(); | 1573 backend->Close(); |
1475 return OrthancPluginErrorCode_Success; | 1574 return OrthancPluginErrorCode_Success; |
1476 } | 1575 } |
1477 ORTHANC_PLUGINS_DATABASE_CATCH | 1576 ORTHANC_PLUGINS_DATABASE_CATCH; |
1478 } | 1577 } |
1479 | 1578 |
1480 | 1579 |
1481 static OrthancPluginErrorCode GetDatabaseVersion(uint32_t* version, | 1580 static OrthancPluginErrorCode GetDatabaseVersion(uint32_t* version, |
1482 void* payload) | 1581 void* payload) |
1483 { | 1582 { |
1484 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1583 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
1485 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 1584 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
1585 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
1486 | 1586 |
1487 try | 1587 try |
1488 { | 1588 { |
1489 *version = backend->GetDatabaseVersion(); | 1589 *version = backend->GetDatabaseVersion(); |
1490 return OrthancPluginErrorCode_Success; | 1590 return OrthancPluginErrorCode_Success; |
1491 } | 1591 } |
1492 ORTHANC_PLUGINS_DATABASE_CATCH | 1592 ORTHANC_PLUGINS_DATABASE_CATCH; |
1493 } | 1593 } |
1494 | 1594 |
1495 | 1595 |
1496 static OrthancPluginErrorCode UpgradeDatabase(void* payload, | 1596 static OrthancPluginErrorCode UpgradeDatabase(void* payload, |
1497 uint32_t targetVersion, | 1597 uint32_t targetVersion, |
1498 OrthancPluginStorageArea* storageArea) | 1598 OrthancPluginStorageArea* storageArea) |
1499 { | 1599 { |
1500 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1600 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
1501 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 1601 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
1602 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
1502 | 1603 |
1503 try | 1604 try |
1504 { | 1605 { |
1505 backend->UpgradeDatabase(targetVersion, storageArea); | 1606 backend->UpgradeDatabase(targetVersion, storageArea); |
1506 return OrthancPluginErrorCode_Success; | 1607 return OrthancPluginErrorCode_Success; |
1507 } | 1608 } |
1508 ORTHANC_PLUGINS_DATABASE_CATCH | 1609 ORTHANC_PLUGINS_DATABASE_CATCH; |
1509 } | 1610 } |
1510 | 1611 |
1511 | 1612 |
1512 static OrthancPluginErrorCode ClearMainDicomTags(void* payload, | 1613 static OrthancPluginErrorCode ClearMainDicomTags(void* payload, |
1513 int64_t internalId) | 1614 int64_t internalId) |
1514 { | 1615 { |
1515 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1616 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
1516 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 1617 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
1618 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
1517 | 1619 |
1518 try | 1620 try |
1519 { | 1621 { |
1520 backend->ClearMainDicomTags(internalId); | 1622 backend->ClearMainDicomTags(internalId); |
1521 return OrthancPluginErrorCode_Success; | 1623 return OrthancPluginErrorCode_Success; |
1522 } | 1624 } |
1523 ORTHANC_PLUGINS_DATABASE_CATCH | 1625 ORTHANC_PLUGINS_DATABASE_CATCH; |
1524 } | 1626 } |
1525 | 1627 |
1526 | 1628 |
1527 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1 | 1629 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1 |
1528 /* Use GetOutput().AnswerResource() */ | 1630 /* Use GetOutput().AnswerResource() */ |
1534 OrthancPluginResourceType queryLevel, | 1636 OrthancPluginResourceType queryLevel, |
1535 uint32_t limit, | 1637 uint32_t limit, |
1536 uint8_t requestSomeInstance) | 1638 uint8_t requestSomeInstance) |
1537 { | 1639 { |
1538 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1640 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
1539 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_MatchingResource); | 1641 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
1642 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_MatchingResource); | |
1540 | 1643 |
1541 try | 1644 try |
1542 { | 1645 { |
1543 std::vector<Orthanc::DatabaseConstraint> lookup; | 1646 std::vector<Orthanc::DatabaseConstraint> lookup; |
1544 lookup.reserve(constraintsCount); | 1647 lookup.reserve(constraintsCount); |
1549 } | 1652 } |
1550 | 1653 |
1551 backend->LookupResources(lookup, queryLevel, limit, (requestSomeInstance != 0)); | 1654 backend->LookupResources(lookup, queryLevel, limit, (requestSomeInstance != 0)); |
1552 return OrthancPluginErrorCode_Success; | 1655 return OrthancPluginErrorCode_Success; |
1553 } | 1656 } |
1554 ORTHANC_PLUGINS_DATABASE_CATCH | 1657 ORTHANC_PLUGINS_DATABASE_CATCH; |
1555 } | 1658 } |
1556 #endif | 1659 #endif |
1557 | 1660 |
1558 | 1661 |
1559 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1 | 1662 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1 |
1560 static OrthancPluginErrorCode CreateInstance(OrthancPluginCreateInstanceResult* output, | 1663 static OrthancPluginErrorCode CreateInstance(OrthancPluginCreateInstanceResult* target, |
1561 void* payload, | 1664 void* payload, |
1562 const char* hashPatient, | 1665 const char* hashPatient, |
1563 const char* hashStudy, | 1666 const char* hashStudy, |
1564 const char* hashSeries, | 1667 const char* hashSeries, |
1565 const char* hashInstance) | 1668 const char* hashInstance) |
1566 { | 1669 { |
1567 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1670 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
1568 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 1671 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
1569 | 1672 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); |
1570 try | 1673 |
1571 { | 1674 try |
1572 backend->CreateInstance(*output, hashPatient, hashStudy, hashSeries, hashInstance); | 1675 { |
1573 return OrthancPluginErrorCode_Success; | 1676 backend->CreateInstance(*target, hashPatient, hashStudy, hashSeries, hashInstance); |
1574 } | 1677 return OrthancPluginErrorCode_Success; |
1575 ORTHANC_PLUGINS_DATABASE_CATCH | 1678 } |
1679 ORTHANC_PLUGINS_DATABASE_CATCH; | |
1576 } | 1680 } |
1577 #endif | 1681 #endif |
1578 | 1682 |
1579 | 1683 |
1580 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1 | 1684 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1 |
1586 const OrthancPluginResourcesContentTags* mainDicomTags, | 1690 const OrthancPluginResourcesContentTags* mainDicomTags, |
1587 uint32_t countMetadata, | 1691 uint32_t countMetadata, |
1588 const OrthancPluginResourcesContentMetadata* metadata) | 1692 const OrthancPluginResourcesContentMetadata* metadata) |
1589 { | 1693 { |
1590 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1694 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
1591 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 1695 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
1696 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
1592 | 1697 |
1593 try | 1698 try |
1594 { | 1699 { |
1595 backend->SetResourcesContent(countIdentifierTags, identifierTags, | 1700 backend->SetResourcesContent(countIdentifierTags, identifierTags, |
1596 countMainDicomTags, mainDicomTags, | 1701 countMainDicomTags, mainDicomTags, |
1597 countMetadata, metadata); | 1702 countMetadata, metadata); |
1598 return OrthancPluginErrorCode_Success; | 1703 return OrthancPluginErrorCode_Success; |
1599 } | 1704 } |
1600 ORTHANC_PLUGINS_DATABASE_CATCH | 1705 ORTHANC_PLUGINS_DATABASE_CATCH; |
1601 } | 1706 } |
1602 #endif | 1707 #endif |
1603 | 1708 |
1604 | 1709 |
1605 // New primitive since Orthanc 1.5.2 | 1710 // New primitive since Orthanc 1.5.2 |
1607 void* payload, | 1712 void* payload, |
1608 int64_t resourceId, | 1713 int64_t resourceId, |
1609 int32_t metadata) | 1714 int32_t metadata) |
1610 { | 1715 { |
1611 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1716 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
1612 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 1717 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
1718 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
1613 | 1719 |
1614 try | 1720 try |
1615 { | 1721 { |
1616 std::list<std::string> values; | 1722 std::list<std::string> values; |
1617 backend->GetChildrenMetadata(values, resourceId, metadata); | 1723 backend->GetChildrenMetadata(values, resourceId, metadata); |
1618 | 1724 |
1619 for (std::list<std::string>::const_iterator | 1725 for (std::list<std::string>::const_iterator |
1620 it = values.begin(); it != values.end(); ++it) | 1726 it = values.begin(); it != values.end(); ++it) |
1621 { | 1727 { |
1622 OrthancPluginDatabaseAnswerString(backend->GetContext(), | 1728 OrthancPluginDatabaseAnswerString(backend->GetContext(), |
1623 backend->GetOutput().GetDatabase(), | 1729 output.GetDatabase(), |
1624 it->c_str()); | 1730 it->c_str()); |
1625 } | 1731 } |
1626 | 1732 |
1627 return OrthancPluginErrorCode_Success; | 1733 return OrthancPluginErrorCode_Success; |
1628 } | 1734 } |
1629 ORTHANC_PLUGINS_DATABASE_CATCH | 1735 ORTHANC_PLUGINS_DATABASE_CATCH; |
1630 } | 1736 } |
1631 | 1737 |
1632 | 1738 |
1633 // New primitive since Orthanc 1.5.2 | 1739 // New primitive since Orthanc 1.5.2 |
1634 static OrthancPluginErrorCode GetLastChangeIndex(int64_t* result, | 1740 static OrthancPluginErrorCode GetLastChangeIndex(int64_t* result, |
1635 void* payload) | 1741 void* payload) |
1636 { | 1742 { |
1637 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1743 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
1638 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 1744 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
1745 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
1639 | 1746 |
1640 try | 1747 try |
1641 { | 1748 { |
1642 *result = backend->GetLastChangeIndex(); | 1749 *result = backend->GetLastChangeIndex(); |
1643 return OrthancPluginErrorCode_Success; | 1750 return OrthancPluginErrorCode_Success; |
1644 } | 1751 } |
1645 ORTHANC_PLUGINS_DATABASE_CATCH | 1752 ORTHANC_PLUGINS_DATABASE_CATCH; |
1646 } | 1753 } |
1647 | 1754 |
1648 | 1755 |
1649 // New primitive since Orthanc 1.5.2 | 1756 // New primitive since Orthanc 1.5.2 |
1650 static OrthancPluginErrorCode TagMostRecentPatient(void* payload, | 1757 static OrthancPluginErrorCode TagMostRecentPatient(void* payload, |
1651 int64_t patientId) | 1758 int64_t patientId) |
1652 { | 1759 { |
1653 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1760 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
1654 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | 1761 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
1762 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None); | |
1655 | 1763 |
1656 try | 1764 try |
1657 { | 1765 { |
1658 backend->TagMostRecentPatient(patientId); | 1766 backend->TagMostRecentPatient(patientId); |
1659 return OrthancPluginErrorCode_Success; | 1767 return OrthancPluginErrorCode_Success; |
1660 } | 1768 } |
1661 ORTHANC_PLUGINS_DATABASE_CATCH | 1769 ORTHANC_PLUGINS_DATABASE_CATCH; |
1662 } | 1770 } |
1663 | 1771 |
1664 | 1772 |
1665 #if defined(ORTHANC_PLUGINS_VERSION_IS_ABOVE) // Macro introduced in 1.3.1 | 1773 #if defined(ORTHANC_PLUGINS_VERSION_IS_ABOVE) // Macro introduced in 1.3.1 |
1666 # if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 5, 4) | 1774 # if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 5, 4) |
1668 static OrthancPluginErrorCode GetAllMetadata(OrthancPluginDatabaseContext* context, | 1776 static OrthancPluginErrorCode GetAllMetadata(OrthancPluginDatabaseContext* context, |
1669 void* payload, | 1777 void* payload, |
1670 int64_t resourceId) | 1778 int64_t resourceId) |
1671 { | 1779 { |
1672 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1780 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
1673 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_Metadata); | 1781 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
1782 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_Metadata); | |
1674 | 1783 |
1675 try | 1784 try |
1676 { | 1785 { |
1677 std::map<int32_t, std::string> result; | 1786 std::map<int32_t, std::string> result; |
1678 backend->GetAllMetadata(result, resourceId); | 1787 backend->GetAllMetadata(result, resourceId); |
1679 | 1788 |
1680 for (std::map<int32_t, std::string>::const_iterator | 1789 for (std::map<int32_t, std::string>::const_iterator |
1681 it = result.begin(); it != result.end(); ++it) | 1790 it = result.begin(); it != result.end(); ++it) |
1682 { | 1791 { |
1683 OrthancPluginDatabaseAnswerMetadata(backend->GetContext(), | 1792 OrthancPluginDatabaseAnswerMetadata(backend->GetContext(), |
1684 backend->GetOutput().GetDatabase(), | 1793 output.GetDatabase(), |
1685 resourceId, it->first, it->second.c_str()); | 1794 resourceId, it->first, it->second.c_str()); |
1686 } | 1795 } |
1687 | 1796 |
1688 return OrthancPluginErrorCode_Success; | 1797 return OrthancPluginErrorCode_Success; |
1689 } | 1798 } |
1690 ORTHANC_PLUGINS_DATABASE_CATCH | 1799 ORTHANC_PLUGINS_DATABASE_CATCH; |
1691 } | 1800 } |
1692 # endif | 1801 # endif |
1693 #endif | 1802 #endif |
1694 | 1803 |
1695 | 1804 |
1702 OrthancPluginResourceType* type, | 1811 OrthancPluginResourceType* type, |
1703 void* payload, | 1812 void* payload, |
1704 const char* publicId) | 1813 const char* publicId) |
1705 { | 1814 { |
1706 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1815 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
1707 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_String); | 1816 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput()); |
1817 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_String); | |
1708 | 1818 |
1709 try | 1819 try |
1710 { | 1820 { |
1711 std::string parent; | 1821 std::string parent; |
1712 if (backend->LookupResourceAndParent(*id, *type, parent, publicId)) | 1822 if (backend->LookupResourceAndParent(*id, *type, parent, publicId)) |
1714 *isExisting = 1; | 1824 *isExisting = 1; |
1715 | 1825 |
1716 if (!parent.empty()) | 1826 if (!parent.empty()) |
1717 { | 1827 { |
1718 OrthancPluginDatabaseAnswerString(backend->GetContext(), | 1828 OrthancPluginDatabaseAnswerString(backend->GetContext(), |
1719 backend->GetOutput().GetDatabase(), | 1829 output.GetDatabase(), |
1720 parent.c_str()); | 1830 parent.c_str()); |
1721 } | 1831 } |
1722 } | 1832 } |
1723 else | 1833 else |
1724 { | 1834 { |
1725 *isExisting = 0; | 1835 *isExisting = 0; |
1726 } | 1836 } |
1727 | 1837 |
1728 return OrthancPluginErrorCode_Success; | 1838 return OrthancPluginErrorCode_Success; |
1729 } | 1839 } |
1730 ORTHANC_PLUGINS_DATABASE_CATCH | 1840 ORTHANC_PLUGINS_DATABASE_CATCH; |
1731 } | 1841 } |
1732 # endif | 1842 # endif |
1733 #endif | 1843 #endif |
1734 | 1844 |
1735 | 1845 |
1857 if (!context) | 1967 if (!context) |
1858 { | 1968 { |
1859 throw std::runtime_error("Unable to register the database backend"); | 1969 throw std::runtime_error("Unable to register the database backend"); |
1860 } | 1970 } |
1861 | 1971 |
1862 backend.RegisterOutput(context, new DatabaseBackendOutput(context, database)); | 1972 backend.RegisterOutput(context, new DatabaseBackendOutputV2(context, database)); |
1863 } | 1973 } |
1864 }; | 1974 }; |
1865 } | 1975 } |