--- a/OrthancServer/Sources/Database/ResourcesContent.cpp	Fri Apr 16 10:48:57 2021 +0200
+++ b/OrthancServer/Sources/Database/ResourcesContent.cpp	Fri Apr 16 17:13:03 2021 +0200
@@ -35,12 +35,119 @@
 #include "ResourcesContent.h"
 
 #include "Compatibility/ISetResourcesContent.h"
+#include "../ServerToolbox.h"
+
+#include "../../../OrthancFramework/Sources/DicomFormat/DicomArray.h"
+#include "../../../OrthancFramework/Sources/OrthancException.h"
 
 #include <cassert>
 
 
 namespace Orthanc
 {
+  static void StoreMainDicomTagsInternal(ResourcesContent& target,
+                                         int64_t resource,
+                                         const DicomMap& tags)
+  {
+    DicomArray flattened(tags);
+
+    for (size_t i = 0; i < flattened.GetSize(); i++)
+    {
+      const DicomElement& element = flattened.GetElement(i);
+      const DicomTag& tag = element.GetTag();
+      const DicomValue& value = element.GetValue();
+      if (!value.IsNull() && 
+          !value.IsBinary())
+      {
+        target.AddMainDicomTag(resource, tag, element.GetValue().GetContent());
+      }
+    }
+  }
+
+
+  static void StoreIdentifiers(ResourcesContent& target,
+                               int64_t resource,
+                               ResourceType level,
+                               const DicomMap& map)
+  {
+    const DicomTag* tags;
+    size_t size;
+
+    ServerToolbox::LoadIdentifiers(tags, size, level);
+
+    for (size_t i = 0; i < size; i++)
+    {
+      // The identifiers tags are a subset of the main DICOM tags
+      assert(DicomMap::IsMainDicomTag(tags[i]));
+        
+      const DicomValue* value = map.TestAndGetValue(tags[i]);
+      if (value != NULL &&
+          !value->IsNull() &&
+          !value->IsBinary())
+      {
+        std::string s = ServerToolbox::NormalizeIdentifier(value->GetContent());
+        target.AddIdentifierTag(resource, tags[i], s);
+      }
+    }
+  }
+
+
+  void ResourcesContent::AddMetadata(int64_t resourceId,
+                                     MetadataType metadata,
+                                     const std::string& value)
+  {
+    if (isNewResource_)
+    {
+      metadata_.push_back(Metadata(resourceId, metadata, value));
+    }
+    else
+    {
+      // This would require to handle the incrementation of revision
+      // numbers in the database backend => only allow setting
+      // metadata on new resources
+      throw OrthancException(ErrorCode_NotImplemented);
+    }
+  }
+
+
+  void ResourcesContent::AddResource(int64_t resource,
+                                     ResourceType level,
+                                     const DicomMap& dicomSummary)
+  {
+    StoreIdentifiers(*this, resource, level, dicomSummary);
+
+    DicomMap tags;
+
+    switch (level)
+    {
+      case ResourceType_Patient:
+        dicomSummary.ExtractPatientInformation(tags);
+        break;
+
+      case ResourceType_Study:
+        // Duplicate the patient tags at the study level (new in Orthanc 0.9.5 - db v6)
+        dicomSummary.ExtractPatientInformation(tags);
+        StoreMainDicomTagsInternal(*this, resource, tags);
+
+        dicomSummary.ExtractStudyInformation(tags);
+        break;
+
+      case ResourceType_Series:
+        dicomSummary.ExtractSeriesInformation(tags);
+        break;
+
+      case ResourceType_Instance:
+        dicomSummary.ExtractInstanceInformation(tags);
+        break;
+
+      default:
+        throw OrthancException(ErrorCode_InternalError);
+    }
+
+    StoreMainDicomTagsInternal(*this, resource, tags);
+  }
+
+
   void ResourcesContent::Store(Compatibility::ISetResourcesContent& compatibility) const
   {
     for (std::list<TagValue>::const_iterator
@@ -59,7 +166,8 @@
     for (std::list<Metadata>::const_iterator
            it = metadata_.begin(); it != metadata_.end(); ++it)
     {
-      compatibility.SetMetadata(it->resourceId_, it->metadata_,  it->value_);
+      assert(isNewResource_);
+      compatibility.SetMetadata(it->resourceId_, it->metadata_,  it->value_, 0 /* initial revision number */);
     }
   }
 }