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