curate 0.0.1 → 0.1.0

data/app/controllers/common_objects_controller.rb

@@ -0,0 +1,27 @@
+require File.expand_path('../../helpers/common_objects_helper', __FILE__)
+class CommonObjectsController < ApplicationController
+  layout 'common_objects'
+
+  respond_to(:html)
+  include Sufia::Noid # for normalize_identifier method
+  prepend_before_filter :normalize_identifier
+  def curation_concern
+    @curation_concern ||= ActiveFedora::Base.find(params[:id], cast: true)
+  end
+  before_filter :curation_concern
+  helper_method :curation_concern
+  helper CommonObjectsHelper
+
+  before_filter :enforce_show_permissions, only: [:show]
+  rescue_from Hydra::AccessDenied do |exception|
+    redirect_to common_object_stub_information_path(curation_concern)
+  end
+
+  def show
+    respond_with(curation_concern)
+  end
+
+  def show_stub_information
+    respond_with(curation_concern)
+  end
+end

data/app/controllers/curation_concern/base_controller.rb

@@ -0,0 +1,26 @@
+module CurationConcern
+  class BaseController < ApplicationController
+    layout 'curate_nd'
+    include Sufia::Noid # for normalize_identifier method
+
+    before_filter :authenticate_user!, :except => [:show]
+    before_filter :agreed_to_terms_of_service!
+    prepend_before_filter :normalize_identifier, except: [:index, :new, :create]
+    before_filter :curation_concern, except: [:index]
+    load_and_authorize_resource :curation_concern, except: [:index, :new, :create], class: "ActiveFedora::Base"
+
+    attr_reader :curation_concern
+    helper_method :curation_concern
+
+    def contributor_agreement
+      @contributor_agreement ||= ContributorAgreement.new(curation_concern, current_user, params)
+    end
+    helper_method :contributor_agreement
+
+    def save_and_add_related_files_submit_value(override_name = action_name)
+      verb_name = ['create', 'new'].include?(override_name) ? 'Create' : 'Update'
+      "#{verb_name} and Add Related Files..."
+    end
+    helper_method :save_and_add_related_files_submit_value
+  end
+end

data/app/controllers/curation_concern/generic_files_controller.rb

@@ -0,0 +1,82 @@
+class CurationConcern::GenericFilesController < CurationConcern::BaseController
+  respond_to(:html)
+
+  before_filter :parent
+  def parent
+    @parent ||=
+    if params[:id]
+      curation_concern.batch
+    else
+      ActiveFedora::Base.find(namespaced_parent_id,cast: true)
+    end
+  end
+  helper_method :parent
+
+  def namespaced_parent_id
+    Sufia::Noid.namespaceize(params[:parent_id])
+  end
+  protected :namespaced_parent_id
+
+  before_filter :authorize_edit_parent_rights!, except: [:show]
+  def authorize_edit_parent_rights!
+    authorize! :edit, parent
+  end
+  protected :authorize_edit_parent_rights!
+
+  before_filter :curation_concern
+  load_and_authorize_resource :curation_concern, class: "ActiveFedora::Base", except: [:new, :create]
+
+  def curation_concern
+    @curation_concern ||=
+    if params[:id]
+      GenericFile.find(params[:id])
+    else
+      GenericFile.new(params[:generic_file])
+    end
+  end
+
+  def new
+    respond_with(curation_concern)
+  end
+
+  def create
+    curation_concern.batch = parent
+    actor.create!
+    respond_with([:curation_concern, parent])
+  rescue ActiveFedora::RecordInvalid
+    respond_with([:curation_concern, curation_concern]) { |wants|
+      wants.html { render 'new', status: :unprocessable_entity }
+    }
+  end
+
+
+  def show
+    respond_with(curation_concern)
+  end
+
+  def edit
+    respond_with(curation_concern)
+  end
+
+  def update
+    actor.update!
+    respond_with([:curation_concern, curation_concern])
+  rescue ActiveFedora::RecordInvalid
+    respond_with([:curation_concern, curation_concern]) { |wants|
+      wants.html { render 'edit', status: :unprocessable_entity }
+    }
+  end
+
+  def destroy
+    parent = curation_concern.batch
+    title = curation_concern.to_s
+    curation_concern.destroy
+    flash[:notice] = "Deleted #{title}"
+    respond_with([:curation_concern, parent])
+  end
+
+  include Morphine
+  register :actor do
+    CurationConcern.actor(curation_concern, current_user, params[:generic_file])
+  end
+end

data/app/controllers/dashboard_controller.rb

@@ -0,0 +1,85 @@
+require 'blacklight/catalog'
+require File.expand_path("../catalog_controller", __FILE__)
+class DashboardController < ApplicationController
+  include Hydra::BatchEditBehavior
+  include Blacklight::Catalog
+  include Blacklight::Configurable # comply with BL 3.7
+
+  # This is needed as of BL 3.7; This must come before mixing in
+  # BlacklightAdvancedSearch::Controller
+  self.copy_blacklight_config_from(CatalogController)
+
+  include Hydra::Controller::ControllerBehavior
+  include ActionView::Helpers::DateHelper
+  include BlacklightAdvancedSearch::ParseBasicQ
+  include BlacklightAdvancedSearch::Controller
+
+  layout 'curate_nd/dashboard'
+
+  before_filter :authenticate_user!
+  before_filter :agreed_to_terms_of_service!
+  before_filter :enforce_show_permissions, :only=>:show
+  before_filter :enforce_viewing_context_for_show_requests, :only=>:show
+
+  # This applies appropriate access controls to all solr queries (the internal method of this is overidden bellow to only include edit files)
+  DashboardController.solr_search_params_logic += [:add_access_controls_to_solr_params]
+  # This filters out objects that you want to exclude from search results, like FileAssets
+  DashboardController.solr_search_params_logic += [:exclude_unwanted_models]
+
+  def index
+    extra_head_content << view_context.auto_discovery_link_tag(:rss, url_for(params.merge(:format => 'rss')), :title => "RSS for results")
+    extra_head_content << view_context.auto_discovery_link_tag(:atom, url_for(params.merge(:format => 'atom')), :title => "Atom for results")
+    (@response, @document_list) = get_search_results
+    @user = current_user
+    @events = @user.events(100)
+    @last_event_timestamp = @user.events.first[:timestamp].to_i || 0 rescue 0
+    @filters = params[:f] || []
+
+    # adding a key to the session so that the history will be saved so that batch_edits select all will work
+    search_session[:dashboard] = true
+    respond_to do |format|
+      format.html { save_current_search_params }
+      format.rss  { render :layout => false }
+      format.atom { render :layout => false }
+    end
+
+    # set up some parameters for allowing the batch controls to show appropiately
+    @max_batch_size = 80
+    count_on_page = @document_list.count {|doc| batch.index(doc.id)}
+    @disable_select_all = @document_list.count > @max_batch_size
+    batch_size = batch.uniq.size
+    @result_set_size = @response.response["numFound"]
+    @empty_batch = batch.empty?
+    @all_checked = (count_on_page == @document_list.count)
+    @entire_result_set_selected = @response.response["numFound"] == batch_size
+    @batch_size_on_other_page = batch_size - count_on_page
+    @batch_part_on_other_page = (@batch_size_on_other_page) > 0
+  end
+
+  def get_related_file
+    @user = current_user
+    #Need to make sure if params get in ways of searching (like page,per_page,q,f). If that happens then have to remove from params and put back in
+    extra_controller_params = {}
+    extra_controller_params.merge!(:fq=>"")
+    @response, @document_list = get_solr_response_for_field_values("is_part_of_s",["info:fedora/#{params[:id]}"],extra_controller_params)
+  end
+
+  private
+
+  def show_site_search?
+    false
+  end
+
+  protected
+  # show only files with edit permissions in lib/hydra/access_controls_enforcement.rb apply_gated_discovery
+  def discovery_permissions
+    ["edit"]
+  end
+
+  def exclude_unwanted_models(solr_parameters, user_parameters)
+    super
+    solr_parameters[:fq] ||= []
+    solr_parameters[:fq] << "-has_model_s:\"info:fedora/afmodel:GenericFile\""
+    return solr_parameters
+  end
+end

data/app/controllers/downloads_controller.rb

@@ -0,0 +1,22 @@
+require 'sufia/noid'
+
+class DownloadsController < ApplicationController
+  include Sufia::Noid # for normalize_identifier method
+
+  def generic_file
+    @generic_file ||= GenericFile.find(params[:id])
+  end
+  before_filter :generic_file
+  prepend_before_filter :normalize_identifier, except: [:index, :new, :create]
+  load_and_authorize_resource :generic_file, class: "GenericFile"
+
+  def show
+    send_data(
+      generic_file.content.content,
+      type: generic_file.content.mimeType,
+      filename: generic_file.filename,
+      disposition: 'inline'
+    )
+  end
+
+end

data/app/controllers/errors_controller.rb

@@ -0,0 +1,19 @@
+class ErrorsController < ApplicationController
+  layout 'curate_nd'
+
+  def show
+    render_response_for_error(exception_wrapper)
+  end
+
+  def exception
+    @exception ||= env['action_dispatch.exception']
+  end
+  protected :exception
+
+  def exception_wrapper
+    @exception_wrapper ||= ActionDispatch::ExceptionWrapper.new(env, exception)
+  end
+  helper_method :exception_wrapper
+  protected :exception_wrapper
+
+end

data/app/controllers/help_requests_controller.rb

@@ -0,0 +1,38 @@
+class HelpRequestsController < ApplicationController
+  SUCCESS_NOTICE = "Thank you for your input!"
+  layout 'curate_nd'
+  before_filter :authenticate_user!
+  before_filter :agreed_to_terms_of_service!
+
+  respond_to(:html)
+  def help_request
+    @help_request ||= build_help_request
+  end
+  helper_method :help_request
+
+  def new
+    respond_with(help_request)
+  end
+
+  def create
+    help_request.save!
+    respond_with(help_request) do |wants|
+      wants.html { redirect_to dashboard_index_path, notice: SUCCESS_NOTICE}
+    end
+  rescue ActiveRecord::RecordInvalid
+    respond_with(help_request)
+  end
+
+  private
+
+  def build_help_request
+    help_request = HelpRequest.new(params[:help_request])
+    help_request.user_agent  ||= user_agent_from_request
+    help_request.release_version = Rails.configuration.build_identifier
+    help_request
+  end
+
+  def user_agent_from_request
+    request.headers['HTTP_USER_AGENT']
+  end
+end

data/app/controllers/terms_of_service_agreements_controller.rb

@@ -0,0 +1,44 @@
+class TermsOfServiceAgreementsController < ApplicationController
+  before_filter :authenticate_user!
+  respond_to(:html)
+
+  layout 'curate_nd/1_column'
+  def new
+  end
+
+  def create
+    if user_just_agreed_to_tos?
+      current_user.agree_to_terms_of_service!
+      redirect_to new_classify_concern_path
+    else
+      flash.now[:notice] = "To proceed, you must agree to the Terms of Service."
+      render 'new'
+    end
+  end
+  def user_just_agreed_to_tos?
+    params[:commit] == i_agree_text
+  end
+  protected :user_just_agreed_to_tos?
+
+  I_AGREE_TEXT = "I Agree"
+  I_DO_NOT_AGREE_TEXT = "I Do Not Agree"
+  def i_agree_text
+    I_AGREE_TEXT
+  end
+  helper_method :i_agree_text
+
+  def i_do_not_agree_text
+    I_DO_NOT_AGREE_TEXT
+  end
+  helper_method :i_do_not_agree_text
+
+  private
+
+  def show_action_bar?
+    false
+  end
+
+  def show_site_search?
+    false
+  end
+end

data/app/controllers/welcome_controller.rb

@@ -0,0 +1,14 @@
+class WelcomeController < ApplicationController
+  layout 'curate_nd/2_column'
+
+  respond_to :html
+  def index
+    respond_with
+  end
+
+  private
+
+  def show_action_bar?
+    false
+  end
+end

data/app/helpers/application_helper.rb

@@ -0,0 +1,89 @@
+require 'active_support'
+
+module ApplicationHelper
+  # This is included to hopefully catch most of the sufia method calls that are
+  # vestigal for the Sufia engine being included in the Gemfile but unmounted.
+  def sufia
+    self
+  end
+
+  def construct_page_title(*elements)
+    (elements.flatten.compact + [application_name]).join(" // ")
+  end
+
+  def curation_concern_page_title(curation_concern)
+    if curation_concern.persisted?
+      construct_page_title(curation_concern.title, "#{curation_concern.human_readable_type} [#{curation_concern.to_param}]")
+    else
+      construct_page_title("New #{curation_concern.human_readable_type}")
+    end
+  end
+
+  def default_page_title
+    text = controller_name.singularize.titleize
+    if action_name
+      text = "#{action_name.titleize} " + text
+    end
+    construct_page_title(text)
+  end
+
+  def curation_concern_attribute_to_html(curation_concern, method_name, label)
+    markup = ""
+    subject = curation_concern.send(method_name)
+    return markup unless subject.present?
+    markup << %(<dt>#{label}</dt>\n)
+    [subject].flatten.compact.each do |value|
+      markup << %(<dd class="attribute #{method_name}">#{h(value)}</dd>\n)
+    end
+    markup.html_safe
+  end
+
+  def classify_for_display(curation_concern)
+    curation_concern.human_readable_type.downcase
+  end
+
+  def bootstrap_navigation_element(name, path)
+    markup = ""
+
+    if current_page? path
+      markup = <<HTML
+<li class="disabled">#{link_to name, '#', tabindex: :'-1'}</li>
+HTML
+    else
+      markup = <<HTML
+<li>#{link_to name, path}</li>
+HTML
+    end
+
+    markup.html_safe()
+  end
+
+  def link_to_edit_permissions(curation_concern, solr_document = nil)
+    markup = <<-HTML
+      <a href="#{edit_polymorphic_path([:curation_concern, curation_concern])}" id="permission_#{curation_concern.to_param}">
+        #{permission_badge_for(curation_concern, solr_document)}
+      </a>
+    HTML
+    markup.html_safe
+  end
+
+  def permission_badge_for(curation_concern, solr_document = nil)
+    solr_document ||= curation_concern.to_solr
+    dom_label_class, link_title = extract_dom_label_class_and_link_title(solr_document)
+    %(<span class="label #{dom_label_class}" title="#{link_title}">#{link_title}</span>).html_safe
+  end
+
+  def extract_dom_label_class_and_link_title(document)
+    hash = document.stringify_keys
+    dom_label_class, link_title = "label-important", "Private"
+    if hash['read_access_group_t'].present?
+      if hash['read_access_group_t'].include?('public')
+        dom_label_class, link_title = 'label-success', 'Open Access'
+      elsif hash['read_access_group_t'].include?('registered')
+        dom_label_class, link_title = "label-info", t('sufia.institution_name')
+      end
+    end
+    return dom_label_class, link_title
+  end
+  private :extract_dom_label_class_and_link_title
+end