ddr-models 2.11.0 → 3.0.0.alpha.1

data/lib/ddr/models/base.rb

@@ -1,15 +1,6 @@
 module Ddr
   module Models
     class Base < ActiveFedora::Base
-      extend Deprecation
-
-      self.deprecation_horizon = 'ddr-models v3.0'
-
-      # Lifecycle events
-      INGEST = "ingest.repo_object"
-      UPDATE = "update.repo_object"
-      DELETE = "delete.repo_object"
-      DEACCESSION = "deaccession.repo_object"
 
       include Describable
       include Governable
@@ -20,41 +11,9 @@ module Ddr
       include Indexing
       include Hydra::Validations
       include HasAdminMetadata
-      extend Deprecation
-
-      # Prevent accidental use of #delete which lacks callbacks
-      private :delete
-
-      define_model_callbacks :deaccession
-
-      before_create :set_ingestion_date, unless: :ingestion_date
-      before_create :set_ingested_by, if: :performed_by, unless: :ingested_by
-      before_create :grant_default_roles
-
-      around_save :notify_update, unless: :new_record?
-      around_save :assign_permanent_id!, if: :assign_permanent_id?, on: :create
-
-      after_create :notify_ingest
-
-      around_deaccession :notify_deaccession
-      around_destroy :notify_delete
 
-      def rights_statement
-        RightsStatement.call(self)
-      end
-      alias_method :effective_license, :rights_statement
-      deprecation_deprecate :effective_license
-
-      def deaccession
-        run_callbacks :deaccession do
-          delete
-        end
-      end
-
-      def copy_admin_policy_or_permissions_from(other)
-        Deprecation.warn(self.class, "`copy_admin_policy_or_permissions_from` is deprecated." \
-                                     " Use `copy_admin_policy_or_roles_from` instead.")
-        copy_admin_policy_or_roles_from(other)
+      after_destroy do
+        notify_event :deletion
       end
 
       def copy_admin_policy_or_roles_from(other)
@@ -62,8 +21,7 @@ module Ddr
       end
 
       def association_query(association)
-        # XXX Ideally we would include a clause to limit by AF model, but this should suffice
-        ActiveFedora::SolrService.construct_query_for_rel(reflections[association].options[:property] => internal_uri)
+        raise NotImplementedError, "The previous implementation does not work with ActiveFedora 9."
       end
 
       # e.g., "Collection duke:1"
@@ -83,127 +41,49 @@ module Ddr
         false
       end
 
-      def publishable?
-        raise NotImplementedError, "Must be implemented by subclasses"
-      end
-
-      def save(options={})
-        cache.with(options) { super }
-      end
-
-      def datastreams_changed
-        datastreams.select { |dsid, ds| ds.changed? }
-      end
-
-      def new_datastreams_having_content
-        datastreams.select { |dsid, ds| ds.new? && ds.has_content? }
-      end
-
-      def datastreams_having_content
-        datastreams.select { |dsid, ds| ds.has_content? }
-      end
-      alias_method :attached_files_having_content, :datastreams_having_content
-      alias_method :datastreams_to_validate, :datastreams_having_content
-      deprecation_deprecate :datastreams_to_validate
-
-      def datastream_history
-        datastreams_having_content.each_with_object({}) do |(dsid, ds), memo|
-          memo[dsid] = ds.version_history
-        end
-      end
-
-      def parent_id
-        parent.id
-      rescue NoMethodError
-        nil
-      end
-
-      private
-
-      def grant_default_roles
-        roles.grant *default_roles
-      end
-
-      def default_roles
-        []
-      end
-
-      def cache
-        @__cache ||= Cache.new
-      end
-
-      def performed_by
-        if user = cache.get(:user)
-          user.to_s
+      # Moves the first (descriptive metadata) identifier into
+      # (administrative metadata) local_id according to the following
+      # rubric:
+      #
+      # No existing local_id:
+      #   - Set local_id to first identifier value
+      #   - Remove first identifier value
+      #
+      # Existing local_id:
+      #   Same as first identifier value
+      #     - Remove first identifier value
+      #   Not same as first identifier value
+      #     :replace option is true
+      #       - Set local_id to first identifier value
+      #       - Remove first identifier value
+      #     :replace option is false
+      #       - Do nothing
+      #
+      # Returns true or false depending on whether the object was
+      # changed by this method
+      def move_first_identifier_to_local_id(replace: true)
+        moved = false
+        identifiers = descMetadata.identifier.to_a
+        first_id = identifiers.shift
+        if first_id
+          if local_id.blank?
+            self.local_id = first_id
+            self.descMetadata.identifier = identifiers
+            moved = true
+          else
+            if local_id == first_id
+              self.descMetadata.identifier = identifiers
+              moved = true
+            else
+              if replace
+                self.local_id = first_id
+                self.descMetadata.identifier = identifiers
+                moved = true
+              end
+            end
+          end
         end
-      end
-
-      def set_ingested_by
-        self.ingested_by = performed_by
-      end
-
-      def set_ingestion_date
-        self.ingestion_date = Time.now.utc.iso8601
-      end
-
-      def default_notification_payload
-        cache.slice(:summary, :comment, :detail)
-          .merge(pid: pid,
-                 user_key: performed_by,
-                 permanent_id: permanent_id,
-                 model: self.class.to_s,
-                 parent: parent_id,
-                 skip_structure_updates: cache.fetch(:skip_structure_updates, false))
-      end
-
-      def notify_ingest
-        payload = default_notification_payload.merge(
-          event_date_time: ingestion_date,
-          datastreams_changed: attached_files_having_content.keys
-        )
-        ActiveSupport::Notifications.instrument(INGEST, payload)
-      end
-
-      def notify_update
-        event_params = default_notification_payload.merge(
-          attributes_changed: changes,
-          datastreams_changed: datastreams_changed.keys,
-          new_datastreams: new_datastreams_having_content.keys,
-          skip_update_derivatives: cache.fetch(:skip_update_derivatives, false)
-        )
-        ActiveSupport::Notifications.instrument(UPDATE, event_params) do |payload|
-          yield
-          payload[:event_date_time] = modified_date
-        end
-      end
-
-      def delete_notification_payload
-        default_notification_payload.merge(
-          datastream_history: datastream_history,
-          create_date: create_date,
-          modified_date: modified_date
-        )
-      end
-
-      def notify_deaccession
-        ActiveSupport::Notifications.instrument(DEACCESSION, delete_notification_payload) do |payload|
-          yield
-        end
-      end
-
-      def notify_delete
-        ActiveSupport::Notifications.instrument(DELETE, delete_notification_payload) do |payload|
-          yield
-        end
-      end
-
-      def assign_permanent_id?
-        permanent_id.nil? && Ddr::Models.auto_assign_permanent_id
-      end
-
-      def assign_permanent_id!
-        yield
-        PermanentId.assign!(self)
+        moved
       end
 
     end

data/lib/ddr/models/describable.rb

@@ -1,17 +1,17 @@
-module Ddr
-  module Models
-    module Describable
-      extend ActiveSupport::Concern
+module Ddr::Models
+  module Describable
+    extend ActiveSupport::Concern
 
     included do
-      has_metadata name: Ddr::Datastreams::DESC_METADATA,
-                   type: Ddr::Datastreams::DescriptiveMetadataDatastream,
-                   versionable: true,
-                   label: "Descriptive Metadata for this object",
-                   control_group: 'M'
-      has_attributes *Ddr::Vocab::Vocabulary.term_names(RDF::DC11),
-                     datastream: Ddr::Datastreams::DESC_METADATA,
-                     multiple: true
+      DescriptiveMetadata.mapping.each do |name, term|
+        property name, predicate: term.predicate do |index|
+          index.as :stored_searchable
+        end
+      end
+    end
+
+    def descMetadata
+      @descMetadata ||= DescriptiveMetadata.new(self)
     end
 
     def has_desc_metadata?
@@ -19,7 +19,7 @@ module Ddr
     end
 
     def desc_metadata_terms *args
-      return Ddr::Datastreams::DescriptiveMetadataDatastream.term_names if args.empty?
+      return DescriptiveMetadata.unqualified_names.sort if args.empty?
       arg = args.pop
       terms = case arg.to_sym
               when :empty
@@ -31,8 +31,8 @@ module Ddr
               when :required
                 desc_metadata_terms(:defined_attributes).select {|t| required? t}
               when :dcterms
-                Ddr::Vocab::Vocabulary.term_names(RDF::DC11) +
-                      (Ddr::Vocab::Vocabulary.term_names(RDF::DC) - Ddr::Vocab::Vocabulary.term_names(RDF::DC11))
+                MetadataMapper.dc11.unqualified_names +
+                  (MetadataMapper.dcterms.unqualified_names - MetadataMapper.dc11.unqualified_names)
               when :dcterms_elements11
                 Ddr::Vocab::Vocabulary.term_names(RDF::DC11)
               when :duke
@@ -48,11 +48,10 @@ module Ddr
     end
 
     def desc_metadata_attributes
-      defattrs = self.class.defined_attributes
-      defattrs.keys.select {|k| defattrs[k].dsid == "descMetadata"}.map(&:to_sym)
+      MetadataMapper.dc11.unqualified_names
     end
 
-    def desc_metadata_values term
+    def desc_metadata_values(term)
       descMetadata.values term
     end
 
@@ -60,13 +59,13 @@ module Ddr
       descMetadata.class.vocabularies
     end
 
-    def set_desc_metadata_values term, values
+    def set_desc_metadata_values(term, values)
       descMetadata.set_values term, values
     end
 
     # Update all descMetadata terms with values in hash
     # Note that term not having key in hash will be set to nil!
-    def set_desc_metadata term_values_hash
+    def set_desc_metadata(term_values_hash)
       desc_metadata_terms.each { |t| set_desc_metadata_values(t, term_values_hash[t]) }
     end
 
@@ -76,6 +75,5 @@ module Ddr
       end
     end
 
-    end
   end
 end

data/lib/ddr/models/engine.rb

@@ -17,46 +17,27 @@ module Ddr
       # Initializers
       #
 
-      initializer "active_fedora.content_model" do
-        ActiveFedora::ContentModel.module_eval do
-          # Returns the first known model for the object is equal to or a
-          # subclass of the object's class.
-          # This bubbles up, e.g., to prevent mis-casting via `.find`.
-          def self.best_model_for(obj)
-            known_models_for(obj).find { |model| model <= obj.class }
-          end
-        end
-      end
-
-      initializer "active_fedora.finder_methods" do
-        ActiveFedora::FinderMethods.module_eval do
-          # Override tries to cast by default
-          def load_from_fedora(pid, cast)
-            inner = ActiveFedora::DigitalObject.find(klass, pid)
-            obj = klass.allocate.init_with_object(inner)
-            if cast != false
-              obj = obj.adapt_to_cmodel
-            end
-            obj
-          end
-        end
-      end
-
       initializer "ddr_models.derivatives" do
         Ddr::Derivatives.update_derivatives = ENV['DERIVATIVES'] ?
                                                 ENV['DERIVATIVES'].split(';').map { |deriv| deriv.strip.to_sym } :
                                                 [ :thumbnail ]
       end
 
-      initializer "ddr_models.image_server" do
-        Ddr::Models.image_server_url = ENV["IMAGE_SERVER_URL"]
+      initializer "ddr_models.external_files" do
+        Ddr::Models.external_file_store = ENV["EXTERNAL_FILE_STORE"]
+        Ddr::Models.multires_image_external_file_store = ENV["MULTIRES_IMAGE_EXTERNAL_FILE_STORE"]
+        Ddr::Models.external_file_subpath_pattern = ENV["EXTERNAL_FILE_SUBPATH_PATTERN"] || "--"
       end
 
-      # Add custom predicates to ActiveFedora
-      initializer "ddr_models.predicates" do
-        ActiveFedora::Predicates.set_predicates(Ddr::Metadata::PREDICATES)
+      initializer "ddr_models.image_server" do
+        Ddr::Models.image_server_url = ENV["IMAGE_SERVER_URL"]
       end
 
+      # # Add custom predicates to ActiveFedora
+      # initializer "ddr_models.predicates" do
+      #   ActiveFedora::Predicates.set_predicates(Ddr::Metadata::PREDICATES)
+      # end
+      # 
       # Set superuser group
       initializer "ddr_auth.superuser" do
         Ddr::Auth.superuser_group = ENV["SUPERUSER_GROUP"]
@@ -66,11 +47,6 @@ module Ddr
         Ddr::Auth.collection_creators_group = ENV["COLLECTION_CREATORS_GROUP"]
       end
 
-      # Set metadata managers group
-      initializer "ddr_auth.metadata_managers_group" do
-        Ddr::Auth.metadata_managers_group = ENV["METADATA_MANAGERS_GROUP"]
-      end
-
       initializer "ezid_client" do
         unless Rails.env.production?
           require "ezid/test_helper"
@@ -82,10 +58,6 @@ module Ddr
         Ddr::Models.fits_home = ENV["FITS_HOME"]
       end
 
-      initializer "vips_path" do
-        Ddr::Models.vips_path = ENV["VIPS_PATH"]
-      end
-
       initializer "ddr_antivirus" do
         require "ddr-antivirus"
         if Rails.env.test?

data/lib/ddr/models/error.rb

@@ -11,8 +11,5 @@ module Ddr
 
     # Content model casting error
     class ContentModelError < Error; end
-
-    # A model instance was not found
-    class NotFoundError < Error; end
   end
 end

data/lib/ddr/models/file_management.rb

@@ -3,96 +3,60 @@ module Ddr::Models
     extend ActiveSupport::Concern
 
     included do
+      attr_accessor :file_to_add
+
       define_model_callbacks :add_file
       before_add_file :virus_scan
-      after_add_file :set_original_filename
-      after_save :create_virus_check_event
-    end
 
-    FileToAdd = Struct.new(:dsid, :source_path, :original_filename)
+      after_save :notify_virus_scan_results
 
-    # @param file [String, File, ActionDispatch::Http::UploadedFile]
-    #   The file, or path to file, to add.
-    # @param dsid [String] The datastream ID to which file should be added.
-    # @param mime_type [String] Explicit mime type to set
-    #   (otherwise discerned from file path or name).
-    # @param external [Boolean] Add file to external datastream.
-    #   Not required for external datastream classes
-    #   or datastream instances having controlGroup 'E'.
-    def add_file(file, dsid, mime_type: nil, external: false, original_filename: nil)
-      mime_type         ||= MediaType.call(file) # XXX Should we use original_filename, if present?
-      source_path         = Ddr::Utils.file_path(file)
-      original_filename ||= Ddr::Utils.file_name(file)
-      file_to_add = FileToAdd.new(dsid, source_path, original_filename)
-      cache.with(file_to_add: file_to_add) do
-        run_callbacks(:add_file) do
-          if external || ( datastreams.include?(dsid) && datastreams[dsid].external? )
-            add_external_file(file, dsid, mime_type: mime_type)
-          else
-            add_file_datastream(file, dsid: dsid, mimeType: mime_type)
-          end
-        end
-      end
     end
 
-    def add_file_datastream(file, opts={})
-      if Ddr::Utils.file_path?(file)
-        file = File.new(file, "rb")
-      end
-      super
-    end
+    # Adds ActiveFedora::File
+    # Overrides ActiveFedora::AttachedFiles#add_file(file, opts)
+    #
+    # Options:
+    #
+    #   :path - The path of the child resource to create
+    #
+    #   :mime_type - Explicit mime type to set (otherwise discerned from file path or name)
+    #
+    #   :original_name - A String value will be understood as the original name of the file.
+    #                    Default processing will take the file basename as the original name.
+    def add_file file, opts={}
+      opts[:mime_type] ||= Ddr::Utils.mime_type_for(file)
+      opts[:original_name] ||= Ddr::Utils.file_name_for(file)
 
-    # @api private
-    # Normally this method should not be called directly.
-    # Call `add_file` with dsid for external datastream, or with
-    # `:external=>true` option if no spec for dsid.
-    def add_external_file(file, dsid, mime_type: nil)
-      file_path = Ddr::Utils.file_path(file) # raises ArgumentError
-      ds = datastreams[dsid] || add_external_datastream(dsid)
-      unless ds.external?
-        raise ArgumentError, "Cannot add external file to non-external datastream."
+      # @file_to_add is set for callbacks to access the data
+      self.file_to_add = file
+
+      run_callbacks(:add_file) do
+        super
       end
-      ds.add_file(file_path, mime_type: mime_type)
-    end
 
-    def external_datastreams
-      datastreams.values.select { |ds| ds.external? }
+      # clear the instance data
+      self.file_to_add = nil
     end
 
-    def external_datastream_file_paths
-      external_datastreams.map(&:file_paths).flatten
-    end
+    protected
 
-    def add_external_datastream dsid, opts={}
-      create_datastream(Ddr::Datastreams::ExternalFileDatastream, dsid).tap do |ds|
-        add_datastream(ds)
-        self.class.build_datastream_accessor(dsid)
-      end
-    end
+    FileToAdd = Struct.new(:file, :dsid, :original_name)
 
-    protected
+    def virus_scan_results
+      @virus_scan_results ||= []
+    end
 
     def virus_scan
-      file_to_add = cache.get(:file_to_add)
-      result = Ddr::Actions::VirusCheck.call(file_to_add.source_path)
-      if file_to_add.dsid == Ddr::Datastreams::CONTENT
-        cache.put(:virus_scan_result, result)
-      end
-    rescue ArgumentError => e # file is a blob (string)
+      path = Ddr::Utils.file_path(file_to_add)
+      virus_scan_results << Ddr::Actions::VirusCheck.call(path)
+    rescue ArgumentError => e # file is a blob
       logger.error(e)
     end
 
-    def create_virus_check_event
-      if result = cache.get(:virus_scan_result)
-        Ddr::Events::VirusCheckEvent.create(result.merge(pid: pid))
-      end
-    end
-
-    def set_original_filename
-      if file_to_add = cache.get(:file_to_add)
-        if file_to_add.dsid == Ddr::Datastreams::CONTENT
-          self.original_filename = file_to_add.original_filename
-        end
+    def notify_virus_scan_results
+      while result = virus_scan_results.shift
+        result.merge! pid: pid
+        ActiveSupport::Notifications.instrument(Ddr::Notifications::VIRUS_CHECK, result)
       end
     end