ddr-models 1.2.0

data/lib/ddr/metadata/vocabulary.rb

@@ -0,0 +1,37 @@
+module Ddr
+  module Metadata
+    class Vocabulary
+
+      def self.label(rdf_vocabulary)
+        case rdf_vocabulary.to_uri
+        when RDF::DC.to_uri
+          "DC Terms"
+        when DukeTerms.to_uri
+          "Duke Terms"
+        end
+      end
+
+      def self.namespace_prefix(rdf_vocabulary)
+        case rdf_vocabulary.to_uri
+        when RDF::DC.to_uri
+          "dcterms"
+        when DukeTerms.to_uri
+          "duke"
+        end
+      end
+
+      def self.property_terms(rdf_vocabulary)
+        rdf_vocabulary.properties.select { |p| p.type.include?("http://www.w3.org/1999/02/22-rdf-syntax-ns#Property") }
+      end
+
+      def self.term_names(rdf_vocabulary)
+        self.property_terms(rdf_vocabulary).map { |term| self.term_name(rdf_vocabulary, term) }
+      end
+
+      def self.term_name(rdf_vocabulary, term)
+        term.to_s.gsub(rdf_vocabulary.to_uri.to_s, "").to_sym
+      end
+
+    end
+  end
+end

data/lib/ddr/models.rb

@@ -0,0 +1,60 @@
+require 'ddr/models/engine'
+require 'ddr/models/version'
+
+# Awful hack to make Hydra::AccessControls::Permissions accessible
+$: << Gem.loaded_specs['hydra-access-controls'].full_gem_path + "/app/models/concerns"
+
+require 'active_record'
+
+require 'hydra-core'
+require 'hydra/derivatives'
+require 'hydra/validations'
+
+require 'ddr/actions'
+require 'ddr/auth'
+require 'ddr/configurable'
+require 'ddr/datastreams'
+require 'ddr/events'
+require 'ddr/index_fields'
+require 'ddr/metadata'
+require 'ddr/notifications'
+require 'ddr/services'
+require 'ddr/utils'
+require 'ddr/workflow'
+
+module Ddr
+  module Models
+    extend ActiveSupport::Autoload
+
+    autoload :Configurable
+
+    autoload :Base
+    autoload :AccessControllable
+    autoload :Describable
+    autoload :EventLoggable
+    autoload :Error
+    autoload :ChecksumInvalid, 'ddr/models/error'
+    autoload :VirusFoundError, 'ddr/models/error'
+    autoload :FixityCheckable
+    autoload :Governable
+    autoload :HasAttachments
+    autoload :HasChildren
+    autoload :HasContent
+    autoload :HasContentMetadata
+    autoload :HasProperties
+    autoload :HasRoleAssignments
+    autoload :HasThumbnail
+    autoload :HasWorkflow
+    autoload :Indexing
+    autoload :FileManagement
+    autoload :Licensable
+    autoload :MintedId
+    autoload :PermanentIdentification
+    autoload :SolrDocument
+    
+    include Ddr::Configurable
+
+  end
+end
+
+Dir[Ddr::Models::Engine.root.to_s + "/app/models/*.rb"].each { |m| require m }

data/lib/ddr/models/access_controllable.rb

@@ -0,0 +1,23 @@
+module Ddr
+  module Models
+    module AccessControllable
+      extend ActiveSupport::Concern
+
+      included do
+        # adds methods for managing Hydra rightsMetadata content
+        include Hydra::AccessControls::Permissions unless include? Hydra::AccessControls::Permissions
+      end
+
+      def set_initial_permissions(user_creator = nil)
+        if user_creator
+          self.permissions_attributes = [{type: "user", access: "edit", name: user_creator.to_s}]
+        end
+      end
+
+      def copy_permissions_from(other)
+        # XXX active-fedora < 7.0
+        self.permissions_attributes = other.permissions.collect { |p| p.to_hash }
+      end
+    end
+  end
+end

data/lib/ddr/models/base.rb

@@ -0,0 +1,37 @@
+module Ddr
+  module Models
+    class Base < ActiveFedora::Base
+
+      include Describable
+      include Governable
+      include AccessControllable
+      include Licensable
+      include HasProperties
+      include HasThumbnail
+      include ActiveFedora::Auditable
+      include EventLoggable
+      include FixityCheckable
+      include FileManagement
+      include Indexing
+      include PermanentIdentification
+      include HasRoleAssignments
+      include Hydra::Validations
+      include HasWorkflow
+      
+      def copy_admin_policy_or_permissions_from(other)
+        copy_permissions_from(other) unless copy_admin_policy_from(other)
+      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)
+      end
+      
+      # e.g., "Collection duke:1"
+      def model_pid
+        [self.class.to_s, pid].join(" ")
+      end  
+
+    end
+  end
+end

data/lib/ddr/models/describable.rb

@@ -0,0 +1,81 @@
+module Ddr
+  module 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::Metadata::Vocabulary.term_names(RDF::DC11),
+                     datastream: Ddr::Datastreams::DESC_METADATA, 
+                     multiple: true
+    end
+  
+    def has_desc_metadata?
+      descMetadata.has_content?
+    end
+  
+    def desc_metadata_terms *args
+      return Ddr::Datastreams::DescriptiveMetadataDatastream.term_names if args.empty?
+      arg = args.pop
+      terms = case arg.to_sym
+              when :empty
+                desc_metadata_terms.select { |t| desc_metadata_values(t).empty? }
+              when :present
+                desc_metadata_terms.select { |t| desc_metadata_values(t).present? }
+              when :defined_attributes
+                desc_metadata_terms & desc_metadata_attributes
+              when :required
+                desc_metadata_terms(:defined_attributes).select {|t| required? t}
+              when :dcterms
+                Ddr::Metadata::Vocabulary.term_names(RDF::DC11) +
+                      (Ddr::Metadata::Vocabulary.term_names(RDF::DC) - Ddr::Metadata::Vocabulary.term_names(RDF::DC11))
+              when :dcterms_elements11
+                Ddr::Metadata::Vocabulary.term_names(RDF::DC11)
+              when :duke
+                Ddr::Metadata::Vocabulary.term_names(Ddr::Metadata::DukeTerms)
+              else
+                raise ArgumentError, "Invalid argument: #{arg.inspect}"
+              end
+      if args.empty?
+        terms
+      else 
+        terms | desc_metadata_terms(*args)
+      end
+    end
+  
+    def desc_metadata_attributes
+      defattrs = self.class.defined_attributes
+      defattrs.keys.select {|k| defattrs[k].dsid == "descMetadata"}.map(&:to_sym)
+    end
+  
+    def desc_metadata_values term
+      descMetadata.values term
+    end
+  
+    def desc_metadata_vocabs
+      descMetadata.class.vocabularies
+    end
+  
+    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
+      desc_metadata_terms.each { |t| set_desc_metadata_values(t, term_values_hash[t]) }
+    end
+  
+    module ClassMethods
+      def find_by_identifier(identifier)
+        find(Ddr::IndexFields::IDENTIFIER => identifier)
+      end
+    end
+
+    end
+  end
+end

data/lib/ddr/models/engine.rb

@@ -0,0 +1,58 @@
+require 'rails'
+
+module Ddr
+  module Models
+    class Engine < ::Rails::Engine
+
+      engine_name 'ddr_models'
+
+      config.generators do |g|
+        g.test_framework :rspec
+        g.fixture_replacement :factory_girl
+        g.assets false
+        g.helper false
+      end
+
+      # Add custom predicates to ActiveFedora
+      initializer 'ddr_models.predicates' do
+        ActiveFedora::Predicates.set_predicates(Ddr::Metadata::PREDICATES)
+      end
+
+      # Configure devise-remote-user
+      initializer 'ddr_auth.remote_user' do
+        require 'devise_remote_user'
+        DeviseRemoteUser.configure do |config|
+          config.auto_create = true
+          config.attribute_map = {
+            email: 'mail', 
+            first_name: 'givenName',
+            middle_name: 'duMiddleName1',
+            nickname: 'eduPersonNickname',
+            last_name: 'sn',
+            display_name: 'displayName'
+          }
+          config.auto_update = true
+          config.logout_url = "/Shibboleth.sso/Logout?return=https://shib.oit.duke.edu/cgi-bin/logout.pl"
+        end
+      end
+
+      # Integration of remote (Grouper) groups via Shibboleth
+      initializer 'ddr_auth.grouper' do
+        # Load configuration for Grouper service, if present
+        if File.exists? "#{Rails.root}/config/grouper.yml"
+          Ddr::Auth::GrouperService.config = YAML.load_file("#{Rails.root}/config/grouper.yml")[Rails.env]
+        end
+
+        Warden::Manager.after_set_user do |user, auth, opts|
+          user.group_service = Ddr::Auth::RemoteGroupService.new(auth.env)
+        end
+      end
+
+      # Set superuser group
+      initializer 'ddr_auth.superuser' do
+        Ddr::Auth.superuser_group = ENV["SUPERUSER_GROUP"]
+      end
+
+    end
+  end
+end

data/lib/ddr/models/error.rb

@@ -0,0 +1,12 @@
+module Ddr
+  module Models
+    # Base class for custom exceptions
+    class Error < StandardError; end
+  
+    # Invalid checksum
+    class ChecksumInvalid < Ddr::Models::Error; end
+
+    # Virus found
+    class VirusFoundError < Ddr::Models::Error; end
+  end
+end

data/lib/ddr/models/event_loggable.rb

@@ -0,0 +1,36 @@
+module Ddr
+  module Models
+    module EventLoggable
+      extend ActiveSupport::Concern
+
+      def events
+        event_class.for_object(self)
+      end
+
+      def update_events
+        event_class(:update).for_object(self)
+      end
+
+      # TESTME
+      def notify_event(type, args={})
+        Ddr::Notifications.notify_event(type, args.merge(pid: pid))
+      end
+
+      def has_events?
+        events.count > 0
+      end
+
+      private 
+
+      def event_class_name(token=nil)
+        type = token ? "#{token.to_s.camelize}Event" : "Event"
+        "Ddr::Events::#{type}"
+      end
+
+      def event_class(token=nil)
+        event_class_name(token).constantize
+      end
+
+    end
+  end
+end

data/lib/ddr/models/file_management.rb

@@ -0,0 +1,183 @@
+require "ddr-antivirus"
+
+module Ddr
+  module 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]) 
+          end
+        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)
+
+        unless ds.external?
+          raise ArgumentError, "Cannot add external file to datastream with controlGroup \"#{ds.controlGroup}\"" 
+        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!
+          # 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!
+        file_path = generate_external_file_path
+        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
+        file_name = generate_external_file_name
+        File.join(external_file_store, generate_external_directory_subpath(file_name), file_name)
+      end
+
+      def external_datastreams
+        datastreams.values.select { |ds| ds.external? }
+      end
+
+      def external_datastream_file_paths
+        external_datastreams.map(&:file_paths).flatten
+      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
+
+      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::Antivirus::Scanner.scan(path)
+      rescue ArgumentError => e # file is a blob
+        logger.error(e)
+      end
+
+      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 external_file_store
+        Ddr::Models.external_file_store
+      end
+
+      def set_external_file_permissions! file_path
+        File.chmod(EXTERNAL_FILE_PERMISSIONS, file_path)
+      end
+
+      def generate_external_file_name
+        SecureRandom.uuid      
+      end
+
+      def generate_external_directory_subpath(file_name)
+        m = Ddr::Models.external_file_subpath_regexp.match(file_name)
+        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
+      end
+
+      def cleanup_external_files_on_destroy
+        paths = external_datastream_file_paths
+        yield
+        File.unlink *paths
+      end
+
+    end
+  end
+end