atrium 0.0.1 → 0.1.1

data/app/models/atrium/is_showcased_mixin.rb

@@ -0,0 +1,34 @@
+require 'active_support/concern'
+module Atrium::IsShowcasedMixin
+  extend ActiveSupport::Concern
+
+  included do
+    has_many(
+      :showcases,
+      class_name: 'Atrium::Showcase',
+      as: :showcases,
+      dependent: :destroy
+    )
+    accepts_nested_attributes_for :showcases
+
+    def showcase_order
+      showcases.each_with_object({}) { |showcase, object|
+        object[showcase[:id]] = showcase.sequence
+      }
+    end
+
+    def showcase_order=(showcase_order = {})
+      showcase_order.each_pair do |showcase_id, sequence|
+        begin
+          showcases.find(showcase_id).update_attributes!(sequence: sequence)
+        rescue ActiveRecord::RecordNotFound
+        end
+      end
+    end
+    attr_accessible(
+      :showcase_order,
+      :showcases_attributes
+    )
+
+  end
+end

data/app/models/atrium/query_param_mixin.rb

@@ -0,0 +1,105 @@
+require 'active_support/concern'
+module Atrium::QueryParamMixin
+  extend ActiveSupport::Concern
+
+  included do
+
+    def find_saved_search_and_format_to_query(search_id)
+      @saved_search_id = search_id
+      return @saved_search_id unless @saved_search_id.present?
+      saved_search = nil
+      begin
+        saved_search = Atrium.saved_search_class.find(search_id)
+      rescue ActiveRecord::RecordNotFound
+        @saved_search_id = nil
+      end
+      @saved_search_id = nil
+      formatted_query_params = {}
+      if saved_search
+        if saved_search.query_params.has_key?(:f)
+          formatted_query_params[:f] = saved_search.query_params[:f]
+        end
+        if saved_search.query_params.has_key?(:q)
+          formatted_query_params[:q] = saved_search.query_params[:q]
+        end
+      end
+      formatted_query_params
+    end
+
+    attr_reader :include_search_id
+
+    attr_accessible :include_search_id
+
+    def include_search_id=(value)
+      return value unless value.present?
+      self.filter_query_params = find_saved_search_and_format_to_query(value)
+    end
+
+    attr_reader :exclude_search_id
+
+    attr_accessible :exclude_search_id
+
+    def exclude_search_id=(value)
+      return value unless value.present?
+      query_params={}
+      query_params[:exclude] =  find_saved_search_and_format_to_query(value)
+      self.exclude_query_params=query_params
+    end
+
+    serialize :filter_query_params, Hash
+
+    def filter_query_params
+      begin
+        super
+      rescue ActiveRecord::SerializationTypeMismatch
+        {}
+      end
+    end
+
+    serialize :exclude_query_params, Hash
+
+    def exclude_query_params
+      begin
+        super
+      rescue ActiveRecord::SerializationTypeMismatch
+        {}
+      end
+    end
+
+    # This is a hopefully temporary work around that can be removed once all
+    # atrium instances have a clean set of data.
+    def read_attribute(attr_name)
+      if attr_name.to_s == 'filter_query_params' || attr_name.to_s == 'exclude_query_params'
+        begin
+          super(attr_name)
+        rescue ActiveRecord::SerializationTypeMismatch
+          {}
+        end
+      else
+        super
+      end
+    end
+
+    attr_reader :remove_filter_query_params
+
+    attr_accessible :remove_filter_query_params
+
+    def remove_filter_query_params=(value)
+      @remove_filter_query_params = value
+      self.filter_query_params = nil if @remove_filter_query_params.to_i ==1
+      @remove_filter_query_params = nil
+    end
+
+    attr_reader :remove_exclude_query_params
+
+    attr_accessible :remove_exclude_query_params
+
+    def remove_exclude_query_params=(value)
+      @remove_exclude_query_params = value
+      self.exclude_query_params = nil if @remove_exclude_query_params.to_i ==1
+      @remove_exclude_query_params = nil
+    end
+
+
+  end
+end

data/app/models/atrium/search/facet.rb

@@ -1,29 +1,18 @@
-class Atrium::Search::Facet < ActiveRecord::Base
-  self.table_name = 'atrium_search_facets'
+module Atrium
+  class Search::Facet < ActiveRecord::Base
+    self.table_name = 'atrium_search_facets'
 
-  belongs_to(
-    :collection,
-    :class_name => 'Atrium::Collection',
-    :foreign_key => 'atrium_collection_id'
-  )
+    validates :collection, presence: true
+    belongs_to(
+      :collection,
+      class_name: 'Atrium::Collection',
+      foreign_key: 'atrium_collection_id',
+      inverse_of: :search_facets
+    )
 
-  scope :find_by_name_and_collection_id, lambda {|name, collection_id|
-    where("#{self.quoted_table_name}.`name` = ? AND #{self.quoted_table_name}.`atrium_collection_id` = ?", name, collection_id)
-  }
-
-  def self.find_or_create_by_name_and_collection_id(name, collection_id)
-    find_by_name_and_collection_id(name, collection_id).first ||
-    self.create(:name => name, :atrium_collection_id => id)
+    validates :name, presence: true
+    attr_accessible(
+      :name
+    )
   end
-
-  validates_presence_of(
-    :atrium_collection_id,
-    :name
-  )
-
-  attr_accessible(
-    :atrium_collection_id,
-    :name
-  )
-
 end

data/app/models/atrium/search/facet_selection.rb

@@ -1,17 +1,15 @@
-require 'morphine'
-class Atrium::Search::FacetSelection
-  attr_reader :field_name
+module Atrium
+  class Search::FacetSelection
+    include Atrium::ApplicationHelper
 
-  def initialize(field_name)
-    @field_name = field_name
-  end
+    attr_reader :field_name
 
-  def label
-    @label ||= facet_configuration[:label]
-  end
+    def initialize(field_name_hash)
+      @field_name = field_name_hash[:field_name]
+    end
 
-  include Morphine
-  register :facet_configuration do
-    CatalogController.blacklight_config.facet_fields[field_name] || {}
+    def label
+      @label ||= Atrium.config.label_for_facet(field_name)
+    end
   end
 end

data/app/models/atrium/showcase.rb

@@ -1,88 +1,87 @@
+# A Atrium::Showcase is a container for storing feature items and descriptions.
+# A Atrium::Showcase can be attached to a collection, exhibit, or to specific
+# combinations of selected facets and facet values within an exhibit. There can
+# be multiple Atrium::Showcase in an Atrium::Exhibit.
 class Atrium::Showcase < ActiveRecord::Base
-  self.table_name = 'atrium_showcases'
-
-  # TODO: remove the need to expose the showcase_id to the AtriumShowcasesController
   attr_accessible(
     :showcases_id,
     :showcases_type,
     :showcase_items,
+    :tag,
+    :sequence,
     :solr_facet_name,
     :value,
     :descriptions_attributes,
-    :facet_selections_attributes,
-    :featured_items_attributes,
-    :related_items_attributes
+    :facet_selections_attributes
   )
 
   has_many(
     :descriptions,
-    :class_name => 'Atrium::Description',
-    :foreign_key => 'atrium_showcase_id',
-    :dependent => :destroy
+    class_name: 'Atrium::Description',
+    foreign_key: 'atrium_showcase_id',
+    dependent: :destroy,
+    inverse_of: :showcase
   )
   accepts_nested_attributes_for(
     :descriptions,
-    :allow_destroy => true
+    allow_destroy: true
   )
 
   has_many(
     :facet_selections,
-    :class_name => 'Atrium::Showcase::FacetSelection',
-    :foreign_key => 'atrium_showcase_id',
-    :dependent => :destroy
+    class_name: 'Atrium::Showcase::FacetSelection',
+    foreign_key: 'atrium_showcase_id',
+    dependent: :destroy
   )
   accepts_nested_attributes_for :facet_selections
 
-  def get_parent_path
-    if for_exhibit?
-      facet={}
-      unless facet_selections.blank?
-        facet[facet_selections.first.solr_facet_name]=facet_selections.first.value
-      end
-      path= Rails.application.routes.url_helpers.atrium_exhibit_path(parent, :f=>facet)
-      return path
-    else
-      return parent
-    end
+  def parent_title
+    parent.pretty_title
   end
 
-  has_many(
-    :featured_items,
-    :class_name => 'Atrium::Showcase::Item::Featured',
-    :foreign_key => 'atrium_showcase_id',
-    :dependent => :destroy
-  )
-  accepts_nested_attributes_for(
-    :featured_items,
-    :allow_destroy => true
-  )
+  def for_exhibit?
+    showcases_type == "Atrium::Exhibit"
+  end
 
-  has_many(
-    :related_items,
-    :class_name => 'Atrium::Showcase::Item::Related',
-    :foreign_key => 'atrium_showcase_id',
-    :dependent => :destroy
-  )
-  accepts_nested_attributes_for(
-    :related_items,
-    :allow_destroy => true
-  )
+  def facet_details
+    logger.debug("Belongs to: #{facet_selections.inspect}")
+    "#{facet_selections.solr_facet_name - facet_selections.value}"
+  end
 
   belongs_to(
     :showcases,
-    :polymorphic => true
+    polymorphic: true
   )
 
+  def parent
+    showcases
+  end
+
+  delegate :collection, to: :showcases
+
   serialize :showcase_items, Hash
 
   def showcase_items
-    read_attribute(:showcase_items) || write_attribute(:showcase_items, {})
+    items = read_attribute(:showcase_items) ||
+      write_attribute(:showcase_items, {})
+
+    if items && items[:solr_doc_ids]
+      items[:solr_doc_ids].split(",")
+    else
+      []
+    end
   end
 
-   def showcase_items=(solr_doc_ids = [])
-    showcase_items[:type]="featured"
-    showcase_items[:solr_doc_ids]=solr_doc_ids.join(',')
-    write_attribute(:showcase_items, showcase_items)
+  def showcase_items=(solr_doc_ids = [])
+    unless solr_doc_ids.blank?
+      items={}
+      items[:type]="featured"
+      items[:solr_doc_ids]=solr_doc_ids.join(',')
+      write_attribute(:showcase_items, items)
+    else
+      write_attribute(:showcase_items, {})
+    end
+
   end
 
   def solr_doc_ids
@@ -93,87 +92,98 @@ class Atrium::Showcase < ActiveRecord::Base
     showcase_items[:type] unless showcase_items.blank?
   end
 
-  def parent
-#    debugger;true
-    if showcases_type && showcases_id
-      begin
-        showcases_type.constantize.find(showcases_id)
-      rescue
-        logger.error("Invalid showcase parent type set for showcase id: #{id}")
-        nil
-      end
+  after_create :assign_sequence
+
+  def assign_sequence
+    unless for_exhibit?
+      sequence= parent.showcases.size
+      self.update_attributes(sequence: sequence)
     end
   end
 
-  def parent_title
-    parent.pretty_title
+  def pretty_title
+    id.blank? ? 'Unnamed Showcase' : "Showcase #{id}"
   end
 
-  def for_exhibit?
-    showcases_type == "Atrium::Exhibit"
-  end
 
-  # This method will select showcase objects that have exactly the selected facets passed in (but no more or no less) and is tied to the given exhibit id
+
+  # This method will select showcase objects that have exactly the selected
+  # facets passed in (but no more or no less) and is tied to the given exhibit
+  # id
+  #
   # It expects two parameters:
   # @param[String] the exhibit id
   # @param[Hash] hash of key value pairs of selected facets
   # @return Array of showcase objects found
-  scope :with_selected_facets, lambda {|*args|
+  scope :with_selected_facets, lambda { |*args|
     parent_id, parent_type, selected_facets = args.flatten(1)
-
     selected_facets =
     if parent_type.eql?("Atrium::Collection")
       {}
     else
       selected_facets
     end
+    facet_selection_quoted_table_name =
+      Atrium::Showcase::FacetSelection.quoted_table_name
     facet_condition_values = []
+
     facet_conditions =
     if selected_facets
       selected_facets.collect {|key,value|
         facet_condition_values << key
-        facet_condition_values << (value.is_a?(String) ? value : value.flatten.compact.to_s)
-
+        facet_condition_values << [value].flatten.compact.first.to_s
         %((
-          #{Atrium::Showcase::FacetSelection.quoted_table_name}.`solr_facet_name` = ?
-          AND #{Atrium::Showcase::FacetSelection.quoted_table_name}.`value` = ?
-         ))
+            #{facet_selection_quoted_table_name}.`solr_facet_name` = ?
+            AND #{facet_selection_quoted_table_name}.`value` = ?
+        ))
       }
     else
       []
     end
-
     if facet_conditions.empty?
-      joins(%(
-        LEFT OUTER JOIN #{Atrium::Showcase::FacetSelection.quoted_table_name}
-        ON #{quoted_table_name}.`id` = #{Atrium::Showcase::FacetSelection.quoted_table_name}.`atrium_showcase_id`)
+      joins(
+        %(
+          LEFT OUTER JOIN #{facet_selection_quoted_table_name}
+          ON #{quoted_table_name}.`id` =
+          #{facet_selection_quoted_table_name}.`atrium_showcase_id`
+        )
       ).
-      where(:showcases_id => parent_id,:showcases_type => parent_type).
-      where("#{Atrium::Showcase::FacetSelection.quoted_table_name}.`id` is NULL")
+        where(showcases_id: parent_id,showcases_type: parent_type).
+        where("#{facet_selection_quoted_table_name}.`id` is NULL")
     else
       # unfortunately have to do subselect here to get this correct
-      conditions = [%(
-        #{Atrium::Showcase::FacetSelection.quoted_table_name}.`atrium_showcase_id`
-        IN (
-          SELECT #{Atrium::Showcase::FacetSelection.quoted_table_name}.`atrium_showcase_id`
-          FROM #{Atrium::Showcase::FacetSelection.quoted_table_name}
-          INNER JOIN #{quoted_table_name}
-          ON #{Atrium::Showcase::FacetSelection.quoted_table_name}.`atrium_showcase_id` = #{quoted_table_name}.`id`
-          WHERE #{quoted_table_name}.showcases_id = ?
-          AND #{quoted_table_name}.`showcases_type` = ?
-          AND (#{facet_conditions.join(" OR ")})
-        )
-      ), parent_id, parent_type] + facet_condition_values
+      conditions = [
+        %(
+          #{facet_selection_quoted_table_name}.`atrium_showcase_id`
+          IN
+          (
+            SELECT #{facet_selection_quoted_table_name}.`atrium_showcase_id`
+            FROM #{facet_selection_quoted_table_name}
+            INNER JOIN #{quoted_table_name}
+            ON #{facet_selection_quoted_table_name}.`atrium_showcase_id` =
+            #{quoted_table_name}.`id`
+            WHERE #{quoted_table_name}.showcases_id = ?
+            AND #{quoted_table_name}.`showcases_type` = ?
+            AND (
+              #{facet_conditions.join(" OR ")}
+            )
+          )
+        ),
+        parent_id,
+        parent_type,
+      ] + facet_condition_values
 
       having_str = %(
-        COUNT(#{Atrium::Showcase::FacetSelection.quoted_table_name}.`atrium_showcase_id`) = #{facet_conditions.size}
+        COUNT(
+          #{facet_selection_quoted_table_name}.`atrium_showcase_id`
+        ) =
+        #{facet_conditions.size}
       )
 
       joins(:facet_selections).
-      where(conditions).
-      group("#{Atrium::Showcase::FacetSelection.quoted_table_name}.`atrium_showcase_id`").
-      having(having_str)
+        where(conditions).
+        group("#{facet_selection_quoted_table_name}.`atrium_showcase_id`").
+        having(having_str)
     end
   }
-
 end