blacklight_folders 1.0.0

data/app/controllers/blacklight/folders/folders_controller.rb

@@ -0,0 +1,162 @@
+require_dependency "blacklight/folders/application_controller"
+
+module Blacklight::Folders
+  class FoldersController < ApplicationController
+    include Blacklight::TokenBasedUser
+    include Blacklight::Catalog::SearchContext
+
+    load_and_authorize_resource class: Blacklight::Folders::Folder, except: [:add_bookmarks, :remove_bookmarks]
+    before_filter :load_and_authorize_folder, only: [:add_bookmarks, :remove_bookmarks]
+    before_filter :clear_session_search_params, only: [:show]
+
+    def index
+      @folders = if current_or_guest_user.new_record?
+        # Just show the temporary folder
+        current_or_guest_user.folders
+      else
+        Blacklight::Folders::Folder.accessible_by(current_ability)
+      end
+
+      if ['created_at', 'updated_at'].include?(params[:order_by])
+        @folders = @folders.order(params[:order_by] + ' DESC')
+      elsif ['name', 'number_of_members'].include?(params[:order_by])
+        @folders = @folders.order(params[:order_by])
+      end
+    end
+
+    def show
+      @response = @folder.response
+      respond_to do |format|
+        format.html { }
+        document_export_formats(format, @response)
+      end
+    end
+
+    def new
+    end
+
+    def edit
+    end
+
+    def create
+      @folder.user = current_user
+      if @folder.save
+        redirect_to @folder
+      else
+        render :new
+      end
+    end
+
+    def update
+      form = folder_form_class.new(create_params)
+      if form.update(@folder)
+        respond_to do |format|
+          format.html do
+            redirect_to @folder, notice: t(:'helpers.submit.folder.updated')
+          end
+          format.json do
+            render json: @folder
+          end
+        end
+      else
+        render :edit
+      end
+    end
+
+    def destroy
+      @folder.destroy
+      redirect_to main_app.root_path, notice: "Folder \"#{@folder.name}\" was successfully deleted."
+    end
+
+    def add_bookmarks
+      doc_ids = Array(params['document_ids'].split(',').map(&:strip))
+      @folder.add_bookmarks(doc_ids)
+
+      if @folder.save
+        message = doc_ids.size == 1 ? t(:'helpers.submit.folder.added_one', folder_name: @folder.name) : t(:'helpers.submit.folder.added_many', folder_name: @folder.name)
+        redirect_to :back, notice: message
+      else
+        redirect_to :back, alert: 'Unable to save bookmarks.'
+      end
+    end
+
+    def remove_bookmarks
+      item_ids = Array(params['item_ids'].split(',').map(&:to_i))
+      items = @folder.items.select {|x| item_ids.include?(x.id)}
+      @folder.remove_bookmarks(items)
+      redirect_to :back
+    end
+
+    protected
+
+      def current_ability
+        if token_user
+          ::Ability.new(token_user)
+        else
+          super
+        end
+      end
+
+      # These methods are extracted from Blacklight::Catalog and maybe can be extracted to a reusable model.
+      def document_export_formats(format, response)
+        format.any do
+          format_name = params.fetch(:format, '').to_sym
+
+          if response.export_formats.include? format_name
+            render_document_export_format format_name, response
+          else
+            raise ActionController::UnknownFormat.new
+          end
+        end
+      end
+
+      ##
+      # Render the document export formats for a response
+      # First, try to render an appropriate template (e.g. index.endnote.erb)
+      # If that fails, just concatenate the document export responses with a newline.
+      def render_document_export_format format_name, response
+        begin
+          render
+        rescue ActionView::MissingTemplate
+          render text: response.documents.map { |x| x.export_as(format_name) if x.exports_as? format_name }.compact.join("\n"), layout: false
+        end
+      end
+    protected
+
+      def folder_form_class
+        FolderForm
+      end
+
+    private
+
+      def _prefixes
+	      @_prefixes ||= super + ['catalog']
+	    end
+
+      def create_params
+        params.require(:folder).permit(:name, :visibility, items_attributes: [:id, :position, :_destroy, :folder_id])
+      end
+
+      def clear_session_search_params
+        # TODO: Is there a blacklight method we can use to do this?
+        session['search'] = nil
+      end
+
+      def load_and_authorize_folder
+        id = params['id'] || params['folder']['id']
+        if id == '0' && current_or_guest_user.new_record?
+          # Clear out the temporary folder
+          current_or_guest_user.folders = []
+          # This should be the only place a real folder is created for a guest user
+          @folder = current_or_guest_user.folders.first_or_initialize(name: Folder.default_folder_name)
+          # Now that the guest user needs a folder, persist the user.
+          current_or_guest_user.save!
+          # Reset the cached cancan ability
+          @current_ability = nil
+        else
+          @folder = Folder.find(id)
+        end
+        authorize! :update_bookmarks, @folder
+      end
+  end
+end

data/app/controllers/concerns/blacklight/folders/application_controller_behavior.rb

@@ -0,0 +1,63 @@
+module Blacklight::Folders
+  module ApplicationControllerBehavior
+    extend ActiveSupport::Concern
+
+    included do
+      rescue_from ::CanCan::AccessDenied, with: :unauthorized_access
+      before_action :give_guest_a_folder, if: :build_a_folder_for_guests?
+
+      define_callbacks :logging_in_user
+      set_callback :logging_in_user, :before, :transfer_guest_user_bookmarks_to_current_user
+
+    end
+
+    # Override cancan to be aware of guest users
+    def current_ability
+      @current_ability ||= ::Ability.new(current_or_guest_user)
+    end
+
+    # Called when a CanCan error is raised. Redirects to the root page and sets a
+    # flash error if the user is signed in, othewise tells the user to sign in.
+    def unauthorized_access(exception)
+      if current_user
+        redirect_to main_app.root_url, alert: exception.message
+      else
+        redirect_to main_app.new_user_session_path, alert: 'Please sign in to continue.'
+      end
+    end
+
+    # Build a folder on the current user so that the nav menu and Folder index page can be displayed
+    def give_guest_a_folder
+      current_or_guest_user.folders.build id: 0,
+                                          name: Blacklight::Folders::Folder.default_folder_name,
+                                          created_at: Time.now,
+                                          updated_at: Time.now
+    end
+
+    # Test to see if the current user needs to have a folder built
+    # Returns true when it's a guest who has no folders
+    def build_a_folder_for_guests?
+      current_or_guest_user.new_record? && current_or_guest_user.folders.empty?
+    end
+
+    private
+
+      def transfer_guest_user_bookmarks_to_current_user
+        return unless respond_to? :current_user and respond_to? :guest_user and current_user and guest_user
+
+        if current_user.default_folder
+          guest_user.folders.each do |f|
+            f.items.each do |i|
+              i.update(folder: current_user.default_folder)
+            end
+            f.delete
+          end
+        else
+          guest_user.folders.each do |f|
+            f.update(user: current_user)
+          end
+        end
+      end
+
+  end
+end

data/app/forms/blacklight/folders/folder_form.rb

@@ -0,0 +1,74 @@
+module Blacklight::Folders
+  class FolderForm
+    def initialize(params)
+      @params = params
+    end
+
+    def update(folder)
+      folder.assign_attributes(preprocess_nested_attributes(@params))
+      reorder_items(folder)
+      folder.save
+    end
+
+    protected
+      def preprocess_nested_attributes(in_params)
+        return in_params unless in_params.key?(:items_attributes)
+        in_params.merge(items_attributes: strip_blank_folders(nested_params_to_array(in_params[:items_attributes])))
+      end
+
+      def nested_params_to_array(attributes_collection)
+        if attributes_collection.is_a? Hash
+          keys = attributes_collection.keys
+          attributes_collection = if keys.include?('id') || keys.include?(:id)
+            [attributes_collection]
+          else
+            attributes_collection.values
+          end
+        end
+        attributes_collection
+      end
+
+      def strip_blank_folders(attributes_collection)
+        attributes_collection.each do |record_attributes|
+          record_attributes.delete(:folder_id) if record_attributes[:folder_id].blank?
+        end
+        attributes_collection
+      end
+
+      # This updates the positions of the folder items
+      def reorder_items(folder)
+        # we have to do a sort_by, not order, because the updated attributes have not been saved.
+        changed_folder, new, changed_position, unchanged = folder.items.
+          sort_by(&:position).
+          group_by do |item|
+            if item.folder_id_was != item.folder_id
+              :changed_folder
+            elsif item.position_was.nil?
+              :new
+            elsif item.position_was != item.position
+              :changed_position
+            else
+              :unchanged
+            end
+        end.values_at(:changed_folder, :new, :changed_position, :unchanged).map(&:to_a)
+
+        # items that will be in this folder
+        unmoved_items = unchanged
+        # place items whose positions were specified
+        changed_position.map {|item| unmoved_items.insert(item.position - 1, item)}
+        # add new items at the end
+        unmoved_items = unmoved_items + new
+        # calculate positions
+        unmoved_items.compact.
+          select {|item| item.folder_id_was == item.folder_id}.
+          each_with_index do |item, position|
+            item.position = position + 1
+          end
+
+        # items that have moved to another folder
+        changed_folder.select {|item| item.folder_id_was != item.folder_id}.each do |item|
+          item.position = nil
+        end
+      end
+  end
+end

data/app/helpers/blacklight/folders/application_helper.rb

@@ -0,0 +1,29 @@
+module Blacklight::Folders
+  module ApplicationHelper
+
+    include CrudLinksHelper
+
+    # The layout file from the main app might invoke
+    # some of the named routes from blacklight, which
+    # causes errors on the blacklight_folders views
+    # unless you add the main_app prefix.
+    def method_missing(method, *args)
+      if main_app_url_helper?(method)
+        main_app.send(method, *args)
+      else
+        super
+      end
+    end
+
+    def search_action_url(*args)
+      main_app.catalog_index_url *args
+    end
+
+  private
+
+    def main_app_url_helper?(method)
+      method.to_s.end_with?('_path', '_url') && main_app.respond_to?(method)
+    end
+
+  end
+end

data/app/helpers/blacklight/folders/crud_links_helper.rb

@@ -0,0 +1,29 @@
+module Blacklight::Folders
+  module CrudLinksHelper
+    def action_label model, action=nil
+      action_default_value model, action
+    end
+
+    private
+    def action_default_value object, key = nil
+      object_model = convert_to_model(object)
+
+      key ||= object_model ? (object_model.persisted? ? :edit : :create) : :view
+
+      case object_model
+      when Symbol, String
+        model = object_model
+        object_name = object_model
+      else
+        model = object_model.class.model_name.human
+        object_name = object_model.class.model_name.i18n_key
+      end
+
+      defaults = []
+      defaults << :"helpers.action.#{object_name}.#{key}"
+      defaults << :"helpers.action.#{key}"
+      defaults << "#{key.to_s.humanize} #{model}"
+      I18n.t(defaults.shift, model: model, default: defaults)
+    end
+  end
+end

data/app/helpers/blacklight/folders/folders_helper.rb

@@ -0,0 +1,14 @@
+module Blacklight::Folders
+  module FoldersHelper
+
+    def human_friendly_visibility(visibility)
+      icon = visibility == Blacklight::Folders::Folder::PUBLIC ? 'unlock' : 'lock'
+      safe_join([content_tag(:span, '', class:"glyphicon glyphicon-#{icon}"),
+        t("activerecord.attributes.blacklight/folders/folder.visibility.#{visibility}")], ' ')
+    end
+
+    def folder_export_url(folder, format)
+      polymorphic_path([blacklight_folders, folder], format: format, only_path: false, encrypted_user_id: encrypt_user_id(current_or_guest_user.id))
+    end
+  end
+end

data/app/helpers/blacklight/folders/main_app_helper.rb

@@ -0,0 +1,30 @@
+# This helper is included by the main app, so that Blacklight Catalog pages can use these functions.
+module Blacklight::Folders::MainAppHelper
+  # Give a list of folder options for a select drop down
+  # @param [Hash] options
+  # @option options [SolrDocument] :without only show folders that don't include this document
+  def options_for_folder_select(options={})
+    collection = if current_or_guest_user.guest?
+      current_or_guest_user.folders
+    else
+      folders = Blacklight::Folders::Folder.for_user(current_or_guest_user)
+      folders = folders.without_document(options[:without]) if options.key?(:without)
+      sort_folders_with_default_first(folders, current_or_guest_user.default_folder)
+    end
+
+    truncated_options_for_select(collection, :name, :id, length: 25, separator: ' ')
+  end
+
+  def truncated_options_for_select(collection, value, key, opts = {})
+    options_for_select(collection.map { |c| [truncate(c[value], opts), c[key]] } )
+  end
+
+  def sort_folders_with_default_first(folders, default)
+    if default
+      [default] + (folders - [default])
+    else
+      folders
+    end
+  end
+
+end

data/app/models/ability.rb

@@ -0,0 +1,4 @@
+class Ability
+  include CanCan::Ability
+  include Blacklight::Folders::Ability
+end

data/app/models/blacklight/folders/folder.rb

@@ -0,0 +1,120 @@
+module Blacklight::Folders
+  class Folder < ActiveRecord::Base
+    belongs_to :user, polymorphic: true
+    validates :user, presence: true
+    validates :name, presence: true
+
+    after_initialize :default_values
+
+    has_many :items, -> { order('position ASC') }, class_name: 'FolderItem', :dependent => :destroy
+    has_many :bookmarks, -> { order('blacklight_folders_folder_items.position ASC') }, through: :items
+    accepts_nested_attributes_for :items, allow_destroy: true
+
+    # visibility
+    PUBLIC = 'public'
+    PRIVATE = 'private'
+    before_save :apply_visibility
+
+    # How many folders will appear in the drop-down menu
+    MENU_LIMIT = 5
+
+    def default_values
+      self.number_of_members ||= 0
+      self.visibility ||= Blacklight::Folders::Folder::PRIVATE
+    end
+
+    def recalculate_size
+      self.number_of_members = items.count
+    end
+
+    def documents
+      response.documents
+    end
+
+    def response
+      @response ||= begin
+        doc_ids = bookmarks.pluck(:document_id)
+        # return [] if doc_ids.empty?
+
+        rows = doc_ids.count
+        query_ids = doc_ids.map{|id| RSolr.escape(id) }
+        query_ids = query_ids.join(' OR ')
+
+        query = query_ids.blank? ? '' : "id:(#{query_ids})"
+        solr_repository.search(q: query, qt: 'document', rows: rows).tap do |response|
+          response.order = doc_ids
+        end
+      end
+    end
+
+    def apply_visibility
+      self.visibility ||= default_visibility
+    end
+
+    def add_bookmarks(doc_ids=[])
+      doc_ids = Array(doc_ids)
+      doc_ids.each do |doc_id|
+        b = bookmarks.build(document_id: doc_id, user_id: user_id)
+        b.document_type = blacklight_config.solr_document_model.to_s
+      end
+    end
+
+    def remove_bookmarks(target=[])
+      items.delete(target)
+    end
+
+    protected
+      def default_visibility
+        PRIVATE
+      end
+
+      def solr_repository
+        @solr_repo ||= Blacklight::SolrRepository.new(blacklight_config)
+      end
+
+      def blacklight_config
+         @blacklight_config ||= begin
+           ::CatalogController.blacklight_config.deep_copy.tap do |config|
+             config.solr_response_model = Blacklight::Folders::SolrResponse
+           end
+         end
+      end
+
+    class << self
+
+      # Find the folders that belong to this user
+      def for_user(user)
+        if user.new_record?
+          user.folders
+        else
+          accessible_by(user.ability, :update).order(:name)
+        end
+      end
+
+      # Find the folders that contain this document
+      def with_document(document)
+        where("id in (#{membership_query(document)})")
+      end
+
+      # Find the folders that don't contain this document
+      def without_document(document)
+        where("id not in (#{membership_query(document)})")
+      end
+
+      def most_recent
+        order('updated_at DESC')
+      end
+
+      def default_folder_name
+        I18n.translate(:'blacklight.folders.default_folder_name')
+      end
+
+      private
+
+        def membership_query(document)
+          Blacklight::Folders::FolderItem.select(:folder_id).joins(:bookmark).where('bookmarks.document_id' => document.id).to_sql
+        end
+
+    end # class << self
+  end
+end

data/app/models/blacklight/folders/folder_item.rb

@@ -0,0 +1,21 @@
+require 'acts_as_list'
+
+module Blacklight::Folders
+  class FolderItem < ActiveRecord::Base
+    after_save :recount_folders
+    belongs_to :folder, touch: true
+    validates :folder_id, presence: true
+    acts_as_list scope: :folder
+
+    belongs_to :bookmark, dependent: :destroy
+    validates :bookmark_id, presence: true
+
+    def recount_folders
+      Array(changes['folder_id']).compact.each do |folder_id|
+        f = Folder.find(folder_id)
+        f.recalculate_size
+        f.save!
+      end
+    end
+  end
+end

data/app/models/blacklight/folders/solr_response.rb

@@ -0,0 +1,20 @@
+module Blacklight::Folders
+  class SolrResponse < Blacklight::SolrResponse
+    attr_reader :doc_ids
+    def docs
+      @docs ||= begin
+        # Put them into the right order (same order as doc_ids),
+        # and cast them to the right model.
+        doc_ids.map.with_index {|id, i|
+          doc_hash = (response['docs'] || []).find{|doc| doc['id'] == id }
+          raise "Couldn't find Solr document for id: `#{id}'" unless doc_hash
+          doc_hash
+        }
+      end
+    end
+
+    def order= doc_ids
+      @doc_ids = doc_ids
+    end
+  end
+end

data/app/models/concerns/blacklight/folders/ability.rb

@@ -0,0 +1,39 @@
+module Blacklight::Folders
+  module Ability
+    def initialize(user)
+      super()
+      folder_permissions(user)
+    end
+
+    def folder_permissions(user)
+      can_manage_my_own_folders(user)
+      can_read_public_folders(user)
+      can :index, Blacklight::Folders::Folder, user_id: user.try(:id)
+    end
+
+    def can_manage_my_own_folders(user)
+      return unless user
+      can [:update_bookmarks], Blacklight::Folders::Folder, user_id: user.id
+      if user.guest?
+        guest_permissions(user)
+      else
+        can [:read, :update, :create, :destroy], Blacklight::Folders::Folder, user_id: user.id
+      end
+
+      can [:create, :destroy], Blacklight::Folders::FolderItem, folder: { user_id: user.id }
+    end
+
+    def can_read_public_folders(user)
+      can :show, Blacklight::Folders::Folder, visibility: Blacklight::Folders::Folder::PUBLIC
+    end
+
+
+    def guest_permissions(user)
+      if user.persisted?
+        can [:read, :update], Blacklight::Folders::Folder, ['user_id = ? AND id IS NOT NULL', user.id] do |f|
+          f.user_id == user.id && f.persisted?
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/blacklight/folders/solr_document.rb

@@ -0,0 +1,3 @@
+module Blacklight::Folders::SolrDocument
+  extend ActiveSupport::Concern
+end

data/app/models/concerns/blacklight/folders/user.rb

@@ -0,0 +1,20 @@
+module Blacklight::Folders::User
+  extend ActiveSupport::Concern
+
+  included do
+    has_many :folders, class_name: 'Blacklight::Folders::Folder', as: :user, inverse_of: :user
+    after_create :create_default_folder
+  end
+
+  def create_default_folder
+    folders.create(name: Blacklight::Folders::Folder.default_folder_name) unless guest?
+  end
+
+  def default_folder
+    folders.where(name: Blacklight::Folders::Folder.default_folder_name).first
+  end
+
+  def ability
+    @ability ||= ::Ability.new(self)
+  end
+end

data/app/views/blacklight/folders/_add_to_folder.html.erb

@@ -0,0 +1,10 @@
+<div id="folder-tools">
+  <% # This displays the folder dropdown on the search page %>
+  <%= form_tag blacklight_folders.add_bookmarks_to_folder_path, method: :patch, data: { behavior: 'move-to-folder' }, style: 'display: none', role: 'form', class: 'form-inline' do %>
+    <div class="form-group">
+      <%= label_tag :folder_id, t('catalog.search.folder.label', doctype: Blacklight::Folders::FolderItem.model_name.human, model: Blacklight::Folders::Folder.model_name.human), class: 'sr-only' %>
+      <%= select_tag :id, options_for_folder_select, prompt: t(:'.select.prompt'), class: "form-control"%>
+      <%= hidden_field_tag(:document_ids, '') %>
+    </div>
+  <% end %>
+</div>

data/app/views/blacklight/folders/_folder_control.html.erb

@@ -0,0 +1 @@
+<%= check_box_tag 'folder_ids[]', document.id, nil, style: 'display: none'%>

data/app/views/blacklight/folders/folders/_folder.html.erb

@@ -0,0 +1,22 @@
+        <tr>
+          <td>
+            <%= can?(:show, folder) ? link_to(folder.name, blacklight_folders.folder_path(folder)) : folder.name %>
+          </td>
+          <td>
+            <%= pluralize(folder.items.count, Blacklight::Folders::FolderItem.model_name.human.downcase) %>
+          </td>
+          <td>
+            <%= human_friendly_visibility(folder.visibility) %>
+          </td>
+          <td>
+            <span title="<%= folder.created_at %>"><%= t('.ago', time: time_ago_in_words(folder.created_at)) %></span>
+          </td>
+          <td>
+            <span title="<%= folder.updated_at %>"><%= t('.ago', time: time_ago_in_words(folder.updated_at)) %></span>
+          </td>
+
+          <td>
+            <%= link_to 'Edit', blacklight_folders.edit_folder_path(folder), method: :get, class: 'btn btn-default' if can? :edit, folder %>
+            <%= link_to 'Delete', blacklight_folders.folder_path(folder), method: :delete, class: 'btn btn-danger', data: { confirm: "Are you sure you want to delete this folder and all its contents?" } if can? :destroy, folder %> </td>
+        </tr>
+

data/app/views/blacklight/folders/folders/_folder_item.html.erb

@@ -0,0 +1,2 @@
+<% doc = docs[folder_item_counter] %>
+<%= render 'document', document: docs[folder_item_counter], document_counter: folder_item_counter %>