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