stash-merritt 0.0.1

data/lib/datacite/mapping/datacite_xml_factory.rb

@@ -0,0 +1,212 @@
+require 'datacite/mapping'
+
+module Datacite
+  module Mapping
+    class DataciteXMLFactory # rubocop:disable Metrics/ClassLength
+      attr_reader :doi_value
+      attr_reader :se_resource_id
+      attr_reader :total_size_bytes
+      attr_reader :version
+
+      def initialize(doi_value:, se_resource_id:, total_size_bytes:, version:)
+        @doi_value = doi_value
+        @se_resource_id = se_resource_id
+        @total_size_bytes = total_size_bytes
+        @version = version && version.to_s
+      end
+
+      def build_datacite_xml(datacite_3: false)
+        dcs_resource = build_resource(datacite_3: datacite_3)
+
+        return dcs_resource.write_xml(mapping: :datacite_3) if datacite_3
+        dcs_resource.write_xml
+      end
+
+      def build_resource(datacite_3: false) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        pub_year = se_resource.publication_years[0] # TODO: make this has_one instead of has_many
+
+        dcs_resource = Resource.new(
+          identifier: Identifier.from_doi(doi_value),
+          creators: se_resource.creators.map do |c|
+            Creator.new(
+              name: c.creator_full_name,
+              identifier: to_dcs_identifier(c.name_identifier),
+              affiliations: c.affiliations.map(&:smart_name)
+            )
+          end,
+          titles: se_resource.titles.map { |t| Title.new(value: t.title, type: t.title_type_mapping_obj) },
+          publisher: to_dcs_publisher(se_resource.publisher),
+          publication_year: to_dcs_pub_year(pub_year)
+        )
+
+        dcs_resource.language = 'en'
+        dcs_resource.resource_type = to_dcs_type(se_resource.resource_type)
+        dcs_resource.sizes = ["#{total_size_bytes} bytes"]
+        dcs_resource.formats = se_resource.formats.map(&:format)
+        dcs_resource.version = version
+
+        add_subjects(dcs_resource)
+        add_contributors(dcs_resource)
+        add_dates(dcs_resource)
+        add_alt_ids(dcs_resource)
+        add_related_ids(dcs_resource)
+        add_rights(dcs_resource)
+        add_descriptions(dcs_resource)
+        add_locations(dcs_resource)
+        add_funding(dcs_resource, datacite_3: datacite_3)
+
+        dcs_resource
+      end
+
+      private
+
+      def se_resource
+        @se_resource ||= StashEngine::Resource.find(se_resource_id)
+      end
+
+      def to_dcs_type(sd_resource_type)
+        ResourceType.new(resource_type_general: sd_resource_type.resource_type_general_mapping_obj,
+                         value: sd_resource_type.resource_type)
+      end
+
+      def add_locations(dcs_resource)
+        dcs_resource.geo_locations = se_resource.geolocations.map do |l|
+          GeoLocation.new(
+            place: l.datacite_mapping_place,
+            point: l.datacite_mapping_point,
+            box: l.datacite_mapping_box
+          )
+        end
+      end
+
+      def add_descriptions(dcs_resource)
+        se_resource.descriptions.where.not(description: nil).each do |d|
+          next if d.description.blank?
+          dcs_resource.descriptions << Description.new(
+            value: d.description,
+            type: d.description_type_mapping_obj
+          )
+        end
+      end
+
+      def add_rights(dcs_resource)
+        dcs_resource.rights_list = se_resource.rights.map do |r|
+          Rights.new(
+            value: r.rights,
+            uri: to_uri(r.rights_uri)
+          )
+        end
+      end
+
+      def add_related_ids(dcs_resource)
+        dcs_resource.related_identifiers = se_resource.related_identifiers.completed.map do |id|
+          RelatedIdentifier.new(
+            relation_type: id.relation_type_mapping_obj,
+            value: id.related_identifier,
+            identifier_type: id.related_identifier_type_mapping_obj,
+            related_metadata_scheme: id.related_metadata_scheme,
+            scheme_uri: to_uri(id.scheme_URI),
+            scheme_type: id.scheme_type
+          )
+        end
+      end
+
+      def add_alt_ids(dcs_resource)
+        dcs_resource.alternate_identifiers = se_resource.alternate_identifiers.map do |id|
+          AlternateIdentifier.new(
+            value: id.alternate_identifier,
+            type: id.alternate_identifier_type
+          )
+        end
+      end
+
+      def add_dates(dcs_resource)
+        dcs_resource.dates = se_resource.datacite_dates.where.not(date: nil).map do |d|
+          sd_date = d.date
+          Date.new(
+            type: d.date_type_mapping_obj,
+            value: sd_date
+          )
+        end
+      end
+
+      def add_subjects(dcs_resource)
+        dcs_resource.subjects = se_resource.subjects.map { |s| Subject.new(value: s.subject) }
+      end
+
+      def add_contributors(dcs_resource)
+        se_resource.contributors.completed.where.not(contributor_type: 'funder').each do |c|
+          dcs_resource.contributors << Contributor.new(
+            name: c.contributor_name,
+            identifier: to_dcs_identifier(c.name_identifier),
+            type: c.contributor_type_mapping_obj,
+            affiliations: c.affiliations.map(&:long_name)
+          )
+        end
+      end
+
+      def add_funding(dcs_resource, datacite_3: false)
+        datacite_3 ? add_dc3_funders(dcs_resource) : add_funding_references(dcs_resource)
+      end
+
+      def sd_funder_contribs
+        se_resource.contributors.completed.where(contributor_type: 'funder')
+      end
+
+      def add_dc3_funders(dcs_resource)
+        sd_funder_contribs.each do |contrib|
+          dcs_resource.descriptions << to_funding_desc(contrib)
+          dcs_resource.contributors << to_dcs_funder(contrib)
+        end
+      end
+
+      def add_funding_references(dcs_resource)
+        dcs_resource.funding_references = sd_funder_contribs.map do |c|
+          FundingReference.new(
+            name: c.contributor_name,
+            award_number: c.award_number
+          )
+        end
+      end
+
+      def to_dcs_funder(contrib)
+        Contributor.new(
+          name: contrib.contributor_name,
+          identifier: to_dcs_identifier(contrib.name_identifier),
+          type: ContributorType::FUNDER
+        )
+      end
+
+      def to_funding_desc(contrib)
+        award_num = contrib.award_number
+        desc_text = "Data were created with funding from #{contrib.contributor_name}"
+        desc_text << " under grant(s) #{award_num}." if award_num
+        Description.new(type: DescriptionType::OTHER, value: desc_text)
+      end
+
+      def to_dcs_identifier(sd_name_ident)
+        return unless sd_name_ident
+        sd_scheme_uri = sd_name_ident.scheme_URI
+        NameIdentifier.new(
+          scheme: sd_name_ident.name_identifier_scheme,
+          scheme_uri: sd_scheme_uri && to_uri(sd_scheme_uri),
+          value: sd_name_ident.name_identifier
+        )
+      end
+
+      def to_dcs_publisher(sd_publisher)
+        return 'unknown' unless sd_publisher
+        sd_publisher.publisher
+      end
+
+      def to_dcs_pub_year(sd_pub_year)
+        return ::Date.today.year unless sd_pub_year
+        sd_pub_year.publication_year
+      end
+
+      def to_uri(uri_or_str)
+        ::XML::MappingExtensions.to_uri(uri_or_str)
+      end
+    end
+  end
+end

data/lib/stash/merritt/ezid_helper.rb

@@ -0,0 +1,50 @@
+require 'stash_ezid/client'
+
+module Stash
+  module Merritt
+    class EzidHelper
+      attr_reader :resource
+      attr_reader :url_helpers
+
+      def initialize(resource:, url_helpers:)
+        @resource = resource
+        @url_helpers = url_helpers
+      end
+
+      # @return [String] the identifier (DOI, ARK, or URN)
+      def ensure_identifier
+        identifier_str = resource.identifier_str
+        return identifier_str if identifier_str
+
+        new_identifier_str = ezid_client.mint_id
+        resource.ensure_identifier(new_identifier_str)
+        new_identifier_str
+      end
+
+      def update_metadata(dc3_xml:)
+        identifier_str = resource.identifier_str
+        landing_page_url = url_helpers.show_path(identifier_str)
+        ezid_client.update_metadata(identifier_str, dc3_xml, landing_page_url)
+      end
+
+      private
+
+      def tenant
+        resource.tenant
+      end
+
+      def ezid_client
+        @ezid_client ||= begin
+          id_params = tenant.identifier_service
+          StashEzid::Client.new(
+            shoulder: id_params.shoulder,
+            account: id_params.account,
+            password: id_params.password,
+            owner: id_params.owner,
+            id_scheme: id_params.scheme
+          )
+        end
+      end
+    end
+  end
+end

data/lib/stash/merritt/module_info.rb

@@ -0,0 +1,12 @@
+module Stash
+  module Merritt
+    # The name of this gem
+    NAME = 'stash-merritt'.freeze
+
+    # The version of this gem
+    VERSION = '0.0.1'.freeze
+
+    # The copyright notice for this gem
+    COPYRIGHT = 'Copyright (c) 2017 The Regents of the University of California'.freeze
+  end
+end

data/lib/stash/merritt/repository.rb

@@ -0,0 +1,17 @@
+require 'stash/repo'
+require 'stash/merritt/submission_job'
+
+module Stash
+  module Merritt
+    class Repository < Stash::Repo::Repository
+
+      def initialize(url_helpers:)
+        super
+      end
+
+      def create_submission_job(resource_id:)
+        SubmissionJob.new(resource_id: resource_id, url_helpers: url_helpers)
+      end
+    end
+  end
+end

data/lib/stash/merritt/submission_job.rb

@@ -0,0 +1,90 @@
+require 'stash/repo'
+require 'stash/merritt/ezid_helper'
+require 'stash/merritt/submission_package'
+require 'stash/merritt/sword_helper'
+
+module Stash
+  module Merritt
+    class SubmissionJob < Stash::Repo::SubmissionJob
+      attr_reader :resource_id
+      attr_reader :url_helpers
+
+      def initialize(resource_id:, url_helpers:)
+        @resource_id = resource_id
+        @url_helpers = url_helpers
+      end
+
+      def submit!
+        log.info("#{Time.now.xmlschema} #{description}")
+        do_submit!
+      rescue => e
+        Stash::Repo::SubmissionResult.failure(resource_id: resource_id, request_desc: description, error: e)
+      end
+
+      def description
+        @description ||= begin
+          resource = StashEngine::Resource.find(resource_id)
+          description_for(resource)
+        rescue => e
+          log.error("Can't find resource #{resource_id}: #{e}\n#{e.backtrace.join("\n")}")
+          "#{self.class} for missing resource #{resource_id}"
+        end
+      end
+
+      private
+
+      def do_submit!
+        package = create_package
+        submit(package)
+        update_metadata(package.dc3_xml)
+        cleanup(package)
+        Stash::Repo::SubmissionResult.success(resource_id: resource_id, request_desc: description, message: 'Success')
+      end
+
+      def resource
+        @resource ||= StashEngine::Resource.find(resource_id)
+      end
+
+      def ezid_helper
+        @ezid_helper ||= EzidHelper.new(resource: resource, url_helpers: url_helpers)
+      end
+
+      def ensure_identifier
+        log.info("#{Time.now.xmlschema} #{self.class}: ensuring identifier for resource #{resource_id} (#{resource.identifier_str})")
+        ezid_helper.ensure_identifier
+      end
+
+      def create_package
+        ensure_identifier
+        log.info("#{Time.now.xmlschema} #{self.class}: creating package for resource #{resource_id} (#{resource.identifier_str})")
+        SubmissionPackage.new(resource: resource)
+      end
+
+      def submit(package)
+        log.info("#{Time.now.xmlschema} #{self.class}: submitting resource #{resource_id} (#{resource.identifier_str})")
+        sword_helper = SwordHelper.new(package: package, logger: log)
+        sword_helper.submit!
+      end
+
+      def update_metadata(dc3_xml)
+        log.info("#{Time.now.xmlschema} #{self.class}: updating identifier metadata for resource #{resource_id} (#{resource.identifier_str})")
+        ezid_helper.update_metadata(dc3_xml: dc3_xml)
+      end
+
+      def cleanup(package)
+        log.info("#{Time.now.xmlschema} #{self.class}: cleaning up temporary files for resource #{resource_id} (#{resource.identifier_str})")
+        package.cleanup!
+      end
+
+      def description_for(resource)
+        msg = "#{self.class} for resource #{resource_id} (#{resource.identifier_str}): "
+        msg << if (update_uri = resource.update_uri)
+                 "posting update to #{update_uri}"
+               else
+                 "posting new object to #{resource.tenant.sword_params[:collection_uri]}"
+               end
+        msg << " (tenant: #{resource.tenant_id})"
+      end
+    end
+  end
+end

data/lib/stash/merritt/submission_package/data_one_manifest_builder.rb

@@ -0,0 +1,41 @@
+require 'stash/repo/file_builder'
+
+module Stash
+  module Merritt
+    class SubmissionPackage
+      class DataONEManifestBuilder < Stash::Repo::FileBuilder
+        HEADER = [
+          '#%dataonem_0.1',
+          '#%profile | http://uc3.cdlib.org/registry/ingest/manifest/mrt-dataone-manifest',
+          '#%prefix | dom: | http://uc3.cdlib.org/ontology/dataonem',
+          '#%prefix | mrt: | http://uc3.cdlib.org/ontology/mom',
+          '#%fields | dom:scienceMetadataFile | dom:scienceMetadataFormat | dom:scienceDataFile | mrt:mimeType'
+        ].join("\n").freeze
+
+        METADATA_FILES = {
+          'mrt-datacite.xml' => 'http://datacite.org/schema/kernel-3.1',
+          'mrt-oaidc.xml' => 'http://dublincore.org/schemas/xmls/qdc/2008/02/11/qualifieddc.xsd'
+        }.freeze
+
+        attr_reader :uploads
+
+        # @param uploads [Array[StashEngine::FileUpload]] a list of file uploads
+        def initialize(uploads)
+          super(file_name: 'mrt-dataone-manifest.txt')
+          @uploads = uploads
+        end
+
+        def contents
+          content = [HEADER]
+          uploads.each do |upload|
+            METADATA_FILES.each do |md_filename, md_schema|
+              content << "#{md_filename} | #{md_schema} | #{upload.upload_file_name} | #{upload.upload_content_type}"
+            end
+          end
+          content << "#%eof\n"
+          content.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/stash/merritt/submission_package/merritt_datacite_builder.rb

@@ -0,0 +1,22 @@
+require 'datacite/mapping/datacite_xml_factory'
+require 'stash/repo/file_builder'
+
+module Stash
+  module Merritt
+    class SubmissionPackage
+      class MerrittDataciteBuilder < Stash::Repo::FileBuilder
+        attr_reader :factory
+
+        # @param factory [DataciteXMLFactory] the Datacite XML factory
+        def initialize(factory)
+          super(file_name: 'mrt-datacite.xml')
+          @factory = factory
+        end
+
+        def contents
+          factory.build_datacite_xml(datacite_3: true)
+        end
+      end
+    end
+  end
+end

data/lib/stash/merritt/submission_package/merritt_delete_builder.rb

@@ -0,0 +1,25 @@
+require 'stash/repo/file_builder'
+
+module Stash
+  module Merritt
+    class SubmissionPackage
+      class MerrittDeleteBuilder < Stash::Repo::FileBuilder
+        attr_reader :resource_id
+
+        def initialize(resource_id:)
+          super(file_name: 'mrt-delete.txt')
+          @resource_id = resource_id
+        end
+
+        def resource
+          @resource ||= StashEngine::Resource.find(resource_id)
+        end
+
+        def contents
+          del_files = resource.file_uploads.deleted
+          del_files.blank? ? nil : del_files.map(&:upload_file_name).join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/stash/merritt/submission_package/merritt_oaidc_builder.rb

@@ -0,0 +1,130 @@
+require 'stash/repo/file_builder'
+
+module Stash
+  module Merritt
+    class SubmissionPackage
+      class MerrittOAIDCBuilder < Stash::Repo::FileBuilder
+        ROOT_ATTRIBUTES = {
+          'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance',
+          'xsi:noNamespaceSchemaLocation' => 'http://dublincore.org/schemas/xmls/qdc/2008/02/11/qualifieddc.xsd',
+          'xmlns:dc' => 'http://purl.org/dc/elements/1.1/',
+          'xmlns:dcterms' => 'http://purl.org/dc/terms/'
+        }.freeze
+
+        DC_RELATION_TYPES = {
+          'cites' => 'references',
+          'iscitedby' => 'isReferencedBy',
+          'isnewversionof' => 'isVersionOf',
+          'ispreviousversionof' => 'hasVersion',
+          'ispartof' => 'isPartOf',
+          'haspart' => 'hasPart'
+        }.freeze
+
+        attr_reader :resource_id
+
+        def initialize(resource_id:)
+          super(file_name: 'mrt-oaidc.xml')
+          @resource_id = resource_id
+        end
+
+        def contents # rubocop:disable Metrics/MethodLength
+          Nokogiri::XML::Builder.new do |xml|
+            xml.qualifieddc(ROOT_ATTRIBUTES) do
+              add_creators(xml)
+              add_contributors(xml)
+              add_title(xml)
+              add_publisher(xml)
+              add_pub_year(xml)
+              add_subjects(xml)
+              add_resource_type(xml)
+              add_rights(xml)
+              add_descriptions(xml)
+              add_related_identifiers(xml)
+            end
+          end.to_xml.to_s
+        end
+
+        private
+
+        def resource
+          @resource ||= StashEngine::Resource.find(resource_id)
+        end
+
+        def tenant
+          resource.tenant
+        end
+
+        def add_creators(xml)
+          resource.creators.each { |c| xml.send(:'dc:creator', c.creator_full_name.delete("\r").to_s) }
+        end
+
+        def add_pub_year(xml)
+          pub_year = resource.publication_years.first
+          xml.send(:'dc:date', pub_year.publication_year) if pub_year
+        end
+
+        def add_publisher(xml)
+          xml.send(:'dc:publisher', (tenant.short_name || tenant.long_name || 'unknown').to_s)
+        end
+
+        def add_title(xml)
+          xml.send(:'dc:title', resource.titles.where(title_type: nil).first.title.to_s)
+        end
+
+        def add_contributors(xml)
+          # Funder contributors are handled under 'add_descriptions' below
+          resource.contributors.where.not(contributor_type: 'funder').each do |c|
+            if (contrib_name = c.contributor_name) && !contrib_name.blank?
+              xml.send(:'dc:contributor', contrib_name.strip)
+            end
+          end
+        end
+
+        def add_subjects(xml)
+          resource.subjects.each { |s| xml.send(:'dc:subject', s.subject.delete("\r").to_s) }
+        end
+
+        def add_resource_type(xml)
+          resource_type = (rt = resource.resource_type) && rt.resource_type_general
+          xml.send(:'dc:type', resource_type.strip) unless resource_type.blank?
+        end
+
+        def add_rights(xml)
+          resource.rights.each do |r|
+            xml.send(:'dc:rights', r.rights.to_s)
+            xml.send(:'dcterms:license', r.rights_uri.to_s, 'xsi:type' => 'dcterms:URI')
+          end
+        end
+
+        def add_descriptions(xml)
+          strip_desc_linefeeds(xml)
+          resource.contributors.where(contributor_type: 'funder').each do |c|
+            xml.send(:'dc:description', to_dc_description(c))
+          end
+        end
+
+        def to_dc_description(contributor)
+          contrib_name = contributor.contributor_name
+          award_num = contributor.award_number
+          desc_text = 'Data were created'
+          desc_text << " with funding from #{contrib_name}" unless contrib_name.blank?
+          desc_text << " under grant(s) #{award_num}" unless award_num.blank?
+        end
+
+        def strip_desc_linefeeds(xml)
+          resource.descriptions.each do |d|
+            desc_text = d.description.to_s.delete("\r")
+            xml.send(:'dc:description', desc_text.to_s) unless desc_text.blank?
+          end
+        end
+
+        def add_related_identifiers(xml)
+          resource.related_identifiers.each do |r|
+            dc_relation_type = DC_RELATION_TYPES[r.relation_type] || 'relation'
+            xml.send(:"dcterms:#{dc_relation_type}", "#{r.related_identifier_type_friendly}: #{r.related_identifier}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stash/merritt/submission_package/stash_wrapper_builder.rb

@@ -0,0 +1,59 @@
+require 'stash/wrapper'
+require 'stash/repo/file_builder'
+
+module Stash
+  module Merritt
+    class SubmissionPackage
+      class StashWrapperBuilder < Stash::Repo::FileBuilder
+        include Stash::Wrapper
+        attr_reader :dcs_resource
+        attr_reader :uploads
+        attr_reader :version_number
+
+        def initialize(dcs_resource:, version_number:, uploads:)
+          super(file_name: 'stash-wrapper.xml')
+          @dcs_resource = dcs_resource
+          @version_number = version_number
+          @uploads = uploads
+        end
+
+        def contents
+          StashWrapper.new(
+            identifier: to_sw_identifier(dcs_resource.identifier),
+            version: Version.new(number: version_number, date: Date.today),
+            license: to_sw_license(dcs_resource.rights_list),
+            inventory: to_sw_inventory(uploads),
+            descriptive_elements: [dcs_resource.save_to_xml]
+          ).write_xml
+        end
+
+        private
+
+        def to_sw_identifier(dcs_identifier)
+          return unless dcs_identifier
+          raise "Invalid identifier type; expected DOI, was #{dcs_identifier.identifier_type}" unless dcs_identifier.identifier_type == 'DOI'
+          Identifier.new(type: IdentifierType::DOI, value: dcs_identifier.value)
+        end
+
+        def to_sw_license(dcs_rights_list)
+          return unless dcs_rights_list && !dcs_rights_list.empty?
+          dcs_rights = dcs_rights_list[0]
+          License.new(name: dcs_rights.value, uri: dcs_rights.uri)
+        end
+
+        def to_sw_inventory(uploads)
+          return unless uploads
+          Inventory.new(files: uploads.map { |upload| to_stash_file(upload) })
+        end
+
+        def to_stash_file(upload)
+          StashFile.new(
+            pathname: upload.upload_file_name,
+            size_bytes: upload.upload_file_size,
+            mime_type: upload.upload_content_type
+          )
+        end
+      end
+    end
+  end
+end