uc3-dmp-id 0.0.140 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 77df36a0f25a15f2e84d967f81668f1826179dc24da3050c2468d26b3189d841
-  data.tar.gz: e39e3057cf70bbb2a3787ff45d3cd8ffeec1ffb01978ba64a7267735fe61e260
+  metadata.gz: 1bdcb2754d5168bdeedf8583b91054cf62fc019d4479686da168d4ca70d83729
+  data.tar.gz: b2af99461aa7614212aae435db0db174eeb50125006d0dacc87698ecaf41b7b8
 SHA512:
-  metadata.gz: 8bd3666ebd7a59e5d83c042860be19aa29e255811fb5fd4aa96e444969847bc90aa074b4b663f4f67e82734ef52985f0233ad4d8106dbf2008ce9a132737d158
-  data.tar.gz: 0ab9b4ed312d4e61e4949dea02af7aa5f8d276bd22c175dbf8a500710bc4ecf641c2fdbaaefab998f0532cf2eb16cf8ba37fb22d78fee59a29f53fecb1557679
+  metadata.gz: 43cdce10f8bccc41fc979c67a4758fd5726206c9066acefcbc8abe65b9d36f79fc69eedb461a9ce584cf61f85ddd0dca13617d99a39e9c831eb56ea725a00eb0
+  data.tar.gz: 393d0e083ca8cfbf2039ba11861576a2eff489d48d8c541279ae30a3f9e7215d39175c49d1203456f56bb00a6a7e3da6c0211d4c3fc7e4f64f32f88e3d96accf

data/lib/uc3-dmp-id/asserter.rb

@@ -5,64 +5,163 @@ require 'time'
 module Uc3DmpId
   class AsserterError < StandardError; end
 
+  # Class that handles changes to a DMP ID's :dmphub_modifications section
   class Asserter
+    DEFAULT_DESCRIPTOR = 'references'
+    DEFAULT_WORK_TYPE = 'other'
+
     class << self
       # Add assertions to a DMP ID - this is performed by non-provenance systems
-      def add(updater:, dmp:, mods:, note: nil, logger: nil)
-
-puts "ADDING ASSERTIONS: #{mods}"
+      # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+      def add(updater:, latest_version:, modified_version:, note: nil, logger: nil)
+        return latest_version unless latest_version.is_a?(Hash)
 
+        owner = latest_version['dmphub_provenance_id']&.gsub('PROVENANCE#', '')
         # If the updater and provenance are the same just return the :dmp as-is
-        return dmp if updater.nil? || !dmp.is_a?(Hash) || !mods.is_a?(Hash) ||
-                      updater&.gsub('PROVENANCE#', '') == dmp['dmphub_provenance_id']&.gsub('PROVENANCE#', '')
-
-        contact = mods['contact']
-        contributor = mods.fetch('contributor', [])
-        project = mods.fetch('project', [])
-        # Return the DMP ID as-is if there are no assertable changes
-        return dmp if contact.nil? && contributor.empty? && project.empty?
-
-        # Clone any existing pending_assertions on the current DMP ID so we can manipulate them
-        assertions = Helper.deep_copy_dmp(obj: dmp.fetch('dmphub_modifications', []))
-        # Return the DMP ID as-is if the assertion is already on the record
-        return dmp if assertions.select { |entry| entry['provenance'] == updater && entry['pending_assertions'] == mods }
-
-        assertions << _generate_assertion(updater: updater, mods: mods, note: note)
-        dmp['dmphub_modifications'] = assertions.flatten
-        dmp
+        return latest_version if updater.nil? || !latest_version.is_a?(Hash) || !modified_version.is_a?(Hash) ||
+                                 updater&.gsub('PROVENANCE#', '') == owner
+
+        # contact = modified_version['contact']
+        # contributor = modified_version.fetch('contributor', [])
+        # project = modified_version.fetch('project', [])
+        funding = modified_version.fetch('project', []).first&.fetch('funding', [])
+        related_works = modified_version.fetch('dmproadmap_related_identifiers', [])
+
+        if related_works.any?
+          latest_version = _add_related_identifier(updater: updater, latest_version: latest_version,
+                                                   identifiers: related_works, note: note, logger: logger)
+        end
+        return latest_version unless !funding.nil? && funding.any?
+
+        _add_funding_mod(updater: updater, latest_version: latest_version, funding: funding,
+                         note: note, logger: logger)
       end
+      # rubocop:enable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
 
-      # Splice together assertions made while the user was updating the DMP ID
+      # Splice together assertions made by the owner of the DMP ID so that any :dmphub_modifications made to
+      # the record while it was being updated are not lost
+      # rubocop:disable Metrics/AbcSize
       def splice(latest_version:, modified_version:, logger: nil)
-
-puts "LATEST_VERSION ASSERTIONS: #{latest_version['dmphub_modifications']}"
-puts "MODIFIED_VERSION ASSERTIONS: #{modified_version['dmphub_modifications']}"
-
-        # Return the modified_version if the timestamps are the same (meaning no new assertions were made while the
-        # user was working on the DMP ID) OR neither version has assertions
+        # Return the modified_version if the timestamps are the same OR neither version has :dmphub_modifications
         return modified_version if latest_version['modified'] == modified_version['modified'] ||
                                    (latest_version.fetch('dmphub_modifications', []).empty? &&
                                     modified_version.fetch('dmphub_modifications', []).empty?)
 
-        # Clone any existing assertions on the current DMP ID so we can manipulate them
+        # Clone any existing :dmphub_modifications on the current DMP ID so we can retain them
         existing_assertions = Helper.deep_copy_dmp(obj: latest_version.fetch('dmphub_modifications', []))
         incoming_assertions = Helper.deep_copy_dmp(obj: modified_version.fetch('dmphub_modifications', []))
-        logger.debug(message: "Existing assertions", details: existing_assertions) if logger.respond_to?(:debug)
-        logger.debug(message: "Incoming modifications", details: incoming_assertions) if logger.respond_to?(:debug)
-
-        # Keep any assetions that were made after the modified on the incoming changes
-        modified_version['dmphub_modifications'] = existing_assertions.select do |entry|
-          !entry['timestamp'].nil? && Time.parse(entry['timestamp']) > Time.parse(modified_version['modified'])
+        if logger.respond_to?(:debug)
+          logger.debug(message: 'Existing dmphub_modifications',
+                       details: existing_assertions)
         end
+        if logger.respond_to?(:debug)
+          logger.debug(message: 'Incoming dmphub_modifications',
+                       details: incoming_assertions)
+        end
+
+        # Keep any :dmphub_modifications and then add the incoming to the Array
+        modified_version['dmphub_modifications'] = existing_assertions
         return modified_version unless incoming_assertions.any?
 
         # Add any of the assertions still on the incoming record back to the latest record
         incoming_assertions.each { |entry| modified_version['dmphub_modifications'] << entry }
         modified_version
       end
+      # rubocop:enable Metrics/AbcSize
 
       private
 
+      # Verify that the DMP ID record does not already have the specified identifiers and then add them
+      # to the :latest_version in the :dmphub_modifications Array
+      #
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+      def _add_related_identifier(updater:, latest_version:, identifiers:, note: '', logger: nil)
+        return latest_version unless updater.is_a?(String) && latest_version.is_a?(Hash) && identifiers.is_a?(Array)
+
+        latest_version['dmphub_modifications'] = [] if latest_version['dmphub_modifications'].nil?
+        known_mods = latest_version['dmphub_modifications'].map do |mod|
+          mod.fetch('dmproadmap_related_identifiers', [])
+        end
+        known_mods = known_mods.flatten.compact.map { |mod| mod['identifier'].downcase.strip }.compact.uniq
+
+        asserted = latest_version.fetch('dmproadmap_related_identifiers', [])
+        asserted = asserted.flatten.compact.map { |mod| mod['identifier'].downcase.strip }.compact.uniq
+
+        additions = []
+        identifiers.each do |related_identifier|
+          # Skip if there is no :type or :identifier value
+          if !related_identifier.is_a?(Hash) || related_identifier['type'].nil? || related_identifier['identifier'].nil?
+            next
+          end
+
+          id = related_identifier['identifier'].downcase.strip
+          # Skip if the :identifier is already listed in :dmphub_modifications or the
+          # :dmproadmap_related_identifiers Arrays
+          next if known_mods.include?(id) || asserted.include?(id)
+
+          related_identifier['work_type'] = DEFAULT_WORK_TYPE if related_identifier['work_type'].nil?
+          related_identifier['descriptor'] = DEFAULT_DESCRIPTOR if related_identifier['descriptor'].nil?
+          additions << related_identifier
+        end
+
+        latest_version['dmproadmap_related_identifiers'] = [] if latest_version['dmproadmap_related_identifiers'].nil?
+        assertion = _generate_assertion(updater: updater, note: note,
+                                        mods: JSON.parse({ dmproadmap_related_identifiers: additions }.to_json))
+        if logger.respond_to?(:debug)
+          logger.debug(message: 'Adding change to :dmphub_modifications.',
+                       details: assertion)
+        end
+        latest_version['dmphub_modifications'] << assertion
+        latest_version
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+      # rubocop:enable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+
+      # Verify that the DMP ID record does not already have the specified funding change and then add it
+      # to the :latest_version in the :dmphub_modifications Array
+      #
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+      def _add_funding_mod(updater:, latest_version:, funding:, note: '', logger: nil)
+        return latest_version unless updater.is_a?(String) && latest_version.is_a?(Hash) && funding.is_a?(Array)
+
+        known_mods = latest_version['dmphub_modifications'].map do |mod|
+          next if mod.nil?
+
+          mod.fetch('funding', {}).fetch('grant_id', {})['identifier']&.downcase&.strip
+        end
+        known_mods = known_mods.flatten.compact.uniq
+
+        asserted = latest_version.fetch('project', [])&.map do |project|
+          next if project.nil?
+
+          project&.fetch('funding', [])&.first&.fetch('grant_id', {})&.[]('identifier')&.downcase&.strip
+        end
+        asserted = asserted.flatten.compact.uniq
+
+        fund = funding.reject { |entry| entry['grant_id'].nil? }.first
+        # Skip if there is no :grant_id
+        return latest_version if !fund.is_a?(Hash) || fund.fetch('grant_id', {})['identifier'].nil?
+
+        grant_id = fund.fetch('grant_id', {})['identifier'].downcase.strip
+        # Skip if the :grant_id is already listed as a :dmphub_modifications or project: :funding
+        return latest_version if known_mods.include?(grant_id) || asserted.include?(grant_id)
+
+        latest_version['dmphub_modifications'] = [] if latest_version['dmphub_modifications'].nil?
+        mod = JSON.parse({ funding: fund }.to_json)
+        mod['funding']['funding_status'] = 'granted'
+        assertion = _generate_assertion(updater: updater, mods: mod, note: note)
+        if logger.respond_to?(:debug)
+          logger.debug(message: 'Adding change to :dmphub_modifications.',
+                       details: assertion)
+        end
+        latest_version['dmphub_modifications'] << assertion
+        latest_version
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+      # rubocop:enable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+
       # Generate an assertion entry. For example:
       #
       # {
@@ -70,56 +169,41 @@ puts "MODIFIED_VERSION ASSERTIONS: #{modified_version['dmphub_modifications']}"
       #    "provenance": "dmphub",
       #    "timestamp": "2023-07-07T14:50:23+00:00",
       #    "note": "data received from the NIH API",
-      #    "pending_assertions": {
-      #      "contact": {
-      #        "name": "Wrong Person"
-      #      },
-      #      "contributor": [
-      #        {
-      #          "name": "Jane Doe",
-      #          "role": ["Investigation"]
-      #        }
-      #      ],
-      #      "dmproadmap_related_identifiers": [
-      #        {
-      #          "work_type": "article",
-      #          "descriptor": "is_cited_by",
-      #          "type": "doi",
-      #          "identifier": "https://dx.doi.org/99.9876/ZYX987.V6"
-      #        }
-      #      ],
-      #      "project": [
-      #        {
-      #          "start": "2024-01-01T00:00:00+07:00",
-      #          "end": "2025-12-31T23:59:59+07:00"
-      #        }
-      #      ],
-      #      "funding": [
-      #        {
-      #          "funder_id": {
-      #            "identifier": "https://doi.org/10.13039/501100001807",
-      #            "type": "fundref"
-      #          },
-      #          "funding_status": "granted",
-      #          "grant_id": {
-      #            "identifier": "2019/22702-3",
-      #            "type": "other"
-      #          }
-      #        }
-      #      ]
+      #    "dmproadmap_related_identifiers": {
+      #      "work_type": "article",
+      #      "descriptor": "is_cited_by",
+      #      "type": "doi",
+      #      "identifier": "https://dx.doi.org/99.9876/ZYX987.V6"
+      #    }
+      #  }
+      #
+      # OR:
+      #
+      #  {
+      #    "id": "ABCD1234",
+      #    "provenance": "dmphub",
+      #    "timestamp": "2023-07-07T14:50:23+00:00",
+      #    "note": "data received from the NIH API",
+      #    "funding": {
+      #      "funding_status": "granted",
+      #      "grant_id": {
+      #        "identifier": "2019/22702-3",
+      #        "type": "other"
+      #      }
       #    }
-      # }
+      #  }
       def _generate_assertion(updater:, mods:, note: '')
-        return nil if updater.nil? || !mod.is_a?(Hash)
+        return nil if updater.nil? || !mods.is_a?(Hash)
 
-        JSON.parse({
+        assertion = {
           id: SecureRandom.hex(4).upcase,
           provenance: updater.gsub('PROVENANCE#', ''),
           timestamp: Time.now.utc.iso8601,
-          status: 'new',
-          note: note,
-          pending_assertions: mods
-        }.to_json)
+          status: 'pending',
+          note: note
+        }
+        mods.each_pair { |key, val| assertion[key] = val }
+        JSON.parse(assertion.to_json)
       end
     end
   end

data/lib/uc3-dmp-id/creator.rb

@@ -6,31 +6,32 @@ require 'time'
 module Uc3DmpId
   class CreatorError < StandardError; end
 
+  # Class that registers a new DMP ID
   class Creator
     MSG_NO_BASE_URL = 'No base URL found for DMP ID (e.g. `doi.org`)'
     MSG_NO_SHOULDER = 'No DOI shoulder found. (e.g. `10.12345/`)'
     MSG_UNABLE_TO_MINT = 'Unable to mint a unique DMP ID.'
 
     class << self
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
       def create(provenance:, json:, logger: nil)
         raise CreatorError, MSG_NO_SHOULDER if ENV['DMP_ID_SHOULDER'].nil?
         raise CreatorError, MSG_NO_BASE_URL if ENV['DMP_ID_BASE_URL'].nil?
 
         # Fail if the provenance is not defined
-        raise DeleterError, MSG_DMP_FORBIDDEN unless provenance.is_a?(Hash) && !provenance['PK'].nil?
+        raise CreatorError, Helper::MSG_DMP_FORBIDDEN unless provenance.is_a?(Hash) && !provenance['PK'].nil?
 
         # Validate the incoming JSON first
         json = Helper.parse_json(json: json)
         errs = Validator.validate(mode: 'author', json: json)
         raise CreatorError, errs.join(', ') if errs.is_a?(Array) && errs.any? && errs.first != Validator::MSG_VALID_JSON
 
-        # Fail if the provenance or owner affiliation are not defined
-        raise CreatorError, MSG_NO_PROVENANCE_OWNER if provenance.nil?
+        # Try to find it by the :dmp_id first and Fail if found
+        dmp_id = Helper.dmp_id_to_pk(json: json.fetch('dmp', {})['dmp_id'])
+        result = Finder.exists?(p_key: dmp_id, logger: logger) unless dmp_id.nil?
+        raise CreatorError, Helper::MSG_DMP_EXISTS if result.is_a?(Hash)
 
-        # TODO: Swap this out with the Finder search once the Dynamo indexes are working
-        # Try to find it first and Fail if found
-        result = Finder.by_json(json: json, logger: logger)
-        raise CreatorError, Uc3DmpId::MSG_DMP_EXISTS if result.is_a?(Hash)
         # raise CreatorError, Uc3DmpId::MSG_DMP_EXISTS unless json['PK'].nil?
 
         client = Uc3DmpDynamo::Client.new
@@ -48,28 +49,32 @@ module Uc3DmpId
 
         # Create the item
         resp = client.put_item(json: annotated, logger: logger)
-        raise CreatorError, Uc3DmpId::MSG_DMP_NO_DMP_ID if resp.nil?
+        raise CreatorError, Helper::MSG_DMP_NO_DMP_ID if resp.nil?
 
         _post_process(json: annotated, logger: logger)
         Helper.cleanse_dmp_json(json: JSON.parse({ dmp: annotated }.to_json))
       end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+      # rubocop:enable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
 
       private
 
+      # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
       def _preregister_dmp_id(client:, provenance:, json:, logger: nil)
         # Use the specified DMP ID if the provenance has permission
         seeding = provenance.fetch('seedingWithLiveDmpIds', false).to_s.downcase == 'true'
         seed_id = json.fetch('dmp', {})['dmproadmap_external_system_identifier']
 
         # If we are seeding already registered DMP IDs from the Provenance system, then return the original DMP ID
-        logger.debug(message: "Seeding DMP ID with #{seed_id.gsub(%r{https?://}, '')}") if seeding && !seed_id.nil?
+        logger.debug(message: "Seeding DMP ID with #{seed_id.gsub(%r{https?://}, '')}") if logger.respond_to?(:debug) &&
+                                                                                           seeding && !seed_id.nil?
         return seed_id.gsub(%r{https?://}, '') if seeding && !seed_id.nil?
 
-        #Generate a new DMP ID
+        # Generate a new DMP ID
         dmp_id = ''
         counter = 0
         while dmp_id == '' && counter <= 10
-          prefix = "#{ENV['DMP_ID_SHOULDER']}#{SecureRandom.hex(2).upcase}#{SecureRandom.hex(2)}"
+          prefix = "#{ENV.fetch('DMP_ID_SHOULDER', nil)}#{SecureRandom.hex(2).upcase}#{SecureRandom.hex(2)}"
           dmp_id = prefix unless Finder.exists?(client: client, p_key: prefix)
           counter += 1
         end
@@ -80,15 +85,13 @@ module Uc3DmpId
         url = ENV['DMP_ID_BASE_URL'].gsub(%r{https?://}, '')
         "#{Helper::PK_DMP_PREFIX}#{url.end_with?('/') ? url : "#{url}/"}#{dmp_id}"
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      # rubocop:enable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
 
       # Once the DMP has been created, we need to register it's DMP ID
       # -------------------------------------------------------------------------
       def _post_process(json:, logger: nil)
         return false unless json.is_a?(Hash)
 
-        # We are creating, so this is always true
-        json['dmphub_updater_is_provenance'] = true
         # Publish the change to the EventBridge
         publisher = Uc3DmpEventBridge::Publisher.new
         publisher.publish(source: 'DmpCreator', event_type: 'EZID update', dmp: json, logger: logger)
@@ -103,8 +106,9 @@ module Uc3DmpId
           SK: json['SK'],
           dmproadmap_related_identifiers: citable_identifiers
         }
-        logger.debug(message: "Fetching citations", details: citable_identifiers)
-        publisher.publish(source: 'DmpUpdater', dmp: json, event_type: 'Citation Fetch', detail: citer_detail, logger: logger)
+        logger.debug(message: 'Fetching citations', details: citable_identifiers) if logger.respond_to?(:debug)
+        publisher.publish(source: 'DmpCreator', dmp: json, event_type: 'Citation Fetch', detail: citer_detail,
+                          logger: logger)
         true
       end
     end

data/lib/uc3-dmp-id/deleter.rb

@@ -12,47 +12,48 @@ module Uc3DmpId
       # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       # -------------------------------------------------------------------------
       def tombstone(provenance:, p_key:, logger: nil)
-        raise DeleterError, MSG_DMP_INVALID_DMP_ID unless p_key.is_a?(String) && !p_key.strip.empty?
+        raise DeleterError, Helper::MSG_DMP_INVALID_DMP_ID unless p_key.is_a?(String) && !p_key.strip.empty?
 
         # Fail if the provenance is not defined
-        raise DeleterError, MSG_DMP_FORBIDDEN unless provenance.is_a?(Hash) && !provenance['PK'].nil?
+        raise DeleterError, Helper::MSG_DMP_FORBIDDEN unless provenance.is_a?(Hash) && !provenance['PK'].nil?
 
         # Fetch the latest version of the DMP ID by it's PK
         client = Uc3DmpDynamo::Client.new
-        dmp = Finder.by_pk(p_key: p_key, client: client, logger: logger)
-        raise DeleterError, MSG_DMP_NOT_FOUND unless dmp.is_a?(Hash) && !dmp['dmp'].nil?
+        dmp = Finder.by_pk(p_key: p_key, client: client, cleanse: false, logger: logger)
+        raise DeleterError, Helper::MSG_DMP_NOT_FOUND unless dmp.is_a?(Hash) && !dmp['dmp'].nil?
 
         # Only allow this if the provenance is the owner of the DMP!
-        raise DeleterError, MSG_DMP_FORBIDDEN if dmp['dmp']['dmphub_provenance_id'] != provenance['PK']
+        raise DeleterError, Helper::MSG_DMP_FORBIDDEN if dmp['dmp']['dmphub_provenance_id'] != provenance['PK']
         # Make sure they're not trying to update a historical copy of the DMP
-        raise DeleterError, MSG_DMP_NO_HISTORICALS if dmp['dmp']['SK'] != Helper::DMP_LATEST_VERSION
+        raise DeleterError, Helper::MSG_DMP_NO_HISTORICALS if dmp['dmp']['SK'] != Helper::DMP_LATEST_VERSION
 
         # Annotate the DMP ID
         dmp['dmp']['SK'] = Helper::DMP_TOMBSTONE_VERSION
-        dmp['dmp']['dmphub_tombstoned_at'] = Time.now.utc.iso8601
-        dmp['dmp']['title'] = "OBSOLETE: #{dmp['title']}"
-        logger.info(message: "Tomstoning DMP ID: #{p_key}") if logger.respond_to?(:debug)
+        dmp['dmp']['title'] = "OBSOLETE: #{dmp['dmp']['title']}"
+        logger.info(message: "Tombstoning DMP ID: #{p_key}") if logger.respond_to?(:debug)
 
         # Set the :modified timestamps
         now = Time.now.utc.iso8601
-        dmp['modified'] = now
+        dmp['dmp']['modified'] = now
+        dmp['dmp']['dmphub_tombstoned_at'] = now
 
         # Create the Tombstone version
-        resp = client.put_item(json: dmp, logger: logger)
-        raise DeleterError, MSG_DMP_NO_TOMBSTONE if resp.nil?
+        resp = client.put_item(json: dmp['dmp'], logger: logger)
+        raise DeleterError, Helper::MSG_DMP_NO_TOMBSTONE if resp.nil?
 
         # Delete the Latest version
-        resp = client.delete_item(p_key: p_key, s_key: Helper::SK_DMP_PREFIX, logger: logger)
+        client.delete_item(p_key: p_key, s_key: Helper::DMP_LATEST_VERSION, logger: logger)
 
         # TODO: We should do a check here to see if it was successful!
 
         # Notify EZID about the removal
         _post_process(json: dmp, logger: logger)
+
         # Return the tombstoned record
-        Helper.cleanse_dmp_json(json: JSON.parse({ dmp: dmp }.to_json))
+        Helper.cleanse_dmp_json(json: dmp)
       rescue Aws::Errors::ServiceError => e
-        logger.error(message: e.message, details: e.backtrace) unless logger.nil?
-        { status: 500, error: Messages::MSG_SERVER_ERROR }
+        logger.error(message: e.message, details: e.backtrace) if logger.respond_to?(:error)
+        raise DeleterError, Helper::MSG_SERVER_ERROR
       end
       # rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
@@ -63,8 +64,6 @@ module Uc3DmpId
       def _post_process(json:, logger: nil)
         return false unless json.is_a?(Hash)
 
-        # Indicate whether or not the updater is the provenance system
-        json['dmphub_updater_is_provenance'] = true
         # Publish the change to the EventBridge
         publisher = Uc3DmpEventBridge::Publisher.new
         publisher.publish(source: 'DmpDeleter', event_type: 'EZID update', dmp: json, logger: logger)