uc3-dmp-id 0.0.97 → 0.0.99

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1b18b3d95b39f2da88fa37724c6fda10a5b52ca9f12c846a931d2437c2d765ba
-  data.tar.gz: bf97c7cd424030c19c720fff5011f9f6605aa375d6c9bf0f962f4ffd10174742
+  metadata.gz: e3bcba612098c1d0acd9a553f25549a198bbefb0f28c9c0ef166038382c17c07
+  data.tar.gz: 5ba9be2055b9c39a4c887930b5250860cd9dc986ddf4d0248d25e786f932c9fe
 SHA512:
-  metadata.gz: 791986d2bf6e7382ad4f1bf84a7e4c6c7d501609a1dfe4d0d3aec0d3554496a5637231db298a01481ec18f0e1055b82c95158cd203a53a6aecbbf8ba4ddb6109
-  data.tar.gz: f0baea87de3fb99225c98bbce5df28adf9ef32fc90593c32334d5094acf2314ea5c9d01d53088bbf1bc5529cdd9f496061aa8544b40687f7624cdde7991e59a0
+  metadata.gz: f3b3e728a5c532fb024dddd69a366fc9867e3a05856562c863b89059a38a320d63e70b9d0241249b2a8d419bf8898e894bd93617c681b3601ea82e701433f558
+  data.tar.gz: 5401aba365595519141ea7f2115366bdaf53b47183ee2fcd3ecba219c9625f8148cc1042faa8f67737f4fb750d60dfe62d2a334ed8e7449a02b8edbd2023744f

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Uc3DmpId
+  class AsserterError < StandardError; end
+
+  class Asserter
+    class << self
+      # Add assertions to a DMP ID - this is performed by non-provenance systems
+      def add(updater:, dmp:, mods:, note: nil, logger: nil)
+        # 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 assertions on the current DMP ID so we can manipulate them
+        assertions = Helper.deep_copy_dmp(obj: dmp.fetch('dmphub_assertions', []))
+        # Return the DMP ID as-is if the assertion is already on the record
+        return dmp if assertions.select { |entry| entry['provenance'] == updater && entry['assertions'] == mods }
+
+        assertions << _generate_assertion(updater: updater, mods: mods, note: note)
+        dmp['dmphub_assertions'] = assertions.flatten
+        dmp
+      end
+
+      # Splice together assertions made while the user was updating the DMP ID
+      def splice(latest_version:, modified_version:, logger: nil)
+        # 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)
+        return modified_version if latest_version['dmphub_updated_at'] == modified_version['dmphub_updated_at']
+
+        # Clone any existing assertions on the current DMP ID so we can manipulate them
+        existing_assertions = Helper.deep_copy_dmp(obj: latest_version.fetch('dmphub_assertions', []))
+        incoming_assertions = Helper.deep_copy_dmp(obj: modified_version.fetch('dmphub_assertions', []))
+        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 dmphub_updated_at on the incoming changes
+        latest_version['dmphub_assertions'] = existing_assertions.select do |entry|
+          !entry['timestamp'].nil? && Time.parse(entry['timestamp']) > Time.parse(modified_version['dmphub_updated_at'])
+        end
+        return latest_version unless incoming_assertions.any?
+
+        # Add any of the assertions still on the incoming record back to the latest record
+        incoming_assertions.each { |entry| latest_version['dmphub_assertions'] << entry }
+        latest_version
+      end
+
+      private
+
+      # Generate an assertion entry. For example:
+      #
+      # {
+      #    "id": "ABCD1234",
+      #    "provenance": "dmphub",
+      #    "timestamp": "2023-07-07T14:50:23+00:00",
+      #    "note": "data received from the NIH API",
+      #    "assertions": {
+      #      "contact": {
+      #        "name": "Wrong Person"
+      #      },
+      #      "contributor": [
+      #        {
+      #          "name": "Jane Doe",
+      #          "role": ["Investigation"]
+      #        }
+      #      ],
+      #      "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"
+      #          }
+      #        }
+      #      ]
+      #    }
+      # }
+      def _generate_assertion(updater:, mods:, note: '')
+        return nil if updater.nil? || !mod.is_a?(Hash)
+
+        JSON.parse({
+          id: SecureRandom.hex(4).upcase,
+          provenance: updater.gsub('PROVENANCE#', ''),
+          timestamp: Time.now.iso8601,
+          status: 'new',
+          note: note,
+          assertions: mods
+        }.to_json)
+      end
+    end
+  end
+end

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

@@ -77,8 +77,7 @@ module Uc3DmpId
       end
       # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
-      # Once the DMP has been created, we need to register it's DMP ID and download any
-      # PDF if applicable
+      # 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)

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

@@ -126,7 +126,7 @@ module Uc3DmpId
         b = deep_copy_dmp(obj: dmp_b)
 
         # ignore some of the attributes before comparing
-        %w[SK dmphub_modification_day dmphub_updated_at dmphub_created_at].each do |key|
+        %w[SK dmphub_modification_day dmphub_updated_at dmphub_created_at dmphub_assertions].each do |key|
         a['dmp'].delete(key) unless a['dmp'][key].nil?
         b['dmp'].delete(key) unless b['dmp'][key].nil?
         end
@@ -212,7 +212,7 @@ module Uc3DmpId
         return json.map { |obj| cleanse_dmp_json(json: obj) }.compact if json.is_a?(Array)
 
         cleansed = {}
-        allowable = %w[dmphub_versions]
+        allowable = %w[dmphub_versions dmphub_updated_at]
         json.each_key do |key|
           next if (key.to_s.start_with?('dmphub') && !allowable.include?(key)) || %w[PK SK].include?(key.to_s)
 

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

@@ -1,53 +1,63 @@
 # frozen_string_literal: true
 
+require 'securerandom'
+
 module Uc3DmpId
   class UpdaterError < StandardError; end
 
   class Updater
     class << self
-      # Update a record in the table
+      # Update a DMP ID
       # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
       # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       # -------------------------------------------------------------------------
-      def update(provenance:, p_key:, json: {}, logger: nil)
+      def update(provenance:, p_key:, json: {}, note: nil, logger: nil)
         raise UpdaterError, MSG_DMP_INVALID_DMP_ID unless p_key.is_a?(String) && !p_key.strip.empty?
 
-        dmp = Helper.parse_json(json: json)
+        mods = Helper.parse_json(json: json).fetch('dmp', {})
         p_key = Helper.append_pk_prefix(p_key: p_key)
+        logger.debug(message: "Incoming modifications for PK #{p_key}", details: mods) if logger.respond_to?(:debug)
 
-        # Add the DMPHub specific attributes
-        annotated = Helper.annotate_dmp_json(provenance: provenance, p_key: p_key, json: dmp['dmp'])
-        logger.debug(message: "Incoming JSON after annotation", details: annotated) if logger.respond_to?(:debug)
-
-        # fetch the existing latest version of the DMP ID
-        client = Uc3DmpDynamo::Client.new(logger: logger)
-        existing = Finder.by_pk(p_key: p_key, client: client, logger: logger, cleanse: false)
-        logger.debug(message: "Existing latest record", details: existing) if logger.respond_to?(:debug)
+        # Fetch the latest version of the DMP ID
+        client = Uc3DmpDynamo::Client.new
+        latest_version = Finder.by_pk(p_key: p_key, client: client, logger: logger, cleanse: false)
+        latest_version = latest_version.nil? ? {} : latest_version.fetch('dmp', {})
+        logger.debug(message: "Latest version for PK #{p_key}", details: latest_version) if logger.respond_to?(:debug)
 
-        errs = _updateable?(provenance: provenance, p_key: p_key, json: annotated)
+        # Verify that the DMP ID is updateable with the info passed in
+        errs = _updateable?(provenance: provenance, p_key: p_key, latest_version: latest_version['dmp'], mods: mods['dmp'])
+        logger.error(message: errs.join(', ')) if errs.is_a?(Array) && errs.any?
         raise UpdaterError, errs if errs.is_a?(Array) && errs.any?
         # Don't continue if nothing has changed!
-        raise UpdaterError, MSG_NO_CHANGE if Helper.eql?(dmp_a: existing, dmp_b: dmp)
+        raise UpdaterError, MSG_NO_CHANGE if Helper.eql?(dmp_a: latest_version, dmp_b: mods)
 
-        # Generate a new version of the DMP. This involves versioning the current latest version
-        new_version = Versioner.new_version(provenance: provenance, p_key: p_key, client: client, logger: logger,
-                                            dmp: dmp, latest_version: existing)
-        logger.debug(message: "New version", details: new_version) if logger.respond_to?(:debug)
-        raise UpdaterError, MSG_DMP_UNABLE_TO_VERSION if new_version.nil?
+        # Version the DMP ID record (if applicable).
+        owner = latest_version['dmphub_provenance_id']
+        updater = provenance['PK']
+        version = Versioner.generate_version(client: client, latest_version: latest_version, owner: owner, updater: updater,
+                                             logger: logger)
+        raise UpdaterError, MSG_DMP_UNABLE_TO_VERSION if version.nil?
 
-        # Save the changes as the new latest version
-        resp = client.put_item(json: new_version, logger: logger)
+        # Splice the assertions
+        version = _process_modifications(owner: owner, updater: updater, version: version, mods: mods, note: note,
+                                         logger: logger)
+
+        # Save the changes
+        resp = client.put_item(json: version, logger: logger)
         raise UpdaterError, MSG_DMP_UNABLE_TO_VERSION if resp.nil?
 
-        # Send the updates to EZID, notify the provenance and download the PDF if applicable
-        _post_process(provenance: provenance, json: dmp, logger: logger)
+        # Send the updates to EZID
+        _post_process(provenance: provenance, json: version, logger: logger)
+
         # Return the new version record
         logger.info(message: "Updated DMP ID: #{p_key}") if logger.respond_to?(:debug)
-        Helper.cleanse_dmp_json(json: JSON.parse({ dmp: new_version }.to_json))
+        Helper.cleanse_dmp_json(json: JSON.parse({ dmp: version }.to_json))
       end
       # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
       # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
+      # Save a DMP ID's corresponding narrative PDF document to S3 and add the download URL for that
+      # document to the DMP ID's :dmpraodmap_related_identifiers array as an `is_metadata_for` relation
       def attach_narrative(provenance:, p_key:, url:, logger: nil)
         raise UpdaterError, MSG_DMP_INVALID_DMP_ID unless p_key.is_a?(String) && !p_key.strip.empty?
 
@@ -59,7 +69,7 @@ module Uc3DmpId
         errs = _updateable?(provenance: provenance, p_key: p_key, json: dmp['dmp'])
         raise UpdaterError, errs if errs.is_a?(Array) && errs.any?
 
-        # Add the DMPHub specific attributes and then add the download URl for the PDF
+        # Add the download URl for the PDF as a related identifier on the DMP ID record
         annotated = Helper.annotate_dmp_json(provenance: provenance, p_key: p_key, json: dmp['dmp'])
         annotated['dmproadmap_related_identifiers'] = [] if annotated['dmproadmap_related_identifiers'].nil?
         annotated['dmproadmap_related_identifiers'] << {
@@ -76,19 +86,30 @@ module Uc3DmpId
 
       private
 
-      # Check if the DMP ID is updateable by the provenance
-      def _updateable?(provenance:, p_key:, json:)
+      # Check to make sure the incoming JSON is valid, the DMP ID requested matches the DMP ID in the JSON
+      def _updateable?(provenance:, p_key:, latest_version: {}, mods: {})
         # Validate the incoming JSON first
-        errs = Validator.validate(mode: 'author', json: json)
+        errs = Validator.validate(mode: 'author', json: JSON.parse({ dmp: mods }.to_json))
         return errs.join(', ') if errs.is_a?(Array) && errs.any? && errs.first != Validator::MSG_VALID_JSON
         # Fail if the provenance is not defined
         return [MSG_DMP_FORBIDDEN] unless provenance.is_a?(Hash) && !provenance['PK'].nil?
         # Verify that the JSON is for the same DMP in the PK
-        dmp_id = json['dmp'].fetch('dmp_id', {})
-        return [MSG_DMP_FORBIDDEN] unless Helper.dmp_id_to_pk(json: dmp_id) == p_key
+        return [MSG_DMP_FORBIDDEN] unless Helper.dmp_id_to_pk(json: mods.fetch('dmp_id', {})) == p_key
+        # Bail out if the DMP ID could not be found or the PKs do not match for some reason
+        return [MSG_DMP_UNKNOWN] if latest_version.nil? || latest_version.fetch['PK'] != p_key
+      end
+
+      def _process_modifications(owner:, updater:, version:, mods:, note: nil, logger: nil)
+        return version unless mods.is_a?(Hash) && !updater.nil?
+        return mods unless version.is_a?(Hash) && !owner.nil?
+
+        # Splice together any assertions that may have been made while the user was editing the DMP ID
+        Asserter.splice(latest_version: version, modified_version: mods, logger: logger) if owner == updater
+        # Attach the incoming changes as an assertion to the DMP ID since the updater is NOT the owner
+        Asserter.add(updater: provenance['PK'], dmp: version, mods: mods, note: note, logger: logger) if owner != updater
       end
 
-      # Once the DMP has been updated, we need to register it's DMP ID and download any PDF if applicable
+      # Once the DMP has been updated, we need to update it's DOI metadata
       # -------------------------------------------------------------------------
       def _post_process(provenance:, json:, logger: nil)
         return false unless json.is_a?(Hash)

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

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Uc3DmpId
-  VERSION = '0.0.97'
+  VERSION = '0.0.99'
 end

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

@@ -26,39 +26,42 @@ module Uc3DmpId
         client.query(args: args, logger: logger)
       end
 
-      # Create a new version of the DMP. This involves:
-      #    - Cloning the existing `VERSION#latest` and setting it's `SK` to `VERSION=yyyy-mm-ddThh:mm:ss+zz:zz`
-      #    - Saving the new `VERSION=yyyy-mm-ddThh:mm:ss+zz:zz` item
-      #    - Splicing in the current changes onto the existing `VERSION#latest` item
-      #    - Returning the spliced `VERSION#latest` back to this method
-      def new_version(provenance:, p_key:, client: nil, dmp:, latest_version: {}, logger: nil)
-
-puts "Provenance: #{provenance}, PK: #{p_key}"
-puts dmp
-
-        return nil unless p_key.is_a?(String) && !p_key.strip.empty? && _versionable?(p_key: p_key, dmp: latest_version['dmp'])
-
-        client = Uc3DmpDynamo::Client.new if client.nil?
-
-        owner = latest_version['dmphub_provenance_id']
-        updater = provenance['PK']
-        prior = _generate_version(client: client, latest_version: latest_version['dmp'], owner: owner, updater: updater)
-        return nil if prior.nil?
+      # Generate a snapshot of the current latest version of the DMP ID using the existing :dmphub_updated_at as
+      # the new SK.
+      # rubocop:disable Metrics/AbcSize,  Metrics/CyclomaticComplexity,  Metrics/PerceivedComplexity
+      def generate_version(client:, latest_version:, owner:, updater:, logger: nil)
+        # Only create a version if the Updater is not the Owner OR the changes have happened on a different day
+        mod_time = Time.parse(latest_version.fetch('dmphub_updated_at', Time.now.iso8601))
+        now = Time.now
+        if mod_time.nil? || !(now - mod_time).is_a?(Float)
+          logger.error(message: "#{SOURCE} unable to determine mod time: #{mod_time}") if logger.respond_to?(:debug)
+          return latest_version
+        end
 
-        args = { owner: owner, updater: updater, base: prior, mods: dmp['dmp'], logger: logger }
-        logger.debug(message: "#{SOURCE} record prior to splicing", details: dmp) if logger.respond_to?(:debug)
+        # Only allow a new version if the owner and updater are the same and it has been at least one hour since
+        # the last version was created
+        same_hour = (now - mod_time).round <= 3600
+        if owner != updater || (owner == updater && same_hour)
+          logger.debug(message: "#{SOURCE} same owner and updater? #{owner == updater}") if logger.respond_to?(:debug)
+          logger.debug(message: "#{SOURCE} already updated within the past hour? #{same_hour}") if logger.respond_to?(:debug)
+          return latest_version
+        end
 
-        # If the system of provenance is making the change then just use the
-        # new version as the base and then splice in any mods made by others
-        # args = args.merge({ base: new_version, mods: original_version })
-        new_version = Splicer.splice_for_owner(args) if owner == updater
-        # Otherwise use the original version as the base and then update the
-        # metadata owned by the updater system
-        new_version = Splicer.splice_for_others(args) if new_version.nil?
+        # Make a copy of the latest_version and then update it's SK to the :dmphub_updated_at to mark it in a point of time
+        # We essentially make a snapshot of the record before making changes
+        prior = Helper.deep_copy_dmp(obj: latest_version)
+        prior['SK'] = "#{Helper::SK_DMP_PREFIX}#{latest_version['dmphub_updated_at'] || Time.now.iso8601}"
+        # Create the prior version record ()
+        client = client.nil? ? Uc3DmpDynamo::Client.new : client
+        resp = client.put_item(json: prior, logger: logger)
+        return nil if resp.nil?
 
-        logger.debug(message: "#{SOURCE} record after splicing", details: new_version) if logger.respond_to?(:debug)
-        new_version
+        msg = "#{SOURCE} created version PK: #{prior['PK']} SK: #{prior['SK']}"
+        logger.info(message: msg, details: prior) if logger.respond_to?(:debug)
+        # Return the latest version
+        latest_version
       end
+      # rubocop:enable Metrics/AbcSize,  Metrics/CyclomaticComplexity,  Metrics/PerceivedComplexity
 
       # Build the :dmphub_versions array and attach it to the DMP JSON
       # rubocop:disable Metrics/AbcSize
@@ -80,44 +83,6 @@ puts dmp
         json
       end
       # rubocop:enable Metrics/AbcSize
-
-      private
-
-      # Determine whether the specified DMP metadata is versionable - returns boolean
-      def _versionable?(p_key:, dmp:)
-
-puts "PK MATCH? #{dmp['PK'] == p_key}, SK IS LATEST? #{dmp['SK'] == Helper::DMP_LATEST_VERSION}, DMP ID PRESENT? #{!dmp.fetch('dmp_id', {})['identifier'].nil?}"
-
-        return false unless dmp.is_a?(Hash) && dmp['PK'] == p_key && dmp['SK'] == Helper::DMP_LATEST_VERSION
-
-        # It's versionable if it has a DMP ID
-        !dmp.fetch('dmp_id', {})['identifier'].nil?
-      end
-
-      # Generate a version
-      # rubocop:disable Metrics/AbcSize,  Metrics/CyclomaticComplexity,  Metrics/PerceivedComplexity
-      def _generate_version(client:, latest_version:, owner:, updater:, logger: nil)
-        # Only create a version if the Updater is not the Owner OR the changes have happened on a different day
-        mod_time = Time.parse(latest_version.fetch('dmphub_updated_at', Time.now.iso8601))
-        now = Time.now
-        logger.debug(message: "#{SOURCE} generating version - mod_time: #{mod_time}") if logger.respond_to?(:debug)
-        return latest_version if mod_time.nil? || !(now - mod_time).is_a?(Float)
-
-        same_hour = (now - mod_time).round <= 3600
-        logger.debug(message: "#{SOURCE} same owner and updater? #{owner == updater}") if logger.respond_to?(:debug)
-        logger.debug(message: "#{SOURCE} already updated within the past hour? #{same_hour}") if logger.respond_to?(:debug)
-        return latest_version if owner != updater || (owner == updater && same_hour)
-
-        latest_version['SK'] = "#{Helper::SK_DMP_PREFIX}#{latest_version['dmphub_updated_at'] || Time.now.iso8601}"
-        # Create the prior version record
-        resp = client.put_item(json: latest_version, logger: logger)
-        return nil if resp.nil?
-
-        msg = "#{SOURCE} created version PK: #{latest_version['PK']} SK: #{latest_version['SK']}"
-        logger.info(message: msg, details: latest_version) if logger.respond_to?(:debug)
-        latest_version
-      end
-      # rubocop:enable Metrics/AbcSize,  Metrics/CyclomaticComplexity,  Metrics/PerceivedComplexity
     end
   end
 end

data/lib/uc3-dmp-id.rb

@@ -6,11 +6,11 @@ require 'json-schema'
 
 require 'uc3-dmp-event-bridge'
 
+require 'uc3-dmp-id/asserter'
 require 'uc3-dmp-id/creator'
 require 'uc3-dmp-id/deleter'
 require 'uc3-dmp-id/finder'
 require 'uc3-dmp-id/helper'
-require 'uc3-dmp-id/splicer'
 require 'uc3-dmp-id/updater'
 require 'uc3-dmp-id/validator'
 require 'uc3-dmp-id/versioner'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: uc3-dmp-id
 version: !ruby/object:Gem::Version
-  version: 0.0.97
+  version: 0.0.99
 platform: ruby
 authors:
 - Brian Riley
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-07-07 00:00:00.000000000 Z
+date: 2023-07-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -131,13 +131,13 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/uc3-dmp-id.rb
+- lib/uc3-dmp-id/asserter.rb
 - lib/uc3-dmp-id/creator.rb
 - lib/uc3-dmp-id/deleter.rb
 - lib/uc3-dmp-id/finder.rb
 - lib/uc3-dmp-id/helper.rb
 - lib/uc3-dmp-id/schemas/amend.rb
 - lib/uc3-dmp-id/schemas/author.rb
-- lib/uc3-dmp-id/splicer.rb
 - lib/uc3-dmp-id/updater.rb
 - lib/uc3-dmp-id/validator.rb
 - lib/uc3-dmp-id/version.rb

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

@@ -1,146 +0,0 @@
-# frozen_string_literal: true
-
-module Uc3DmpId
-  class SplicerError < StandardError; end
-
-  class Splicer
-    class << self
-      # Splice changes from other systems onto the system of provenance's updated record
-      # --------------------------------------------------------------
-      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-      def splice_for_owner(owner:, updater:, base:, mods:, logger: nil)
-        return base if owner.nil? || updater.nil? || mods.nil?
-        return mods if base.nil?
-
-        provenance_regex = /"dmphub_provenance_id":"#{Helper::PK_PROVENANCE_PREFIX}[a-zA-Z\-_]+"/
-        others = base.to_json.match(provenance_regex)
-        # Just return it as is if there are no mods by other systems
-        return mods if others.nil?
-
-        spliced = Helper.deep_copy_dmp(obj: base)
-        cloned_mods = Helper.deep_copy_dmp(obj: mods)
-
-        # ensure that the :project and :funding are defined
-        spliced['project'] = [{}] if spliced['project'].nil? || spliced['project'].empty?
-        spliced['project'].first['funding'] = [] if spliced['project'].first['funding'].nil?
-        # get all the new funding and retain other system's funding metadata
-        mod_fundings = cloned_mods.fetch('project', [{}]).first.fetch('funding', [])
-        other_fundings = spliced['project'].first['funding'].reject { |fund| fund['dmphub_provenance_id'].nil? }
-        # process funding (just attach all funding not owned by the system of provenance)
-        spliced['project'].first['funding'] = mod_fundings
-        spliced['project'].first['funding'] << other_fundings if other_fundings.any?
-        return spliced if cloned_mods['dmproadmap_related_identifiers'].nil?
-
-        # process related_identifiers (just attach all related identifiers not owned by the system of provenance)
-        spliced['dmproadmap_related_identifiers'] = [] if spliced['dmproadmap_related_identifiers'].nil?
-        mod_relateds = cloned_mods.fetch('dmproadmap_related_identifiers', [])
-        other_relateds = spliced['dmproadmap_related_identifiers'].reject { |id| id['dmphub_provenance_id'].nil? }
-        spliced['dmproadmap_related_identifiers'] = mod_relateds
-        spliced['dmproadmap_related_identifiers'] << other_relateds if other_relateds.any?
-
-        logger.debug(message: "JSON after splicing in changes from provenance", details: spliced) if logger.respond_to?(:debug)
-        spliced
-      end
-      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
-      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-
-      # Splice changes from the other system onto the system of provenance and other system's changes
-      # --------------------------------------------------------------
-      # rubocop:disable Metrics/AbcSize
-      def splice_for_others(owner:, updater:, base:, mods:, logger: nil)
-        return base if owner.nil? || updater.nil? || base.nil? || mods.nil?
-
-        spliced = Helper.deep_copy_dmp(obj: base)
-        base_funds = spliced.fetch('project', [{}]).first.fetch('funding', [])
-        base_relateds = spliced.fetch('dmproadmap_related_identifiers', [])
-
-        mod_funds = mods.fetch('project', [{}]).first.fetch('funding', [])
-        mod_relateds = mods.fetch('dmproadmap_related_identifiers', [])
-
-        # process funding
-        spliced['project'].first['funding'] = _update_funding(
-          updater: updater, base: base_funds, mods: mod_funds
-        )
-        return spliced if mod_relateds.empty?
-
-        # process related_identifiers
-        spliced['dmproadmap_related_identifiers'] = _update_related_identifiers(
-          updater: updater, base: base_relateds, mods: mod_relateds
-        )
-
-        logger.debug(message: "JSON after splicing in changes from non-provenance", details: spliced) if logger.respond_to?(:debug)
-        spliced
-      end
-      # rubocop:enable Metrics/AbcSize
-
-      private
-
-      # These Splicing operations could probably be refined or genericized to traverse the Hash
-      # and apply to each object
-
-      # Splice funding changes
-      # --------------------------------------------------------------
-      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-      def _update_funding(updater:, base:, mods:)
-        return base if updater.nil? || mods.nil? || mods.empty?
-
-        spliced = Helper.deep_copy_dmp(obj: base)
-        mods.each do |funding|
-          # Ignore it if it has no status or grant id
-          next if funding['funding_status'].nil? && funding['grant_id'].nil?
-
-          # See if there is an existing funding record for the funder that's waiting on an update
-          spliced = [] if spliced.nil?
-          items = spliced.select do |orig|
-            !orig['funder_id'].nil? &&
-              orig['funder_id'] == funding['funder_id'] &&
-              %w[applied planned].include?(orig['funding_status'])
-          end
-          # Always grab the most current
-          items = items.sort { |a, b| b.fetch('dmphub_created_at', '') <=> a.fetch('dmphub_created_at', '') }
-          item = items.first
-
-          # Out with the old and in with the new
-          spliced.delete(item) unless item.nil?
-          # retain the original name
-          funding['name'] = item['name'] unless item.nil?
-          item = Helper.deep_copy_dmp(obj: funding)
-
-          item['funding_status'] == funding['funding_status'] unless funding['funding_status'].nil?
-          spliced << item if funding['grant_id'].nil?
-          next if funding['grant_id'].nil?
-
-          item['grant_id'] = funding['grant_id']
-          item['funding_status'] = funding['grant_id'].nil? ? 'rejected' : 'granted'
-
-          # Add the provenance to the entry
-          item['grant_id']['dmphub_provenance_id'] = updater
-          item['grant_id']['dmphub_created_at'] = Time.now.iso8601
-          spliced << item
-        end
-        spliced
-      end
-      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
-      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-
-      # Splice related identifier changes
-      # --------------------------------------------------------------
-      def _update_related_identifiers(updater:, base:, mods:)
-        return base if updater.nil? || mods.nil? || mods.empty?
-
-        # Remove the updater's existing related identifiers and replace with the new set
-        spliced = base.nil? ? [] : Helper.deep_copy_dmp(obj: base)
-        spliced = spliced.reject { |related| related['dmphub_provenance_id'] == updater }
-        # Add the provenance to the entry
-        updates = mods.nil? ? [] : Helper.deep_copy_dmp(obj: mods)
-        updates = updates.map do |related|
-          related['dmphub_provenance_id'] = updater
-          related
-        end
-        spliced + updates
-      end
-    end
-  end
-end