ddr-models 2.0.1 → 2.1.0.rc1

data/lib/ddr/models/base.rb

@@ -5,8 +5,6 @@ module Ddr
       include Describable
       include Governable
       include AccessControllable
-      include Licensable
-      include HasProperties
       include HasThumbnail
       include EventLoggable
       include FixityCheckable

data/lib/ddr/models/describable.rb

@@ -72,7 +72,7 @@ module Ddr
 
     module ClassMethods
       def find_by_identifier(identifier)
-        find(Ddr::IndexFields::IDENTIFIER_ALL => identifier)
+        find(Ddr::Index::Fields::IDENTIFIER_ALL => identifier)
       end
     end
 

data/lib/ddr/models/effective_license.rb

@@ -0,0 +1,9 @@
+module Ddr::Models
+  class EffectiveLicense
+
+    def self.call(obj)
+      License.call(obj) || InheritedLicense.call(obj)
+    end
+
+  end
+end

data/lib/ddr/models/engine.rb

@@ -79,6 +79,19 @@ module Ddr
         end
       end
 
+      initializer "fits_home" do
+        Ddr::Models.fits_home = ENV["FITS_HOME"]
+      end
+
+      initializer "ddr_antivirus" do
+        require "ddr-antivirus"
+        if Rails.env.test?
+          Ddr::Antivirus.test_mode!
+        else
+          Ddr::Antivirus.scanner_adapter = :clamd
+        end
+      end
+
     end
   end
 end

data/lib/ddr/models/file_management.rb

@@ -1,198 +1,195 @@
-require "ddr-antivirus"
+module Ddr::Models
+  module FileManagement
+    extend ActiveSupport::Concern
 
-module Ddr
-  module Models
-    module FileManagement
-      extend ActiveSupport::Concern
+    EXTERNAL_FILE_PERMISSIONS = 0644
 
-      EXTERNAL_FILE_PERMISSIONS = 0644
+    included do
+      attr_accessor :file_to_add
 
-      included do
-        attr_accessor :file_to_add
+      define_model_callbacks :add_file
+      before_add_file :virus_scan
 
-        define_model_callbacks :add_file
-        before_add_file :virus_scan
+      after_save :notify_virus_scan_results
 
-        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
+      # 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])
-          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])
         end
-
-        # clear the instance data
-        self.file_to_add = nil
       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={}
-        file_path = Ddr::Utils.file_path(file) # raises ArgumentError
-
-        # Retrieve or create the datastream
-        ds = datastreams.include?(dsid) ? datastreams[dsid] : add_external_datastream(dsid)
+      # clear the instance data
+      self.file_to_add = nil
+    end
 
-        unless ds.external?
-          raise ArgumentError, "Cannot add external file to datastream with controlGroup \"#{ds.controlGroup}\""
-        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={}
+      file_path = Ddr::Utils.file_path(file) # raises ArgumentError
 
-        if ds.dsLocation_changed?
-          raise Ddr::Models::Error, "Cannot add external file to datastream when dsLocation change is pending."
-        end
+      # Retrieve or create the datastream
+      ds = datastreams.include?(dsid) ? datastreams[dsid] : add_external_datastream(dsid)
 
-        # 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)
+      unless ds.external?
+        raise ArgumentError, "Cannot add external file to datastream with controlGroup \"#{ds.controlGroup}\""
+      end
 
-        # 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
+      if ds.dsLocation_changed?
+        raise Ddr::Models::Error, "Cannot add external file to datastream when dsLocation change is pending."
+      end
 
-        # set appropriate permissions on the file
-        set_external_file_permissions!(store_path)
+      # 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)
 
-        # set dsLocation to file URI for storage path
-        ds.dsLocation = Ddr::Utils.path_to_uri(store_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
 
-      # 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
+      # set appropriate permissions on the file
+      set_external_file_permissions!(store_path)
 
-      #
-      # 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)
-      end
+      # set dsLocation to file URI for storage path
+      ds.dsLocation = Ddr::Utils.path_to_uri(store_path)
+    end
 
-      def external_datastreams
-        datastreams.values.select { |ds| ds.external? }
-      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
 
-      def external_datastream_file_paths
-        external_datastreams.map(&:file_paths).flatten
-      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)
+    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
-      end
+    def external_datastreams
+      datastreams.values.select { |ds| ds.external? }
+    end
 
-      protected
+    def external_datastream_file_paths
+      external_datastreams.map(&:file_paths).flatten
+    end
 
-      FileToAdd = Struct.new(:file, :dsid, :original_name)
+    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
+    end
 
-      def virus_scan_results
-        @virus_scan_results ||= []
-      end
+    protected
 
-      def virus_scan
-        path = Ddr::Utils.file_path(file_to_add[:file])
-        virus_scan_results << Ddr::Antivirus::Scanner.scan(path)
-      rescue ArgumentError => e # file is a blob
-        logger.error(e)
-      end
+    FileToAdd = Struct.new(:file, :dsid, :original_name)
 
-      def notify_virus_scan_results
-        while result = virus_scan_results.shift
-          ActiveSupport::Notifications.instrument(Ddr::Notifications::VIRUS_CHECK, result: result, pid: pid)
-        end
-      end
+    def virus_scan_results
+      @virus_scan_results ||= []
+    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
-        end
-      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 set_external_file_permissions! file_path
-        File.chmod(EXTERNAL_FILE_PERMISSIONS, file_path)
+    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
 
-      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"
-          end
-        else
-          content_file_name
-        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
       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 set_external_file_permissions! file_path
+      File.chmod(EXTERNAL_FILE_PERMISSIONS, file_path)
+    end
 
-      def cleanup_external_files_on_destroy
-        paths = external_datastream_file_paths
-        yield
-        File.unlink *paths
+    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"
+        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

data/lib/ddr/models/governable.rb

@@ -27,10 +27,6 @@ module Ddr
         end
       end
 
-      def inherited_license
-        admin_policy.default_license if admin_policy
-      end
-
       def copy_admin_policy_from(other)
         # XXX In active-fedora 7.0 can do
         # self.admin_policy = other.admin_policy

data/lib/ddr/models/has_admin_metadata.rb

@@ -1,78 +1,86 @@
 require "resque"
 
-module Ddr
-  module Models
-    module HasAdminMetadata
-      extend ActiveSupport::Concern
-
-      included do
-        has_metadata "adminMetadata",
-          type: Ddr::Datastreams::AdministrativeMetadataDatastream,
-          versionable: true,
-          control_group: "M"
-
-        has_attributes :admin_set,
-                       :display_format,
-                       :local_id,
-                       :permanent_id,
-                       :permanent_url,
-                       :research_help_contact,
-                       :workflow_state,
-          datastream: "adminMetadata",
-          multiple: false
-
-        delegate :publish, :publish!, :unpublish, :unpublish!, :published?, to: :workflow
-
-        after_create :assign_permanent_id!, if: "Ddr::Models.auto_assign_permanent_ids"
-        around_destroy :update_permanent_id_on_destroy, if: "permanent_id.present?"
-      end
-
-      def permanent_id_manager
-        @permanent_id_manager ||= Ddr::Managers::PermanentIdManager.new(self)
-      end
-
-      def roles
-        Ddr::Auth::Roles::PropertyRoleSet.new(adminMetadata.access_role)
-      end
-
-      def inherited_roles
-        Ddr::Auth::InheritedRoles.call(self)
-      end
-
-      def workflow
-        @workflow ||= Ddr::Managers::WorkflowManager.new(self)
-      end
-
-      def assign_permanent_id!
-        permanent_id_manager.assign_later
-      end
-
-      def grant_roles_to_creator(creator)
-        roles.grant type: Ddr::Auth::Roles::EDITOR,
-                    agent: creator,
-                    scope: Ddr::Auth::Roles::RESOURCE_SCOPE
-      end
-
-      def copy_resource_roles_from(other)
-        roles.grant *(other.roles.in_resource_scope)
-      end
-
-      def effective_permissions(agents)
-        Ddr::Auth::EffectivePermissions.call(self, agents)
-      end
-
-      def research_help
-        Ddr::Contacts.get(research_help_contact) if research_help_contact
-      end
-
-      private
-
-      def update_permanent_id_on_destroy
-        @permanent_id = permanent_id
-        yield
-        Resque.enqueue(Ddr::Jobs::PermanentId::MakeUnavailable, @permanent_id, "deleted")
-      end
+module Ddr::Models
+  module HasAdminMetadata
+    extend ActiveSupport::Concern
+
+    included do
+      has_metadata "adminMetadata",
+                   type: Ddr::Datastreams::AdministrativeMetadataDatastream,
+                   versionable: true,
+                   control_group: "M"
+
+      has_attributes :admin_set,
+                     :depositor,
+                     :display_format,
+                     :license,
+                     :local_id,
+                     :permanent_id,
+                     :permanent_url,
+                     :research_help_contact,
+                     :workflow_state,
+                     datastream: "adminMetadata",
+                     multiple: false
+
+      delegate :publish, :publish!, :unpublish, :unpublish!, :published?, to: :workflow
+
+      after_create :assign_permanent_id!, if: "Ddr::Models.auto_assign_permanent_ids"
+      around_destroy :update_permanent_id_on_destroy, if: "permanent_id.present?"
+    end
+
+    def permanent_id_manager
+      @permanent_id_manager ||= Ddr::Managers::PermanentIdManager.new(self)
+    end
+
+    def roles
+      Ddr::Auth::Roles::PropertyRoleSet.new(adminMetadata.access_role)
+    end
+
+    def inherited_roles
+      Ddr::Auth::InheritedRoles.call(self)
+    end
+
+    def workflow
+      @workflow ||= Ddr::Managers::WorkflowManager.new(self)
+    end
+
+    def assign_permanent_id!
+      permanent_id_manager.assign_later
+    end
+
+    def grant_roles_to_creator(creator)
+      roles.grant type: Ddr::Auth::Roles::EDITOR,
+                  agent: creator,
+                  scope: Ddr::Auth::Roles::RESOURCE_SCOPE
+    end
 
+    def copy_resource_roles_from(other)
+      roles.grant *(other.roles.in_resource_scope)
     end
+
+    def effective_permissions(agents)
+      Ddr::Auth::EffectivePermissions.call(self, agents)
+    end
+
+    def research_help
+      Ddr::Contacts.get(research_help_contact) if research_help_contact
+    end
+
+    def effective_license
+      EffectiveLicense.call(self)
+    end
+
+    def inherited_license
+      InheritedLicense.call(self)
+    end
+
+    private
+
+    def update_permanent_id_on_destroy
+      @permanent_id = permanent_id
+      yield
+      Resque.enqueue(Ddr::Jobs::PermanentId::MakeUnavailable, @permanent_id, "deleted")
+    end
+
   end
 end