uc3-dmp-id 0.0.26 → 0.0.27

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 954c6e2dd1011830b68f910538d55ec53dac556a2ba3a32980460084d4489573
-  data.tar.gz: 3cea22766eae0f7c90451077fd2fe6e8e5a009e3183eca13793ab6e66d4e2340
+  metadata.gz: 4bb37c3774e0bfdc3bde166671d245f5928fd1a15a3320e3f6736d9100cc667c
+  data.tar.gz: 842260600fdc60be2fef3beebbc9d5b8418ba0f90c0f5d4bd97b7d2c3d760255
 SHA512:
-  metadata.gz: c1d0da31992fda270ccd51a37896a871c7108d38ebd31b812b2d0bb6f77a1e587ad2f5adabb3f14b584cf65635587154ace4a6a5b76c6a52f6ad765bdad1e00e
-  data.tar.gz: a25603e080fecb8edbc0d4e21c470d819a5e4900aee60253cdcff04e49e263fff89dc44ac908e696b2cdc0fb9527b8c680157e9a6f08f1852ed2eb0c559af465
+  metadata.gz: 8be8f0d5ec703707d5c7fc3ac2a836a91cfd4704d837a61aaa99191f033521cdb99a9268b37384e35b8300bd0cdf0f7f2b6b3de65a4f8d88ddcb409133d574c8
+  data.tar.gz: 0160566bfeb48fb811e6bb7d9dda0065c88a09040b13f35423ca4020296c7247e5cf70aead0d7e3dd1e482205051c831d21247a15b04e4657aecffd3a8ca9d45

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

@@ -7,7 +7,6 @@ module Uc3DmpId
 
   class Creator
     MSG_NO_BASE_URL = 'No base URL found for DMP ID (e.g. `doi.org`)'
-    MSG_NO_PROVENANCE_OWNER = 'No provenance system and/or owner defined.'
     MSG_NO_SHOULDER = 'No DOI shoulder found. (e.g. `10.12345/`)'
     MSG_UNABLE_TO_MINT = 'Unable to mint a unique DMP ID.'
 
@@ -16,12 +15,16 @@ module Uc3DmpId
         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?
+
         # Validate the incoming JSON first
         errs = Validator.validate(mode: 'author', json: Helper.parse_json(json: json))&.fetch('dmp', {})
         raise CreatorError, errs.join(', ') if errs.is_a?(Array) && errs.any?
 
         # Fail if the provenance or owner affiliation are not defined
         raise CreatorError, MSG_NO_PROVENANCE_OWNER if provenance.nil? || owner_org.nil?
+        raise CreatorError, MSG_NO_OWNER_ORG unless owner_org.is_a?(String) && !owner_org.strip.empty?
 
         # Try to find it first and Fail if found
         result = Finder.by_json(json: json, debug: debug)
@@ -78,7 +81,7 @@ module Uc3DmpId
         # We are creating, so this is always true
         json['dmphub_updater_is_provenance'] = true
         # Publish the change to the EventBridge
-        EventPublisher.publish(source: 'DmpCreator', dmp: json, debug: @debug)
+        # EventPublisher.publish(source: 'DmpCreator', dmp: json, debug: @debug)
         true
       end
     end

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

@@ -1,11 +1,69 @@
 # frozen_string_literal: true
 
 module Uc3DmpId
-  class Uc3DmpIdDeleterError < StandardError; end
+  class DeleterError < StandardError; end
 
+  # Utility to Tombstone DMP ID'a
   class Deleter
     class << self
+      # Delete/Tombstone a record in the table
+      # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      # -------------------------------------------------------------------------
+      def tombstone(provenance:, p_key:, debug: false)
+        raise DeleterError, 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?
+
+        # Fetch the latest version of the DMP ID by it's PK
+        client = Uc3DmpDynamo::Client.new(debug: debug)
+        dmp = Finder.by_pk(p_key: p_key, client: client, debug: debug)
+        raise DeleterError, 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']
+        # 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
+
+        # Annotate the DMP ID
+        dmp['dmp']['SK'] = Helper::DMP_TOMBSTONE_VERSION
+        dmp['dmp']['dmphub_tombstoned_at'] = Time.now.iso8601
+        dmp['dmp']['title'] = "OBSOLETE: #{dmp['title']}"
+        puts "Tombstoning DMP #{p_key}" if debug
+
+        # Create the Tombstone version
+        resp = client.put_item(json: dmp, debug: debug)
+        raise DeleterError, 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, debug: debug)
+
+# TODO: We should do a check here to see if it was successful!
+puts resp.inspect
+
+        # Notify EZID about the removal
+        _post_process(json: dmp)
+        dmp
+      rescue Aws::Errors::ServiceError => e
+        Responder.log_error(source: source, message: e.message,
+                            details: ([@provenance] << e.backtrace).flatten)
+        { status: 500, error: Messages::MSG_SERVER_ERROR }
+      end
+      # rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+      private
+
+      # Once the DMP has been tombstoned, we need to notify EZID
+      # -------------------------------------------------------------------------
+      def _post_process(json:)
+        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
+        # EventPublisher.publish(source: 'DmpDeleter', dmp: json, debug: @debug)
+        true
+      end
     end
   end
 end

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

@@ -21,22 +21,6 @@ module Uc3DmpId
       end
       # rubocop:enable Metrics/MethodLength
 
-      # Find the DMP's versions
-      # -------------------------------------------------------------------------
-      def versions(p_key:, client: nil, debug: false)
-        raise FinderError, MSG_MISSING_PK if p_key.nil?
-
-        args = {
-          key_conditions: {
-            PK: { attribute_value_list: [Helper.append_pk_prefix(p_key: p_key)], comparison_operator: 'EQ' }
-          },
-          projection_expression: 'modified',
-          scan_index_forward: false
-        }
-        client = client.nil? ? Uc3DmpDynamo::Client.new(debug: debug) : client
-        client.query(args: args, debug: debug)
-      end
-
       # Find a DMP based on the contents of the incoming JSON
       # -------------------------------------------------------------------------
       def by_json(json:, debug: false)
@@ -73,7 +57,7 @@ module Uc3DmpId
         dmp = resp['dmp'].nil? ? JSON.parse({ dmp: resp }.to_json) : resp
         return nil if dmp['dmp']['PK'].nil?
 
-        dmp = _append_versions(p_key: dmp['dmp']['PK'], dmp: dmp, client: client, debug: debug)
+        dmp = Versioner.append_versions(p_key: dmp['dmp']['PK'], dmp: dmp, client: client, debug: debug)
         Helper.cleanse_dmp_json(json: dmp)
       end
 
@@ -119,28 +103,6 @@ module Uc3DmpId
         by_pk(p_key: dmp['dmp']['PK'], s_key: dmp['dmp']['SK'])
       end
       # rubocop:enable Metrics/AbcSize
-
-      private
-
-      # Build the dmphub_versions array and attach it to the dmp
-      # rubocop:disable Metrics/AbcSize
-      def _append_versions(p_key:, dmp:, client: nil, debug: false)
-        return dmp if p_key.nil? || !dmp.is_a?(Hash) || dmp['dmp'].nil?
-
-        results = versions(p_key: p_key, client: client, debug: debug)
-        return dmp unless results.length > 1
-
-        versions = results.map do |ver|
-          next if ver['modified'].nil?
-          {
-            timestamp: ver['modified'],
-            url: "#{Helper.api_base_url}dmps/#{Helper.remove_pk_prefix(p_key: p_key)}?version=#{ver['modified']}"
-          }
-        end
-        dmp['dmp']['dmphub_versions'] = JSON.parse(versions.to_json)
-        dmp
-      end
-      # rubocop:enable Metrics/AbcSize
     end
   end
 end

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

@@ -110,6 +110,29 @@ module Uc3DmpId
         json.is_a?(String) ? JSON.parse(json) : nil
       end
 
+      # Compare the DMP IDs to see if they are the same
+      def eql?(dmp_a:, dmp_b:)
+        return dmp_a == dmp_b unless dmp_a.is_a?(Hash) && !dmp_a['dmp'].nil? && dmp_b.is_a?(Hash) && !dmp_b['dmp'].nil?
+
+        # return true if they're identical
+        return true if dmp_a == dmp_b
+
+        # If the PK do not match, then they are not equivalent!
+        return false unless dmp_a.is_a?(Hash) && dmp_a['dmp'].fetch('PK', '').start_with?(Helper::PK_DMP_PREFIX) &&
+                            dmp_b.is_a?(Hash) && dmp_b['dmp'].fetch('PK', '').start_with?(Helper::PK_DMP_PREFIX) &&
+                            dmp_a['dmp']['PK'] == dmp_b['dmp']['PK']
+
+        a = deep_copy_dmp(obj: dmp_a)
+        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|
+        a['dmp'].delete(key) unless a['dmp'][key].nil?
+        b['dmp'].delete(key) unless b['dmp'][key].nil?
+        end
+        a == b
+      end
+
       # Add DMPHub specific fields to the DMP ID JSON
       def annotate_dmp_json(provenance:, owner_org:, p_key:, json:)
         json = parse_json(json: json)
@@ -166,6 +189,30 @@ module Uc3DmpId
         cleansed.keys.any? ? cleansed : nil
       end
       # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+      # Ruby's clone/dup methods do not clone/dup the children, so we need to do it here
+      # --------------------------------------------------------------
+      # rubocop:disable Metrics/AbcSize
+      def deep_copy_dmp(obj:)
+        case obj.class.name
+        when 'Array'
+          obj.map { |item| deep_copy_dmp(obj: item) }
+        when 'Hash'
+          hash = obj.dup
+          hash.each_pair do |key, value|
+            if key.is_a?(::String) || key.is_a?(::Symbol)
+              hash[key] = deep_copy_dmp(obj: value)
+            else
+              hash.delete(key)
+              hash[deep_copy_dmp(obj: key)] = deep_copy_dmp(obj: value)
+            end
+          end
+          hash
+        else
+          obj.dup
+        end
+      end
+      # rubocop:enable Metrics/AbcSize
     end
   end
 end

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

@@ -0,0 +1,150 @@
+# 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:, debug: false)
+        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?
+
+        puts 'JSON after splicing in changes from provenance' if debug
+        puts spliced if 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:, debug: false)
+        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
+        )
+
+        puts 'JSON after splicing in changes from non-provenance' if debug
+        puts spliced if 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

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

@@ -1,11 +1,75 @@
 # frozen_string_literal: true
 
 module Uc3DmpId
-  class Uc3DmpIdUpdaterError < StandardError; end
+  class UpdaterError < StandardError; end
 
   class Updater
     class << self
+      # Update a record in the table
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      # -------------------------------------------------------------------------
+      def update(provenance:, p_key:, json: {})
+      raise DeleterError, MSG_DMP_INVALID_DMP_ID unless p_key.is_a?(String) && !p_key.strip.empty?
 
+      dmp = Helper.parse_json(json: json)
+      errs = _updateable?(provenance: provenance, p_key: p_key, dmp: dmp)
+      raise DeleterError, errs if errs.is_a?(Array) && errs.any?
+
+      # Add the DMPHub specific attributes
+      annotated = Helper.annotate_dmp(provenance: provenance, json: dmp, p_key: p_key)
+
+      # fetch the existing latest version of the DMP ID
+      client = Uc3DmpDynamo::Client.new(debug: debug)
+      existing = Finder.by_pk(p_key: p_key, client: client, debug: debug)
+      # Don't continue if nothing has changed!
+      raise DeleterError, MSG_NO_CHANGE if Helper.eql?(dmp_a: existing, dmp_b: annotated)
+
+      # Generate a new version of the DMP. This involves versioning the current latest version
+      new_version = versioner.new_version(p_key: p_key, dmp: json)
+      raise DeleterError, MSG_DMP_UNABLE_TO_VERSION if new_version.nil?
+
+      # Save the changes as the new latest version
+      resp = client.put_item(json: new_version, debug: debug)
+      raise DeleterError, MSG_DMP_UNABLE_TO_VERSION if resp.nil?
+
+      # Send the updates to EZID, notify the provenance and download the PDF if applicable
+      _post_process(json: dmp)
+
+      resp
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+    private
+
+    # Check if the DMP ID is updateable by the provenance
+    def _updateable?(provenance:, p_key:, json:)
+      # Validate the incoming JSON first
+      errs = Validator.validate(mode: 'author', json: json)&.fetch('dmp', {})
+      return errs.join(', ') if errs.is_a?(Array) && errs.any?
+
+      # 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.fetch('dmp_id', {})
+      return [MSG_DMP_FORBIDDEN] unless Helper.dmp_id_to_pk(json: dmp_id) == p_key
+      # Make sure they're not trying to update a historical copy of the DMP
+      return [MSG_DMP_NO_HISTORICALS] if json['SK'] != Helper::DMP_LATEST_VERSION
+    end
+
+    # Once the DMP has been updated, we need to register it's DMP ID and download any PDF if applicable
+    # -------------------------------------------------------------------------
+    def _post_process(json:)
+      return false unless json.is_a?(Hash)
+
+      # Indicate whether or not the updater is the provenance system
+      json['dmphub_updater_is_provenance'] = @provenance['PK'] == json['dmphub_provenance_id']
+      # Publish the change to the EventBridge
+      # EventPublisher.publish(source: 'DmpUpdater', dmp: json, debug: @debug)
+      true
+    end
     end
   end
 end

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

@@ -34,7 +34,7 @@ module Uc3DmpId
         errors = ([MSG_INVALID_JSON] << errors).flatten.compact.uniq unless errors.empty?
         errors.map { |err| err.gsub(/in schema [a-z0-9-]+/, '').strip }
       rescue JSON::Schema::ValidationError => e
-        raise Uc3DmpIdValidatorError, MSG_BAD_JSON % { msg: e.message, trace: e.backtrace }
+        ["#{MSG_INVALID_JSON} - #{e.message}"]
       end
 
       # ------------------------------------------------------------------------------------
@@ -45,10 +45,13 @@ module Uc3DmpId
       # ------------------------------------------------------------------------------------
       def _load_schema(mode:)
 
-puts "Loading schema -- ::Uc3DmpId::Schemas::#{mode.to_s.downcase.capitalize}"
+puts "::Uc3DmpId::Schemas::Author defined? #{Object.const_defined?('::Uc3DmpId::Schemas::Author')}"
+puts "Uc3DmpId::Schemas::Author defined? #{Object.const_defined?('Uc3DmpId::Schemas::Author')}"
+puts "Schemas::Author defined? #{Object.const_defined?('Schemas::Author')}"
+puts "Author defined? #{Object.const_defined?('Author')}"
 
         # Instatiate the matching schema
-        schema = "::Uc3DmpId::Schemas::#{mode.to_s.downcase.capitalize}".split('::').inject(Object) { |o,c| o.const_get c }
+        schema = "Schemas::#{mode.to_s.downcase.capitalize}".split('::').inject(Object) { |o,c| o.const_get c }
         schema.respond_to?(:load) ? schema.load : nil
       end
 

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

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

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

@@ -1,11 +1,116 @@
 # frozen_string_literal: true
 
+require 'uc3-dmp-dynamo'
+
 module Uc3DmpId
-  class Uc3DmpIdVersionerError < StandardError; end
+  class VersionerError < StandardError; end
 
   class Versioner
     class << self
 
+      # Find the DMP ID's versions
+      # -------------------------------------------------------------------------
+      def get_versions(p_key:, client: nil, debug: false)
+        return [] unless p_key.is_a?(String) && !p_key.strip.empty?
+
+        args = {
+          key_conditions: {
+            PK: { attribute_value_list: [Helper.append_pk_prefix(p_key: p_key)], comparison_operator: 'EQ' }
+          },
+          projection_expression: 'modified',
+          scan_index_forward: false
+        }
+        client = client.nil? ? Uc3DmpDynamo::Client.new(debug: debug) : client
+        client.query(args: args, debug: debug)
+      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(client:, provenance:, p_key:, client: nil, dmp:, latest_version: {})
+        return nil unless p_key.is_a?(String) && !p_key.strip.empty? && _versionable?(dmp: dmp)
+
+        client = Uc3DmpDynamo::Client.new(debug: debug) if client.nil?
+        latest_version = Finder.by_p_key(client: client, p_key: p_key) unless latest_version.is_a?(Hash) &&
+                                                                              !latest_version['PK'].nil?
+
+        # Only continue if there was an existing record and its the latest version
+        return nil unless latest['SK'] != Helper::DMP_LATEST_VERSION
+
+        owner = latest['dmphub_provenance_id']
+        updater = provenance['PK']
+        prior = _generate_version(client: client, latest_version: latest, owner: owner, updater: updater)
+        return nil if prior.nil?
+
+        args = { owner: owner, updater: updater, base: prior, mods: dmp, debug: debug }
+        puts 'DMP ID update prior to splicing changes' if debug
+        puts dmp
+
+        args = { owner: owner, updater: updater, base: prior, mods: dmp, debug: debug }
+        # 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?
+        new_version
+      end
+
+      # Build the :dmphub_versions array and attach it to the DMP JSON
+      # rubocop:disable Metrics/AbcSize
+      def append_versions(p_key:, dmp:, client: nil, debug: false)
+        json = Helper.parse_json(json: dmp)
+        return json unless p_key.is_a?(String) && !p_key.strip.empty? && json.is_a?(Hash) && !json['dmp'].nil?
+
+        results = get_versions(p_key: p_key, client: client, debug: debug)
+        return json unless results.length > 1
+
+        versions = results.map do |ver|
+          next if ver['modified'].nil?
+          {
+            timestamp: ver['modified'],
+            url: "#{Helper.api_base_url}dmps/#{Helper.remove_pk_prefix(p_key: p_key)}?version=#{ver['modified']}"
+          }
+        end
+        json['dmp']['dmphub_versions'] = JSON.parse(versions.to_json)
+        json
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      private
+
+      # Determine whether the specified DMP metadata is versionable - returns boolean
+      def _versionable?(dmp:)
+        return false unless dmp.is_a?(Hash) && dmp['PK'].nil? && dmp['SK'].nil?
+
+        # 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:, debug: false)
+        # 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
+        return latest_version if mod_time.nil? || !(now - mod_time).is_a?(Float)
+
+        same_hour = (now - mod_time).round <= 3600
+        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, debug: debug)
+        return nil if resp.nil?
+
+        puts "Created new version #{latest_version['PK']} - #{latest_version['SK']}" if debug
+        latest_version
+      end
+      # rubocop:enable Metrics/AbcSize,  Metrics/CyclomaticComplexity,  Metrics/PerceivedComplexity
     end
   end
 end

data/lib/uc3-dmp-id.rb

@@ -8,20 +8,25 @@ 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'
+
 require 'uc3-dmp-id/schemas/amend'
 require 'uc3-dmp-id/schemas/author'
 
 module Uc3DmpId
   MSG_DMP_EXISTS = 'DMP already exists. Try :update instead.'
-  MSG_DMP_UNKNOWN = 'DMP does not exist. Try :create instead.'
-  MSG_DMP_NOT_FOUND = 'DMP does not exist.'
   MSG_DMP_FORBIDDEN = 'You do not have permission.'
-  MSG_DMP_NO_DMP_ID = 'A DMP ID could not be registered at this time.'
   MSG_DMP_INVALID_DMP_ID = 'Invalid DMP ID format.'
+  MSG_DMP_NO_DMP_ID = 'A DMP ID could not be registered at this time.'
   MSG_DMP_NO_HISTORICALS = 'You cannot modify a historical version of the DMP.'
+  MSG_NO_OWNER_ORG = 'Could not determine ownership of the DMP ID.'
+  MSG_DMP_NO_TOMBSTONE = 'Unable to tombstone the DMP ID at this time.'
+  MSG_DMP_NO_UPDATE = 'Unable to update the DMP ID at this time.'
+  MSG_DMP_NOT_FOUND = 'DMP does not exist.'
   MSG_DMP_UNABLE_TO_VERSION = 'Unable to version this DMP.'
+  MSG_DMP_UNKNOWN = 'DMP does not exist. Try :create instead.'
 end
 # rubocop:enable Naming/FileName

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: uc3-dmp-id
 version: !ruby/object:Gem::Version
-  version: 0.0.26
+  version: 0.0.27
 platform: ruby
 authors:
 - Brian Riley
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-06-06 00:00:00.000000000 Z
+date: 2023-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -123,6 +123,7 @@ files:
 - 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