dor-services 8.6.0 → 9.0.0

data/lib/dor/release_tags/purl.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module Dor
-  module ReleaseTags
-    class Purl
-      # Determine projects in which an item is released
-      # @param [String] pid identifier of the item to get the release tags for
-      def initialize(pid:, purl_host:)
-        Deprecation.warn(self, "Dor::ReleaseTags::Purl is deprecated and will be removed in dor-services 9.0. (it's moving to dor-services-app)")
-        @pid = pid
-        @purl_host = purl_host
-      end
-
-      # This function calls purl and gets a list of all release tags currently in purl.  It then compares to the list you have generated.
-      # Any tag that is on purl, but not in the newly generated list is added to the new list with a value of false.
-      # @param new_tags [Hash{String => Boolean}] all new tags in the form of !{"Project" => Boolean}
-      # @return [Hash{String => Boolean}] all namespaces, keys are Project name Strings, values are Boolean
-      def released_for(new_tags)
-        missing_tags = release_tags_from_purl.map(&:downcase) - new_tags.keys.map(&:downcase)
-        missing_tags.each do |missing_tag|
-          new_tags[missing_tag.capitalize] = { 'release' => false }
-        end
-        new_tags
-      end
-
-      private
-
-      # Pull all release nodes from the public xml obtained via the purl query
-      # @param doc [Nokogiri::HTML::Document] The druid of the object you want
-      # @return [Array] An array containing all the release tags
-      def release_tags_from_purl_xml(doc)
-        nodes = doc.xpath('//publicObject/releaseData').children
-        # We only want the nodes with a name that isn't text
-        nodes.reject { |n| n.name.nil? || n.name.casecmp('text') == 0 }.map { |n| n.attr('to') }.uniq
-      end
-
-      # Pull all release nodes from the public xml obtained via the purl query
-      # @return [Array] An array containing all the release tags
-      def release_tags_from_purl
-        release_tags_from_purl_xml(purl_client.fetch)
-      end
-
-      def purl_client
-        PurlClient.new(host: @purl_host,
-                       pid: pid)
-      end
-
-      attr_reader :pid
-    end
-  end
-end

data/lib/dor/release_tags/purl_client.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module Dor
-  module ReleaseTags
-    # Calls the purl service and returns the XML document
-    class PurlClient
-      def initialize(host:, pid:)
-        @host = host
-        @pid = pid
-      end
-
-      # Get XML from the purl service
-      # Fetches purl xml for a druid
-      # @raise [OpenURI::HTTPError]
-      # @return [Nokogiri::HTML::Document] parsed XML for the druid or an empty document if no purl is found
-      def fetch
-        handler = proc do |exception, attempt_number, total_delay|
-          # We assume a 404 means the document has never been published before and thus has no purl
-          Dor.logger.warn "[Attempt #{attempt_number}] GET #{url} -- #{exception.class}: #{exception.message}; #{total_delay} seconds elapsed."
-          raise exception unless exception.is_a? OpenURI::HTTPError
-          return Nokogiri::HTML::Document.new if exception.io.status.first == '404' # ["404", "Not Found"] from OpenURI::Meta.status
-        end
-
-        with_retries(max_retries: 3, base_sleep_seconds: 3, max_sleep_seconds: 5, handler: handler) do |attempt|
-          # If you change the method used for opening the webpage, you can change the :rescue param to handle the new method's errors
-          Dor.logger.debug "[Attempt #{attempt}] GET #{url}"
-          return Nokogiri::XML(OpenURI.open_uri(url))
-        end
-      end
-
-      private
-
-      # Take the and create the entire purl url that will usable for the open method in open-uri, returns http
-      # @return [String] the full url
-      def url
-        @url ||= "https://#{@host}/#{druid_without_prefix}.xml"
-      end
-
-      def druid_without_prefix
-        PidUtils.remove_druid_prefix(@pid)
-      end
-    end
-  end
-end

data/lib/dor/services/release_tag_service.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module Dor
-  class ReleaseTagService
-    # Determine projects in which an item is released
-    # @param [Dor::Item] item to get the release tags for
-    # @return [Hash{String => Boolean}] all namespaces, keys are Project name Strings, values are Boolean
-    def self.for(item)
-      new(item)
-    end
-
-    def initialize(item)
-      Deprecation.warn(self, "Dor::ReleaseTagService is deprecated and will be removed in dor-services 9.0. (it's moving to dor-services-app)")
-      @identity_metadata_service = ReleaseTags::IdentityMetadata.new(item)
-      @purl_service = ReleaseTags::Purl.new(pid: item.pid, purl_host: Dor::Config.stacks.document_cache_host)
-    end
-
-    # Called in Dor::UpdateMarcRecordService (in dor-services-app too)
-    # Determine projects in which an item is released
-    # @return [Hash{String => Boolean}] all namespaces, keys are Project name Strings, values are Boolean
-    def released_for(skip_live_purl:)
-      released_hash = identity_metadata_service.released_for({})
-      released_hash = purl_service.released_for(released_hash) unless skip_live_purl
-      released_hash
-    end
-
-    # Helper method to get the release tags as a nodeset
-    # @return [Hash] all release tags and their attributes
-    delegate :release_tags, to: :identity_metadata_service
-
-    # Take a hash of tags as obtained via Dor::Item.release_tags and returns the newest tag for each namespace
-    # @param tags [Hash] a hash of tags obtained via Dor::Item.release_tags or matching format
-    # @return [Hash] a hash of latest tags for each to value
-    delegate :newest_release_tag, to: :identity_metadata_service
-
-    private
-
-    attr_reader :identity_metadata_service, :purl_service
-  end
-end

data/lib/dor/services/state_service.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Dor
-  class StateService
-    extend Deprecation
-
-    # having version is preferred as without it, a call to
-    # fedora will be made to retrieve it.
-    def initialize(pid, version: nil)
-      Deprecation.warn(self, 'Dor::StateService is deprecated and will be removed in dor-services 9')
-      @pid = pid
-      @version = version || fetch_version
-    end
-
-    def allows_modification?
-      !client.lifecycle('dor', pid, 'submitted') ||
-        client.active_lifecycle('dor', pid, 'opened', version: version) ||
-        client.workflow_status('dor', pid, 'accessionWF', 'sdr-ingest-transfer') == 'hold'
-    end
-
-    private
-
-    attr_reader :pid, :version
-
-    def fetch_version
-      Deprecation.warn(self, 'Calling the state service without passing in a version is deprecated and will be removed in dor-services 9')
-      Dor.find(pid).current_version
-    end
-
-    def client
-      Dor::Config.workflow.client
-    end
-  end
-end

data/lib/dor/services/status_service.rb

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-module Dor
-  # Query the processing status of an item.
-  # This has a dependency on the workflow service (app) to get milestones.
-  class StatusService
-    # verbiage we want to use to describe an item when it has completed a particular step
-    STATUS_CODE_DISP_TXT = {
-      0 => 'Unknown Status', # if there are no milestones for the current version, someone likely messed up the versioning process.
-      1 => 'Registered',
-      2 => 'In accessioning',
-      3 => 'In accessioning (described)',
-      4 => 'In accessioning (described, published)',
-      5 => 'In accessioning (described, published, deposited)',
-      6 => 'Accessioned',
-      7 => 'Accessioned (indexed)',
-      8 => 'Accessioned (indexed, ingested)',
-      9 => 'Opened'
-    }.freeze
-
-    # milestones from accessioning and the order they happen in
-    STEPS = {
-      'registered' => 1,
-      'submitted' => 2,
-      'described' => 3,
-      'published' => 4,
-      'deposited' => 5,
-      'accessioned' => 6,
-      'indexed' => 7,
-      'shelved' => 8,
-      'opened' => 9
-    }.freeze
-
-    # @return [Hash{Symbol => Object}] including :current_version, :status_code and :status_time
-    def self.status_info(work)
-      new(work).status_info
-    end
-
-    def self.status(work, include_time = false)
-      new(work).status(include_time)
-    end
-
-    def initialize(work)
-      @work = work
-    end
-
-    # @return [Hash{Symbol => Object}] including :current_version, :status_code and :status_time
-    def status_info
-      # if we have an accessioned milestone, this is the last possible step and should be the status regardless of time stamp
-      accessioned_milestones = current_milestones.select { |m| m[:milestone] == 'accessioned' }
-      return { current_version: current_version, status_code: STEPS['accessioned'], status_time: accessioned_milestones.last[:at].utc.xmlschema } unless accessioned_milestones.empty?
-
-      status_code = 0
-      status_time = nil
-      # for each milestone in the current version, see if it comes at the same time or after the current 'last' step, if so, make it the last and record the date/time
-      current_milestones.each do |m|
-        m_name = m[:milestone]
-        m_time = m[:at].utc.xmlschema
-        next unless STEPS.key?(m_name) && (!status_time || m_time >= status_time)
-
-        status_code = STEPS[m_name]
-        status_time = m_time
-      end
-
-      { current_version: current_version, status_code: status_code, status_time: status_time }
-    end
-
-    # @param [Boolean] include_time
-    # @return [String] single composed status from status_info
-    def status(include_time = false)
-      status_info_hash = status_info
-      current_version = status_info_hash[:current_version]
-      status_code = status_info_hash[:status_code]
-      status_time = status_info_hash[:status_time]
-
-      # use the translation table to get the appropriate verbage for the latest step
-      result = "v#{current_version} #{STATUS_CODE_DISP_TXT[status_code]}"
-      result += " #{format_date(status_time)}" if include_time
-      result
-    end
-
-    def milestones
-      @milestones ||= Dor::Config.workflow.client.milestones('dor', work.pid)
-    end
-
-    private
-
-    attr_reader :work
-
-    def current_version
-      @current_version ||= begin
-                             work.versionMetadata.current_version_id
-                           rescue StandardError
-                             '1'
-                           end
-    end
-
-    def current_milestones
-      current = []
-      # only get steps that are part of accessioning and part of the current version. That can mean they were archived with the current version
-      # number, or they might be active (no version number).
-      milestones.each do |m|
-        if STEPS.key?(m[:milestone]) && (m[:version].nil? || m[:version] == current_version)
-          current << m unless m[:milestone] == 'registered' && current_version.to_i > 1
-        end
-      end
-      current
-    end
-
-    # handles formating utc date/time to human readable
-    # XXX: bad form to hardcode TZ here.
-    def format_date(datetime)
-      d =
-        if datetime.is_a?(Time)
-          datetime
-        else
-          DateTime.parse(datetime).in_time_zone(ActiveSupport::TimeZone.new('Pacific Time (US & Canada)'))
-        end
-      I18n.l(d).strftime('%Y-%m-%d %I:%M%p')
-    rescue StandardError
-      d = datetime.is_a?(Time) ? datetime : Time.parse(datetime.to_s)
-      d.strftime('%Y-%m-%d %I:%M%p')
-    end
-  end
-end

data/lib/dor/static_config/workflow_config.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module Dor
-  class StaticConfig
-    # Represents the configuration for the workflow service
-    class WorkflowConfig
-      def initialize(hash)
-        @url = hash.fetch(:url)
-        @timeout = hash.fetch(:timeout)
-        @logfile = hash.fetch(:logfile)
-        @shift_age = hash.fetch(:shift_age)
-      end
-
-      def configure(&block)
-        instance_eval(&block)
-      end
-
-      def client
-        @client ||= Dor::Workflow::Client.new(url: url, logger: client_logger, timeout: timeout)
-      end
-
-      def url(new_value = nil)
-        @url = new_value if new_value
-        @url
-      end
-
-      def timeout(new_value = nil)
-        @timeout = new_value if new_value
-        @timeout
-      end
-
-      def logfile(new_value = nil)
-        @logfile = new_value if new_value
-        @logfile
-      end
-
-      def shift_age(new_value = nil)
-        @shift_age = new_value if new_value
-        @shift_age
-      end
-
-      def client_logger
-        if logfile && shift_age
-          Logger.new(logfile, shift_age)
-        elsif logfile
-          Logger.new(logfile)
-        end
-      end
-    end
-  end
-end

data/lib/dor/workflow/document.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-module Dor
-  module Workflow
-    class Document
-      include ::OM::XML::Document
-
-      set_terminology do |t|
-        t.root(path: 'workflow')
-        t.repository(path: { attribute: 'repository' })
-        t.workflowId(path: { attribute: 'id' })
-        t.process do
-          t.name_(path: { attribute: 'name' })
-          t.status(path: { attribute: 'status' })
-          t.timestamp(path: { attribute: 'datetime' }) # , :data_type => :date)
-          t.elapsed(path: { attribute: 'elapsed' })
-          t.lifecycle(path: { attribute: 'lifecycle' })
-          t.attempts(path: { attribute: 'attempts' }, index_as: [:not_searchable])
-          t.version(path: { attribute: 'version' })
-        end
-      end
-
-      @@definitions = {}
-
-      def initialize(node)
-        Deprecation.warn(self, 'Dor::Workflow::Document is deprecated and will be removed from dor-services version 9')
-        self.ng_xml = Nokogiri::XML(node)
-      end
-
-      # @return [Dor::WorkflowDefinitionDs]
-      def definition
-        @definition ||= begin
-          if @@definitions.key? workflowId.first
-            @@definitions[workflowId.first]
-          else
-            wfo = Dor::WorkflowObject.find_by_name(workflowId.first)
-            wf_def = wfo ? wfo.definition : nil
-            @@definitions[workflowId.first] = wf_def
-            wf_def
-          end
-        end
-      end
-
-      def [](value)
-        processes.find { |p| p.name == value }
-      end
-
-      def processes
-        # if the workflow service didnt return any processes, dont return any processes from the reified wf
-        return [] if ng_xml.search('/workflow/process').length == 0
-
-        @processes ||=
-          if definition
-            definition.processes.collect do |process|
-              nodes = ng_xml.xpath("/workflow/process[@name = '#{process.name}']")
-              node = nodes.max { |a, b| a.attr('version').to_i <=> b.attr('version').to_i }
-              process.update!(node, self)
-            end
-          else
-            find_by_terms(:workflow, :process).collect do |x|
-              pnode = Dor::Workflow::Process.new(repository, workflowId, {})
-              pnode.update!(x, self)
-            end.sort_by(&:datetime)
-          end
-      end
-
-      def inspect
-        "#<#{self.class.name}:#{object_id}>"
-      end
-    end
-  end
-end

data/lib/dor/workflow/process.rb

@@ -1,157 +0,0 @@
-# frozen_string_literal: true
-
-module Dor
-  module Workflow
-    class Process
-      attr_reader :owner, :repo, :workflow
-
-      # @param repo [String] the name of the repository, typically 'dor'
-      # @param workflow [String] the name of the workflow, e.g. 'assemblyWF'
-      # @param attrs [Nokogiri::XML::Node, Hash]
-      def initialize(repo, workflow, attrs)
-        Deprecation.warn(self, 'Dor::Workflow::Process is deprecated and will be removed from dor-services version 9')
-        @workflow = workflow
-        @repo = repo
-        if attrs.is_a? Nokogiri::XML::Node
-          init_from_node(attrs)
-        else
-          @attrs = attrs
-        end
-      end
-
-      def init_from_node(node)
-        @attrs = {
-          'name' => node['name'],
-          'sequence' => node['sequence'] ? node['sequence'].to_i : nil,
-          'status' => node['status'], # TODO: see how this affects argo
-          'lifecycle' => node['lifecycle'],
-          'label' => node.at_xpath('label/text()').to_s,
-          'batch_limit' => node['batch-limit'] ? node['batch-limit'].to_i : nil,
-          'error_limit' => node['error-limit'] ? node['error-limit'].to_i : nil,
-          'priority' => node['priority'] ? node['priority'].to_i : 0,
-          'prerequisite' => node.xpath('prereq').collect do |p|
-            repo = p['repository'].nil? || p['repository'] == @repo ? nil : p['repository']
-            wf   = p['workflow'].nil? || p['workflow'] == @workflow ? nil : p['workflow']
-            [repo, wf, p.text.to_s].compact.join(':')
-          end
-        }
-      end
-
-      def name
-        @attrs['name']
-      end
-
-      def sequence
-        @attrs['sequence']
-      end
-
-      def lifecycle
-        @attrs['lifecycle']
-      end
-
-      def label
-        @attrs['label']
-      end
-
-      def batch_limit
-        @attrs['batch_limit']
-      end
-
-      def error_limit
-        @attrs['error_limit']
-      end
-
-      def error_message
-        @attrs['errorMessage']
-      end
-
-      def prerequisite
-        @attrs['prerequisite']
-      end
-
-      def status
-        @attrs['status']
-      end
-
-      def note
-        @attrs['note']
-      end
-
-      def version
-        @attrs['version']
-      end
-
-      def priority
-        @attrs['priority']
-      end
-
-      def completed?
-        status == 'completed'
-      end
-
-      def error?
-        status == 'error'
-      end
-
-      def waiting?
-        status == 'waiting'
-      end
-
-      def date_time
-        @attrs['datetime']
-      end
-
-      def archived?
-        @attrs['archived'] =~ /true$/i
-      end
-
-      def ready?
-        waiting? && !prerequisite.nil? && prerequisite.all? { |pr| (prq = owner[pr]) && prq.completed? }
-      end
-
-      def blocked?
-        waiting? && !prerequisite.nil? && prerequisite.any? { |pr| (prq = owner[pr]) && (prq.error? || prq.blocked?) }
-      end
-
-      def state
-        if blocked?
-          'blocked'
-        elsif ready?
-          'ready'
-        else
-          status
-        end
-      end
-
-      def attempts
-        @attrs['attempts'].to_i
-      end
-
-      def datetime
-        @attrs['datetime'] ? Time.parse(@attrs['datetime']) : nil
-      end
-
-      def elapsed
-        @attrs['elapsed'].nil? ? nil : @attrs['elapsed'].to_f
-      end
-
-      # Updates this object with the attributes passed in.
-      # @param info [Hash,Nokogiri::XML::Element,NilClass]
-      # @param new_owner [Dor::Workflow::Document]
-      def update!(info, new_owner)
-        raise ArgumentError, 'Owner can not be nil. It must be an instance of Dor::Workflow::Document' unless new_owner
-
-        @owner = new_owner
-        return self if info.nil?
-
-        info = Hash[info.attributes.collect { |k, v| [k, v.value] }] if info.is_a? Nokogiri::XML::Node
-        @attrs.merge! info
-        self
-      end
-
-      def to_hash
-        @attrs.reject { |_k, v| v.nil? || v == 0 || (v.respond_to?(:empty?) && v.empty?) }
-      end
-    end
-  end
-end