Mercurial > hg > orthanc-databases
annotate Framework/Plugins/OrthancCppDatabasePlugin.h @ 85:1012fe77241c db-changes
new extension implemented for PostgreSQL and SQLite: GetLastChangeIndex
author | Sebastien Jodogne <s.jodogne@gmail.com> |
---|---|
date | Thu, 10 Jan 2019 18:04:12 +0100 |
parents | 2ee166f77501 |
children | eb08ec14fb04 |
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; |
0 | 535 }; |
536 | |
537 | |
538 | |
539 /** | |
540 * @brief Bridge between C and C++ database engines. | |
541 * | |
542 * Class creating the bridge between the C low-level primitives for | |
543 * custom database engines, and the high-level IDatabaseBackend C++ | |
544 * interface. | |
545 * | |
546 * @ingroup Callbacks | |
547 **/ | |
548 class DatabaseBackendAdapter | |
549 { | |
550 private: | |
551 // This class cannot be instantiated | |
552 DatabaseBackendAdapter() | |
553 { | |
554 } | |
555 | |
556 static void LogError(IDatabaseBackend* backend, | |
557 const std::runtime_error& e) | |
558 { | |
559 backend->GetOutput().LogError("Exception in database back-end: " + std::string(e.what())); | |
560 } | |
561 | |
562 | |
563 static OrthancPluginErrorCode AddAttachment(void* payload, | |
564 int64_t id, | |
565 const OrthancPluginAttachment* attachment) | |
566 { | |
567 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
568 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
569 | |
570 try | |
571 { | |
572 backend->AddAttachment(id, *attachment); | |
573 return OrthancPluginErrorCode_Success; | |
574 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
575 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 576 } |
577 | |
578 | |
579 static OrthancPluginErrorCode AttachChild(void* payload, | |
580 int64_t parent, | |
581 int64_t child) | |
582 { | |
583 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
584 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
585 | |
586 try | |
587 { | |
588 backend->AttachChild(parent, child); | |
589 return OrthancPluginErrorCode_Success; | |
590 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
591 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 592 } |
593 | |
594 | |
595 static OrthancPluginErrorCode ClearChanges(void* payload) | |
596 { | |
597 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
598 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
599 | |
600 try | |
601 { | |
602 backend->ClearChanges(); | |
603 return OrthancPluginErrorCode_Success; | |
604 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
605 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 606 } |
607 | |
608 | |
609 static OrthancPluginErrorCode ClearExportedResources(void* payload) | |
610 { | |
611 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
612 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
613 | |
614 try | |
615 { | |
616 backend->ClearExportedResources(); | |
617 return OrthancPluginErrorCode_Success; | |
618 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
619 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 620 } |
621 | |
622 | |
623 static OrthancPluginErrorCode CreateResource(int64_t* id, | |
624 void* payload, | |
625 const char* publicId, | |
626 OrthancPluginResourceType resourceType) | |
627 { | |
628 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
629 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
630 | |
631 try | |
632 { | |
633 *id = backend->CreateResource(publicId, resourceType); | |
634 return OrthancPluginErrorCode_Success; | |
635 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
636 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 637 } |
638 | |
639 | |
640 static OrthancPluginErrorCode DeleteAttachment(void* payload, | |
641 int64_t id, | |
642 int32_t contentType) | |
643 { | |
644 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
645 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
646 | |
647 try | |
648 { | |
649 backend->DeleteAttachment(id, contentType); | |
650 return OrthancPluginErrorCode_Success; | |
651 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
652 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 653 } |
654 | |
655 | |
656 static OrthancPluginErrorCode DeleteMetadata(void* payload, | |
657 int64_t id, | |
658 int32_t metadataType) | |
659 { | |
660 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
661 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
662 | |
663 try | |
664 { | |
665 backend->DeleteMetadata(id, metadataType); | |
666 return OrthancPluginErrorCode_Success; | |
667 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
668 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 669 } |
670 | |
671 | |
672 static OrthancPluginErrorCode DeleteResource(void* payload, | |
673 int64_t id) | |
674 { | |
675 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
676 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
677 | |
678 try | |
679 { | |
680 backend->DeleteResource(id); | |
681 return OrthancPluginErrorCode_Success; | |
682 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
683 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 684 } |
685 | |
686 | |
687 static OrthancPluginErrorCode GetAllInternalIds(OrthancPluginDatabaseContext* context, | |
688 void* payload, | |
689 OrthancPluginResourceType resourceType) | |
690 { | |
691 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
692 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
693 | |
694 try | |
695 { | |
696 std::list<int64_t> target; | |
697 backend->GetAllInternalIds(target, resourceType); | |
698 | |
699 for (std::list<int64_t>::const_iterator | |
700 it = target.begin(); it != target.end(); ++it) | |
701 { | |
702 OrthancPluginDatabaseAnswerInt64(backend->GetOutput().context_, | |
703 backend->GetOutput().database_, *it); | |
704 } | |
705 | |
706 return OrthancPluginErrorCode_Success; | |
707 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
708 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 709 } |
710 | |
711 | |
712 static OrthancPluginErrorCode GetAllPublicIds(OrthancPluginDatabaseContext* context, | |
713 void* payload, | |
714 OrthancPluginResourceType resourceType) | |
715 { | |
716 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
717 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
718 | |
719 try | |
720 { | |
721 std::list<std::string> ids; | |
722 backend->GetAllPublicIds(ids, resourceType); | |
723 | |
724 for (std::list<std::string>::const_iterator | |
725 it = ids.begin(); it != ids.end(); ++it) | |
726 { | |
727 OrthancPluginDatabaseAnswerString(backend->GetOutput().context_, | |
728 backend->GetOutput().database_, | |
729 it->c_str()); | |
730 } | |
731 | |
732 return OrthancPluginErrorCode_Success; | |
733 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
734 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 735 } |
736 | |
737 | |
738 static OrthancPluginErrorCode GetAllPublicIdsWithLimit(OrthancPluginDatabaseContext* context, | |
739 void* payload, | |
740 OrthancPluginResourceType resourceType, | |
741 uint64_t since, | |
742 uint64_t limit) | |
743 { | |
744 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
745 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
746 | |
747 try | |
748 { | |
749 std::list<std::string> ids; | |
750 backend->GetAllPublicIds(ids, resourceType, since, limit); | |
751 | |
752 for (std::list<std::string>::const_iterator | |
753 it = ids.begin(); it != ids.end(); ++it) | |
754 { | |
755 OrthancPluginDatabaseAnswerString(backend->GetOutput().context_, | |
756 backend->GetOutput().database_, | |
757 it->c_str()); | |
758 } | |
759 | |
760 return OrthancPluginErrorCode_Success; | |
761 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
762 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 763 } |
764 | |
765 | |
766 static OrthancPluginErrorCode GetChanges(OrthancPluginDatabaseContext* context, | |
767 void* payload, | |
768 int64_t since, | |
769 uint32_t maxResult) | |
770 { | |
771 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
772 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_Change); | |
773 | |
774 try | |
775 { | |
776 bool done; | |
777 backend->GetChanges(done, since, maxResult); | |
778 | |
779 if (done) | |
780 { | |
781 OrthancPluginDatabaseAnswerChangesDone(backend->GetOutput().context_, | |
782 backend->GetOutput().database_); | |
783 } | |
784 | |
785 return OrthancPluginErrorCode_Success; | |
786 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
787 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 788 } |
789 | |
790 | |
791 static OrthancPluginErrorCode GetChildrenInternalId(OrthancPluginDatabaseContext* context, | |
792 void* payload, | |
793 int64_t id) | |
794 { | |
795 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
796 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
797 | |
798 try | |
799 { | |
800 std::list<int64_t> target; | |
801 backend->GetChildrenInternalId(target, id); | |
802 | |
803 for (std::list<int64_t>::const_iterator | |
804 it = target.begin(); it != target.end(); ++it) | |
805 { | |
806 OrthancPluginDatabaseAnswerInt64(backend->GetOutput().context_, | |
807 backend->GetOutput().database_, *it); | |
808 } | |
809 | |
810 return OrthancPluginErrorCode_Success; | |
811 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
812 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 813 } |
814 | |
815 | |
816 static OrthancPluginErrorCode GetChildrenPublicId(OrthancPluginDatabaseContext* context, | |
817 void* payload, | |
818 int64_t id) | |
819 { | |
820 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
821 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
822 | |
823 try | |
824 { | |
825 std::list<std::string> ids; | |
826 backend->GetChildrenPublicId(ids, id); | |
827 | |
828 for (std::list<std::string>::const_iterator | |
829 it = ids.begin(); it != ids.end(); ++it) | |
830 { | |
831 OrthancPluginDatabaseAnswerString(backend->GetOutput().context_, | |
832 backend->GetOutput().database_, | |
833 it->c_str()); | |
834 } | |
835 | |
836 return OrthancPluginErrorCode_Success; | |
837 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
838 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 839 } |
840 | |
841 | |
842 static OrthancPluginErrorCode GetExportedResources(OrthancPluginDatabaseContext* context, | |
843 void* payload, | |
844 int64_t since, | |
845 uint32_t maxResult) | |
846 { | |
847 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
848 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_ExportedResource); | |
849 | |
850 try | |
851 { | |
852 bool done; | |
853 backend->GetExportedResources(done, since, maxResult); | |
854 | |
855 if (done) | |
856 { | |
857 OrthancPluginDatabaseAnswerExportedResourcesDone(backend->GetOutput().context_, | |
858 backend->GetOutput().database_); | |
859 } | |
860 return OrthancPluginErrorCode_Success; | |
861 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
862 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 863 } |
864 | |
865 | |
866 static OrthancPluginErrorCode GetLastChange(OrthancPluginDatabaseContext* context, | |
867 void* payload) | |
868 { | |
869 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
870 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_Change); | |
871 | |
872 try | |
873 { | |
874 backend->GetLastChange(); | |
875 return OrthancPluginErrorCode_Success; | |
876 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
877 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 878 } |
879 | |
880 | |
881 static OrthancPluginErrorCode GetLastExportedResource(OrthancPluginDatabaseContext* context, | |
882 void* payload) | |
883 { | |
884 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
885 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_ExportedResource); | |
886 | |
887 try | |
888 { | |
889 backend->GetLastExportedResource(); | |
890 return OrthancPluginErrorCode_Success; | |
891 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
892 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 893 } |
894 | |
895 | |
896 static OrthancPluginErrorCode GetMainDicomTags(OrthancPluginDatabaseContext* context, | |
897 void* payload, | |
898 int64_t id) | |
899 { | |
900 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
901 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_DicomTag); | |
902 | |
903 try | |
904 { | |
905 backend->GetMainDicomTags(id); | |
906 return OrthancPluginErrorCode_Success; | |
907 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
908 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 909 } |
910 | |
911 | |
912 static OrthancPluginErrorCode GetPublicId(OrthancPluginDatabaseContext* context, | |
913 void* payload, | |
914 int64_t id) | |
915 { | |
916 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
917 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
918 | |
919 try | |
920 { | |
921 std::string s = backend->GetPublicId(id); | |
922 OrthancPluginDatabaseAnswerString(backend->GetOutput().context_, | |
923 backend->GetOutput().database_, | |
924 s.c_str()); | |
925 | |
926 return OrthancPluginErrorCode_Success; | |
927 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
928 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 929 } |
930 | |
931 | |
932 static OrthancPluginErrorCode GetResourceCount(uint64_t* target, | |
933 void* payload, | |
934 OrthancPluginResourceType resourceType) | |
935 { | |
936 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
937 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
938 | |
939 try | |
940 { | |
941 *target = backend->GetResourceCount(resourceType); | |
942 return OrthancPluginErrorCode_Success; | |
943 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
944 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 945 } |
946 | |
947 | |
948 static OrthancPluginErrorCode GetResourceType(OrthancPluginResourceType* resourceType, | |
949 void* payload, | |
950 int64_t id) | |
951 { | |
952 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
953 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
954 | |
955 try | |
956 { | |
957 *resourceType = backend->GetResourceType(id); | |
958 return OrthancPluginErrorCode_Success; | |
959 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
960 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 961 } |
962 | |
963 | |
964 static OrthancPluginErrorCode GetTotalCompressedSize(uint64_t* target, | |
965 void* payload) | |
966 { | |
967 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
968 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
969 | |
970 try | |
971 { | |
972 *target = backend->GetTotalCompressedSize(); | |
973 return OrthancPluginErrorCode_Success; | |
974 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
975 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 976 } |
977 | |
978 | |
979 static OrthancPluginErrorCode GetTotalUncompressedSize(uint64_t* target, | |
980 void* payload) | |
981 { | |
982 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
983 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
984 | |
985 try | |
986 { | |
987 *target = backend->GetTotalUncompressedSize(); | |
988 return OrthancPluginErrorCode_Success; | |
989 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
990 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 991 } |
992 | |
993 | |
994 static OrthancPluginErrorCode IsExistingResource(int32_t* existing, | |
995 void* payload, | |
996 int64_t id) | |
997 { | |
998 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
999 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1000 | |
1001 try | |
1002 { | |
1003 *existing = backend->IsExistingResource(id); | |
1004 return OrthancPluginErrorCode_Success; | |
1005 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1006 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1007 } |
1008 | |
1009 | |
1010 static OrthancPluginErrorCode IsProtectedPatient(int32_t* isProtected, | |
1011 void* payload, | |
1012 int64_t id) | |
1013 { | |
1014 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1015 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1016 | |
1017 try | |
1018 { | |
1019 *isProtected = backend->IsProtectedPatient(id); | |
1020 return OrthancPluginErrorCode_Success; | |
1021 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1022 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1023 } |
1024 | |
1025 | |
1026 static OrthancPluginErrorCode ListAvailableMetadata(OrthancPluginDatabaseContext* context, | |
1027 void* payload, | |
1028 int64_t id) | |
1029 { | |
1030 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1031 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1032 | |
1033 try | |
1034 { | |
1035 std::list<int32_t> target; | |
1036 backend->ListAvailableMetadata(target, id); | |
1037 | |
1038 for (std::list<int32_t>::const_iterator | |
1039 it = target.begin(); it != target.end(); ++it) | |
1040 { | |
1041 OrthancPluginDatabaseAnswerInt32(backend->GetOutput().context_, | |
1042 backend->GetOutput().database_, | |
1043 *it); | |
1044 } | |
1045 | |
1046 return OrthancPluginErrorCode_Success; | |
1047 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1048 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1049 } |
1050 | |
1051 | |
1052 static OrthancPluginErrorCode ListAvailableAttachments(OrthancPluginDatabaseContext* context, | |
1053 void* payload, | |
1054 int64_t id) | |
1055 { | |
1056 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1057 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1058 | |
1059 try | |
1060 { | |
1061 std::list<int32_t> target; | |
1062 backend->ListAvailableAttachments(target, id); | |
1063 | |
1064 for (std::list<int32_t>::const_iterator | |
1065 it = target.begin(); it != target.end(); ++it) | |
1066 { | |
1067 OrthancPluginDatabaseAnswerInt32(backend->GetOutput().context_, | |
1068 backend->GetOutput().database_, | |
1069 *it); | |
1070 } | |
1071 | |
1072 return OrthancPluginErrorCode_Success; | |
1073 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1074 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1075 } |
1076 | |
1077 | |
1078 static OrthancPluginErrorCode LogChange(void* payload, | |
1079 const OrthancPluginChange* change) | |
1080 { | |
1081 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1082 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1083 | |
1084 try | |
1085 { | |
1086 backend->LogChange(*change); | |
1087 return OrthancPluginErrorCode_Success; | |
1088 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1089 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1090 } |
1091 | |
1092 | |
1093 static OrthancPluginErrorCode LogExportedResource(void* payload, | |
1094 const OrthancPluginExportedResource* exported) | |
1095 { | |
1096 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1097 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1098 | |
1099 try | |
1100 { | |
1101 backend->LogExportedResource(*exported); | |
1102 return OrthancPluginErrorCode_Success; | |
1103 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1104 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1105 } |
1106 | |
1107 | |
1108 static OrthancPluginErrorCode LookupAttachment(OrthancPluginDatabaseContext* context, | |
1109 void* payload, | |
1110 int64_t id, | |
1111 int32_t contentType) | |
1112 { | |
1113 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1114 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_Attachment); | |
1115 | |
1116 try | |
1117 { | |
1118 backend->LookupAttachment(id, contentType); | |
1119 return OrthancPluginErrorCode_Success; | |
1120 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1121 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1122 } |
1123 | |
1124 | |
1125 static OrthancPluginErrorCode LookupGlobalProperty(OrthancPluginDatabaseContext* context, | |
1126 void* payload, | |
1127 int32_t property) | |
1128 { | |
1129 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1130 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1131 | |
1132 try | |
1133 { | |
1134 std::string s; | |
1135 if (backend->LookupGlobalProperty(s, property)) | |
1136 { | |
1137 OrthancPluginDatabaseAnswerString(backend->GetOutput().context_, | |
1138 backend->GetOutput().database_, | |
1139 s.c_str()); | |
1140 } | |
1141 | |
1142 return OrthancPluginErrorCode_Success; | |
1143 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1144 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1145 } |
1146 | |
1147 | |
1148 static OrthancPluginErrorCode LookupIdentifier3(OrthancPluginDatabaseContext* context, | |
1149 void* payload, | |
1150 OrthancPluginResourceType resourceType, | |
1151 const OrthancPluginDicomTag* tag, | |
1152 OrthancPluginIdentifierConstraint constraint) | |
1153 { | |
1154 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1155 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1156 | |
1157 try | |
1158 { | |
1159 std::list<int64_t> target; | |
1160 backend->LookupIdentifier(target, resourceType, tag->group, tag->element, constraint, tag->value); | |
1161 | |
1162 for (std::list<int64_t>::const_iterator | |
1163 it = target.begin(); it != target.end(); ++it) | |
1164 { | |
1165 OrthancPluginDatabaseAnswerInt64(backend->GetOutput().context_, | |
1166 backend->GetOutput().database_, *it); | |
1167 } | |
1168 | |
1169 return OrthancPluginErrorCode_Success; | |
1170 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1171 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1172 } |
1173 | |
1174 | |
1175 static OrthancPluginErrorCode LookupIdentifierRange(OrthancPluginDatabaseContext* context, | |
1176 void* payload, | |
1177 OrthancPluginResourceType resourceType, | |
1178 uint16_t group, | |
1179 uint16_t element, | |
1180 const char* start, | |
1181 const char* end) | |
1182 { | |
1183 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1184 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1185 | |
1186 try | |
1187 { | |
1188 std::list<int64_t> target; | |
1189 backend->LookupIdentifierRange(target, resourceType, group, element, start, end); | |
1190 | |
1191 for (std::list<int64_t>::const_iterator | |
1192 it = target.begin(); it != target.end(); ++it) | |
1193 { | |
1194 OrthancPluginDatabaseAnswerInt64(backend->GetOutput().context_, | |
1195 backend->GetOutput().database_, *it); | |
1196 } | |
1197 | |
1198 return OrthancPluginErrorCode_Success; | |
1199 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1200 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1201 } |
1202 | |
1203 | |
1204 static OrthancPluginErrorCode LookupMetadata(OrthancPluginDatabaseContext* context, | |
1205 void* payload, | |
1206 int64_t id, | |
1207 int32_t metadata) | |
1208 { | |
1209 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1210 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1211 | |
1212 try | |
1213 { | |
1214 std::string s; | |
1215 if (backend->LookupMetadata(s, id, metadata)) | |
1216 { | |
1217 OrthancPluginDatabaseAnswerString(backend->GetOutput().context_, | |
1218 backend->GetOutput().database_, s.c_str()); | |
1219 } | |
1220 | |
1221 return OrthancPluginErrorCode_Success; | |
1222 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1223 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1224 } |
1225 | |
1226 | |
1227 static OrthancPluginErrorCode LookupParent(OrthancPluginDatabaseContext* context, | |
1228 void* payload, | |
1229 int64_t id) | |
1230 { | |
1231 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1232 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1233 | |
1234 try | |
1235 { | |
1236 int64_t parent; | |
1237 if (backend->LookupParent(parent, id)) | |
1238 { | |
1239 OrthancPluginDatabaseAnswerInt64(backend->GetOutput().context_, | |
1240 backend->GetOutput().database_, parent); | |
1241 } | |
1242 | |
1243 return OrthancPluginErrorCode_Success; | |
1244 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1245 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1246 } |
1247 | |
1248 | |
1249 static OrthancPluginErrorCode LookupResource(OrthancPluginDatabaseContext* context, | |
1250 void* payload, | |
1251 const char* publicId) | |
1252 { | |
1253 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1254 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1255 | |
1256 try | |
1257 { | |
1258 int64_t id; | |
1259 OrthancPluginResourceType type; | |
1260 if (backend->LookupResource(id, type, publicId)) | |
1261 { | |
1262 OrthancPluginDatabaseAnswerResource(backend->GetOutput().context_, | |
1263 backend->GetOutput().database_, | |
1264 id, type); | |
1265 } | |
1266 | |
1267 return OrthancPluginErrorCode_Success; | |
1268 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1269 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1270 } |
1271 | |
1272 | |
1273 static OrthancPluginErrorCode SelectPatientToRecycle(OrthancPluginDatabaseContext* context, | |
1274 void* payload) | |
1275 { | |
1276 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1277 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1278 | |
1279 try | |
1280 { | |
1281 int64_t id; | |
1282 if (backend->SelectPatientToRecycle(id)) | |
1283 { | |
1284 OrthancPluginDatabaseAnswerInt64(backend->GetOutput().context_, | |
1285 backend->GetOutput().database_, id); | |
1286 } | |
1287 | |
1288 return OrthancPluginErrorCode_Success; | |
1289 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1290 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1291 } |
1292 | |
1293 | |
1294 static OrthancPluginErrorCode SelectPatientToRecycle2(OrthancPluginDatabaseContext* context, | |
1295 void* payload, | |
1296 int64_t patientIdToAvoid) | |
1297 { | |
1298 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1299 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1300 | |
1301 try | |
1302 { | |
1303 int64_t id; | |
1304 if (backend->SelectPatientToRecycle(id, patientIdToAvoid)) | |
1305 { | |
1306 OrthancPluginDatabaseAnswerInt64(backend->GetOutput().context_, | |
1307 backend->GetOutput().database_, id); | |
1308 } | |
1309 | |
1310 return OrthancPluginErrorCode_Success; | |
1311 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1312 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1313 } |
1314 | |
1315 | |
1316 static OrthancPluginErrorCode SetGlobalProperty(void* payload, | |
1317 int32_t property, | |
1318 const char* value) | |
1319 { | |
1320 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1321 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1322 | |
1323 try | |
1324 { | |
1325 backend->SetGlobalProperty(property, value); | |
1326 return OrthancPluginErrorCode_Success; | |
1327 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1328 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1329 } |
1330 | |
1331 | |
1332 static OrthancPluginErrorCode SetMainDicomTag(void* payload, | |
1333 int64_t id, | |
1334 const OrthancPluginDicomTag* tag) | |
1335 { | |
1336 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1337 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1338 | |
1339 try | |
1340 { | |
1341 backend->SetMainDicomTag(id, tag->group, tag->element, tag->value); | |
1342 return OrthancPluginErrorCode_Success; | |
1343 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1344 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1345 } |
1346 | |
1347 | |
1348 static OrthancPluginErrorCode SetIdentifierTag(void* payload, | |
1349 int64_t id, | |
1350 const OrthancPluginDicomTag* tag) | |
1351 { | |
1352 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1353 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1354 | |
1355 try | |
1356 { | |
1357 backend->SetIdentifierTag(id, tag->group, tag->element, tag->value); | |
1358 return OrthancPluginErrorCode_Success; | |
1359 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1360 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1361 } |
1362 | |
1363 | |
1364 static OrthancPluginErrorCode SetMetadata(void* payload, | |
1365 int64_t id, | |
1366 int32_t metadata, | |
1367 const char* value) | |
1368 { | |
1369 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1370 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1371 | |
1372 try | |
1373 { | |
1374 backend->SetMetadata(id, metadata, value); | |
1375 return OrthancPluginErrorCode_Success; | |
1376 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1377 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1378 } |
1379 | |
1380 | |
1381 static OrthancPluginErrorCode SetProtectedPatient(void* payload, | |
1382 int64_t id, | |
1383 int32_t isProtected) | |
1384 { | |
1385 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1386 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1387 | |
1388 try | |
1389 { | |
1390 backend->SetProtectedPatient(id, (isProtected != 0)); | |
1391 return OrthancPluginErrorCode_Success; | |
1392 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1393 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1394 } |
1395 | |
1396 | |
1397 static OrthancPluginErrorCode StartTransaction(void* payload) | |
1398 { | |
1399 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1400 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1401 | |
1402 try | |
1403 { | |
1404 backend->StartTransaction(); | |
1405 return OrthancPluginErrorCode_Success; | |
1406 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1407 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1408 } |
1409 | |
1410 | |
1411 static OrthancPluginErrorCode RollbackTransaction(void* payload) | |
1412 { | |
1413 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1414 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1415 | |
1416 try | |
1417 { | |
1418 backend->RollbackTransaction(); | |
1419 return OrthancPluginErrorCode_Success; | |
1420 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1421 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1422 } |
1423 | |
1424 | |
1425 static OrthancPluginErrorCode CommitTransaction(void* payload) | |
1426 { | |
1427 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1428 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1429 | |
1430 try | |
1431 { | |
1432 backend->CommitTransaction(); | |
1433 return OrthancPluginErrorCode_Success; | |
1434 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1435 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1436 } |
1437 | |
1438 | |
1439 static OrthancPluginErrorCode Open(void* payload) | |
1440 { | |
1441 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1442 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1443 | |
1444 try | |
1445 { | |
1446 backend->Open(); | |
1447 return OrthancPluginErrorCode_Success; | |
1448 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1449 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1450 } |
1451 | |
1452 | |
1453 static OrthancPluginErrorCode Close(void* payload) | |
1454 { | |
1455 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1456 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1457 | |
1458 try | |
1459 { | |
1460 backend->Close(); | |
1461 return OrthancPluginErrorCode_Success; | |
1462 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1463 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1464 } |
1465 | |
1466 | |
1467 static OrthancPluginErrorCode GetDatabaseVersion(uint32_t* version, | |
1468 void* payload) | |
1469 { | |
1470 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
76
a1c6238b26f8
new extension implemented for PostgreSQL: GetChildrenMetadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
75
diff
changeset
|
1471 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); |
0 | 1472 |
1473 try | |
1474 { | |
1475 *version = backend->GetDatabaseVersion(); | |
1476 return OrthancPluginErrorCode_Success; | |
1477 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1478 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1479 } |
1480 | |
1481 | |
1482 static OrthancPluginErrorCode UpgradeDatabase(void* payload, | |
1483 uint32_t targetVersion, | |
1484 OrthancPluginStorageArea* storageArea) | |
1485 { | |
1486 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
76
a1c6238b26f8
new extension implemented for PostgreSQL: GetChildrenMetadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
75
diff
changeset
|
1487 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); |
0 | 1488 |
1489 try | |
1490 { | |
1491 backend->UpgradeDatabase(targetVersion, storageArea); | |
1492 return OrthancPluginErrorCode_Success; | |
1493 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1494 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1495 } |
1496 | |
1497 | |
1498 static OrthancPluginErrorCode ClearMainDicomTags(void* payload, | |
1499 int64_t internalId) | |
1500 { | |
1501 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
76
a1c6238b26f8
new extension implemented for PostgreSQL: GetChildrenMetadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
75
diff
changeset
|
1502 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); |
0 | 1503 |
1504 try | |
1505 { | |
1506 backend->ClearMainDicomTags(internalId); | |
1507 return OrthancPluginErrorCode_Success; | |
1508 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1509 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1510 } |
1511 | |
69
19764fc60ade
compatibility with Orthanc SDDK 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
67
diff
changeset
|
1512 |
78 | 1513 #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
|
1514 /* Use GetOutput().AnswerResource() */ |
19764fc60ade
compatibility with Orthanc SDDK 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
67
diff
changeset
|
1515 static OrthancPluginErrorCode LookupResources( |
19764fc60ade
compatibility with Orthanc SDDK 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
67
diff
changeset
|
1516 OrthancPluginDatabaseContext* context, |
19764fc60ade
compatibility with Orthanc SDDK 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
67
diff
changeset
|
1517 void* payload, |
19764fc60ade
compatibility with Orthanc SDDK 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
67
diff
changeset
|
1518 uint32_t constraintsCount, |
19764fc60ade
compatibility with Orthanc SDDK 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
67
diff
changeset
|
1519 const OrthancPluginDatabaseConstraint* constraints, |
19764fc60ade
compatibility with Orthanc SDDK 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
67
diff
changeset
|
1520 OrthancPluginResourceType queryLevel, |
19764fc60ade
compatibility with Orthanc SDDK 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
67
diff
changeset
|
1521 uint32_t limit, |
19764fc60ade
compatibility with Orthanc SDDK 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
67
diff
changeset
|
1522 uint8_t requestSomeInstance) |
19764fc60ade
compatibility with Orthanc SDDK 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
67
diff
changeset
|
1523 { |
19764fc60ade
compatibility with Orthanc SDDK 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
67
diff
changeset
|
1524 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
19764fc60ade
compatibility with Orthanc SDDK 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
67
diff
changeset
|
1525 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_MatchingResource); |
19764fc60ade
compatibility with Orthanc SDDK 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
67
diff
changeset
|
1526 |
19764fc60ade
compatibility with Orthanc SDDK 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
67
diff
changeset
|
1527 try |
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 std::vector<Orthanc::DatabaseConstraint> lookup; |
19764fc60ade
compatibility with Orthanc SDDK 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
67
diff
changeset
|
1530 lookup.reserve(constraintsCount); |
19764fc60ade
compatibility with Orthanc SDDK 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
67
diff
changeset
|
1531 |
19764fc60ade
compatibility with Orthanc SDDK 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
67
diff
changeset
|
1532 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
|
1533 { |
19764fc60ade
compatibility with Orthanc SDDK 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
67
diff
changeset
|
1534 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
|
1535 } |
19764fc60ade
compatibility with Orthanc SDDK 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
67
diff
changeset
|
1536 |
19764fc60ade
compatibility with Orthanc SDDK 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
67
diff
changeset
|
1537 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
|
1538 return OrthancPluginErrorCode_Success; |
19764fc60ade
compatibility with Orthanc SDDK 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
67
diff
changeset
|
1539 } |
19764fc60ade
compatibility with Orthanc SDDK 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
67
diff
changeset
|
1540 ORTHANC_PLUGINS_DATABASE_CATCH |
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 #endif |
19764fc60ade
compatibility with Orthanc SDDK 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
67
diff
changeset
|
1543 |
71
d40c5fecd160
new extension implemented for PostgreSQL: CreateInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
70
diff
changeset
|
1544 |
78 | 1545 #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
|
1546 static OrthancPluginErrorCode CreateInstance(OrthancPluginCreateInstanceResult* output, |
d40c5fecd160
new extension implemented for PostgreSQL: CreateInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
70
diff
changeset
|
1547 void* payload, |
d40c5fecd160
new extension implemented for PostgreSQL: CreateInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
70
diff
changeset
|
1548 const char* hashPatient, |
d40c5fecd160
new extension implemented for PostgreSQL: CreateInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
70
diff
changeset
|
1549 const char* hashStudy, |
d40c5fecd160
new extension implemented for PostgreSQL: CreateInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
70
diff
changeset
|
1550 const char* hashSeries, |
d40c5fecd160
new extension implemented for PostgreSQL: CreateInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
70
diff
changeset
|
1551 const char* hashInstance) |
d40c5fecd160
new extension implemented for PostgreSQL: CreateInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
70
diff
changeset
|
1552 { |
d40c5fecd160
new extension implemented for PostgreSQL: CreateInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
70
diff
changeset
|
1553 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
76
a1c6238b26f8
new extension implemented for PostgreSQL: GetChildrenMetadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
75
diff
changeset
|
1554 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); |
71
d40c5fecd160
new extension implemented for PostgreSQL: CreateInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
70
diff
changeset
|
1555 |
d40c5fecd160
new extension implemented for PostgreSQL: CreateInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
70
diff
changeset
|
1556 try |
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 backend->CreateInstance(*output, hashPatient, hashStudy, hashSeries, hashInstance); |
d40c5fecd160
new extension implemented for PostgreSQL: CreateInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
70
diff
changeset
|
1559 return OrthancPluginErrorCode_Success; |
d40c5fecd160
new extension implemented for PostgreSQL: CreateInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
70
diff
changeset
|
1560 } |
d40c5fecd160
new extension implemented for PostgreSQL: CreateInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
70
diff
changeset
|
1561 ORTHANC_PLUGINS_DATABASE_CATCH |
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 #endif |
d40c5fecd160
new extension implemented for PostgreSQL: CreateInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
70
diff
changeset
|
1564 |
75
52c70007bb87
new extension implemented for PostgreSQL: SetResourcesContent
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
74
diff
changeset
|
1565 |
78 | 1566 #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
|
1567 static OrthancPluginErrorCode SetResourcesContent( |
52c70007bb87
new extension implemented for PostgreSQL: SetResourcesContent
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
74
diff
changeset
|
1568 void* payload, |
52c70007bb87
new extension implemented for PostgreSQL: SetResourcesContent
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
74
diff
changeset
|
1569 uint32_t countIdentifierTags, |
52c70007bb87
new extension implemented for PostgreSQL: SetResourcesContent
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
74
diff
changeset
|
1570 const OrthancPluginResourcesContentTags* identifierTags, |
52c70007bb87
new extension implemented for PostgreSQL: SetResourcesContent
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
74
diff
changeset
|
1571 uint32_t countMainDicomTags, |
52c70007bb87
new extension implemented for PostgreSQL: SetResourcesContent
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
74
diff
changeset
|
1572 const OrthancPluginResourcesContentTags* mainDicomTags, |
52c70007bb87
new extension implemented for PostgreSQL: SetResourcesContent
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
74
diff
changeset
|
1573 uint32_t countMetadata, |
52c70007bb87
new extension implemented for PostgreSQL: SetResourcesContent
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
74
diff
changeset
|
1574 const OrthancPluginResourcesContentMetadata* metadata) |
52c70007bb87
new extension implemented for PostgreSQL: SetResourcesContent
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
74
diff
changeset
|
1575 { |
52c70007bb87
new extension implemented for PostgreSQL: SetResourcesContent
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
74
diff
changeset
|
1576 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
76
a1c6238b26f8
new extension implemented for PostgreSQL: GetChildrenMetadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
75
diff
changeset
|
1577 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); |
75
52c70007bb87
new extension implemented for PostgreSQL: SetResourcesContent
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
74
diff
changeset
|
1578 |
52c70007bb87
new extension implemented for PostgreSQL: SetResourcesContent
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
74
diff
changeset
|
1579 try |
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 backend->SetResourcesContent(countIdentifierTags, identifierTags, |
52c70007bb87
new extension implemented for PostgreSQL: SetResourcesContent
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
74
diff
changeset
|
1582 countMainDicomTags, mainDicomTags, |
52c70007bb87
new extension implemented for PostgreSQL: SetResourcesContent
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
74
diff
changeset
|
1583 countMetadata, metadata); |
52c70007bb87
new extension implemented for PostgreSQL: SetResourcesContent
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
74
diff
changeset
|
1584 return OrthancPluginErrorCode_Success; |
52c70007bb87
new extension implemented for PostgreSQL: SetResourcesContent
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
74
diff
changeset
|
1585 } |
52c70007bb87
new extension implemented for PostgreSQL: SetResourcesContent
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
74
diff
changeset
|
1586 ORTHANC_PLUGINS_DATABASE_CATCH |
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 #endif |
52c70007bb87
new extension implemented for PostgreSQL: SetResourcesContent
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
74
diff
changeset
|
1589 |
0 | 1590 |
76
a1c6238b26f8
new extension implemented for PostgreSQL: GetChildrenMetadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
75
diff
changeset
|
1591 // New primitive since Orthanc 1.5.2 |
a1c6238b26f8
new extension implemented for PostgreSQL: GetChildrenMetadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
75
diff
changeset
|
1592 static OrthancPluginErrorCode GetChildrenMetadata(OrthancPluginDatabaseContext* context, |
a1c6238b26f8
new extension implemented for PostgreSQL: GetChildrenMetadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
75
diff
changeset
|
1593 void* payload, |
a1c6238b26f8
new extension implemented for PostgreSQL: GetChildrenMetadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
75
diff
changeset
|
1594 int64_t resourceId, |
a1c6238b26f8
new extension implemented for PostgreSQL: GetChildrenMetadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
75
diff
changeset
|
1595 int32_t metadata) |
a1c6238b26f8
new extension implemented for PostgreSQL: GetChildrenMetadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
75
diff
changeset
|
1596 { |
a1c6238b26f8
new extension implemented for PostgreSQL: GetChildrenMetadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
75
diff
changeset
|
1597 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); |
a1c6238b26f8
new extension implemented for PostgreSQL: GetChildrenMetadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
75
diff
changeset
|
1598 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); |
a1c6238b26f8
new extension implemented for PostgreSQL: GetChildrenMetadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
75
diff
changeset
|
1599 |
a1c6238b26f8
new extension implemented for PostgreSQL: GetChildrenMetadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
75
diff
changeset
|
1600 try |
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 std::list<std::string> values; |
a1c6238b26f8
new extension implemented for PostgreSQL: GetChildrenMetadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
75
diff
changeset
|
1603 backend->GetChildrenMetadata(values, resourceId, metadata); |
a1c6238b26f8
new extension implemented for PostgreSQL: GetChildrenMetadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
75
diff
changeset
|
1604 |
a1c6238b26f8
new extension implemented for PostgreSQL: GetChildrenMetadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
75
diff
changeset
|
1605 for (std::list<std::string>::const_iterator |
a1c6238b26f8
new extension implemented for PostgreSQL: GetChildrenMetadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
75
diff
changeset
|
1606 it = values.begin(); it != values.end(); ++it) |
a1c6238b26f8
new extension implemented for PostgreSQL: GetChildrenMetadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
75
diff
changeset
|
1607 { |
a1c6238b26f8
new extension implemented for PostgreSQL: GetChildrenMetadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
75
diff
changeset
|
1608 OrthancPluginDatabaseAnswerString(backend->GetOutput().context_, |
a1c6238b26f8
new extension implemented for PostgreSQL: GetChildrenMetadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
75
diff
changeset
|
1609 backend->GetOutput().database_, |
a1c6238b26f8
new extension implemented for PostgreSQL: GetChildrenMetadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
75
diff
changeset
|
1610 it->c_str()); |
a1c6238b26f8
new extension implemented for PostgreSQL: GetChildrenMetadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
75
diff
changeset
|
1611 } |
a1c6238b26f8
new extension implemented for PostgreSQL: GetChildrenMetadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
75
diff
changeset
|
1612 |
a1c6238b26f8
new extension implemented for PostgreSQL: GetChildrenMetadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
75
diff
changeset
|
1613 return OrthancPluginErrorCode_Success; |
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 ORTHANC_PLUGINS_DATABASE_CATCH |
a1c6238b26f8
new extension implemented for PostgreSQL: GetChildrenMetadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
75
diff
changeset
|
1616 } |
85
1012fe77241c
new extension implemented for PostgreSQL and SQLite: GetLastChangeIndex
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
78
diff
changeset
|
1617 |
1012fe77241c
new extension implemented for PostgreSQL and SQLite: GetLastChangeIndex
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
78
diff
changeset
|
1618 |
1012fe77241c
new extension implemented for PostgreSQL and SQLite: GetLastChangeIndex
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
78
diff
changeset
|
1619 // 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
|
1620 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
|
1621 void* payload) |
1012fe77241c
new extension implemented for PostgreSQL and SQLite: GetLastChangeIndex
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
78
diff
changeset
|
1622 { |
1012fe77241c
new extension implemented for PostgreSQL and SQLite: GetLastChangeIndex
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
78
diff
changeset
|
1623 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
|
1624 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); |
76
a1c6238b26f8
new extension implemented for PostgreSQL: GetChildrenMetadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
75
diff
changeset
|
1625 |
85
1012fe77241c
new extension implemented for PostgreSQL and SQLite: GetLastChangeIndex
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
78
diff
changeset
|
1626 try |
1012fe77241c
new extension implemented for PostgreSQL and SQLite: GetLastChangeIndex
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
78
diff
changeset
|
1627 { |
1012fe77241c
new extension implemented for PostgreSQL and SQLite: GetLastChangeIndex
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
78
diff
changeset
|
1628 *result = backend->GetLastChangeIndex(); |
1012fe77241c
new extension implemented for PostgreSQL and SQLite: GetLastChangeIndex
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
78
diff
changeset
|
1629 return OrthancPluginErrorCode_Success; |
1012fe77241c
new extension implemented for PostgreSQL and SQLite: GetLastChangeIndex
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
78
diff
changeset
|
1630 } |
1012fe77241c
new extension implemented for PostgreSQL and SQLite: GetLastChangeIndex
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
78
diff
changeset
|
1631 ORTHANC_PLUGINS_DATABASE_CATCH |
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 |
76
a1c6238b26f8
new extension implemented for PostgreSQL: GetChildrenMetadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
75
diff
changeset
|
1634 |
0 | 1635 public: |
1636 /** | |
1637 * Register a custom database back-end written in C++. | |
1638 * | |
1639 * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). | |
1640 * @param backend Your custom database engine. | |
1641 **/ | |
1642 | |
1643 static void Register(OrthancPluginContext* context, | |
1644 IDatabaseBackend& backend) | |
1645 { | |
1646 OrthancPluginDatabaseBackend params; | |
1647 memset(¶ms, 0, sizeof(params)); | |
1648 | |
1649 OrthancPluginDatabaseExtensions extensions; | |
1650 memset(&extensions, 0, sizeof(extensions)); | |
1651 | |
1652 params.addAttachment = AddAttachment; | |
1653 params.attachChild = AttachChild; | |
1654 params.clearChanges = ClearChanges; | |
1655 params.clearExportedResources = ClearExportedResources; | |
1656 params.createResource = CreateResource; | |
1657 params.deleteAttachment = DeleteAttachment; | |
1658 params.deleteMetadata = DeleteMetadata; | |
1659 params.deleteResource = DeleteResource; | |
1660 params.getAllPublicIds = GetAllPublicIds; | |
1661 params.getChanges = GetChanges; | |
1662 params.getChildrenInternalId = GetChildrenInternalId; | |
1663 params.getChildrenPublicId = GetChildrenPublicId; | |
1664 params.getExportedResources = GetExportedResources; | |
1665 params.getLastChange = GetLastChange; | |
1666 params.getLastExportedResource = GetLastExportedResource; | |
1667 params.getMainDicomTags = GetMainDicomTags; | |
1668 params.getPublicId = GetPublicId; | |
1669 params.getResourceCount = GetResourceCount; | |
1670 params.getResourceType = GetResourceType; | |
1671 params.getTotalCompressedSize = GetTotalCompressedSize; | |
1672 params.getTotalUncompressedSize = GetTotalUncompressedSize; | |
1673 params.isExistingResource = IsExistingResource; | |
1674 params.isProtectedPatient = IsProtectedPatient; | |
1675 params.listAvailableMetadata = ListAvailableMetadata; | |
1676 params.listAvailableAttachments = ListAvailableAttachments; | |
1677 params.logChange = LogChange; | |
1678 params.logExportedResource = LogExportedResource; | |
1679 params.lookupAttachment = LookupAttachment; | |
1680 params.lookupGlobalProperty = LookupGlobalProperty; | |
69
19764fc60ade
compatibility with Orthanc SDDK 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
67
diff
changeset
|
1681 params.lookupIdentifier = NULL; // Unused starting with Orthanc 0.9.5 (db v6) |
0 | 1682 params.lookupIdentifier2 = NULL; // Unused starting with Orthanc 0.9.5 (db v6) |
1683 params.lookupMetadata = LookupMetadata; | |
1684 params.lookupParent = LookupParent; | |
1685 params.lookupResource = LookupResource; | |
1686 params.selectPatientToRecycle = SelectPatientToRecycle; | |
1687 params.selectPatientToRecycle2 = SelectPatientToRecycle2; | |
1688 params.setGlobalProperty = SetGlobalProperty; | |
1689 params.setMainDicomTag = SetMainDicomTag; | |
1690 params.setIdentifierTag = SetIdentifierTag; | |
1691 params.setMetadata = SetMetadata; | |
1692 params.setProtectedPatient = SetProtectedPatient; | |
1693 params.startTransaction = StartTransaction; | |
1694 params.rollbackTransaction = RollbackTransaction; | |
1695 params.commitTransaction = CommitTransaction; | |
1696 params.open = Open; | |
1697 params.close = Close; | |
1698 | |
1699 extensions.getAllPublicIdsWithLimit = GetAllPublicIdsWithLimit; | |
1700 extensions.getDatabaseVersion = GetDatabaseVersion; | |
1701 extensions.upgradeDatabase = UpgradeDatabase; | |
1702 extensions.clearMainDicomTags = ClearMainDicomTags; | |
69
19764fc60ade
compatibility with Orthanc SDDK 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
67
diff
changeset
|
1703 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
|
1704 extensions.lookupIdentifier3 = LookupIdentifier3; // New in Orthanc 0.9.5 (db v6) |
0 | 1705 |
1706 bool performanceWarning = true; | |
1707 | |
1708 #if defined(ORTHANC_PLUGINS_VERSION_IS_ABOVE) // Macro introduced in Orthanc 1.3.1 | |
1709 # if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 4, 0) | |
1710 extensions.lookupIdentifierRange = LookupIdentifierRange; // New in Orthanc 1.4.0 | |
1711 # endif | |
1712 #endif | |
1713 | |
78 | 1714 #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
|
1715 // Optimizations brought by Orthanc 1.5.2 |
52c70007bb87
new extension implemented for PostgreSQL: SetResourcesContent
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
74
diff
changeset
|
1716 extensions.lookupResources = LookupResources; // Fast lookup |
52c70007bb87
new extension implemented for PostgreSQL: SetResourcesContent
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
74
diff
changeset
|
1717 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
|
1718 extensions.getChildrenMetadata = GetChildrenMetadata; |
85
1012fe77241c
new extension implemented for PostgreSQL and SQLite: GetLastChangeIndex
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
78
diff
changeset
|
1719 extensions.getLastChangeIndex = GetLastChangeIndex; |
71
d40c5fecd160
new extension implemented for PostgreSQL: CreateInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
70
diff
changeset
|
1720 |
d40c5fecd160
new extension implemented for PostgreSQL: CreateInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
70
diff
changeset
|
1721 if (backend.HasCreateInstance()) |
d40c5fecd160
new extension implemented for PostgreSQL: CreateInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
70
diff
changeset
|
1722 { |
75
52c70007bb87
new extension implemented for PostgreSQL: SetResourcesContent
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
74
diff
changeset
|
1723 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
|
1724 } |
d40c5fecd160
new extension implemented for PostgreSQL: CreateInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
70
diff
changeset
|
1725 |
69
19764fc60ade
compatibility with Orthanc SDDK 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
67
diff
changeset
|
1726 performanceWarning = false; |
19764fc60ade
compatibility with Orthanc SDDK 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
67
diff
changeset
|
1727 #endif |
19764fc60ade
compatibility with Orthanc SDDK 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
67
diff
changeset
|
1728 |
0 | 1729 if (performanceWarning) |
1730 { | |
24
17f849b2af34
sharing plugin initialization code
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
16
diff
changeset
|
1731 char info[1024]; |
17f849b2af34
sharing plugin initialization code
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
16
diff
changeset
|
1732 sprintf(info, |
17f849b2af34
sharing plugin initialization code
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
16
diff
changeset
|
1733 "Performance warning: The database index plugin was compiled " |
17f849b2af34
sharing plugin initialization code
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
16
diff
changeset
|
1734 "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
|
1735 "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
|
1736 ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER, |
17f849b2af34
sharing plugin initialization code
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
16
diff
changeset
|
1737 ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER, |
17f849b2af34
sharing plugin initialization code
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
16
diff
changeset
|
1738 ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER); |
17f849b2af34
sharing plugin initialization code
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
16
diff
changeset
|
1739 |
17f849b2af34
sharing plugin initialization code
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
16
diff
changeset
|
1740 OrthancPluginLogWarning(context, info); |
0 | 1741 } |
1742 | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1743 OrthancPluginDatabaseContext* database = |
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1744 OrthancPluginRegisterDatabaseBackendV2(context, ¶ms, &extensions, &backend); |
0 | 1745 if (!context) |
1746 { | |
1747 throw std::runtime_error("Unable to register the database backend"); | |
1748 } | |
1749 | |
1750 backend.RegisterOutput(new DatabaseBackendOutput(context, database)); | |
1751 } | |
1752 }; | |
1753 } |