sufia 6.0.0 → 6.1.0

data/sufia-models/app/models/concerns/sufia/user_usage_stats.rb

@@ -1,15 +0,0 @@
-module Sufia::UserUsageStats
-
-  def stats
-    @stats ||= UserStat.where(user_id: id).order(date: :asc)
-  end
-
-  def total_file_views
-    stats.reduce(0) { |total, stat| total + stat.file_views }
-  end
-
-  def total_file_downloads
-    stats.reduce(0) { |total, stat| total + stat.file_downloads }
-  end
-
-end

data/sufia-models/app/models/datastreams/file_content_datastream.rb

@@ -1,4 +0,0 @@
-class FileContentDatastream < ActiveFedora::File
-  include Hydra::Derivatives::ExtractMetadata
-  include Sufia::FileContent::Versions
-end

data/sufia-models/app/models/datastreams/fits_datastream.rb

@@ -1,152 +0,0 @@
-class FitsDatastream < ActiveFedora::OmDatastream
-  include OM::XML::Document
-
-  def prefix(_)
-    ""
-  end
-
-  set_terminology do |t|
-    t.root(path: "fits",
-           xmlns: "http://hul.harvard.edu/ois/xml/ns/fits/fits_output",
-           schema: "http://hul.harvard.edu/ois/xml/xsd/fits/fits_output.xsd")
-    t.identification {
-      t.identity {
-        t.format_label(path: {attribute: "format"})
-        t.mime_type(path: {attribute: "mimetype"}, index_as: [:stored_searchable])
-      }
-    }
-    t.fileinfo {
-      t.file_size(path: "size")
-      t.last_modified(path: "lastmodified")
-      t.filename(path: "filename")
-      t.original_checksum(path: "md5checksum")
-      t.rights_basis(path: "rightsBasis")
-      t.copyright_basis(path: "copyrightBasis")
-      t.copyright_note(path: "copyrightNote")
-    }
-    t.filestatus {
-      t.well_formed(path: "well-formed")
-      t.valid(path: "valid")
-      t.status_message(path: "message")
-    }
-    t.metadata {
-      t.document {
-        t.file_title(path: "title")
-        t.file_author(path: "author")
-        t.file_language(path: "language")
-        t.page_count(path: "pageCount")
-        t.word_count(path: "wordCount")
-        t.character_count(path: "characterCount")
-        t.paragraph_count(path: "paragraphCount")
-        t.line_count(path: "lineCount")
-        t.table_count(path: "tableCount")
-        t.graphics_count(path: "graphicsCount")
-      }
-      t.image {
-        t.byte_order(path: "byteOrder")
-        t.compression(path: "compressionScheme")
-        t.width(path: "imageWidth")
-        t.height(path: "imageHeight")
-        t.color_space(path: "colorSpace")
-        t.profile_name(path: "iccProfileName")
-        t.profile_version(path: "iccProfileVersion")
-        t.orientation(path: "orientation")
-        t.color_map(path: "colorMap")
-        t.image_producer(path: "imageProducer")
-        t.capture_device(path: "captureDevice")
-        t.scanning_software(path: "scanningSoftwareName")
-        t.exif_version(path: "exifVersion")
-        t.gps_timestamp(path: "gpsTimeStamp")
-        t.latitude(path: "gpsDestLatitude")
-        t.longitude(path: "gpsDestLongitude")
-      }
-      t.text {
-        t.character_set(path: "charset")
-        t.markup_basis(path: "markupBasis")
-        t.markup_language(path: "markupLanguage")
-      }
-      t.audio {
-        t.duration(path: "duration")
-        t.bit_depth(path: "bitDepth")
-        t.sample_rate(path: "sampleRate")
-        t.channels(path: "channels")
-        t.data_format(path: "dataFormatType")
-        t.offset(path: "offset")
-      }
-      t.video {
-        t.width(path: "imageWidth")
-        t.height(path: "imageHeight")
-        t.duration(path: "duration")
-        t.sample_rate(path: "sampleRate")
-        t.frame_rate(path: "frameRate")
-      }
-    }
-    t.format_label(proxy: [:identification, :identity, :format_label])
-    t.mime_type(proxy: [:identification, :identity, :mime_type])
-    t.file_size(proxy: [:fileinfo, :file_size])
-    t.last_modified(proxy: [:fileinfo, :last_modified])
-    t.filename(proxy: [:fileinfo, :filename])
-    t.original_checksum(proxy: [:fileinfo, :original_checksum])
-    t.rights_basis(proxy: [:fileinfo, :rights_basis])
-    t.copyright_basis(proxy: [:fileinfo, :copyright_basis])
-    t.copyright_note(proxy: [:fileinfo, :copyright_note])
-    t.well_formed(proxy: [:filestatus, :well_formed])
-    t.valid(proxy: [:filestatus, :valid])
-    t.status_message(proxy: [:filestatus, :status_message])
-    t.file_title(proxy: [:metadata, :document, :file_title])
-    t.file_author(proxy: [:metadata, :document, :file_author])
-    t.page_count(proxy: [:metadata, :document, :page_count])
-    t.file_language(proxy: [:metadata, :document, :file_language])
-    t.word_count(proxy: [:metadata, :document, :word_count])
-    t.character_count(proxy: [:metadata, :document, :character_count])
-    t.paragraph_count(proxy: [:metadata, :document, :paragraph_count])
-    t.line_count(proxy: [:metadata, :document, :line_count])
-    t.table_count(proxy: [:metadata, :document, :table_count])
-    t.graphics_count(proxy: [:metadata, :document, :graphics_count])
-    t.byte_order(proxy: [:metadata, :image, :byte_order])
-    t.compression(proxy: [:metadata, :image, :compression])
-    t.width(proxy: [:metadata, :image, :width])
-    t.video_width( proxy: [:metadata, :video, :width])
-    t.height(proxy: [:metadata, :image, :height])
-    t.video_height(proxy: [:metadata, :video, :height])
-    t.color_space(proxy: [:metadata, :image, :color_space])
-    t.profile_name(proxy: [:metadata, :image, :profile_name])
-    t.profile_version(proxy: [:metadata, :image, :profile_version])
-    t.orientation(proxy: [:metadata, :image, :orientation])
-    t.color_map(proxy: [:metadata, :image, :color_map])
-    t.image_producer(proxy: [:metadata, :image, :image_producer])
-    t.capture_device(proxy: [:metadata, :image, :capture_device])
-    t.scanning_software(proxy: [:metadata, :image, :scanning_software])
-    t.exif_version(proxy: [:metadata, :image, :exif_version])
-    t.gps_timestamp(proxy: [:metadata, :image, :gps_timestamp])
-    t.latitude(proxy: [:metadata, :image, :latitude])
-    t.longitude(proxy: [:metadata, :image, :longitude])
-    t.character_set(proxy: [:metadata, :text, :character_set])
-    t.markup_basis(proxy: [:metadata, :text, :markup_basis])
-    t.markup_language(proxy: [:metadata, :text, :markup_language])
-    t.duration(proxy: [:metadata, :audio, :duration])
-    t.video_duration(proxy: [:metadata, :video, :duration])
-    t.bit_depth(proxy: [:metadata, :audio, :bit_depth])
-    t.sample_rate(proxy: [:metadata, :audio, :sample_rate])
-    t.video_sample_rate(proxy: [:metadata, :video, :sample_rate])
-    t.channels(proxy: [:metadata, :audio, :channels])
-    t.data_format(proxy: [:metadata, :audio, :data_format])
-    t.offset(proxy: [:metadata, :audio, :offset])
-    t.frame_rate(proxy: [:metadata, :video, :frame_rate])
-  end
-
-  def self.xml_template
-    builder = Nokogiri::XML::Builder.new do |xml|
-      xml.fits(xmlns: 'http://hul.harvard.edu/ois/xml/ns/fits/fits_output',
-               'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance',
-               'xsi:schemaLocation' =>
-    "http://hul.harvard.edu/ois/xml/ns/fits/fits_output
-    http://hul.harvard.edu/ois/xml/xsd/fits/fits_output.xsd",
-               version: "0.6.0",
-               timestamp: "1/25/12 11:04 AM") {
-        xml.identification { xml.identity(toolname: 'FITS') }
-      }
-    end
-    builder.doc
-  end
-end

data/sufia-models/app/models/domain_term.rb

@@ -1,5 +0,0 @@
-class DomainTerm < ActiveRecord::Base
-
-  # TODO we should add an index on this join table and remove the uniq query
-  has_and_belongs_to_many :local_authorities, -> {uniq}
-end

data/sufia-models/app/models/featured_work.rb

@@ -1,22 +0,0 @@
-class FeaturedWork < ActiveRecord::Base
-  FEATURE_LIMIT = 5
-  validate :count_within_limit, on: :create
-  validates :order, inclusion: { in: Proc.new{ 0..FEATURE_LIMIT } }
-
-  default_scope { order(:order) }
-
-  def count_within_limit
-    unless FeaturedWork.can_create_another?
-      errors.add(:base, "Limited to #{FEATURE_LIMIT} featured works.")
-    end
-  end
-
-  attr_accessor :generic_file_solr_document
-
-  class << self
-    def can_create_another?
-      FeaturedWork.count < FEATURE_LIMIT
-    end
-  end
-end
-

data/sufia-models/app/models/file_download_stat.rb

@@ -1,18 +0,0 @@
-class FileDownloadStat < ActiveRecord::Base
-  extend Sufia::FileStatUtils
-
-  def to_flot
-    [ self.class.convert_date(date), downloads ]
-  end
-
-  def self.statistics file_id, start_date, user_id=nil
-    combined_stats file_id, start_date, :downloads, :totalEvents, user_id
-  end
-
-  # Sufia::Download is sent to Sufia::Analytics.profile as #sufia__download
-  # see Legato::ProfileMethods.method_name_from_klass
-  def self.ga_statistics start_date, file_id
-    Sufia::Analytics.profile.sufia__download(sort: 'date', start_date: start_date, end_date: Date.yesterday).for_file(file_id)
-  end
-
-end

data/sufia-models/app/models/file_usage.rb

@@ -1,34 +0,0 @@
-class FileUsage
-
-  attr_accessor :id, :created, :path, :downloads, :pageviews
-
-  def initialize id
-    file = ::GenericFile.find(id)
-    user = User.where(email: file.depositor).first
-    user_id = user ? user.id : nil
-
-    self.id = id
-    self.path = Sufia::Engine.routes.url_helpers.generic_file_path(id)
-    earliest = Sufia.config.analytic_start_date
-    self.created = ::GenericFile.find(id).create_date
-    self.created = earliest > created ? earliest : created unless earliest.blank?
-    self.downloads = FileDownloadStat.to_flots FileDownloadStat.statistics(id, created, user_id)
-    self.pageviews = FileViewStat.to_flots FileViewStat.statistics(id, created, user_id)
-  end
-
-  def total_downloads
-    self.downloads.reduce(0) { |total, result| total + result[1].to_i }
-  end
-
-  def total_pageviews
-    self.pageviews.reduce(0) { |total, result| total + result[1].to_i }
-  end
-
-  # Package data for visualization using JQuery Flot
-  def to_flot
-    [
-      { label: "Pageviews",  data: pageviews },
-      { label: "Downloads",  data: downloads }
-    ]
-  end
-end

data/sufia-models/app/models/file_view_stat.rb

@@ -1,18 +0,0 @@
-class FileViewStat < ActiveRecord::Base
-  extend Sufia::FileStatUtils
-
-  def to_flot
-    [ self.class.convert_date(date), views ]
-  end
-
-  def self.statistics file_id, start_date, user_id=nil
-    combined_stats file_id, start_date, :views, :pageviews, user_id
-  end
-
-  # Sufia::Download is sent to Sufia::Analytics.profile as #sufia__download
-  # see Legato::ProfileMethods.method_name_from_klass
-  def self.ga_statistics start_date, file_id
-    path = Sufia::Engine.routes.url_helpers.generic_file_path(file_id)
-    Sufia::Analytics.profile.sufia__pageview(sort: 'date', start_date: start_date).for_path(path)
-  end
-end

data/sufia-models/app/models/follow.rb

@@ -1,12 +0,0 @@
-class Follow < ActiveRecord::Base
-  extend ActsAsFollower::FollowerLib
-  extend ActsAsFollower::FollowScopes
-
-  # NOTE: Follows belong to the "followable" interface, and also to followers
-  belongs_to :followable, polymorphic: true
-  belongs_to :follower, polymorphic: true
-
-  def block!
-    self.update_attribute(:blocked, true)
-  end
-end

data/sufia-models/app/models/generic_file.rb

@@ -1,3 +0,0 @@
-class GenericFile < ActiveFedora::Base
-  include Sufia::GenericFile
-end

data/sufia-models/app/models/geo_names_resource.rb

@@ -1,18 +0,0 @@
-class GeoNamesResource < ActiveResource::Base
-  self.site = "http://api.geonames.org/"
-  self.element_name = "searchJSON"
-  self.collection_name = "searchJSON"
-
-  def self.collection_path(prefix_options = {}, query_options = nil)
-    super(prefix_options, query_options).gsub(/\.json|\.xml/, "")
-  end
-
-  def self.instantiate_collection(collection, original_params = {}, prefix_options = {})
-      col = super(collection["geonames"], original_params, prefix_options)
-      col.map! { |item| { label: item.name + (item.adminName1 ? ", " + item.adminName1 : "") + ", " + item.countryName, value: item.name + (item.adminName1 ? ", " + item.adminName1 : "") + ", " + item.countryName} }
-  end
-
-  def self.find_location(location)
-    return GeoNamesResource.find(:all, params: { q: location, username: "cam156", maxRows: 10})
-  end
-end

data/sufia-models/app/models/group.rb

@@ -1,8 +0,0 @@
-## This could extend from a module that would make it an ldap group
-class Group
-
-  def self.exists?(cn)
-    false
-  end
-
-end

data/sufia-models/app/models/local_authority.rb

@@ -1,86 +0,0 @@
-class LocalAuthority < ActiveRecord::Base
-
-  # TODO we should add an index on this join table and remove the uniq query
-  has_and_belongs_to_many :domain_terms, -> { uniq }
-  
-  has_many :local_authority_entries
-
-  def self.harvest_rdf(name, sources, opts = {})
-    return unless self.where(name: name).empty?
-    authority = self.create(name: name)
-    format = opts.fetch(:format, :ntriples)
-    predicate = opts.fetch(:predicate, ::RDF::SKOS.prefLabel)
-    entries = []
-    sources.each do |uri|
-      ::RDF::Reader.open(uri, format: format) do |reader|
-        reader.each_statement do |statement|
-          if statement.predicate == predicate
-            entries << LocalAuthorityEntry.new(local_authority: authority,
-                                               label: statement.object.to_s,
-                                               uri: statement.subject.to_s)
-          end
-        end
-      end
-    end
-    if LocalAuthorityEntry.respond_to? :import
-      LocalAuthorityEntry.import entries
-    else
-      entries.each { |e| e.save! }
-    end
-  end
-
-  def self.harvest_tsv(name, sources, opts = {})
-    return unless self.where(name: name).empty?
-    authority = self.create(name: name)
-    prefix = opts.fetch(:prefix, "")
-    entries = []
-    sources.each do |uri|
-      open(uri) do |f|
-        f.each_line do |tsv|
-          fields = tsv.split(/\t/)
-          entries << LocalAuthorityEntry.new(local_authority: authority,
-                                             uri: "#{prefix}#{fields[0]}/",
-                                             label: fields[2])
-        end
-      end
-    end
-    if LocalAuthorityEntry.respond_to? :import
-      LocalAuthorityEntry.import entries
-    else
-      entries.each { |e| e.save! }
-    end
-  end
-
-  def self.register_vocabulary(model, term, name)
-    authority = self.find_by_name(name)
-    return if authority.blank?
-    model = model.to_s.sub(/RdfDatastream$/, '').underscore.pluralize
-    domain_term = DomainTerm.find_or_create_by(model: model, term: term)
-    return if domain_term.local_authorities.include? authority
-    domain_term.local_authorities << authority
-  end
-
-  def self.entries_by_term(model, term, query)
-    return if query.empty?
-    lowQuery = query.downcase
-    hits = []
-    # move lc_subject into it's own table since being part of the usual structure caused it to be too slow.  
-    # When/if we move to having multiple dictionaries for subject we will need to also do a check for the appropriate dictionary. 
-    if (term == 'subject' && model == 'generic_files') # and local_authoritiy = lc_subject 
-        sql = SubjectLocalAuthorityEntry.where("lowerLabel like ?", "#{lowQuery}%").select("label, uri").limit(25).to_sql
-        SubjectLocalAuthorityEntry.find_by_sql(sql).each do |hit|
-          hits << {uri: hit.uri, label: hit.label}
-        end
-    else 
-      dterm = DomainTerm.where(model: model, term: term).first
-      if dterm
-        authorities = dterm.local_authorities.collect(&:id).uniq      
-        sql = LocalAuthorityEntry.where("local_authority_id in (?)", authorities).where("lower(label) like ?", "#{lowQuery}%").select("label, uri").limit(25).to_sql
-        LocalAuthorityEntry.find_by_sql(sql).each do |hit|
-          hits << {uri: hit.uri, label: hit.label}
-        end
-      end
-    end
-    return hits
-  end
-end

data/sufia-models/app/models/local_authority_entry.rb

@@ -1,3 +0,0 @@
-class LocalAuthorityEntry < ActiveRecord::Base
-  belongs_to :local_authority
-end

data/sufia-models/app/models/proxy_deposit_request.rb

@@ -1,85 +0,0 @@
-class ProxyDepositRequest < ActiveRecord::Base
-  include Blacklight::SearchHelper
-  include ActionView::Helpers::UrlHelper
-
-  belongs_to :receiving_user, class_name: 'User'
-  belongs_to :sending_user, class_name: 'User'
-
-  validates :sending_user, :generic_file_id, presence: true
-  validate :transfer_to_should_be_a_valid_username
-  validate :sending_user_should_not_be_receiving_user
-  validate :should_not_be_already_part_of_a_transfer
-
-  after_save :send_request_transfer_message
-
-  attr_reader :transfer_to
-
-  def transfer_to=(key)
-    @transfer_to = key
-    self.receiving_user = User.find_by_user_key(key)
-  end
-
-  def transfer_to_should_be_a_valid_username
-    errors.add(:transfer_to, "must be an existing user") unless receiving_user
-  end
-
-  def sending_user_should_not_be_receiving_user
-    errors.add(:sending_user, 'must specify another user to receive the file') if receiving_user and receiving_user.user_key == sending_user.user_key
-  end
-
-  def should_not_be_already_part_of_a_transfer
-    transfers = ProxyDepositRequest.where(generic_file_id: generic_file_id, status: 'pending')
-    errors.add(:open_transfer, 'must close open transfer on the file before creating a new one') unless transfers.blank? || ( transfers.count == 1 && transfers[0].id == self.id)
-  end
-
-  def send_request_transfer_message
-    if self.updated_at == self.created_at
-      message = "#{link_to(sending_user.name, Sufia::Engine.routes.url_helpers.profile_path(sending_user.user_key))} wants to transfer a file to you. Review all <a href='#{Sufia::Engine.routes.url_helpers.transfers_path}'>transfer requests</a>"
-      User.batchuser.send_message(receiving_user, message, "Ownership Change Request")
-      else
-        message = "Your transfer request was #{status}."
-        message = message + " Comments: #{receiver_comment}" if !receiver_comment.blank?
-        User.batchuser.send_message(sending_user, message, "Ownership Change #{status}")
-    end
-  end
-
-  def pending?
-    self.status == 'pending'
-  end
-
-  def accepted?
-    self.status == 'accepted'
-  end
-
-  # @param [Boolean] reset (false) should the access controls be reset. This means revoking edit access from the depositor
-  def transfer!(reset = false)
-    Sufia.queue.push(ContentDepositorChangeEventJob.new(generic_file_id, receiving_user.user_key, reset))
-    self.status = 'accepted'
-    self.fulfillment_date = Time.now
-    save!
-  end
-
-  def reject!(comment = nil)
-    self.receiver_comment = comment if comment
-    self.status = 'rejected'
-    self.fulfillment_date = Time.now
-    save!
-  end
-
-  def cancel!
-    self.status = 'canceled'
-    self.fulfillment_date = Time.now
-    save!
-  end
-
-  def deleted_file?
-    !GenericFile.exists?(generic_file_id)
-  end
-
-  def title
-    return 'file not found' if deleted_file?
-    query = ActiveFedora::SolrQueryBuilder.construct_query_for_ids([generic_file_id])
-    solr_response = ActiveFedora::SolrService.query(query, raw: true)
-    SolrDocument.new(solr_response['response']['docs'].first, solr_response).title
-  end
-end