discerner 1.1.18

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

@@ -0,0 +1,35 @@
+module Discerner
+  module Methods
+    module Models
+      module ExportParameter
+        def self.included(base)
+          base.send :include, SoftDelete
+
+          # Associations
+          base.send :belongs_to, :parameter,  :inverse_of => :export_parameters
+          base.send :belongs_to, :search,     :inverse_of => :export_parameters
+
+          # Scopes
+          base.send(:scope, :ordered, -> { base.order('discerner_export_parameters.id ASC') })
+          base.send(:scope, :by_parameter_category, ->(parameter_category) { base.includes(:parameter).where('discerner_parameters.parameter_category_id' => parameter_category.id) unless parameter_category.blank?})
+
+          # Validations
+          base.send :validates, :parameter, :search, :presence => { :message => "for export parameter can't be blank" }
+
+          # Whitelisting attributes
+          base.send :attr_accessible, :parameter_id, :search_id, :parameter, :search
+        end
+
+        # Instance Methods
+        def initialize(*args)
+          super(*args)
+        end
+
+        def disabled?
+          return false unless persisted?
+          deleted? || parameter.blank? || parameter.deleted?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module Discerner
+  module Methods
+    module Models
+      module Operator
+        def self.included(base)
+          base.send :include, SoftDelete
+
+          # Associations
+          base.send :has_many,                :search_parameter_values, :inverse_of => :operator
+          base.send :has_many,                :search_combinations,     :inverse_of => :operator
+          base.send :has_and_belongs_to_many, :parameter_types, :join_table => :discerner_operators_parameter_types
+
+          # Validations
+          base.send :validates, :symbol, :presence => true, :uniqueness => {:message => "for operator has already been taken"}
+          base.send :validates, :operator_type, :presence => true
+          base.send :validate,  :type_supported?
+
+          # Whitelisting attributes
+          base.send :attr_accessible, :operator_type, :symbol, :text, :deleted_at
+        end
+
+        # Instance Methods
+        def initialize(*args)
+          super(*args)
+        end
+
+        def css_class_name
+          css_class = parameter_types.map{ |t| t.name }
+          css_class << operator_type unless operator_type.blank?
+          css_class.join(' ')
+        end
+
+        private
+          def type_supported?
+            return if self.operator_type.blank?
+            supported_types = ['comparison', 'text_comparison', 'range', 'list', 'presence']
+            errors.add(:base,"Operator type '#{self.operator_type}' is not supported, please use one of the following types: #{supported_types.join(', ')}") unless supported_types.include?(self.operator_type)
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+module Discerner
+  module Methods
+    module Models
+      module Parameter
+        def self.included(base)
+          base.send :include, SoftDelete
+
+          # Associations
+          base.send :belongs_to,  :parameter_category,          :inverse_of => :parameters
+          base.send :belongs_to,  :parameter_type,              :inverse_of => :parameters
+          base.send :has_many,    :parameter_values,            :inverse_of => :parameter, :dependent => :destroy
+          base.send :has_many,    :search_parameters,           :inverse_of => :parameter, :dependent => :destroy
+          base.send :has_many,    :export_parameters,           :inverse_of => :parameter, :dependent => :destroy
+          base.send :has_many,    :parameter_value_categories,  :inverse_of => :parameter, :dependent => :destroy
+
+          #Validations
+          base.send :validates, :name, :unique_identifier, :parameter_category, :presence => { :message => "for parameter can't be blank" }
+          base.send :validate,  :validate_unique_identifier
+          base.send :validate,  :validate_search_attributes
+          base.send :validate,  :validate_export_attributes
+
+          # Scopes
+          base.send(:scope, :searchable, -> {base.not_deleted.where('search_model is not null and search_method is not null')})
+          base.send(:scope, :exportable, -> {base.not_deleted.where('export_model is not null and export_method is not null')})
+
+          # Hooks
+          base.send :after_commit, :cascade_delete_parameter_values, :on => :update, :if => Proc.new { |record| record.previous_changes.include?('deleted_at') }
+
+          # Whitelisting attributes
+          base.send :attr_accessible, :name, :parameter_category, :parameter_category_id, :parameter_type, :parameter_type_id,
+                    :search_model, :search_method, :unique_identifier, :export_model, :export_method
+        end
+
+        # Instance Methods
+        def initialize(*args)
+          super(*args)
+        end
+
+        def used_in_search?
+          search_parameters.any? || export_parameters.any?
+        end
+
+        def display_name
+          "#{parameter_category.name} - #{name}"
+        end
+
+        def css_class_name
+          css_class_array = [parameter_type.name, parameter_category.css_class_name, parameter_category.dictionary.css_class_name]
+          css_class_array << 'exclusive' if exclusive
+          css_class_array.join(' ')
+        end
+
+        private
+          def validate_search_parameters
+            errors.add(:base,"Search should have at least one search criteria.") if
+              self.search_parameters.size < 1 || self.search_parameters.all?{|search_parameter| search_parameter.marked_for_destruction? }
+          end
+
+          def validate_unique_identifier
+            return if self.parameter_category.blank?
+            existing_parameters =  Discerner::Parameter.
+              joins({ :parameter_category => :dictionary }).
+              where('discerner_dictionaries.id = ? and discerner_parameters.unique_identifier = ?', self.parameter_category.dictionary.id, self.unique_identifier)
+            existing_parameters = existing_parameters.where('discerner_parameters.id != ?', self.id) unless self.id.blank?
+            errors.add(:base,"Unique identifier has to be unique within dictionary.") if existing_parameters.any?
+          end
+
+          def validate_search_attributes
+            unless self.search_model.blank? && self.search_method.blank?
+              errors.add(:base,"Searchable parameter should have search model, search method and parameter_type defined.") if self.search_model.blank? || self.search_method.blank? || self.parameter_type.blank?
+            end
+          end
+
+          def validate_export_attributes
+            unless self.export_model.blank? && self.export_method.blank?
+              errors.add(:base,"Exportable parameter should have export model and search method defined.") if self.export_model.blank? || self.export_method.blank?
+            end
+          end
+
+          def cascade_delete_parameter_values
+            return unless deleted?
+            parameter_values.each do |pv|
+              pv.deleted_at = Time.now
+              pv.save
+            end
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+module Discerner
+  module Methods
+    module Models
+      module ParameterCategory
+        def self.included(base)
+          base.send :include, SoftDelete
+
+          # Associations
+          base.send :belongs_to,  :dictionary, :inverse_of => :parameter_categories
+          base.send :has_many,    :parameters, :inverse_of => :parameter_category,  :dependent => :destroy
+
+          # Validations
+          base.send :validates, :name, :presence => true, :uniqueness => { :scope => :dictionary_id, :message => "for parameter category has already been taken"}
+          base.send :validates, :dictionary, :presence => { :message => "for parameter category can't be blank" }
+
+          # Scopes
+          base.send(:scope, :searchable, -> {base.includes(:parameters).where('discerner_parameters.search_model is not null and discerner_parameters.search_method is not null and discerner_parameters.deleted_at is null')})
+          base.send(:scope, :exportable, -> {base.includes(:parameters).where('discerner_parameters.export_model is not null and discerner_parameters.export_method is not null and discerner_parameters.deleted_at is null')})
+          base.send(:scope, :ordered_by_name, -> {base.order('discerner_parameter_categories.name ASC')})
+
+          # Hooks
+          base.send :after_commit, :cascade_delete_parameters, :on => :update, :if => Proc.new { |record| record.previous_changes.include?('deleted_at') }
+
+          # Whitelisting attributes
+          base.send :attr_accessible, :deleted_at, :dictionary, :dictionary_id, :name
+        end
+
+        # Instance Methods
+        def initialize(*args)
+          super(*args)
+        end
+
+        def parameterized_name
+          name.parameterize.underscore
+        end
+
+        def searchable_parameters
+          parameters.searchable
+        end
+
+        def exportable_parameters
+          parameters.exportable
+        end
+
+        def css_class_name
+          "parameter_category_#{parameterized_name}"
+        end
+
+        private
+          def cascade_delete_parameters
+            return unless deleted?
+            parameters.each do |p|
+              p.deleted_at = Time.now
+              p.save
+            end
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module Discerner
+  module Methods
+    module Models
+      module ParameterType
+        def self.included(base)
+          base.send :include, SoftDelete
+
+          # Associations
+          base.send :has_many,                :parameters,  :inverse_of => :parameter_type
+          base.send :has_and_belongs_to_many, :operators,   :join_table => :discerner_operators_parameter_types
+
+          # Validations
+          base.send :validates, :name, :presence => true, :uniqueness => {:message => "for parameter type has already been taken"}
+          base.send :validate,  :name_supported?
+
+          # Whitelisting attributes
+          base.send :attr_accessible, :deleted_at, :name
+        end
+
+        # Instance Methods
+        def initialize(*args)
+          super(*args)
+        end
+
+        def name_supported?
+          return if self.name.blank?
+          supported_types = ['numeric', 'date', 'list', 'combobox', 'text', 'string', 'search']
+          errors.add(:base,"Parameter type '#{self.name}' is not supported, please use one of the following types: #{supported_types.join(', ')}") unless supported_types.include?(self.name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+module Discerner
+  module Methods
+    module Models
+      module ParameterValue
+        def self.included(base)
+          base.send :include, SoftDelete
+
+          # Associations
+          base.send :belongs_to,  :parameter,                       :inverse_of => :parameter_values
+          base.send :has_many,    :search_parameter_values,         :inverse_of => :parameter_value, :dependent => :destroy
+          base.send :has_one,     :parameter_value_categorization,  :inverse_of => :parameter_value, :dependent => :destroy
+          base.send :has_one,     :parameter_value_category,        :through=> :parameter_value_categorization
+
+          # Scopes
+          base.send(:scope, :ordered_by_name, -> { base.order('discerner_parameter_values.name ASC') })
+          base.send(:scope, :ordered_by_parameter_and_name, -> { base.order('discerner_parameter_values.parameter_id ASC, discerner_parameter_values.name ASC') })
+
+          #Validations
+          base.send :validates, :parameter, :presence => true
+          base.send :validates, :search_value, :length => { :maximum => 1000 }, :uniqueness => {:scope => :parameter_id, :message => "for parameter value has already been taken"}
+          base.send :validates, :name, :presence => true, :length => { :maximum => 1000 }
+          base.send :validate,  :parameter_category_belongs_to_parameter
+
+          # Hooks
+          base.send :after_commit, :create_search_parameter_values, :on => :create
+          base.send :after_commit, :update_search_parameter_values, :on => :update, :if => Proc.new { |record| record.previous_changes.include?('deleted_at') }
+          base.send :scope, :categorized, -> {base.joins(:parameter_value_category)}
+          base.send :scope, :uncategorized, -> {base.includes(:parameter_value_category).where(:discerner_parameter_value_categories => {:name => nil})}
+
+          # Whitelisting attributes
+          base.send :attr_accessible, :search_value, :name, :parameter, :parameter_id
+        end
+
+        # Instance Methods
+        def initialize(*args)
+          super(*args)
+        end
+
+        def used_in_search?
+          if parameter.parameter_type.name == 'list'
+            search_parameter_values.chosen.any?
+          else
+            search_parameter_values.any?
+          end
+        end
+
+        def display_name
+          if parameter_value_category
+            "#{parameter_value_category.name} - #{name} "
+          else
+            name
+          end
+        end
+
+        private
+          def parameter_category_belongs_to_parameter
+            unless parameter_value_category.blank?
+              errors.add(:base,"Parameter category #{parameter_value_category.name} does not belong to parameter #{parameter.name}") unless parameter_value_category.parameter_id == parameter.id
+            end
+          end
+
+          def create_search_parameter_values
+            # create additional search_parameter_values for list search_parameters so they can be dislayed as nested attribures
+            return if parameter.blank? || parameter.parameter_type.blank?
+            if parameter.parameter_type.name == 'list'
+              parameter.search_parameters.each do |sp|
+                if sp.search_parameter_values.where(:parameter_value_id => id).blank?
+                  max_display_order = sp.search_parameter_values.ordered_by_display_order.last.display_order || -1
+                  sp.search_parameter_values.build(:parameter_value_id => id, :display_order => max_display_order + 1)
+                  sp.save
+                end
+              end
+            end
+          end
+
+          def update_search_parameter_values
+            create_search_parameter_values
+            # destroy search_parameter_values that reference this value but are not chosen (list options)
+            return unless deleted?
+            search_parameter_values.each do |spv|
+              spv.destroy if parameter.parameter_type.name == 'list' && !spv.chosen
+            end
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Discerner
+  module Methods
+    module Models
+      module ParameterValueCategorization
+        def self.included(base)
+          base.send :include, SoftDelete
+
+          # Associations
+          base.send :belongs_to, :parameter_value_category, :inverse_of => :parameter_value_categorizations
+          base.send :belongs_to, :parameter_value,          :inverse_of => :parameter_value_categorization
+
+          # Validations
+          base.send :validates_presence_of, :parameter_value_category, :parameter_value
+
+          # Whitelisting attributes
+          base.send :attr_accessible, :parameter_value_category_id, :parameter_value_id, :parameter_value_category, :parameter_value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module Discerner
+  module Methods
+    module Models
+      module ParameterValueCategory
+        def self.included(base)
+          base.send :include, SoftDelete
+
+          # Associations
+          base.send :belongs_to, :parameter,                       :inverse_of => :parameter_value_categories
+          base.send :has_many,   :parameter_value_categorizations, :dependent => :destroy
+          base.send :has_many,   :parameter_values, :through => :parameter_value_categorizations
+
+          # Scopes
+          base.send(:scope, :ordered_by_name, -> { base.order('discerner_parameter_value_categories.name ASC') })
+          base.send(:scope, :ordered_by_display_order_and_name, -> { base.order('discerner_parameter_value_categories.display_order ASC, discerner_parameter_value_categories.name ASC') })
+
+          # Validations
+          base.send :validates_presence_of, :parameter, :unique_identifier, :name
+          base.send :validates, :unique_identifier, :uniqueness => {:scope => [:parameter_id, :deleted_at], :message => "for parameter value category has already been taken"}
+          base.send :validate, :parameter_value_belongs_to_parameter
+
+          # Whitelisting attributes
+          base.send :attr_accessible, :parameter, :parameter_id, :unique_identifier, :name
+        end
+
+        def css_class
+          "parameter_value_category_#{parameterized_name}"
+        end
+
+        def parameterized_name
+          name.parameterize.underscore
+        end
+
+        private
+          def parameter_value_belongs_to_parameter
+            unless parameter.blank?
+              parameter_values.each do |parameter_value|
+                errors.add(:base,"Parameter value #{parameter_value.name} does not belong to parameter #{parameter.name}") unless parameter_value.parameter_id == parameter.id
+              end
+            end
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,147 @@
+module Discerner
+  module Methods
+    module Models
+      module Search
+        def self.included(base)
+          base.send :include, SoftDelete
+          base.send :include, Warning
+
+          # Associations
+          base.send :belongs_to, :dictionary
+          base.send :has_many, :search_parameters,    :inverse_of => :search
+          base.send :has_many, :search_combinations,  :inverse_of => :search
+          base.send :has_many, :combined_searches,    :through => :search_combinations
+          base.send :has_many, :export_parameters,    :inverse_of => :search
+
+          # Validations
+          base.send :validates, :dictionary, :presence => { :message => "for search can't be blank" }
+          base.send :validate, :validate_search_parameters
+
+          # Scopes
+          base.send(:scope, :by_user, ->(username) { base.where(:username => username) unless username.blank?})
+
+          # Nested attributes
+          base.send :accepts_nested_attributes_for, :search_parameters, :allow_destroy => true,
+            :reject_if => proc { |attributes| attributes['parameter_id'].blank? && attributes['parameter'].blank? }
+
+          base.send :accepts_nested_attributes_for, :search_combinations, :allow_destroy => true,
+            :reject_if => proc { |attributes| attributes['combined_search_id'].blank? && attributes['combined_search'].blank? }
+
+          # Hooks
+          base.send :after_commit, :update_associations, :on => :update, :if => Proc.new { |record| record.previous_changes.include?('deleted_at') }
+
+          # Whitelisting attributes
+          base.send :attr_accessible, :deleted_at, :name, :username, :search_parameters, :search_parameters_attributes,
+          :dictionary, :dictionary_id, :search_combinations_attributes
+        end
+
+        # Instance Methods
+        def initialize(*args)
+          super(*args)
+        end
+
+        def display_name
+          name.blank? ? "[No name specified]" : name
+        end
+
+        def parameterized_name
+          display_name.parameterize.underscore
+        end
+
+        def traverse
+          return unless combined_searches.any?
+          searches = []
+          combined_searches.each do |s|
+            searches << s
+            nested_searches = s.traverse
+            searches << nested_searches unless nested_searches.blank?
+          end
+          searches
+        end
+
+        def nested_searches
+          nested_searches = traverse || []
+          nested_searches.flatten.compact
+        end
+
+        def parameter_categories
+          search_parameters.map{|p| p.parameter.parameter_category unless p.parameter.blank?}.uniq
+        end
+
+        def to_conditions
+          search_models = {}
+          all_search_parameters = nested_searches.map { |ns| ns.search_parameters }.flatten
+          all_search_parameters.concat(search_parameters).flatten!
+
+          all_search_parameters.each do |search_parameter|
+            search_models[search_parameter.parameter.search_model] = { :search_parameters => [], :conditions => nil } unless search_models.has_key?(search_parameter.parameter.search_model)
+            search_models[search_parameter.parameter.search_model][:search_parameters] << search_parameter
+          end
+
+          search_models.each do |k,v|
+            predicates = []
+            arguments = []
+
+            v[:search_parameters].each do |search_parameter|
+              sql = search_parameter.to_sql unless search_parameter.search_parameter_values.empty?
+              unless sql.nil?
+                predicates << sql[:predicates]
+                arguments << sql[:values] unless sql[:values].blank?
+              end
+            end
+
+            search_models[k][:conditions] = [predicates.join(' and '), *flatten_arguments(arguments)]
+          end
+          search_models
+        end
+
+        def flatten_arguments(arguments)
+          args = []
+          arguments.each do |a|
+            a.each do |b|
+              args << b
+            end
+          end
+          args
+        end
+
+        def disabled?
+          return false unless persisted?
+          if export_parameters.select{|ep| ep.disabled?}.any?
+            warnings.add(:base, "Search uses deleted export parameters")
+            return true
+          end
+          deleted? ||
+          dictionary.deleted? ||
+          search_parameters.select{|sp| sp.disabled?}.any? ||
+          search_combinations.select{|sc| sc.disabled?}.any?
+        end
+
+        def searched_model?(model_name)
+          conditions.has_key?(model_name)
+        end
+
+        def conditions(force=false)
+          @conditions = self.to_conditions if @conditions.blank? || force
+          @conditions
+        end
+
+        private
+          def validate_search_parameters
+            if self.search_parameters.size < 1 || self.search_parameters.all?{|search_parameter| search_parameter.marked_for_destruction? }
+              errors.add(:base,"Search should have at least one search criteria.")
+            end
+          end
+
+          def update_associations
+            [search_parameters, export_parameters, search_combinations].each do |accociated_records|
+              accociated_records.each do |r|
+                r.deleted_at = Time.now
+                r.save
+              end
+            end
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module Discerner
+  module Methods
+    module Models
+      module SearchCombination
+        def self.included(base)
+          base.send :include, SoftDelete
+          base.send :include, Warning
+
+          # Associations
+          base.send :belongs_to, :operator, :inverse_of => :search_combinations
+          base.send :belongs_to, :search,   :inverse_of => :search_combinations,  :foreign_key => :search_id
+          base.send :belongs_to, :combined_search, :foreign_key => :combined_search_id, :class_name => 'Discerner::Search'
+
+          # Scopes
+          base.send(:scope, :ordered_by_display_order, -> { base.order('discerner_search_combinations.display_order ASC') })
+
+          # Validations
+          base.send :validates_presence_of, :search, :combined_search
+          base.send :validate, :validate_searches
+
+          # Whitelisting attributes
+          base.send :attr_accessible, :combined_search_id, :display_order, :operator_id, :search_id, :search, :combined_search
+        end
+
+        # Instance Methods
+        def initialize(*args)
+          super(*args)
+        end
+
+        def validate_searches
+          return if self.search_id.blank? || self.combined_search_id.blank?
+          errors.add(:base,"Search cannot be combined with itself.") if self.search_id == self.combined_search_id
+        end
+
+        def disabled?
+          return false unless persisted?
+          return true if deleted?
+          if combined_search.deleted?
+            warnings.add(:base, "Combined search has been deleted and has to be removed from the search")
+            return true
+          elsif combined_search.disabled?
+            warnings.add(:base, "Combined search has been disabled and has to be removed from the search")
+            return true
+          end
+          return false
+        end
+      end
+    end
+  end
+end