worthwhile 0.0.1.alpha → 0.0.1

data/app/models/concerns/curation_concern/curatable.rb

@@ -0,0 +1,77 @@
+# Replaces Curate's CurationConcern::Model
+module CurationConcern::Curatable
+  extend ActiveSupport::Concern
+
+  included do
+    include ::CurationConcern::HumanReadableType
+    include Sufia::Noid
+    include Sufia::ModelMethods
+    include Hydra::Collections::Collectible
+    include Solrizer::Common
+    include ::CurationConcern::HasRepresentative
+
+    # Modules in Curate's CurationConcern::Model that we _might_ pull in later
+    # include Curate::ActiveModelAdaptor
+
+    has_metadata 'properties', type: Worthwhile::PropertiesDatastream
+    has_attributes :relative_path, :depositor, :owner, datastream: :properties, multiple: false
+    class_attribute :human_readable_short_description
+    attr_accessor :files
+  end
+
+  def as_json(options)
+    { pid: pid, title: title, model: self.class.to_s, curation_concern_type: human_readable_type }
+  end
+
+  def as_rdf_object
+    RDF::URI.new(internal_uri)
+  end
+
+  def to_solr(solr_doc={}, opts={})
+    super.tap do |solr_doc|
+      index_collection_pids(solr_doc)
+      solr_doc[Solrizer.solr_name('noid', Sufia::GenericFile.noid_indexer)] = noid
+      add_derived_date_created(solr_doc)
+    end
+  end
+
+  def to_s
+    title.join(', ')
+  end
+
+  # Returns a string identifying the path associated with the object. ActionPack uses this to find a suitable partial to represent the object.
+  def to_partial_path
+    "curation_concern/#{super}"
+  end
+
+  def can_be_member_of_collection?(collection)
+    collection == self ? false : true
+  end
+
+  protected
+
+  # A searchable date field that is derived from the (text) field date_created
+  def add_derived_date_created(solr_doc)
+    if self.respond_to?(:date_created)
+      self.class.create_and_insert_terms('date_created_derived', derived_dates, [:dateable], solr_doc)
+    end
+  end
+
+  def derived_dates
+    dates = Array(date_created)
+    dates.map { |date| Curate::DateFormatter.parse(date.to_s).to_s }
+  end
+
+  def index_collection_pids(solr_doc)
+    solr_doc[Solrizer.solr_name(:collection, :facetable)] ||= []
+    solr_doc[Solrizer.solr_name(:collection)] ||= []
+    self.collection_ids.each do |collection_id|
+      collection_obj = ActiveFedora::Base.load_instance_from_solr(collection_id)
+      if collection_obj.is_a?(Collection)
+        solr_doc[Solrizer.solr_name(:collection, :facetable)] << collection_id
+        solr_doc[Solrizer.solr_name(:collection)] << collection_id
+      end
+    end
+    solr_doc
+  end
+end

data/app/models/concerns/curation_concern/has_representative.rb

@@ -0,0 +1,14 @@
+module CurationConcern::HasRepresentative
+  extend ActiveSupport::Concern
+
+  included do
+    has_attributes :representative, datastream: :properties, multiple: false
+  end
+
+  def to_solr(solr_doc={}, opts={})
+    super.tap do |solr_doc|
+      solr_doc[Solrizer.solr_name('representative', :stored_searchable)] = representative
+    end
+  end
+
+end

data/app/models/concerns/curation_concern/human_readable_type.rb

@@ -0,0 +1,23 @@
+module CurationConcern
+  module HumanReadableType
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :human_readable_short_description, :human_readable_type
+      self.human_readable_type = name.demodulize.titleize
+    end
+
+    def human_readable_type
+      self.class.human_readable_type
+    end
+
+    def to_solr(solr_doc={}, opts={})
+      super(solr_doc, opts)
+      solr_doc[Solrizer.solr_name('human_readable_type',:facetable)] = human_readable_type
+      solr_doc[Solrizer.solr_name('human_readable_type', :stored_searchable)] = human_readable_type
+      return solr_doc
+    end
+
+  end
+end
+

data/app/models/concerns/curation_concern/with_basic_metadata.rb

@@ -0,0 +1,49 @@
+# Basic metadata for all Works
+# Required fields:
+#   dc:title
+#   dc:rights
+#
+# Optional fields:
+#   dc:contributor
+#   dc:coverage
+#   dc:creator
+#   dc:date
+#   dc:description
+#   dc:format
+#   dc:identifier
+#   dc:language
+#   dc:publisher
+#   dc:relation
+#   dc:source
+#   dc:subject
+#   dc:type
+module CurationConcern::WithBasicMetadata
+  extend ActiveSupport::Concern
+
+  included do
+    has_metadata "descMetadata", type: ::GenericWorkMetadata
+    # Validations that apply to all types of Work AND Collections
+    validates_presence_of :title,  message: 'Your work must have a title.'
+
+
+    # Single-value fields
+    has_attributes :created, :date_modified, :date_uploaded, datastream: :descMetadata, multiple: false
+
+    # Multi-value fields
+    has_attributes :contributor, :creator, :coverage, :date, :description, :content_format, :identifier,
+                  :language, :publisher, :relation, :rights, :source, :subject, :title, :type,
+                  datastream: :descMetadata, multiple: true
+  end
+
+
+  # TODO created and date_uploaded?
+  # TODO created and date_created
+  # has_attributes :date_uploaded, :date_modified, :title, :description,
+  #               datastream: :descMetadata, multiple: false
+  #
+  # has_attributes :related_url, :based_near, :part_of, :creator, :contributor,
+  #                :tag, :rights, :publisher, :date_created, :subject, :resource_type,
+  #                 :identifier, :language,
+  #               datastream: :descMetadata, multiple: true
+
+end

data/app/models/concerns/curation_concern/with_editors.rb

@@ -0,0 +1,44 @@
+module CurationConcern
+  module WithEditors
+    extend ActiveSupport::Concern
+
+    def add_editor_group(group_name)
+      self.edit_groups += [group]
+    end
+
+    # @param groups [Array<String>] a list of group names to add
+    def add_editor_groups(groups)
+      groups.each { |g| add_editor_group(g) }
+    end
+
+    def remove_editor_group(group)
+      self.edit_groups -= [group]
+    end
+
+    # @param groups [Array<String>] a list of users to remove
+    def remove_editor_groups(groups)
+      groups.each { |g| remove_editor_group(g) }
+    end
+
+    # @param user [String] the user account you want to grant edit access to.
+    def add_editor(user)
+      self.edit_users += [user]
+    end
+
+    # @param users [Array<String>] a list of users to add
+    def add_editors(users)
+      users.each { |u| add_editor(u) }
+    end
+
+    # @param user [String] the user account you want to revoke edit access for.
+    def remove_editor(user)
+      self.edit_users -= [user]
+    end
+
+    # @param users [Array<String>] a list of users to remove
+    def remove_editors(users)
+      users.each { |u| remove_editor(u) }
+    end
+  end
+end
+

data/app/models/concerns/curation_concern/with_generic_files.rb

@@ -0,0 +1,23 @@
+# Copied from Curate
+module CurationConcern
+  module WithGenericFiles
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :generic_files, property: :is_part_of, class_name: "Worthwhile::GenericFile"
+      before_destroy :before_destroy_cleanup_generic_files
+    end
+
+    def before_destroy_cleanup_generic_files
+      generic_files.each(&:destroy)
+    end
+
+    def copy_visibility_to_files
+      generic_files.each do |gf|
+        gf.visibility = visibility
+        gf.save!
+      end
+    end
+
+  end
+end

data/app/models/concerns/curation_concern/with_linked_resources.rb

@@ -0,0 +1,21 @@
+module CurationConcern
+  module WithLinkedResources
+    extend ActiveSupport::Concern
+
+    included do
+
+      # attribute :linked_resource_urls, multiple: true
+      attr_accessor :linked_resource_urls
+
+      has_many :linked_resources, property: :is_part_of, class_name:"Worthwhile::LinkedResource"
+
+      after_destroy :after_destroy_cleanup_linked_resources
+    end
+
+    def after_destroy_cleanup_linked_resources
+      linked_resources.each(&:destroy)
+    end
+
+  end
+end
+

data/app/models/concerns/curation_concern/work.rb

@@ -0,0 +1,24 @@
+module CurationConcern::Work
+  extend ActiveSupport::Concern
+  include ::CurationConcern::Curatable
+  include ::CurationConcern::WithGenericFiles
+  include Hydra::AccessControls::Embargoable
+  include ::CurationConcern::WithEditors
+  include CurationConcern::WithLinkedResources
+
+  # Modules in Curate's CurationConcern::Work that we _might_ pull in later
+  # include Curate::ActiveModelAdaptor
+  # include CurationConcern::WithLinkedContributors
+  # include CurationConcern::WithRelatedWorks
+
+  included do
+    has_metadata "properties", type: Worthwhile::PropertiesDatastream
+    has_attributes :depositor, :representative, datastream: :properties, multiple: false
+  end
+
+  def to_solr(solr_doc={}, opts={})
+    super(solr_doc, opts)
+    Solrizer.set_field(solr_doc, 'generic_type', 'Work', :facetable)
+    return solr_doc
+  end
+end

data/app/models/concerns/worthwhile/ability.rb

@@ -0,0 +1,34 @@
+module Worthwhile
+  module Ability
+    extend ActiveSupport::Concern
+    included do
+      self.ability_logic += [:worthwhile_permissions]
+    end
+
+    def worthwhile_permissions
+      
+      unless current_user.new_record?
+        can :create, Worthwhile::ClassifyConcern
+        can :create, [Worthwhile::GenericFile, Worthwhile::LinkedResource]
+      end
+
+      if user_groups.include? 'admin'
+       can [:discover, :show, :read, :edit, :update, :destroy], :all
+      end
+
+      can :collect, :all
+
+    end
+    
+    # Add this to your ability_logic if you want all logged in users to be able to submit content
+    def everyone_can_create_curation_concerns
+      unless current_user.new_record?
+        can :create, [Worthwhile.configuration.curation_concerns]
+        can :create, Collection
+      end
+    end
+
+  end
+end
+
+

data/app/models/concerns/worthwhile/generic_file/versioned_content.rb

@@ -0,0 +1,18 @@
+module Worthwhile
+  class GenericFile
+    module VersionedContent
+      def versions
+        return [] unless persisted?
+        @versions ||= content.versions.collect {|version| Worthwhile::ContentVersion.new(content, version)}
+      end
+
+      def latest_version
+        versions.first || Worthwhile::ContentVersion::Null.new(content)
+      end
+
+      def current_version_id
+        latest_version.version_id
+      end
+    end
+  end
+end

data/app/models/concerns/worthwhile/generic_file_base.rb

@@ -0,0 +1,64 @@
+module Worthwhile
+  module GenericFileBase
+    extend ActiveSupport::Concern
+    include Hydra::AccessControls::Embargoable
+    include Sufia::ModelMethods
+    include Sufia::Noid
+    include Sufia::GenericFile::MimeTypes
+    include Sufia::GenericFile::Characterization
+    include Sufia::GenericFile::Audit
+    include Sufia::GenericFile::WebForm
+    include Sufia::GenericFile::Derivatives
+    include Sufia::GenericFile::Metadata
+    include Sufia::GenericFile::Versions
+    include Sufia::Permissions::Readable
+    include Worthwhile::GenericFile::VersionedContent
+
+    included do
+      belongs_to :batch, property: :is_part_of, class_name: 'ActiveFedora::Base'
+
+      before_destroy :remove_representative_relationship
+
+      attr_accessor :file
+
+      # make filename single-value (Sufia::GenericFile::Characterization makes it multivalue)
+      # has_attributes :filename, datastream: :characterization, multiple: false
+      def filename
+        content.label
+      end
+    end
+
+    def human_readable_type
+      self.class.to_s.demodulize.titleize
+    end
+
+    def representative
+      to_param
+    end
+
+    def copy_permissions_from(obj)
+      self.datastreams['rightsMetadata'].ng_xml = obj.datastreams['rightsMetadata'].ng_xml
+    end
+
+    def update_parent_representative_if_empty(obj)
+      return unless obj.representative.blank?
+      obj.representative = self.pid
+      obj.save
+    end
+
+    def remove_representative_relationship
+      return unless ActiveFedora::Base.exists?(batch)
+      return unless batch.representative == self.pid
+      batch.representative = nil
+      batch.save
+    end
+
+    def to_solr(solr_doc = {})
+      super.tap do |solr_doc|
+        # Enables Riiif to not have to recalculate this each time.
+        solr_doc['height_isi'] = Integer(height.first) if height.present?
+        solr_doc['width_isi'] = Integer(width.first) if width.present?
+      end
+    end
+  end
+end

data/app/models/concerns/worthwhile/solr_document_behavior.rb

@@ -0,0 +1,140 @@
+# This was moved out of sufia-models and into sufia/app/models.
+# Copied the file in here to retain the functionality until/unless the file gets moved back into sufia-models.
+# -*- encoding : utf-8 -*-
+module Worthwhile
+  module SolrDocumentBehavior
+    def title_or_label
+      title || label
+    end
+
+    ##
+    # Give our SolrDocument an ActiveModel::Naming appropriate route_key
+    def route_key
+      get(Solrizer.solr_name('has_model', :symbol)).split(':').last.downcase
+    end
+
+    def to_param
+      noid || id
+    end
+
+    def to_s
+      title_or_label
+    end
+
+    ##
+    # Offer the source (ActiveFedora-based) model to Rails for some of the
+    # Rails methods (e.g. link_to).
+    # @example
+    #   link_to '...', SolrDocument(:id => 'bXXXXXX5').new => <a href="/dams_object/bXXXXXX5">...</a>
+    def to_model
+      m = ActiveFedora::Base.load_instance_from_solr(id, self)
+      m.class == ActiveFedora::Base ? self : m
+    end
+
+    def collection?
+      hydra_model == 'Collection'
+    end
+
+    # Method to return the ActiveFedora model
+    def hydra_model
+      self[Solrizer.solr_name('active_fedora_model', Solrizer::Descriptor.new(:string, :stored, :indexed))]
+    end
+
+    def noid
+      self[Solrizer.solr_name('noid', Sufia::GenericFile.noid_indexer)]
+    end
+
+    def human_readable_type
+      Array(self[Solrizer.solr_name('human_readable_type', :stored_searchable)]).first
+    end
+
+    def representative 
+      Array(self[Solrizer.solr_name('representative', :stored_searchable)]).first
+    end
+
+    def date_uploaded
+      field = self[Solrizer.solr_name("desc_metadata__date_uploaded", :stored_sortable, type: :date)]
+      return unless field.present?
+      begin
+        Date.parse(field).to_formatted_s(:standard)
+      rescue
+        Rails.logger.info "Unable to parse date: #{field.first.inspect} for #{self['id']}"
+      end
+    end
+
+    def depositor(default = '')
+      val = Array(self[Solrizer.solr_name("depositor")]).first
+      val.present? ? val : default
+    end
+
+    def title
+      Array(self[Solrizer.solr_name('desc_metadata__title')]).first
+    end
+
+    def description
+      Array(self[Solrizer.solr_name('desc_metadata__description')]).first
+    end
+
+    def label
+      Array(self[Solrizer.solr_name('label')]).first
+    end
+
+    def file_format
+       Array(self[Solrizer.solr_name('file_format')]).first
+    end
+
+    def creator
+      Array(self[Solrizer.solr_name("desc_metadata__creator")]).first
+    end
+
+    def tags
+      Array(self[Solrizer.solr_name("desc_metadata__tag")])
+    end
+
+    def resource_type
+      Array(self[Solrizer.solr_name("desc_metadata__resource_type")])
+    end
+
+    def mime_type
+      Array(self[Solrizer.solr_name("mime_type")]).first
+    end
+
+    def read_groups
+      Array(self[::Ability.read_group_field])
+    end
+
+    def edit_groups
+      Array(self[::Ability.edit_group_field])
+    end
+
+    def edit_people
+      Array(self[::Ability.edit_user_field])
+    end
+
+    def public?
+      read_groups.include?('public')
+    end
+
+    def registered?
+      read_groups.include?('registered')
+    end
+
+    def pdf?
+      ['application/pdf'].include? self.mime_type
+    end
+
+    def image?
+      ['image/png','image/jpeg', 'image/jpg', 'image/jp2', 'image/bmp', 'image/gif', 'image/tiff'].include? self.mime_type
+    end
+
+    def video?
+      ['video/mpeg', 'video/mp4', 'video/webm', 'video/x-msvideo', 'video/avi', 'video/quicktime', 'application/mxf'].include? self.mime_type
+    end
+
+    def audio?
+      # audio/x-wave is the mime type that fits 0.6.0 returns for a wav file.
+      # audio/mpeg is the mime type that fits 0.6.0 returns for an mp3 file.
+      ['audio/mp3', 'audio/mpeg', 'audio/x-wave', 'audio/x-wav', 'audio/ogg'].include? self.mime_type
+    end
+  end
+end