sdr-client 2.12.0 → 2.13.0.beta1

data/lib/sdr_client/redesigned_client/cli.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+require 'byebug'
+require 'launchy'
+require 'thor'
+require_relative 'cli/config'
+require_relative 'cli/credentials'
+require_relative 'cli/update'
+
+module SdrClient
+  class RedesignedClient
+    # The SDR command-line interface
+    class CLI < Thor
+      include Thor::Actions
+
+      # Make sure Thor commands preserve exit statuses
+      # @see https://github.com/rails/thor/wiki/Making-An-Executable
+      def self.exit_on_failure?
+        true
+      end
+
+      # Print out help and exit with error code if command not found
+      def self.handle_no_command_error(command)
+        puts "Command '#{command}' not found, displaying help:"
+        puts
+        puts help
+        exit(1)
+      end
+
+      def self.default_url
+        'https://sdr-api-prod.stanford.edu'
+      end
+
+      package_name 'sdr'
+
+      class_option :url, desc: 'URL of SDR API endpoint', type: :string, default: default_url
+
+      desc 'get DRUID', 'Retrieve an object from the SDR'
+      def get(druid)
+        say client.find(object_id: druid)
+      end
+
+      desc 'version', 'Display the SDR CLI version'
+      def version
+        say VERSION
+      end
+
+      desc 'update DRUID', 'Update an object in the SDR'
+      option :skip_polling, type: :boolean, default: false, aliases: '-s',
+                            desc: 'Print out job ID instead of polling for result'
+      option :apo, desc: 'Druid identifier of the admin policy object', aliases: '--admin-policy'
+      option :collection, desc: 'Druid identifier of the collection object'
+      option :copyright, desc: 'Copyright statement'
+      option :use_and_reproduction, desc: 'Use and reproduction statement'
+      option :license, desc: 'License URI'
+      option :view, enum: %w[world stanford location-based citation-only dark], desc: 'Access view level for the object'
+      option :download, enum: %w[world stanford location-based none], desc: 'Access download level for the object'
+      option :location, enum: %w[spec music ars art hoover m&m], desc: 'Access location for the object'
+      option :cdl, type: :boolean, default: false, desc: 'Controlled digital lending'
+      option :cocina_file, desc: 'Path to a file containing Cocina JSON'
+      option :cocina_pipe, type: :boolean, default: false, desc: 'Indicate Cocina JSON is being piped in'
+      option :basepath, default: Dir.getwd, desc: 'Base path for the files'
+      def update(druid)
+        validate_druid!(druid)
+        # Make sure client is configured
+        client
+        job_id = CLI::Update.run(druid, **options)
+        if options[:skip_polling]
+          say "job ID #{job_id} queued (not polling because `-s` flag was supplied)"
+          return
+        end
+
+        job_status = client.job_status(job_id: job_id)
+        if job_status.wait_until_complete
+          say "success! (druid: #{job_status.druid})"
+        else
+          say_error "errored! #{job_status.errors}"
+        end
+      end
+
+      desc 'deposit OPTIONAL_FILES', 'Deposit (accession) an object into the SDR'
+      option :skip_polling, type: :boolean, default: false, aliases: '-s',
+                            desc: 'Print out job ID instead of polling for result'
+      option :apo, required: true, desc: 'Druid identifier of the admin policy object', aliases: '--admin-policy'
+      option :source_id, required: true, desc: 'Source ID for this object'
+      option :label, desc: 'Object label'
+      option :type, enum: %w[image book document map manuscript media three_dimensional object collection admin_policy],
+                    desc: 'The object type'
+      option :collection, desc: 'Druid identifier of the collection object'
+      option :catkey, desc: 'Symphony catkey for this item'
+      option :folio_instance_hrid, desc: 'Folio instance HRID for this item'
+      option :copyright, desc: 'Copyright statement'
+      option :use_and_reproduction, desc: 'Use and reproduction statement'
+      option :viewing_direction, enum: %w[left-to-right right-to-left], desc: 'Viewing direction (if a book)'
+      option :view, enum: %w[world stanford location-based citation-only dark], desc: 'Access view level for the object'
+      option :files_metadata, desc: 'JSON string representing per-file metadata'
+      option :grouping_strategy, enum: %w[default filename], desc: 'Strategy for grouping files into filesets'
+      option :basepath, default: Dir.getwd, desc: 'Base path for the files'
+      def deposit(*files)
+        register_or_deposit(files: files, accession: true)
+      end
+
+      desc 'register OPTIONAL_FILES', 'Create a draft object in the SDR and retrieve a Druid identifier'
+      option :skip_polling, type: :boolean, default: false, aliases: '-s',
+                            desc: 'Print out job ID instead of polling for result'
+      option :apo, required: true, desc: 'Druid identifier of the admin policy object', aliases: '--admin-policy'
+      option :source_id, required: true, desc: 'Source ID for this object'
+      option :label, desc: 'Object label'
+      option :type, enum: %w[image book document map manuscript media three_dimensional object collection admin_policy],
+                    desc: 'The object type'
+      option :collection, desc: 'Druid identifier of the collection object'
+      option :catkey, desc: 'Symphony catkey for this item'
+      option :folio_instance_hrid, desc: 'Folio instance HRID for this item'
+      option :copyright, desc: 'Copyright statement'
+      option :use_and_reproduction, desc: 'Use and reproduction statement'
+      option :viewing_direction, enum: %w[left-to-right right-to-left], desc: 'Viewing direction (if a book)'
+      option :view, enum: %w[world stanford location-based citation-only dark], desc: 'Access view level for the object'
+      option :files_metadata, desc: 'JSON string representing per-file metadata'
+      option :grouping_strategy, enum: %w[default filename], desc: 'Strategy for grouping files into filesets'
+      option :basepath, default: Dir.getwd, desc: 'Base path for the files'
+      def register(*files)
+        register_or_deposit(files: files, accession: false)
+      end
+
+      private
+
+      def client
+        SdrClient::RedesignedClient.configure(
+          url: options[:url],
+          token: Credentials.read || SdrClient::RedesignedClient.default_token,
+          token_refresher: -> { login_via_proxy }
+        )
+      end
+
+      def login_via_proxy
+        say 'Opened the configured authentication proxy in your browser. ' \
+            'Once there, generate a new token and copy the entire value.'
+        Launchy.open(authentication_proxy_url)
+        # Some CLI environments will pop up a message about opening the URL in
+        # an existing browse. Since this is OS-dependency, and not something
+        # we can control via Launchy, just wait a bit before rendering the
+        # `ask` prompt so it's clearer to the user what's happening
+        sleep 0.5
+        token_string = ask('Paste token here:')
+        expiry = JSON.parse(token_string)['exp']
+        CLI::Credentials.write(token_string)
+        say "You are now authenticated for #{options[:url]} until #{expiry}"
+        token_string
+      end
+
+      def authentication_proxy_url
+        Settings.authentication_proxy_url[options[:url]]
+      end
+
+      def register_or_deposit(files:, accession:)
+        opts = munge_options(options, files, accession)
+        job_id = client.build_and_deposit(apo: options[:apo], source_id: options[:source_id], **opts)
+        if opts.delete(:skip_polling)
+          say "job ID #{job_id} queued (not polling because `-s` flag was supplied)"
+          return
+        end
+
+        job_status = client.job_status(job_id: job_id)
+        if job_status.wait_until_complete
+          say "success! (druid: #{job_status.druid})"
+        else
+          say_error "errored! #{job_status.errors}"
+        end
+      end
+
+      def munge_options(options, files, accession)
+        options.to_h.symbolize_keys.tap do |opts|
+          opts[:access] = accession
+          opts[:type] = Cocina::Models::ObjectType.public_send(options[:type]) if options[:type]
+          opts[:files] = expand_files(files) if files.present?
+          opts[:files_metadata] = JSON.parse(options[:files_metadata]) if options[:files_metadata]
+          opts.delete(:apo)
+          opts.delete(:source_id)
+        end
+      end
+
+      def expand_files(files)
+        files.flat_map do |file|
+          next file unless Dir.exist?(file)
+
+          Dir.glob("#{file}/**/*").select { |f| File.file?(f) }
+        end
+      end
+
+      def validate_druid!(druid)
+        return if druid.present?
+
+        say_error "Not a valid druid: #{druid.inspect}"
+        exit(1)
+      end
+    end
+  end
+end

data/lib/sdr_client/redesigned_client/create_resource.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module SdrClient
+  class RedesignedClient
+    # Creates a resource (metadata) in SDR
+    class CreateResource
+      def self.run(...)
+        new(...).run
+      end
+
+      # @param [Boolean] accession should the accessionWF be started
+      # @param [Boolean] assign_doi should a DOI be assigned to this item
+      # @param [Cocina::Models::RequestDRO, Cocina::Models::RequestCollection] metadata
+      # @param [Hash<Symbol,String>] the result of the metadata call
+      # @param [String] priority what processing priority should be used
+      #                          either 'low' or 'default'
+      def initialize(accession:, metadata:, assign_doi: false, priority: nil)
+        @accession = accession
+        @priority = priority
+        @assign_doi = assign_doi
+        @metadata = metadata
+      end
+
+      # @param [Hash<Symbol,String>] the result of the metadata call
+      # @return [String] job id for the background job result
+      def run
+        json = metadata.to_json
+        logger.debug("Starting upload metadata: #{json}")
+
+        response_hash = client.post(
+          path: path,
+          body: json,
+          headers: { 'X-Cocina-Models-Version' => Cocina::Models::VERSION },
+          expected_status: 201
+        )
+
+        logger.info("Response from server: #{response_hash.to_json}")
+
+        response_hash.fetch(:jobId)
+      end
+
+      private
+
+      attr_reader :metadata, :priority
+
+      def logger
+        SdrClient::RedesignedClient.config.logger
+      end
+
+      def client
+        SdrClient::RedesignedClient.instance
+      end
+
+      def accession?
+        @accession
+      end
+
+      def assign_doi?
+        @assign_doi
+      end
+
+      def path
+        params = { accession: accession? }
+        params[:priority] = priority if priority
+        params[:assign_doi] = true if assign_doi? # false is default
+        query_string = params.map { |k, v| "#{k}=#{v}" }.join('&')
+        "/v1/resources?#{query_string}"
+      end
+    end
+  end
+end

data/lib/sdr_client/redesigned_client/deposit.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module SdrClient
+  class RedesignedClient
+    # Deposit into the SDR API
+    class Deposit
+      def self.deposit_model(...)
+        new(...).deposit_model
+      end
+
+      # @param [Cocina::Model::RequestDRO] model for depositing
+      # @param [Boolean] accession should the accessionWF be started
+      # @param [String] basepath filepath to which filepaths are relative
+      # @param [Array<String>] files a list of relative filepaths to upload
+      # @param [Hash] options optional parameters
+      # @option options [Boolean] assign_doi should a DOI be assigned to this item
+      # @option options [String] priority what processing priority should be used ('low', 'default')
+      # @option options [String] grouping_strategy what strategy will be used to group files
+      # @option options [String] file_set_strategy what strategy will be used to group file sets
+      # @option options [RequestBuilder] request_builder a request builder instance
+      def initialize(model:, accession:, basepath:, files: [], **options)
+        @model = model
+        @accession = accession
+        @basepath = basepath
+        @files = files
+        @options = options
+      end
+
+      def deposit_model # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        check_files_exist!
+        child_files_match! unless options[:request_builder]
+
+        file_metadata = UploadFilesMetadataBuilder.build(files: files, mime_types: mime_types, basepath: basepath)
+        upload_responses = UploadFiles.upload(file_metadata: file_metadata,
+                                              filepath_map: filepath_map)
+        if options[:request_builder]
+          @model = StructuralGrouper.group(
+            request_builder: options[:request_builder],
+            upload_responses: upload_responses,
+            grouping_strategy: options[:grouping_strategy],
+            file_set_strategy: options[:file_set_strategy]
+          )
+          child_files_match!
+        end
+
+        new_request_dro = UpdateDroWithFileIdentifiers.update(request_dro: model,
+                                                              upload_responses: upload_responses)
+        CreateResource.run(accession: accession,
+                           priority: options[:priority],
+                           assign_doi: options[:assign_doi],
+                           metadata: new_request_dro)
+      end
+
+      private
+
+      attr_reader :model, :files, :basepath, :accession, :options
+
+      def check_files_exist!
+        SdrClient::RedesignedClient.config.logger.info('checking to see if files exist')
+        files.each do |filepath|
+          raise Errno::ENOENT, filepath unless ::File.exist?(absolute_filepath_for(filepath))
+        end
+      end
+
+      def child_files_match!
+        # Files without request files.
+        files.each do |filepath|
+          raise "Request file not provided for #{filepath}" if request_files[filepath].nil?
+        end
+
+        # Request files without files
+        request_files.each_key do |request_filename|
+          raise "File not provided for request file #{request_filename}" unless files.include?(request_filename)
+        end
+      end
+
+      # Map of relative filepaths to mimetypes
+      def mime_types
+        return mime_types_from_request_builder if options[:request_builder]
+
+        request_files.transform_values { |file| file.hasMimeType || 'application/octet-stream' }
+      end
+
+      def mime_types_from_request_builder
+        files.to_h do |filepath|
+          [filepath, options[:request_builder].for(filepath)['mime_type']]
+        end
+      end
+
+      # Map of absolute filepaths to Cocina::Models::RequestFiles
+      def request_files
+        @request_files ||=
+          if model.structural
+            model.structural.contains.map do |file_set|
+              file_set.structural.contains.map do |file|
+                [file.filename, file]
+              end
+            end.flatten(1).to_h
+          else
+            {}
+          end
+      end
+
+      def absolute_filepath_for(filename)
+        ::File.join(basepath, filename)
+      end
+
+      def filepath_map
+        @filepath_map ||= files.each_with_object({}) do |filepath, obj|
+          obj[filepath] = absolute_filepath_for(filepath)
+        end
+      end
+    end
+  end
+end

data/lib/sdr_client/redesigned_client/direct_upload_request.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module SdrClient
+  class RedesignedClient
+    DirectUploadRequest = Struct.new(:checksum, :byte_size, :content_type, :filename, keyword_init: true) do
+      def self.from_file(path, file_name:, content_type:)
+        checksum = Digest::MD5.file(path).base64digest
+        new(checksum: checksum,
+            byte_size: ::File.size(path),
+            content_type: clean_and_translate_content_type(content_type),
+            filename: file_name)
+      end
+
+      def to_h
+        {
+          blob: { filename: filename, byte_size: byte_size, checksum: checksum,
+                  content_type: self.class.clean_and_translate_content_type(content_type) }
+        }
+      end
+
+      def to_json(*_args)
+        JSON.generate(to_h)
+      end
+
+      # Invalid JSON files with a content type of application/json will trigger 400 errors in sdr-api
+      # since they are parsed and rejected (not clear why and what part of the stack is doing this).
+      # The work around is to change the content_type for any JSON files to a custom stand-in and
+      # specific to avoid the parsing, and then have this translated back to application/json after .
+      # upload is complete. There is a corresponding change in sdr-api to translate the content_type back
+      # before the Cocina is saved.
+      # See https://github.com/sul-dlss/happy-heron/issues/3075 for the original bug report
+      # See https://github.com/sul-dlss/sdr-api/pull/585 for the change in sdr-api
+      def self.clean_and_translate_content_type(content_type)
+        return 'application/octet-stream' if content_type.blank?
+
+        # ActiveStorage is expecting "application/x-stata-dta" not "application/x-stata-dta;version=14"
+        content_type = content_type.split(';')&.first
+
+        content_type == 'application/json' ? 'application/x-stanford-json' : content_type
+      end
+    end
+  end
+end

data/lib/sdr_client/redesigned_client/direct_upload_response.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module SdrClient
+  class RedesignedClient
+    DirectUploadResponse = Struct.new(:id, :key, :checksum, :byte_size, :content_type,
+                                      :filename, :metadata, :created_at, :direct_upload,
+                                      :signed_id, :service_name, keyword_init: true)
+  end
+end

data/lib/sdr_client/redesigned_client/file.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module SdrClient
+  class RedesignedClient
+    # This represents the File metadata that we send to the server for doing a deposit
+    class File
+      # @param [String] external_identifier used for object IDs (e.g., druids)
+      # @param [String] label the required object label
+      # @param [String] filename a filename
+      # @param [Hash] options optional parameters
+      # @option options [String] view the access level for viewing the object
+      # @option options [String] download the access level for downloading the object
+      # @option options [Boolean] preserve whether to preserve the file or not
+      # @option options [Boolean] shelve whether to shelve the file or not
+      # @option options [Boolean] publish whether to publish the file or not
+      # @option options [String] mime_type the MIME type of the file
+      # @option options [String] md5 the MD5 digest of the file
+      # @option options [String] sha1 the SHA1 digest of the file
+      # @option options [String] use the use and reproduction statement
+      def initialize(external_identifier:, label:, filename:, **options)
+        @external_identifier = external_identifier
+        @label = label
+        @filename = filename
+        @options = options
+      end
+
+      def to_h # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        {
+          type: Cocina::Models::ObjectType.file,
+          label: label,
+          filename: filename,
+          externalIdentifier: external_identifier,
+          access: {
+            view: view,
+            download: download
+          },
+          administrative: {
+            sdrPreserve: preserve,
+            shelve: shelve,
+            publish: publish
+          },
+          version: 1,
+          hasMessageDigests: message_digests
+        }.tap do |json|
+          json['hasMimeType'] = mime_type if mime_type
+          json['use'] = use if use
+        end
+      end
+
+      private
+
+      attr_reader :external_identifier, :label, :filename, :options
+
+      def message_digests
+        [].tap do |message_digests|
+          message_digests << { type: 'md5', digest: md5 } if md5
+          message_digests << { type: 'sha1', digest: sha1 } if sha1
+        end
+      end
+
+      def view
+        options.fetch(:view, 'dark')
+      end
+
+      def download
+        options.fetch(:download, 'none')
+      end
+
+      def preserve
+        options.fetch(:preserve, true)
+      end
+
+      def shelve
+        return false if view == 'dark'
+
+        options.fetch(:shelve, true)
+      end
+
+      def publish
+        options.fetch(:publish, true)
+      end
+
+      def mime_type
+        options[:mime_type]
+      end
+
+      def md5
+        options[:md5]
+      end
+
+      def sha1
+        options[:sha1]
+      end
+
+      def use
+        options[:use]
+      end
+    end
+  end
+end

data/lib/sdr_client/redesigned_client/file_set.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module SdrClient
+  class RedesignedClient
+    # This represents the FileSet metadata that we send to the server for doing a deposit
+    class FileSet
+      # @param [String] label
+      # @param [Array] uploads
+      # @param [Hash<String,Hash<String,String>>] uploads_metadata the file level metadata
+      # @param [Array] files
+      # @param [Class] type_strategy (FileTypeFileSetStrategy) a class that helps us determine how to type the fileset
+      def initialize(label:, type_strategy:, uploads: [], uploads_metadata: {}, files: [])
+        @label = label
+        @type_strategy = type_strategy
+        @files = uploads.empty? ? files : files_from(uploads, uploads_metadata)
+      end
+
+      def to_h
+        {
+          type: type_strategy.run(files: files),
+          label: label,
+          structural: {
+            contains: files.map(&:to_h)
+          },
+          version: 1
+        }
+      end
+
+      private
+
+      attr_reader :files, :label, :type_strategy
+
+      def files_from(uploads, uploads_metadata)
+        uploads.map do |upload|
+          SdrClient::RedesignedClient::File.new(**file_args(upload, uploads_metadata.fetch(upload.filename, {})))
+        end
+      end
+
+      # This creates the metadata for each file and symbolizes the keys
+      # @return [Hash<Symbol,String>]
+      def file_args(upload, upload_metadata)
+        args = {
+          external_identifier: upload.signed_id,
+          label: ::File.basename(upload.filename),
+          filename: upload.filename
+        }
+        args.merge!(upload_metadata)
+        # Symbolize
+        args.transform_keys(&:to_sym)
+      end
+    end
+  end
+end

data/lib/sdr_client/redesigned_client/file_type_file_set_strategy.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module SdrClient
+  class RedesignedClient
+    # This strategy is for building the type of a fileset
+    class FileTypeFileSetStrategy
+      # @return [String] The URI that represents the type of file_set
+      def self.run(...)
+        Cocina::Models::FileSetType.file
+      end
+    end
+  end
+end

data/lib/sdr_client/redesigned_client/find.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module SdrClient
+  class RedesignedClient
+    # Find an object
+    class Find
+      def self.run(...)
+        new(...).run
+      end
+
+      # @param [String] object_id an ID for an object
+      def initialize(object_id:)
+        @object_id = object_id
+      end
+
+      # @raise [Failed] if the find operation fails
+      # @return [String] JSON for the given Cocina object or an error
+      def run
+        logger.info("Retrieving metadata from: #{path}")
+        client.get(path: path)
+      end
+
+      private
+
+      attr_reader :object_id
+
+      def logger
+        SdrClient::RedesignedClient.config.logger
+      end
+
+      def client
+        SdrClient::RedesignedClient.instance
+      end
+
+      def path
+        format('/v1/resources/%<object_id>s', object_id: object_id)
+      end
+    end
+  end
+end

data/lib/sdr_client/redesigned_client/image_file_set_strategy.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module SdrClient
+  class RedesignedClient
+    # This strategy is for building the type of a fileset
+    class ImageFileSetStrategy
+      # @return [String] The URI that represents the type of file_set
+      def self.run(...)
+        Cocina::Models::FileSetType.image
+      end
+    end
+  end
+end