ddr-models 2.6.2 → 2.7.0.rc1

data/lib/ddr/models/base.rb

@@ -2,9 +2,14 @@ module Ddr
   module Models
     class Base < ActiveFedora::Base
 
+      # Lifecycle events
+      INGEST = "ingest.repo_object"
+      UPDATE = "update.repo_object"
+      DELETE = "delete.repo_object"
+      DEACCESSION = "deaccession.repo_object"
+
       include Describable
       include Governable
-      include AccessControllable
       include HasThumbnail
       include EventLoggable
       include FixityCheckable
@@ -12,21 +17,24 @@ 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, only: :around
+      define_model_callbacks :deaccession
 
-      extend Deprecation
-      # Deprecate Hydra permissions-related methods
-      deprecation_deprecate *(Hydra::AccessControls::Permissions.public_instance_methods)
+      before_create :set_ingestion_date, unless: :ingestion_date
+      before_create :set_ingested_by, if: :performed_by, unless: :ingested_by
+      before_create :grant_default_roles
+
+      after_create :notify_ingest
+      after_create :assign_permanent_id!, if: :assign_permanent_id?
+
+      around_save :notify_update, unless: :new_record?
 
-      around_save :notify_save
-      around_save :notify_workflow_change, if: [:workflow_state_changed?, :persisted?]
-      after_create :assign_permanent_id, if: :assign_permanent_id?
       around_deaccession :notify_deaccession
-      around_destroy :notify_destroy
+      around_destroy :notify_delete
 
       def deaccession
         run_callbacks :deaccession do
@@ -66,88 +74,104 @@ module Ddr
         false
       end
 
-      def legacy_authorization
-        Ddr::Auth::LegacyAuthorization.new(self)
-      end
-
-      # 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 = identifier.to_a
-        first_id = identifiers.shift
-        if first_id
-          if local_id.blank?
-            self.local_id = first_id
-            self.identifier = identifiers
-            moved = true
-          else
-            if local_id == first_id
-              self.identifier = identifiers
-              moved = true
-            else
-              if replace
-                self.local_id = first_id
-                self.identifier = identifiers
-                moved = true
-              end
-            end
-          end
-        end
-        moved
-      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 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
+
       private
 
-      def notify_save
-        ActiveSupport::Notifications.instrument("save.#{self.class.to_s.underscore}",
-                                                pid: pid,
-                                                changes: changes,
-                                                created: new_record?) do |payload|
-          yield
+      def grant_default_roles
+        if default_roles.present?
+          roles.grant *default_roles
         end
       end
 
-      def notify_workflow_change
-        ActiveSupport::Notifications.instrument("#{workflow_state}.workflow.#{self.class.to_s.underscore}", pid: pid) do |payload|
+      def default_roles
+        []
+      end
+
+      def cache
+        @__cache ||= Cache.new
+      end
+
+      def performed_by
+        if user = cache.get(:user)
+          user.to_s
+        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)
+      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
+        )
+        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.#{self.class.to_s.underscore}",
-                                                pid: pid,
-                                                permanent_id: permanent_id) do |payload|
+        ActiveSupport::Notifications.instrument(DEACCESSION, delete_notification_payload) do |payload|
           yield
         end
       end
 
-      def notify_destroy
-        ActiveSupport::Notifications.instrument("destroy.#{self.class.to_s.underscore}",
-                                                pid: pid,
-                                                permanent_id: permanent_id) do |payload|
+      def notify_delete
+        ActiveSupport::Notifications.instrument(DELETE, delete_notification_payload) do |payload|
           yield
         end
       end
@@ -156,7 +180,7 @@ module Ddr
         permanent_id.nil? && Ddr::Models.auto_assign_permanent_id
       end
 
-      def assign_permanent_id
+      def assign_permanent_id!
         PermanentId.assign!(self)
       end
 

data/lib/ddr/models/cache.rb

@@ -0,0 +1,20 @@
+module Ddr::Models
+  class Cache < Hash
+
+    def get(key)
+      self[key]
+    end
+
+    def put(key, value)
+      self[key] = value
+    end
+
+    def with(options, &block)
+      merge!(options)
+      block_result = yield
+      reject! { |k, v| options.include?(k) }
+      block_result
+    end
+
+  end
+end

data/lib/ddr/models/engine.rb

@@ -48,12 +48,6 @@ module Ddr
                                                 [ :thumbnail ]
       end
 
-      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
-
       initializer "ddr_models.image_server" do
         Ddr::Models.image_server_url = ENV["IMAGE_SERVER_URL"]
       end
@@ -88,6 +82,10 @@ 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/file_management.rb

@@ -2,115 +2,57 @@ module Ddr::Models
   module FileManagement
     extend ActiveSupport::Concern
 
-    EXTERNAL_FILE_PERMISSIONS = 0644
-
     included do
-      attr_accessor :file_to_add
-
       define_model_callbacks :add_file
       before_add_file :virus_scan
-
-      after_save :notify_virus_scan_results
-
-      # Deleting the datastream external files on destroying the object can't
-      # be handled with a datastream around_destroy callback.
-      # See https://groups.google.com/d/msg/hydra-tech/xJaZr2wVhbg/4iafvso98w8J
-      around_destroy :cleanup_external_files_on_destroy
-    end
-
-    # add_file(file, dsid, opts={})
-    #
-    # Comparable to Hydra::ModelMethods#add_file(file, dsid, file_name)
-    #
-    # Options:
-    #
-    #   :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.
-    #                    `false` or `nil` indicate that the file basename is not the original
-    #                    name. Default processing will take the file basename as the original
-    #                    name.
-    #
-    #   :external - Add to file to external datastream. Not required for datastream specs
-    #               where :control_group=>"E".
-    #
-    #   :use_original - For external datastream file, do not copy file to new file path,
-    #                   but use in place (set dsLocation to file URI for current path.
-    def add_file file, dsid, opts={}
-      opts[:mime_type] ||= Ddr::Utils.mime_type_for(file)
-
-      # @file_to_add is set for callbacks to access the data
-      original_name = opts.fetch(:original_name, Ddr::Utils.file_name_for(file))
-      self.file_to_add = FileToAdd.new(file, dsid, original_name)
-
-      run_callbacks(:add_file) do
-        if opts.delete(:external) || datastreams.include?(dsid) && datastreams[dsid].external?
-          add_external_file(file, dsid, opts)
-        else
-          file = File.new(file, "rb") if Ddr::Utils.file_path?(file)
-          # ActiveFedora method accepts file-like objects, not paths
-          add_file_datastream(file, dsid: dsid, mimeType: opts[:mime_type])
+      after_add_file :set_original_filename
+      after_save :create_virus_check_event
+    end
+
+    FileToAdd = Struct.new(:dsid, :source_path, :original_filename)
+
+    # @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)
+      mime_type       ||= Ddr::Utils.mime_type_for(file)
+      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
 
-      # clear the instance data
-      self.file_to_add = nil
+    def add_file_datastream(file, opts={})
+      if Ddr::Utils.file_path?(file)
+        file = File.new(file, "rb")
+      end
+      super
     end
 
-    # Normally this method should not be called directly. Call `add_file` with dsid for
-    # external datastream id, or with `:external=>true` option if no spec for dsid.
-    def add_external_file file, dsid, opts={}
+    # @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
-
-      # Retrieve or create the datastream
-      ds = datastreams.include?(dsid) ? datastreams[dsid] : add_external_datastream(dsid)
-
+      ds = datastreams[dsid] || add_external_datastream(dsid)
       unless ds.external?
-        raise ArgumentError, "Cannot add external file to datastream with controlGroup \"#{ds.controlGroup}\""
+        raise ArgumentError, "Cannot add external file to non-external datastream."
       end
-
-      if ds.dsLocation_changed?
-        raise Ddr::Models::Error, "Cannot add external file to datastream when dsLocation change is pending."
-      end
-
-      # Set the MIME type
-      # The :mime_type option will be present when called from `add_file`.
-      # The fallback is there in case `add_external_file` is called directly.
-      ds.mimeType = opts[:mime_type] || Ddr::Utils.mime_type_for(file, file_path)
-
-      # Copy the file to storage unless we're using the original
-      if opts[:use_original]
-        raise Ddr::Models::Error, "Cannot add file to repository that is owned by another user." unless File.owned?(file_path)
-        store_path = file_path
-      else
-        # generate new storage path for file
-        store_path = create_external_file_path!(ds)
-        # copy the original file to the storage location
-        FileUtils.cp file_path, store_path
-      end
-
-      # set appropriate permissions on the file
-      set_external_file_permissions!(store_path)
-
-      # set dsLocation to file URI for storage path
-      ds.dsLocation = Ddr::Utils.path_to_uri(store_path)
-    end
-
-    # Create directory (if necessary) for newly generated file path and return path
-    def create_external_file_path! ds
-      file_path = generate_external_file_path(ds)
-      FileUtils.mkdir_p(File.dirname(file_path))
-      file_path
-    end
-
-    #
-    # Generates a new external file storage location
-    #
-    # => {external_file_store}/1/e/69/1e691815-0631-4f9b-8e23-2dfb2eec9c70
-    #
-    def generate_external_file_path ds
-      file_name = generate_external_file_name(ds)
-      File.join(external_file_store(ds.dsid), generate_external_directory_subpath, file_name)
+      ds.add_file(file_path, mime_type: mime_type)
     end
 
     def external_datastreams
@@ -122,74 +64,37 @@ module Ddr::Models
     end
 
     def add_external_datastream dsid, opts={}
-      klass = self.class.datastream_class_for_name(dsid)
-      datastream = create_datastream(klass, dsid, controlGroup: "E")
-      add_datastream(datastream)
-      self.class.build_datastream_accessor(dsid)
-      datastream
+      create_datastream(Ddr::Datastreams::ExternalFileDatastream, dsid).tap do |ds|
+        add_datastream(ds)
+        self.class.build_datastream_accessor(dsid)
+      end
     end
 
     protected
 
-    FileToAdd = Struct.new(:file, :dsid, :original_name)
-
-    def virus_scan_results
-      @virus_scan_results ||= []
-    end
-
     def virus_scan
-      path = Ddr::Utils.file_path(file_to_add[:file])
-      virus_scan_results << Ddr::Actions::VirusCheck.call(path)
-    rescue ArgumentError => e # file is a blob
-      logger.error(e)
-    end
-
-    def notify_virus_scan_results
-      while result = virus_scan_results.shift
-        result.merge! pid: pid
-        ActiveSupport::Notifications.instrument(Ddr::Notifications::VIRUS_CHECK, result)
+      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)
+      logger.error(e)
     end
 
-    def external_file_store dsid
-      case dsid
-      when Ddr::Datastreams::MULTIRES_IMAGE
-        Ddr::Models.multires_image_external_file_store
-      else
-        Ddr::Models.external_file_store
+    def create_virus_check_event
+      if result = cache.get(:virus_scan_result)
+        Ddr::Events::VirusCheckEvent.create(result.merge(pid: pid))
       end
     end
 
-    def set_external_file_permissions! file_path
-      File.chmod(EXTERNAL_FILE_PERMISSIONS, file_path)
-    end
-
-    def generate_external_file_name ds
-      content_file_name = Ddr::Utils::sanitize_filename(original_filename) || datastreams[ds.dsid].default_file_name
-      case ds.dsid
-      when Ddr::Datastreams::MULTIRES_IMAGE
-        case ds.mimeType
-        when "image/tiff"
-          "#{File.basename(content_file_name, File.extname(content_file_name))}.ptif"
+    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
-      else
-        content_file_name
       end
     end
 
-    def generate_external_directory_subpath
-      subdir = SecureRandom.uuid
-      m = Ddr::Models.external_file_subpath_regexp.match(subdir)
-      raise "File name does not match external file subpath pattern: #{file_name}" unless m
-      subpath_segments = m.to_a[1..-1]
-      File.join *subpath_segments, subdir
-    end
-
-    def cleanup_external_files_on_destroy
-      paths = external_datastream_file_paths
-      yield
-      File.unlink *paths
-    end
-
   end
 end