36 #include "OrthancCDatabasePlugin.h"
73 AllowedAnswers_Attachment,
74 AllowedAnswers_Change,
75 AllowedAnswers_DicomTag,
76 AllowedAnswers_ExportedResource
80 OrthancPluginDatabaseContext* database_;
81 AllowedAnswers allowedAnswers_;
83 void SetAllowedAnswers(AllowedAnswers allowed)
85 allowedAnswers_ = allowed;
90 OrthancPluginDatabaseContext* database) :
93 allowedAnswers_(AllowedAnswers_All )
97 void LogError(
const std::string& message)
102 void LogWarning(
const std::string& message)
107 void LogInfo(
const std::string& message)
112 void SignalDeletedAttachment(
const std::string& uuid,
114 uint64_t uncompressedSize,
115 const std::string& uncompressedHash,
116 int32_t compressionType,
117 uint64_t compressedSize,
118 const std::string& compressedHash)
121 attachment.uuid = uuid.c_str();
122 attachment.contentType = contentType;
123 attachment.uncompressedSize = uncompressedSize;
124 attachment.uncompressedHash = uncompressedHash.c_str();
125 attachment.compressionType = compressionType;
126 attachment.compressedSize = compressedSize;
127 attachment.compressedHash = compressedHash.c_str();
129 OrthancPluginDatabaseSignalDeletedAttachment(context_, database_, &attachment);
132 void SignalDeletedResource(
const std::string& publicId,
135 OrthancPluginDatabaseSignalDeletedResource(context_, database_, publicId.c_str(), resourceType);
138 void SignalRemainingAncestor(
const std::string& ancestorId,
141 OrthancPluginDatabaseSignalRemainingAncestor(context_, database_, ancestorId.c_str(), ancestorType);
144 void AnswerAttachment(
const std::string& uuid,
146 uint64_t uncompressedSize,
147 const std::string& uncompressedHash,
148 int32_t compressionType,
149 uint64_t compressedSize,
150 const std::string& compressedHash)
152 if (allowedAnswers_ != AllowedAnswers_All &&
153 allowedAnswers_ != AllowedAnswers_Attachment)
155 throw std::runtime_error(
"Cannot answer with an attachment in the current state");
159 attachment.uuid = uuid.c_str();
160 attachment.contentType = contentType;
161 attachment.uncompressedSize = uncompressedSize;
162 attachment.uncompressedHash = uncompressedHash.c_str();
163 attachment.compressionType = compressionType;
164 attachment.compressedSize = compressedSize;
165 attachment.compressedHash = compressedHash.c_str();
167 OrthancPluginDatabaseAnswerAttachment(context_, database_, &attachment);
170 void AnswerChange(int64_t seq,
173 const std::string& publicId,
174 const std::string& date)
176 if (allowedAnswers_ != AllowedAnswers_All &&
177 allowedAnswers_ != AllowedAnswers_Change)
179 throw std::runtime_error(
"Cannot answer with a change in the current state");
184 change.changeType = changeType;
185 change.resourceType = resourceType;
186 change.publicId = publicId.c_str();
187 change.date = date.c_str();
189 OrthancPluginDatabaseAnswerChange(context_, database_, &change);
192 void AnswerDicomTag(uint16_t group,
194 const std::string& value)
196 if (allowedAnswers_ != AllowedAnswers_All &&
197 allowedAnswers_ != AllowedAnswers_DicomTag)
199 throw std::runtime_error(
"Cannot answer with a DICOM tag in the current state");
204 tag.element = element;
205 tag.value = value.c_str();
207 OrthancPluginDatabaseAnswerDicomTag(context_, database_, &tag);
210 void AnswerExportedResource(int64_t seq,
212 const std::string& publicId,
213 const std::string& modality,
214 const std::string& date,
215 const std::string& patientId,
216 const std::string& studyInstanceUid,
217 const std::string& seriesInstanceUid,
218 const std::string& sopInstanceUid)
220 if (allowedAnswers_ != AllowedAnswers_All &&
221 allowedAnswers_ != AllowedAnswers_ExportedResource)
223 throw std::runtime_error(
"Cannot answer with an exported resource in the current state");
228 exported.resourceType = resourceType;
229 exported.publicId = publicId.c_str();
230 exported.modality = modality.c_str();
231 exported.date = date.c_str();
232 exported.patientId = patientId.c_str();
233 exported.studyInstanceUid = studyInstanceUid.c_str();
234 exported.seriesInstanceUid = seriesInstanceUid.c_str();
235 exported.sopInstanceUid = sopInstanceUid.c_str();
237 OrthancPluginDatabaseAnswerExportedResource(context_, database_, &exported);
282 virtual void Open() = 0;
284 virtual void Close() = 0;
286 virtual void AddAttachment(int64_t
id,
289 virtual void AttachChild(int64_t parent,
292 virtual void ClearChanges() = 0;
294 virtual void ClearExportedResources() = 0;
296 virtual int64_t CreateResource(
const char* publicId,
299 virtual void DeleteAttachment(int64_t
id,
300 int32_t attachment) = 0;
302 virtual void DeleteMetadata(int64_t
id,
303 int32_t metadataType) = 0;
305 virtual void DeleteResource(int64_t
id) = 0;
307 virtual void GetAllPublicIds(std::list<std::string>& target,
311 virtual void GetChanges(
bool& done ,
313 uint32_t maxResults) = 0;
315 virtual void GetChildrenInternalId(std::list<int64_t>& target ,
318 virtual void GetChildrenPublicId(std::list<std::string>& target ,
322 virtual void GetExportedResources(
bool& done ,
324 uint32_t maxResults) = 0;
327 virtual void GetLastChange() = 0;
330 virtual void GetLastExportedResource() = 0;
333 virtual void GetMainDicomTags(int64_t
id) = 0;
335 virtual std::string GetPublicId(int64_t resourceId) = 0;
341 virtual uint64_t GetTotalCompressedSize() = 0;
343 virtual uint64_t GetTotalUncompressedSize() = 0;
345 virtual bool IsExistingResource(int64_t internalId) = 0;
347 virtual bool IsProtectedPatient(int64_t internalId) = 0;
349 virtual void ListAvailableMetadata(std::list<int32_t>& target ,
352 virtual void ListAvailableAttachments(std::list<int32_t>& target ,
360 virtual bool LookupAttachment(int64_t
id,
361 int32_t contentType) = 0;
363 virtual bool LookupGlobalProperty(std::string& target ,
364 int32_t property) = 0;
375 const char* value) = 0;
378 const char* value) = 0;
380 virtual bool LookupMetadata(std::string& target ,
382 int32_t metadataType) = 0;
384 virtual bool LookupParent(int64_t& parentId ,
385 int64_t resourceId) = 0;
387 virtual bool LookupResource(int64_t&
id ,
389 const char* publicId) = 0;
391 virtual bool SelectPatientToRecycle(int64_t& internalId ) = 0;
393 virtual bool SelectPatientToRecycle(int64_t& internalId ,
394 int64_t patientIdToAvoid) = 0;
396 virtual void SetGlobalProperty(int32_t property,
397 const char* value) = 0;
399 virtual void SetMainDicomTag(int64_t
id,
402 const char* value) = 0;
404 virtual void SetIdentifierTag(int64_t
id,
407 const char* value) = 0;
409 virtual void SetMetadata(int64_t
id,
410 int32_t metadataType,
411 const char* value) = 0;
413 virtual void SetProtectedPatient(int64_t internalId,
414 bool isProtected) = 0;
416 virtual void StartTransaction() = 0;
418 virtual void RollbackTransaction() = 0;
420 virtual void CommitTransaction() = 0;
434 const std::runtime_error& e)
436 backend->GetOutput().LogError(
"Exception in database back-end: " + std::string(e.what()));
440 static int32_t AddAttachment(
void* payload,
445 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
449 backend->AddAttachment(
id, *attachment);
452 catch (std::runtime_error& e)
454 LogError(backend, e);
460 static int32_t AttachChild(
void* payload,
465 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
469 backend->AttachChild(parent, child);
472 catch (std::runtime_error& e)
474 LogError(backend, e);
480 static int32_t ClearChanges(
void* payload)
483 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
487 backend->ClearChanges();
490 catch (std::runtime_error& e)
492 LogError(backend, e);
498 static int32_t ClearExportedResources(
void* payload)
501 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
505 backend->ClearExportedResources();
508 catch (std::runtime_error& e)
510 LogError(backend, e);
516 static int32_t CreateResource(int64_t*
id,
518 const char* publicId,
522 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
526 *
id = backend->CreateResource(publicId, resourceType);
529 catch (std::runtime_error& e)
531 LogError(backend, e);
537 static int32_t DeleteAttachment(
void* payload,
542 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
546 backend->DeleteAttachment(
id, contentType);
549 catch (std::runtime_error& e)
551 LogError(backend, e);
557 static int32_t DeleteMetadata(
void* payload,
559 int32_t metadataType)
562 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
566 backend->DeleteMetadata(
id, metadataType);
569 catch (std::runtime_error& e)
571 LogError(backend, e);
577 static int32_t DeleteResource(
void* payload,
581 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
585 backend->DeleteResource(
id);
588 catch (std::runtime_error& e)
590 LogError(backend, e);
596 static int32_t GetAllPublicIds(OrthancPluginDatabaseContext* context,
601 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
605 std::list<std::string> ids;
606 backend->GetAllPublicIds(ids, resourceType);
608 for (std::list<std::string>::const_iterator
609 it = ids.begin(); it != ids.end(); ++it)
611 OrthancPluginDatabaseAnswerString(backend->GetOutput().context_,
612 backend->GetOutput().database_,
618 catch (std::runtime_error& e)
620 LogError(backend, e);
626 static int32_t GetChanges(OrthancPluginDatabaseContext* context,
632 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_Change);
637 backend->GetChanges(done, since, maxResult);
641 OrthancPluginDatabaseAnswerChangesDone(backend->GetOutput().context_,
642 backend->GetOutput().database_);
647 catch (std::runtime_error& e)
649 LogError(backend, e);
655 static int32_t GetChildrenInternalId(OrthancPluginDatabaseContext* context,
660 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
664 std::list<int64_t> target;
665 backend->GetChildrenInternalId(target,
id);
667 for (std::list<int64_t>::const_iterator
668 it = target.begin(); it != target.end(); ++it)
670 OrthancPluginDatabaseAnswerInt64(backend->GetOutput().context_,
671 backend->GetOutput().database_, *it);
676 catch (std::runtime_error& e)
678 LogError(backend, e);
684 static int32_t GetChildrenPublicId(OrthancPluginDatabaseContext* context,
689 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
693 std::list<std::string> ids;
694 backend->GetChildrenPublicId(ids,
id);
696 for (std::list<std::string>::const_iterator
697 it = ids.begin(); it != ids.end(); ++it)
699 OrthancPluginDatabaseAnswerString(backend->GetOutput().context_,
700 backend->GetOutput().database_,
706 catch (std::runtime_error& e)
708 LogError(backend, e);
714 static int32_t GetExportedResources(OrthancPluginDatabaseContext* context,
720 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_ExportedResource);
725 backend->GetExportedResources(done, since, maxResult);
729 OrthancPluginDatabaseAnswerExportedResourcesDone(backend->GetOutput().context_,
730 backend->GetOutput().database_);
734 catch (std::runtime_error& e)
736 LogError(backend, e);
742 static int32_t GetLastChange(OrthancPluginDatabaseContext* context,
746 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_Change);
750 backend->GetLastChange();
753 catch (std::runtime_error& e)
755 LogError(backend, e);
761 static int32_t GetLastExportedResource(OrthancPluginDatabaseContext* context,
765 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_ExportedResource);
769 backend->GetLastExportedResource();
772 catch (std::runtime_error& e)
774 LogError(backend, e);
780 static int32_t GetMainDicomTags(OrthancPluginDatabaseContext* context,
785 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_DicomTag);
789 backend->GetMainDicomTags(
id);
792 catch (std::runtime_error& e)
794 LogError(backend, e);
800 static int32_t GetPublicId(OrthancPluginDatabaseContext* context,
805 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
809 std::string s = backend->GetPublicId(
id);
810 OrthancPluginDatabaseAnswerString(backend->GetOutput().context_,
811 backend->GetOutput().database_,
816 catch (std::runtime_error& e)
818 LogError(backend, e);
824 static int32_t GetResourceCount(uint64_t* target,
829 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
833 *target = backend->GetResourceCount(resourceType);
836 catch (std::runtime_error& e)
838 LogError(backend, e);
849 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
853 *resourceType = backend->GetResourceType(
id);
856 catch (std::runtime_error& e)
858 LogError(backend, e);
864 static int32_t GetTotalCompressedSize(uint64_t* target,
868 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
872 *target = backend->GetTotalCompressedSize();
875 catch (std::runtime_error& e)
877 LogError(backend, e);
883 static int32_t GetTotalUncompressedSize(uint64_t* target,
887 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
891 *target = backend->GetTotalUncompressedSize();
894 catch (std::runtime_error& e)
896 LogError(backend, e);
902 static int32_t IsExistingResource(int32_t* existing,
907 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
911 *existing = backend->IsExistingResource(
id);
914 catch (std::runtime_error& e)
916 LogError(backend, e);
922 static int32_t IsProtectedPatient(int32_t* isProtected,
927 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
931 *isProtected = backend->IsProtectedPatient(
id);
934 catch (std::runtime_error& e)
936 LogError(backend, e);
942 static int32_t ListAvailableMetadata(OrthancPluginDatabaseContext* context,
947 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
951 std::list<int32_t> target;
952 backend->ListAvailableMetadata(target,
id);
954 for (std::list<int32_t>::const_iterator
955 it = target.begin(); it != target.end(); ++it)
957 OrthancPluginDatabaseAnswerInt32(backend->GetOutput().context_,
958 backend->GetOutput().database_,
964 catch (std::runtime_error& e)
966 LogError(backend, e);
972 static int32_t ListAvailableAttachments(OrthancPluginDatabaseContext* context,
977 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
981 std::list<int32_t> target;
982 backend->ListAvailableAttachments(target,
id);
984 for (std::list<int32_t>::const_iterator
985 it = target.begin(); it != target.end(); ++it)
987 OrthancPluginDatabaseAnswerInt32(backend->GetOutput().context_,
988 backend->GetOutput().database_,
994 catch (std::runtime_error& e)
996 LogError(backend, e);
1002 static int32_t LogChange(
void* payload,
1006 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1010 backend->LogChange(*change);
1013 catch (std::runtime_error& e)
1015 LogError(backend, e);
1021 static int32_t LogExportedResource(
void* payload,
1025 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1029 backend->LogExportedResource(*exported);
1032 catch (std::runtime_error& e)
1034 LogError(backend, e);
1040 static int32_t LookupAttachment(OrthancPluginDatabaseContext* context,
1043 int32_t contentType)
1046 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_Attachment);
1050 backend->LookupAttachment(
id, contentType);
1053 catch (std::runtime_error& e)
1055 LogError(backend, e);
1061 static int32_t LookupGlobalProperty(OrthancPluginDatabaseContext* context,
1066 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1071 if (backend->LookupGlobalProperty(s, property))
1073 OrthancPluginDatabaseAnswerString(backend->GetOutput().context_,
1074 backend->GetOutput().database_,
1080 catch (std::runtime_error& e)
1082 LogError(backend, e);
1088 static int32_t LookupIdentifier(OrthancPluginDatabaseContext* context,
1093 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1097 std::list<int64_t> target;
1100 for (std::list<int64_t>::const_iterator
1101 it = target.begin(); it != target.end(); ++it)
1103 OrthancPluginDatabaseAnswerInt64(backend->GetOutput().context_,
1104 backend->GetOutput().database_, *it);
1109 catch (std::runtime_error& e)
1111 LogError(backend, e);
1117 static int32_t LookupIdentifier2(OrthancPluginDatabaseContext* context,
1122 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1126 std::list<int64_t> target;
1129 for (std::list<int64_t>::const_iterator
1130 it = target.begin(); it != target.end(); ++it)
1132 OrthancPluginDatabaseAnswerInt64(backend->GetOutput().context_,
1133 backend->GetOutput().database_, *it);
1138 catch (std::runtime_error& e)
1140 LogError(backend, e);
1146 static int32_t LookupMetadata(OrthancPluginDatabaseContext* context,
1152 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1157 if (backend->LookupMetadata(s,
id, metadata))
1159 OrthancPluginDatabaseAnswerString(backend->GetOutput().context_,
1160 backend->GetOutput().database_, s.c_str());
1165 catch (std::runtime_error& e)
1167 LogError(backend, e);
1173 static int32_t LookupParent(OrthancPluginDatabaseContext* context,
1178 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1183 if (backend->LookupParent(parent,
id))
1185 OrthancPluginDatabaseAnswerInt64(backend->GetOutput().context_,
1186 backend->GetOutput().database_, parent);
1191 catch (std::runtime_error& e)
1193 LogError(backend, e);
1199 static int32_t LookupResource(OrthancPluginDatabaseContext* context,
1201 const char* publicId)
1204 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1210 if (backend->LookupResource(
id, type, publicId))
1212 OrthancPluginDatabaseAnswerResource(backend->GetOutput().context_,
1213 backend->GetOutput().database_,
1219 catch (std::runtime_error& e)
1221 LogError(backend, e);
1227 static int32_t SelectPatientToRecycle(OrthancPluginDatabaseContext* context,
1231 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1236 if (backend->SelectPatientToRecycle(
id))
1238 OrthancPluginDatabaseAnswerInt64(backend->GetOutput().context_,
1239 backend->GetOutput().database_, id);
1244 catch (std::runtime_error& e)
1246 LogError(backend, e);
1252 static int32_t SelectPatientToRecycle2(OrthancPluginDatabaseContext* context,
1254 int64_t patientIdToAvoid)
1257 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1262 if (backend->SelectPatientToRecycle(
id, patientIdToAvoid))
1264 OrthancPluginDatabaseAnswerInt64(backend->GetOutput().context_,
1265 backend->GetOutput().database_, id);
1270 catch (std::runtime_error& e)
1272 LogError(backend, e);
1278 static int32_t SetGlobalProperty(
void* payload,
1283 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1287 backend->SetGlobalProperty(property, value);
1290 catch (std::runtime_error& e)
1292 LogError(backend, e);
1298 static int32_t SetMainDicomTag(
void* payload,
1303 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1307 backend->SetMainDicomTag(
id, tag->group, tag->element, tag->value);
1310 catch (std::runtime_error& e)
1312 LogError(backend, e);
1318 static int32_t SetIdentifierTag(
void* payload,
1323 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1327 backend->SetIdentifierTag(
id, tag->group, tag->element, tag->value);
1330 catch (std::runtime_error& e)
1332 LogError(backend, e);
1338 static int32_t SetMetadata(
void* payload,
1344 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1348 backend->SetMetadata(
id, metadata, value);
1351 catch (std::runtime_error& e)
1353 LogError(backend, e);
1359 static int32_t SetProtectedPatient(
void* payload,
1361 int32_t isProtected)
1364 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1368 backend->SetProtectedPatient(
id, (isProtected != 0));
1371 catch (std::runtime_error& e)
1373 LogError(backend, e);
1379 static int32_t StartTransaction(
void* payload)
1382 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1386 backend->StartTransaction();
1389 catch (std::runtime_error& e)
1391 LogError(backend, e);
1397 static int32_t RollbackTransaction(
void* payload)
1400 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1404 backend->RollbackTransaction();
1407 catch (std::runtime_error& e)
1409 LogError(backend, e);
1415 static int32_t CommitTransaction(
void* payload)
1418 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1422 backend->CommitTransaction();
1425 catch (std::runtime_error& e)
1427 LogError(backend, e);
1433 static int32_t Open(
void* payload)
1436 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1443 catch (std::runtime_error& e)
1445 LogError(backend, e);
1451 static int32_t Close(
void* payload)
1454 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1461 catch (std::runtime_error& e)
1463 LogError(backend, e);
1474 memset(¶ms, 0,
sizeof(params));
1476 params.addAttachment = AddAttachment;
1477 params.attachChild = AttachChild;
1478 params.clearChanges = ClearChanges;
1479 params.clearExportedResources = ClearExportedResources;
1480 params.createResource = CreateResource;
1481 params.deleteAttachment = DeleteAttachment;
1482 params.deleteMetadata = DeleteMetadata;
1483 params.deleteResource = DeleteResource;
1484 params.getAllPublicIds = GetAllPublicIds;
1485 params.getChanges = GetChanges;
1486 params.getChildrenInternalId = GetChildrenInternalId;
1487 params.getChildrenPublicId = GetChildrenPublicId;
1488 params.getExportedResources = GetExportedResources;
1489 params.getLastChange = GetLastChange;
1490 params.getLastExportedResource = GetLastExportedResource;
1491 params.getMainDicomTags = GetMainDicomTags;
1492 params.getPublicId = GetPublicId;
1493 params.getResourceCount = GetResourceCount;
1494 params.getResourceType = GetResourceType;
1495 params.getTotalCompressedSize = GetTotalCompressedSize;
1496 params.getTotalUncompressedSize = GetTotalUncompressedSize;
1497 params.isExistingResource = IsExistingResource;
1498 params.isProtectedPatient = IsProtectedPatient;
1499 params.listAvailableMetadata = ListAvailableMetadata;
1500 params.listAvailableAttachments = ListAvailableAttachments;
1501 params.logChange = LogChange;
1502 params.logExportedResource = LogExportedResource;
1503 params.lookupAttachment = LookupAttachment;
1504 params.lookupGlobalProperty = LookupGlobalProperty;
1505 params.lookupIdentifier = LookupIdentifier;
1506 params.lookupIdentifier2 = LookupIdentifier2;
1507 params.lookupMetadata = LookupMetadata;
1508 params.lookupParent = LookupParent;
1509 params.lookupResource = LookupResource;
1510 params.selectPatientToRecycle = SelectPatientToRecycle;
1511 params.selectPatientToRecycle2 = SelectPatientToRecycle2;
1512 params.setGlobalProperty = SetGlobalProperty;
1513 params.setMainDicomTag = SetMainDicomTag;
1514 params.setIdentifierTag = SetIdentifierTag;
1515 params.setMetadata = SetMetadata;
1516 params.setProtectedPatient = SetProtectedPatient;
1517 params.startTransaction = StartTransaction;
1518 params.rollbackTransaction = RollbackTransaction;
1519 params.commitTransaction = CommitTransaction;
1521 params.close = Close;
1523 OrthancPluginDatabaseContext* database = OrthancPluginRegisterDatabaseBackend(context, ¶ms, &backend);
1526 throw std::runtime_error(
"Unable to register the database backend");
Definition: OrthancCDatabasePlugin.h:88
void OrthancPluginLogInfo(OrthancPluginContext *context, const char *message)
Log an information.
Definition: OrthancCPlugin.h:700
void OrthancPluginLogError(OrthancPluginContext *context, const char *message)
Log an error.
Definition: OrthancCPlugin.h:668
OrthancPluginResourceType
Definition: OrthancCPlugin.h:383
virtual void LookupIdentifier(std::list< int64_t > &target, uint16_t group, uint16_t element, const char *value)=0
Definition: OrthancCppDatabasePlugin.h:42
Definition: OrthancCppDatabasePlugin.h:45
Definition: OrthancCDatabasePlugin.h:81
struct _OrthancPluginContext_t OrthancPluginContext
Data structure that contains information about the Orthanc core.
Definition: OrthancCppDatabasePlugin.h:425
Definition: OrthancCppDatabasePlugin.h:64
Definition: OrthancCDatabasePlugin.h:97
Definition: OrthancCDatabasePlugin.h:309
Definition: OrthancCppDatabasePlugin.h:243
Definition: OrthancCDatabasePlugin.h:70
void OrthancPluginLogWarning(OrthancPluginContext *context, const char *message)
Log a warning.
Definition: OrthancCPlugin.h:684