worthwhile-models 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9e40a4356445e489fdd44804236d674d99cd7f29
+  data.tar.gz: 426954c2064b078d0a811069528a96642cb4fdfb
+SHA512:
+  metadata.gz: dd3b23367115d00157ecd7c21b38c8dc0a279f328f4a7d1fe5bfbca99b08518c8512c43056a689b4f8a4d343d6c0db0b302e505e33298052a3b5bdc63b8f358f
+  data.tar.gz: c36133602cc143df28212470c1c0d43588703c2cc9d3840e4525de1f05170ea9c27dc80597f147038aeef302fd2abb3ad5f1832f0c1a54c20aea7194cb63462f

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

@@ -0,0 +1,62 @@
+module CurationConcern
+  module CollectionModel
+    extend ActiveSupport::Concern
+
+    include Hydra::AccessControls::Permissions
+    include Hydra::AccessControls::WithAccessRight
+    include Sufia::Noid
+    include CurationConcern::HumanReadableType
+    include Hydra::Collection
+    include Hydra::Collections::Collectible
+    include CurationConcern::HasRepresentative
+
+    def add_member(collectible)
+      if can_add_to_members?(collectible)
+        collectible.collections << self
+        collectible.save
+        self.members << collectible
+        self.save
+      end
+    end
+
+    def to_s
+      self.title.present? ? title : "No Title"
+    end
+
+    def to_solr(solr_doc={}, opts={})
+      super.tap do |solr_doc|
+        Solrizer.set_field(solr_doc, 'generic_type', human_readable_type, :facetable)
+        solr_doc[Solrizer.solr_name('noid', Sufia::GenericFile.noid_indexer)] = noid
+        index_collection_pids(solr_doc)
+      end
+    end
+
+    def can_be_member_of_collection?(collection)
+      collection == self ? false : true
+    end
+
+
+    # ------------------------------------------------
+    # overriding method from active-fedora:
+    # lib/active_fedora/semantic_node.rb
+    #
+    # The purpose of this override is to ensure that
+    # a collection cannot contain itself.
+    #
+    # TODO:  After active-fedora 7.0 is released, this
+    # logic can be moved into a before_add callback.
+    # ------------------------------------------------
+    def add_relationship(predicate, target, literal=false)
+      return if self == target
+      super
+    end
+
+    private
+    def can_add_to_members?(collectible)
+      collectible.can_be_member_of_collection?(self)
+    rescue NoMethodError
+      false
+    end
+
+  end
+end

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

data/app/models/generic_work.rb

@@ -0,0 +1,5 @@
+# Override this file locally if you want to define your own GenericWork class
+class GenericWork < ActiveFedora::Base
+  include ::CurationConcern::Work
+  include ::CurationConcern::WithBasicMetadata
+end

data/app/models/worthwhile/classify_concern.rb

@@ -0,0 +1,47 @@
+require 'active_attr'
+module Worthwhile
+  class ClassifyConcern
+    include ActiveAttr::Model
+    attribute :curation_concern_type
+
+    validates(
+      :curation_concern_type,
+      presence: true,
+      inclusion: { in: lambda { |record| record.registered_curation_concern_types } }
+    )
+
+    def all_curation_concern_classes
+      registered_curation_concern_types.sort.map { |c| self.class.to_class(c) }
+    end
+
+    def registered_curation_concern_types
+      Worthwhile.configuration.registered_curation_concern_types
+    end
+
+    def possible_curation_concern_types
+      registered_curation_concern_types.collect do |concern|
+        [self.class.to_class(concern).human_readable_type, concern]
+      end
+    end
+
+    def curation_concern_class
+      if possible_curation_concern_types.detect{|name, class_name|
+          class_name == curation_concern_type
+        }
+        self.class.to_class(curation_concern_type)
+      else
+        raise RuntimeError, "Invalid :curation_concern_type"
+      end
+    end
+
+    def self.to_class(type)
+      # TODO we may want to allow a different (or nil) namespace
+      type.camelize.constantize
+      # begin
+      #   "::#{type.camelize}".constantize
+      # rescue NameError
+      #   "Worthwhile::#{type}".constantize
+      # end
+    end
+  end
+end

data/app/models/worthwhile/content_version.rb

@@ -0,0 +1,23 @@
+module Worthwhile
+  class ContentVersion
+    class Null
+      def initialize(content)
+      end
+      def created_on; 'unknown'; end
+      def committer_name; 'unknown'; end
+      def formatted_created_on(*args); 'unknown'; end
+      def version_id; 'unknown'; end
+    end
+
+    attr_reader :version_id, :created_on, :committer_name
+    def initialize(content, version_structure)
+      @created_on = version_structure.dsCreateDate
+      @version_id = version_structure.versionID
+      @committer_name = content.version_committer(version_structure)
+    end
+
+    def formatted_created_on(format = :long_ordinal )
+      created_on.localtime.to_formatted_s(format)
+    end
+  end
+end

data/app/models/worthwhile/contributor_agreement.rb

@@ -0,0 +1,23 @@
+module Worthwhile
+  class ContributorAgreement
+    attr_reader :curation_concern, :user
+    def initialize(curation_concern, user, params)
+      @curation_concern = curation_concern
+      @user = user
+      @param_value = params[param_key.to_sym] || params[param_key.to_s]
+    end
+
+    def acceptance_value
+      'accept'
+    end
+
+    def param_key
+      :accept_contributor_agreement
+    end
+    attr_reader :param_value
+
+    def is_being_accepted?
+      param_value == acceptance_value
+    end
+  end
+end

data/app/models/worthwhile/generic_file.rb

@@ -0,0 +1,5 @@
+module Worthwhile
+  class GenericFile < ActiveFedora::Base
+    include Worthwhile::GenericFileBase
+  end
+end

data/app/models/worthwhile/linked_resource.rb

@@ -0,0 +1,41 @@
+module Worthwhile
+  class LinkedResource < ActiveFedora::Base
+    include ::CurationConcern::Work
+
+    has_file_datastream "content", control_group: 'E'
+    has_metadata "descMetadata", type: GenericFileRdfDatastream
+    
+    belongs_to :batch, property: :is_part_of, class_name: 'ActiveFedora::Base'
+
+    validates :url, presence: true
+
+    self.human_readable_short_description = "An arbitrary URL reference."
+    include ActionView::Helpers::SanitizeHelper
+    
+    has_attributes :date_uploaded, :date_modified, :title, :description, datastream: :descMetadata, multiple: false
+
+    # Creator is multiple to match Sufia::GenericFile#creator
+    has_attributes :creator, datastream: :descMetadata, multiple: true
+
+    def url=(url)
+      u = URI::Parser.new.parse(url)
+      return unless [URI::HTTP, URI::HTTPS, URI::FTP].include?(u.class)
+      content.dsLocation = u.to_s
+    end
+
+    def url
+      content.dsLocation
+    end
+
+    def to_s
+      url
+    end
+
+    def to_solr(solr_doc={}, opts={})
+      super
+      Solrizer.set_field(solr_doc, 'url', url, :stored_searchable)
+      solr_doc
+    end
+  end
+end
+

data/app/models/worthwhile/quick_classification_query.rb

@@ -0,0 +1,31 @@
+module Worthwhile
+  class QuickClassificationQuery
+
+    def self.each_for_context(*args, &block)
+      new(*args).all.each(&block)
+    end
+
+    attr_reader :user
+
+    def initialize(user, options = {})
+      @user = user
+      @concern_name_normalizer = options.fetch(:concern_name_normalizer, ClassifyConcern.method(:to_class))
+      @registered_curation_concern_names = options.fetch(:registered_curation_concern_names, Worthwhile.configuration.registered_curation_concern_types)
+    end
+
+    def all
+      ActiveFedora::Base.logger.debug "User is #{user}"
+      ActiveFedora::Base.logger.debug "try is #{normalized_curation_concern_names.first}"
+      ActiveFedora::Base.logger.debug "can is  #{user.can?(:create, normalized_curation_concern_names.first)}"
+      normalized_curation_concern_names.select {|klass| user.can?(:create, klass)}
+    end
+
+    private
+
+    attr_reader :concern_name_normalizer, :registered_curation_concern_names
+
+    def normalized_curation_concern_names
+      registered_curation_concern_names.collect{|name| concern_name_normalizer.call(name) }
+    end
+  end
+end

data/lib/worthwhile/models.rb

@@ -0,0 +1,7 @@
+require "worthwhile/models/version"
+require "worthwhile/models/engine"
+module Worthwhile
+  module Models
+  end
+end
+

data/lib/worthwhile/models/engine.rb

@@ -0,0 +1,11 @@
+require 'sufia/models'
+module Worthwhile
+  module Models
+    class Engine < ::Rails::Engine
+      # config.autoload_paths += %W(
+      #   #{config.root}/app/models/datastreams
+      # )
+    end
+  end
+end
+

data/lib/worthwhile/models/version.rb

@@ -0,0 +1,5 @@
+module Worthwhile
+  module Models
+    VERSION = "0.1.0"
+  end
+end

data/worthwhile-models.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+version = File.read(File.expand_path("../../WORTHWHILE_VERSION", __FILE__)).strip
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = "worthwhile-models"
+  spec.version       = version
+  spec.authors       = ["Justin Coyne"]
+  spec.email         = ["justin@curationexperts.com"]
+  spec.summary       = %q{Simple institutional repository models for Hydra}
+  spec.description   = %q{An extensible repository data-model with works and and many attached files}
+  spec.homepage      = ""
+  spec.license       = "APACHE2"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'hydra-head', '~> 7.2.2'
+  spec.add_dependency "active_attr"
+  spec.add_dependency 'sufia-models', '~> 4.0.0'
+  spec.add_dependency 'hydra-collections', '~> 2.0.5'
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+end

metadata

@@ -0,0 +1,153 @@
+--- !ruby/object:Gem::Specification
+name: worthwhile-models
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Justin Coyne
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: hydra-head
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 7.2.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 7.2.2
+- !ruby/object:Gem::Dependency
+  name: active_attr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sufia-models
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+- !ruby/object:Gem::Dependency
+  name: hydra-collections
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.5
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: An extensible repository data-model with works and and many attached
+  files
+email:
+- justin@curationexperts.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- app/models/concerns/curation_concern/collection_model.rb
+- app/models/concerns/curation_concern/curatable.rb
+- app/models/concerns/curation_concern/has_representative.rb
+- app/models/concerns/curation_concern/human_readable_type.rb
+- app/models/concerns/curation_concern/with_basic_metadata.rb
+- app/models/concerns/curation_concern/with_editors.rb
+- app/models/concerns/curation_concern/with_generic_files.rb
+- app/models/concerns/curation_concern/with_linked_resources.rb
+- app/models/concerns/curation_concern/work.rb
+- app/models/concerns/worthwhile/ability.rb
+- app/models/concerns/worthwhile/generic_file/versioned_content.rb
+- app/models/concerns/worthwhile/generic_file_base.rb
+- app/models/concerns/worthwhile/solr_document_behavior.rb
+- app/models/generic_work.rb
+- app/models/worthwhile/classify_concern.rb
+- app/models/worthwhile/content_version.rb
+- app/models/worthwhile/contributor_agreement.rb
+- app/models/worthwhile/generic_file.rb
+- app/models/worthwhile/linked_resource.rb
+- app/models/worthwhile/quick_classification_query.rb
+- lib/worthwhile/models.rb
+- lib/worthwhile/models/engine.rb
+- lib/worthwhile/models/version.rb
+- worthwhile-models.gemspec
+homepage: ''
+licenses:
+- APACHE2
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Simple institutional repository models for Hydra
+test_files: []