discerner 1.1.18

data/db/migrate/20130222052924_change_search_attribute_to_method.rb

@@ -0,0 +1,29 @@
+class ChangeSearchAttributeToMethod < ActiveRecord::Migration
+  class Search < ActiveRecord::Base
+    include Discerner::Methods::Models::Parameter
+  end
+
+  def self.up
+    add_column :discerner_parameters, :search_method, :string
+
+    Discerner::Parameter.order(:id).each do |p|
+      p.search_method = p.search_attribute
+      p.save!
+    end
+
+    remove_index :discerner_parameters, :name => 'index_discerner_parameters'
+    remove_column :discerner_parameters, :search_attribute
+  end
+
+  def self.down
+    add_column :discerner_parameters, :search_attribute, :string
+
+    Discerner::Parameter.order(:id).each do |p|
+      p.search_attribute = p.search_method
+      p.save!
+    end
+
+    remove_column :discerner_parameters, :search_method
+    add_index :discerner_parameters, [:search_model, :search_attribute, :parameter_category_id, :deleted_at], :unique => true, :name => 'index_discerner_parameters'
+  end
+end

data/db/migrate/20130222070959_add_export_columns_to_discerner_parameters.rb

@@ -0,0 +1,6 @@
+class AddExportColumnsToDiscernerParameters < ActiveRecord::Migration
+  def change
+    add_column :discerner_parameters, :export_model, :string
+    add_column :discerner_parameters, :export_method, :string
+  end
+end

data/db/migrate/20130227031747_add_unique_identifier_to_discerner_operators.rb

@@ -0,0 +1,16 @@
+class AddUniqueIdentifierToDiscernerOperators < ActiveRecord::Migration
+  class Operator < ActiveRecord::Base
+    include Discerner::Methods::Models::Operator
+  end
+
+  def change
+    add_column :discerner_operators, :unique_identifier, :string
+
+    Discerner::Operator.order(:id).each do |p|
+      p.unique_identifier = p.text.parameterize.underscore
+      p.save!
+    end
+    remove_index :discerner_operators, :name => 'index_discerner_operators'
+    add_index :discerner_operators, [:unique_identifier, :deleted_at], :unique => true, :name => 'index_discerner_operators'
+  end
+end

data/db/migrate/20130306015019_change_discerner_parameter_values_name.rb

@@ -0,0 +1,9 @@
+class ChangeDiscernerParameterValuesName < ActiveRecord::Migration
+  def up
+    change_column :discerner_parameter_values, :name, :string, :limit => 1000
+  end
+
+  def down
+    change_column :discerner_parameter_values, :name, :string, :limit => 255
+  end
+end

data/db/migrate/20130306212430_add_deleted_at_to_discerner_search_parameters.rb

@@ -0,0 +1,5 @@
+class AddDeletedAtToDiscernerSearchParameters < ActiveRecord::Migration
+  def change
+    add_column :discerner_search_parameters, :deleted_at, :datetime
+  end
+end

data/db/migrate/20130306212504_add_deleted_at_to_discerner_search_parameter_values.rb

@@ -0,0 +1,5 @@
+class AddDeletedAtToDiscernerSearchParameterValues < ActiveRecord::Migration
+  def change
+    add_column :discerner_search_parameter_values, :deleted_at, :datetime
+  end
+end

data/db/migrate/20130306212527_add_deleted_at_to_discerner_search_combinations.rb

@@ -0,0 +1,5 @@
+class AddDeletedAtToDiscernerSearchCombinations < ActiveRecord::Migration
+  def change
+    add_column :discerner_search_combinations, :deleted_at, :datetime
+  end
+end

data/db/migrate/20130306212818_add_deleted_at_to_discerner_export_parameters.rb

@@ -0,0 +1,5 @@
+class AddDeletedAtToDiscernerExportParameters < ActiveRecord::Migration
+  def change
+    add_column :discerner_export_parameters, :deleted_at, :datetime
+  end
+end

data/db/migrate/20130311190717_add_operator_type_to_discerner_operators.rb

@@ -0,0 +1,5 @@
+class AddOperatorTypeToDiscernerOperators < ActiveRecord::Migration
+  def change
+    add_column :discerner_operators, :operator_type, :string
+  end
+end

data/db/migrate/20131212175110_remove_extra_search_parameter_values.rb

@@ -0,0 +1,10 @@
+class RemoveExtraSearchParameterValues < ActiveRecord::Migration
+  def up
+    sql = Discerner::SearchParameterValue.joins(:search_parameter => {:parameter => :parameter_type}).where("discerner_parameter_types.name = 'combobox' and chosen is null").to_sql
+    search_parameter_values_array = Discerner::SearchParameterValue.find_by_sql(sql)
+    search_parameter_values_array.each{|r| r.delete}
+  end
+
+  def down
+  end
+end

data/db/migrate/20140204170625_create_discerner_parameter_value_categories.rb

@@ -0,0 +1,16 @@
+class CreateDiscernerParameterValueCategories < ActiveRecord::Migration
+  def change
+    create_table :discerner_parameter_value_categories do |t|
+      t.integer :parameter_id
+      t.string :name
+      t.string :unique_identifier
+      t.integer :display_order
+      t.datetime :deleted_at
+      t.boolean :collapse
+
+      t.timestamps
+    end
+
+    add_index :discerner_parameter_value_categories, [:parameter_id, :unique_identifier, :deleted_at], :unique => true, :name => 'discerner_parameter_value_categories_uniq_index'
+  end
+end

data/db/migrate/20140204170646_create_discerner_parameter_value_categorizations.rb

@@ -0,0 +1,12 @@
+class CreateDiscernerParameterValueCategorizations < ActiveRecord::Migration
+  def change
+    create_table :discerner_parameter_value_categorizations do |t|
+      t.integer :parameter_value_category_id
+      t.integer :parameter_value_id
+      t.datetime :deleted_at
+
+      t.timestamps
+    end
+    add_index :discerner_parameter_value_categorizations, [:parameter_value_category_id, :parameter_value_id, :deleted_at], :unique => true, :name => 'discerner_parameter_value_categorizations_uniq_index'
+  end
+end

data/db/migrate/20140227191827_remove_blank_parameter_values_from_export_parameters.rb

@@ -0,0 +1,10 @@
+class RemoveBlankParameterValuesFromExportParameters < ActiveRecord::Migration
+  def up
+    Discerner::Parameter.where(:search_model => nil).each do |p|
+      p.parameter_values.destroy_all
+    end
+  end
+
+  def down
+  end
+end

data/lib/discerner/engine.rb

@@ -0,0 +1,16 @@
+require 'haml'
+require 'jquery-rails'
+require 'jquery-ui-rails'
+
+module Discerner
+  class Engine < ::Rails::Engine
+    isolate_namespace Discerner
+    root = File.expand_path('../../', __FILE__)
+    config.autoload_paths << root
+    config.generators do |g|
+      g.test_framework   :rspec
+      g.integration_tool :rspec
+      g.template_engine  :haml
+    end
+  end
+end

data/lib/discerner/methods/controllers/export_parameters_controller.rb

@@ -0,0 +1,38 @@
+module Discerner
+  module Methods
+    module Controllers
+      module ExportParametersController
+        def self.included(base)
+          base.send :helper, :all
+          base.send :before_filter, :load_search
+          base.send :layout, 'layouts/discerner/searches'
+        end
+
+        def index
+          if @discerner_search.disabled?
+            error_message = "There is an issue with the this export that has to be corrected before it can be executed"
+            if @discerner_search.warnings.any?
+              error_message << ': '
+              error_message << @discerner_search.warnings.full_messages.join(',')
+            end
+          end
+          flash[:error] = error_message unless error_message.blank?
+        end
+
+        def assign
+          existing_export_parameters = @discerner_search.export_parameters || []
+          export_parameter_ids = params[:parameter_ids] || []
+
+          existing_export_parameters.map{ |export_parameter| export_parameter.delete unless export_parameter_ids.include?(export_parameter.parameter_id) }
+          export_parameter_ids.map{ |parameter_id| @discerner_search.export_parameters.create(:parameter_id => parameter_id) unless existing_export_parameters.where(:parameter_id => parameter_id).any?}
+          redirect_to search_path(@discerner_search, :format => 'xls')
+        end
+
+        private
+          def load_search
+            @discerner_search = Discerner::Search.find(params[:id])
+          end
+      end
+    end
+  end
+end

data/lib/discerner/methods/controllers/parameters_controller.rb

@@ -0,0 +1,30 @@
+module Discerner
+  module Methods
+    module Controllers
+      module ParametersController
+        def self.included(base)
+          base.send :before_filter, :load_parameter
+        end
+
+        def values
+          @parameter_values = @parameter.parameter_values.includes(:parameter_value_category).not_deleted.ordered_by_name
+          @search_parameter_value_id = params[:search_parameter_value_id]
+          @searchable_parameter_values = {}
+          @searchable_parameter_values[@parameter.id] = @parameter_values
+          respond_to do |format|
+            format.html { render :layout => false }
+            format.json { render :text => { :type => @parameter.parameter_type.name,
+              :parameter_values => @parameter_values.map { |v| { :parameter_value_id => v.id, :name => v.name } }}.to_json }
+          end
+        end
+
+        private
+          def load_parameter
+            id = params[:id]
+            id ||= params[:parameter_id]
+            @parameter = Parameter.find(id)
+          end
+      end
+    end
+  end
+end

data/lib/discerner/methods/controllers/searches_controller.rb

@@ -0,0 +1,204 @@
+module Discerner
+  module Methods
+    module Controllers
+      module SearchesController
+        def self.included(base)
+          base.send :before_filter, :load_search, :only => [:edit, :update, :rename, :destroy, :show]
+        end
+
+        def new
+          set_searchable_dictionaries
+          if @searchable_dictionaries.any?
+            set_searchables
+            @discerner_search = Discerner::Search.new
+          else
+            flash[:error] = 'No searchable dictionaries found. Make sure that dictionaries are loaded.'
+          end
+        end
+
+        def create
+          @discerner_search           = Discerner::Search.new(params[:search])
+          @discerner_search.username  = discerner_user.username unless discerner_user.blank?
+
+          set_searchable_dictionaries
+          set_searchables
+          respond_to do |format|
+            if @discerner_search.save
+              format.html { redirect_to(edit_search_path(@discerner_search)) }
+            else
+              format.html { render :action => "new" }
+            end
+          end
+        end
+
+        def edit
+          set_searchable_dictionaries
+          set_searchables
+
+          if @discerner_search.disabled?
+            error_message = "There is an issue with the this search that has to be corrected before it can be executed"
+            if @discerner_search.warnings.any?
+              error_message << ': '
+              error_message << @discerner_search.warnings.full_messages.join(',')
+            end
+          else
+            if dictionary_model
+              dictionary =  dictionary_model.new(@discerner_search)
+              if dictionary.respond_to?('search')
+                @results = dictionary.search(params, dictionary_search_options)
+              else
+                error_message = "Model '#{dictionary_model_name}' instance does not respond to 'search' method. You need to implement it to be able to run search on this dictionary"
+              end
+            else
+              error_message = "Model '#{dictionary_model_name}' could not be found. You need to create it to be able to run search on this dictionary"
+            end
+          end
+          flash[:error] = error_message unless error_message.blank?
+        end
+
+        def update
+          set_searchable_dictionaries
+          set_searchables
+          respond_to do |format|
+            if @discerner_search.update_attributes(params[:search])
+              format.html { redirect_to(edit_search_path(@discerner_search), :notice => 'Search was successfully updated.') }
+              format.js
+            else
+              format.html { render :action => "edit" }
+              format.js
+            end
+          end
+        end
+
+        def index
+          searches = Discerner::Search.not_deleted.includes(
+            :dictionary,
+            :export_parameters   => [:parameter => [:parameter_type]],
+            :search_combinations => [:combined_search => [:search_parameters => [:parameter => [:parameter_type], :search_parameter_values => [:parameter_value]]]],
+            :search_parameters   => [:parameter => [:parameter_type], :search_parameter_values => [:parameter_value]])
+
+          username = discerner_user.username unless discerner_user.blank?
+          searches = searches.by_user(username) unless username.blank?
+
+          searches = searches.where('discerner_searches.name like ?', '%' + params[:query] + '%') unless params[:query].blank?
+          @discerner_searches = searches.order("discerner_searches.updated_at DESC")
+        end
+
+        def destroy
+          @discerner_search.deleted_at = Time.now
+          @discerner_search.save
+          respond_to do |format|
+            format.html { redirect_to searches_path }
+          end
+        end
+
+        def show
+          if @discerner_search.disabled?
+            error_message = "There is an issue with the this search that has to be corrected before it can be exported"
+            if @discerner_search.warnings.any?
+              error_message << ': '
+              error_message << @discerner_search.warnings.full_messages.join(',')
+            end
+          else
+            if dictionary_model
+              dictionary =  dictionary_model.new(@discerner_search)
+              if not dictionary.respond_to?('export')
+                error_message = "Model '#{dictionary_model_name}' instance does not respond to 'export' method. You need to implement it to be able to run export on this dictionary"
+              end
+            else
+              error_message = "Model '#{dictionary_model_name}' could not be found. You need to create it to be able to run export on this dictionary"
+            end
+          end
+          flash[:error] = error_message unless error_message.blank?
+
+          respond_to do |format|
+            if error_message
+              format.html
+              format.csv { redirect_to export_parameters_path(@discerner_search)  }
+              format.xls { redirect_to export_parameters_path(@discerner_search)  }
+            else
+              @export_data = dictionary.export(params, dictionary_search_options)
+              filename ="#{@discerner_search.parameterized_name}_#{Date.today.strftime('%m_%d_%Y')}"
+              format.html
+              format.csv do
+
+                send_data @export_data,
+                  :type => 'text/csv; charset=iso-8859-1; header=present',
+                  :disposition => "attachment; filename=#{filename}.csv"
+              end
+              format.xls do
+                headers["Content-type"] = "application/vnd.ms-excel"
+                headers['Content-Transfer-Encoding'] = 'binary'
+                headers['Expires'] = '0'
+                headers['Pragma'] = 'public'
+                headers["Cache-Control"] = "must-revalidate, post-check=0, pre-check=0"
+                headers["Content-Disposition"] = "attachment; filename=\"#{filename}.xls\""
+                headers['Content-Description'] = 'File Transfer'
+                render "discerner/dictionaries/#{@discerner_search.dictionary.parameterized_name}/show"
+              end
+            end
+          end
+        end
+
+        private
+          def load_search
+            @discerner_search = Discerner::Search.find(params[:id])
+          end
+
+          def dictionary_model_name
+            @discerner_search.dictionary.parameterized_name.camelize
+          end
+
+          def dictionary_model
+            dictionary_model_name.safe_constantize
+          end
+
+          def dictionary_search_options
+            options = { :username => nil }
+            options[:username] = discerner_user.username unless discerner_user.blank?
+            options
+          end
+
+          def set_searchable_dictionaries
+            if @discenrer_search && @discerner_search.persisted?
+              @searchable_dictionaries = [@discerner_search.dictionary]
+            else
+              @searchable_dictionaries = Discerner::Dictionary.not_deleted
+            end
+          end
+
+          def set_searchables
+            if @discerner_search
+              dictionary_ids = []
+              dictionary_ids << @discerner_search.dictionary_id
+            else
+              dictionary_ids = @searchable_dictionaries.map(&:id)
+            end
+
+            @searchable_parameter_categories  = Discerner::ParameterCategory.includes(:dictionary).where(:dictionary_id => dictionary_ids).not_deleted.searchable.ordered_by_name.to_a
+            parameters_available              = Discerner::Parameter.includes(:parameter_type, :parameter_category => [:dictionary]).where(:parameter_category_id => @searchable_parameter_categories.map(&:id)).not_deleted.searchable.to_a
+            parameters_used                   = @discerner_search && @discerner_search.persisted? ? @discerner_search.search_parameters.map{ |sp| sp.parameter } : []
+            @searchable_parameters            = parameters_available.flatten | parameters_used.flatten
+            @searchable_parameter_values      = map_searchable_values
+          end
+
+          def map_searchable_values
+            searchable_values = {}
+
+            # getting all values at once to save database calls
+            values_available = Discerner::ParameterValue.includes(:parameter_value_category).not_deleted.where(:parameter_id => @searchable_parameters.map(&:id)).ordered_by_parameter_and_name.to_a
+            values_used = []
+            if @discerner_search && @discerner_search.persisted?
+              values_used = Discerner::ParameterValue.includes(:parameter_value_category).joins(:search_parameter_values => :search_parameter).where(:discerner_search_parameters => {:search_id => @discerner_search.id}).ordered_by_parameter_and_name.to_a
+            end
+
+            @searchable_parameters.each do |sp|
+              values  = values_available.select{|pv| pv.parameter_id == sp.id} | values_used.select{|pv| pv.parameter_id == sp.id}
+              searchable_values[sp.id] = values.uniq.reject{|v| v.blank?}
+            end
+            searchable_values
+          end
+     end
+    end
+  end
+end

data/lib/discerner/methods/helpers/searches_helper.rb

@@ -0,0 +1,145 @@
+module Discerner
+  module Methods
+    module Helpers
+      module SearchesHelper
+        def discerner_results_partial
+          "discerner/dictionaries/#{@discerner_search.dictionary.parameterized_name}/results"
+        end
+
+        def generate_nested_attributes_template(f, association, association_prefix = nil )
+          if association_prefix.nil?
+            association_prefix = association.to_s.singularize
+          end
+          new_object = f.object.class.reflect_on_association(association).klass.new
+          fields = f.fields_for(association, new_object, :child_index => "new_#{association}") do |form_builder|
+            render(association_prefix + "_fields", :f => form_builder)
+          end
+          escape_javascript(fields)
+        end
+
+        def link_to_add_fields(name, association, html_options={})
+          css_class = html_options[:class] || ' '
+          css_class += "add_#{association.to_s} add add_link icon_link"
+          html_options[:class] = css_class
+          link_to(name, 'javascript:void(0);', html_options)
+        end
+
+        def link_to_remove_fields(name, f, association)
+          f.hidden_field(:_destroy) + link_to(name, "javascript:void(0);", :class => "delete_#{association.to_s} delete_link icon_link")
+        end
+
+        def link_to_soft_delete_fields(name, f, association)
+          f.hidden_field(:soft_delete) + link_to(name, "javascript:void(0);", :class => "delete_#{association.to_s} delete_link icon_link")
+        end
+
+        def nested_record_id(builder, assocation)
+          builder.object.id.nil? ? "new_nested_record" : "#{assocation.to_s.singularize}_#{builder.object.id}"
+        end
+
+        def operator_options(type=nil)
+          operators = Discerner::Operator.not_deleted
+          unless type.blank?
+            operators = operators.joins(:parameter_types).where("discerner_parameter_types.name in (?)", type).
+            select('DISTINCT text, discerner_operators.id, discerner_operators.operator_type')
+          end
+          operators.includes(:parameter_types).uniq.map {|o| [o.text, o.id, {:class => o.css_class_name}]}
+        end
+
+        def dictionary_options(searchable_dictionaries)
+          searchable_dictionaries.map{|d| [d.name, d.id, {:class => d.css_class_name}]}
+        end
+
+        def combined_searches_options(search=nil)
+          all_searches = Discerner::Search.order(:id)
+
+          username = discerner_user.username unless discerner_user.blank?
+          all_searches = all_searches.by_user(username) unless username.blank?
+
+          if search.blank? || !search.persisted?
+            searches = all_searches.not_deleted.reject{|s| s.disabled?}
+          else
+            searches_available = all_searches.not_deleted.
+              where('id != ? and dictionary_id = ?', search.id,search.dictionary_id).
+              reject{|s| s.nested_searches.include?(search) || s.disabled?}
+            searches_used = search.combined_searches
+            searches = searches_available | searches_used
+          end
+          searches.map {|s| [s.display_name, s.id, {:class => s.dictionary.css_class_name}]}
+        end
+
+        def parameter_options(searchable_parameters, base_id=nil)
+          options = []
+          searchable_parameters.each do |p|
+            option = [p.display_name, p.id]
+            html_options = {:class => p.css_class_name}
+            html_options[:id] = searchable_object_index(p, base_id) unless base_id.blank?
+            option << html_options
+            options << option
+          end
+          options
+        end
+
+        def parameter_value_options(searchable_values, base_id=nil)
+          options = []
+          searchable_values.each do |pv|
+            option = [pv.display_name, pv.id]
+            html_options = {}
+            html_options[:id] = searchable_object_index(pv, base_id) unless base_id.blank?
+            option << html_options
+            options << option
+          end
+          options
+        end
+
+        def searchable_object_index(object, base_id=nil)
+          "#{base_id}_#{object.id}"
+        end
+
+        def exportable_parameter_categories(search=nil)
+          if search.blank? || !search.persisted?
+            parameter_categories = Discerner::ParameterCategory.not_deleted.exportable.to_a
+          else
+            parameter_categories_available = search.dictionary.parameter_categories.exportable.to_a
+            parameter_categories_used      = search.export_parameters.map{ |ep| ep.parameter.parameter_category }.flatten
+            parameter_categories           = parameter_categories_available | parameter_categories_used
+          end
+          parameter_categories.sort{|a,b| a.parameters.length <=> b.parameters.length}
+        end
+
+        def exportable_parameters(search, category)
+          return if search.blank? || !search.persisted?
+          parameters_available = category.parameters.exportable.to_a
+          parameters_used      = search.export_parameters.map{|ep| ep.parameter}.reject{|p| p.parameter_category != category }.flatten
+          parameters           = parameters_available | parameters_used
+          parameters.sort{|a,b| a.name <=> b.name}
+        end
+
+        def search_parameter_values(search_parameter)
+          search_parameter_values = search_parameter.parameter.parameter_type.name == 'list' ? search_parameter.search_parameter_values.chosen : search_parameter.search_parameter_values
+          display_values = []
+          search_parameter_values.each do |spv|
+            string = ''
+            value = spv.parameter_value.blank? ? spv.value : spv.parameter_value.name
+            string += spv.operator.text unless spv.operator.blank?
+            string += " \"#{value}\"" unless value.blank?
+            string += " \"#{spv.additional_value}\"" unless spv.additional_value.blank?
+            display_values << string
+          end
+          display_values.join(' or ')
+        end
+
+        def discerner_export_link
+          link_to "Export options", export_parameters_path(@discerner_search), :class => "discerner-button discerner-button-positive"
+        end
+
+        def format_datetime(datetime)
+          datetime.strftime("%m/%d/%Y %I:%M %p") if datetime
+        end
+
+        def format_date(date)
+          date.strftime("%m/%d/%Y") if date
+        end
+      end
+    end
+  end
+end

data/lib/discerner/methods/models/dictionary.rb

@@ -0,0 +1,54 @@
+module Discerner
+  module Methods
+    module Models
+      module Dictionary
+        def self.included(base)
+          base.send :include, SoftDelete
+
+          # Associations
+          base.send :has_many, :parameter_categories, :dependent => :destroy
+          base.send :has_many, :searches
+
+          #Validations
+          base.send :validates, :name, :presence => true, :uniqueness => {:message => "for dictionary has already been taken"}
+
+          # Hooks
+          base.send :after_commit, :cascade_delete_parameter_categories, :on => :update, :if => Proc.new { |record| record.previous_changes.include?('deleted_at') }
+
+          # Whitelisting attributes
+          base.send :attr_accessible, :name, :deleted_at
+        end
+
+        # Instance Methods
+        def initialize(*args)
+          super(*args)
+        end
+
+        def css_class_name
+          "dictionary_#{parameterized_name}"
+        end
+
+        def parameterized_name
+          name.parameterize.underscore
+        end
+
+        def searchable_categories
+          parameter_categories.searchable
+        end
+
+        def exportable_categories
+          parameter_categories.exportable
+        end
+
+        private
+          def cascade_delete_parameter_categories
+            return unless deleted?
+            parameter_categories.each do |pc|
+              pc.deleted_at = Time.now
+              pc.save
+            end
+          end
+      end
+    end
+  end
+end