discerner 1.1.18

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

@@ -0,0 +1,128 @@
+module Discerner
+  module Methods
+    module Models
+      module SearchParameter
+        def self.included(base)
+          base.send :include, SoftDelete
+          base.send :include, Warning
+
+          # Associations
+          base.send :belongs_to,  :search,     :inverse_of => :search_parameters
+          base.send :belongs_to,  :parameter,  :inverse_of => :search_parameters
+          base.send :has_many,    :search_parameter_values, :dependent => :destroy, :inverse_of => :search_parameter
+
+          # Scopes
+          base.send(:scope, :by_parameter_category, ->(parameter_category) { base.includes(:parameter).where('discerner_parameters.parameter_category_id' => parameter_category.id) unless parameter_category.blank?})
+          base.send(:scope, :ordered_by_display_order, -> { base.order('discerner_search_parameters.display_order ASC') })
+          base.send(:scope, :ordered, -> { base.order('discerner_search_parameters.id ASC') })
+
+          #Validations
+          base.send :validates_presence_of, :search, :parameter
+
+          # Nested attributes
+          base.send :accepts_nested_attributes_for, :search_parameter_values, :allow_destroy => true
+
+          # 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, :search, :search_id, :parameter, :parameter_id, :search_parameter_values_attributes, :display_order
+        end
+
+        # Instance Methods
+        def initialize(*args)
+          super(*args)
+        end
+
+        def check_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 parameterized_name
+          name.blank? ? 'no_name_specified' : name.parameterize.underscore
+        end
+
+        def prepare_sql
+          sql = {}
+          parameter_type = parameter.parameter_type.name
+          case parameter_type
+          when 'list'
+            values    = [search_parameter_values.chosen.map { |spv| spv.parameter_value.search_value }]
+            predicate = "#{parameter.search_method} in (?)"
+          when 'combobox'
+            values    = [search_parameter_values.map { |spv| spv.parameter_value.search_value unless spv.parameter_value.nil? }.compact]
+            predicate = "#{parameter.search_method} in (?)" unless values.blank?
+          else # 'numeric','date', 'text', 'string
+            spvs = []
+            values = []
+            search_parameter_values.map {|spv| spvs << spv.to_sql}
+
+            predicates = spvs.map { |s| s[:predicates] }.join(' or ')
+            predicate = "(#{predicates})"
+
+            spvs.each do |spv|
+              if spv[:values].is_a?(Array)
+                spv[:values].each do |v|
+                  values << v
+                end
+              else
+                values << spv[:values] unless spv[:values].blank?
+              end
+            end
+          end
+          sql[:predicates] = predicate
+          sql[:values] = values
+          sql
+        end
+
+        def search_model_class
+          return if parameter.search_model.blank? || parameter.search_method.blank?
+          search_model_class = parameter.search_model.safe_constantize
+          raise "Search model #{parameter.search_model} could not be found" if search_model_class.blank?
+          search_model_class
+        end
+
+        def search_model_attribute_method?
+          search_model_class && search_model_class.attribute_method?(parameter.search_method)
+        end
+
+        def to_sql
+          sql = prepare_sql
+          if search_model_class && !search_model_attribute_method?
+            raise "Search model #{parameter.search_model} does not respond to search method #{parameter.search_method}" unless search_model_class.respond_to?(parameter.search_method)
+            sql = search_model_class.send(parameter.search_method, sql)
+          end
+          sql
+        end
+
+        def disabled?
+          return false unless persisted?
+          if parameter.blank?
+            warnings.add(:base, "Parameter has to be selected")
+            return true
+          elsif parameter.deleted?
+            warnings.add(:base, "Parameter has been deleted and has to be removed from the search")
+            return true
+          elsif search_parameter_values.blank? || (parameter.parameter_type.name == 'list' && search_parameter_values.select{|spv| spv.chosen?}.empty?)
+            warnings.add(:base, "Parameter value has to be selected")
+            return true
+          elsif deleted? || search_parameter_values.select{ |spv| spv.disabled?}.any?
+            return true
+          end
+        end
+
+
+
+        private
+          def update_associations
+            search_parameter_values.each do |r|
+              r.deleted_at = Time.now
+              r.save
+            end
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,130 @@
+module Discerner
+  module Methods
+    module Models
+      module SearchParameterValue
+        def self.included(base)
+          base.send :include, SoftDelete
+          base.send :include, Warning
+
+          # Associations
+          base.send :belongs_to, :search_parameter, :inverse_of => :search_parameter_values
+          base.send :belongs_to, :parameter_value,  :inverse_of => :search_parameter_values
+          base.send :belongs_to, :operator,         :inverse_of => :search_parameter_values
+
+          # Scopes
+          base.send(:scope, :chosen, -> { base.where(:chosen => true) })
+          base.send(:scope, :ordered_by_display_order, -> { base.order('discerner_search_parameter_values.display_order ASC') })
+
+          #Validations
+          base.send :validate,  :validate_operator
+          base.send :validates, :search_parameter, :presence => true
+
+          # Hooks
+          base.send :before_validation, :cleanup_parameter_values
+          base.send :after_commit, :destroy_if_deleted_parameter_value, :on => :update
+
+          # Whitelisting attributes
+          base.send :attr_accessible, :additional_value, :chosen, :display_order, :operator_id, :parameter_value_id, :search_parameter_id, :value, :parameter_value, :operator, :search_parameter
+        end
+
+        # Instance Methods
+        def initialize(*args)
+          super(*args)
+        end
+
+        def to_sql
+          sql = {}
+          raise "Search operator has to be defined in order to run 'to_sql' method on search_parameter_value" if operator.blank?
+          case operator.operator_type
+            when 'comparison'
+              sql[:predicates] = "#{search_parameter.parameter.search_method} #{operator.symbol} ?"
+              sql[:values]    = formatted_values.first
+            when 'range'
+              sql[:predicates] = "#{search_parameter.parameter.search_method} #{operator.symbol} ? and ?"
+              sql[:values]    = formatted_values
+            when 'text_comparison'
+              sql[:predicates] = "#{search_parameter.parameter.search_method} #{operator.symbol} ?"
+              sql[:values]    = "%#{formatted_values.first}%"
+            when 'presence'
+              sql[:predicates] = "#{search_parameter.parameter.search_method} #{operator.symbol}"
+            end
+          sql
+        end
+
+        def formatted_values
+          all_values = [value, additional_value].compact
+          case search_parameter.parameter.parameter_type.name
+          when 'date'
+            all_values.map{|v| v.to_date}
+          when 'numeric'
+            all_values.map{|v| v.to_f}
+          else
+            all_values
+          end
+        end
+
+        def disabled?
+          return false unless persisted?
+          if parameter_value.blank? && value.blank? && operator && operator.operator_type != 'presence'
+            warnings.add(:base, "Parameter value has to be selected")
+            return true
+          end
+          if chosen? && parameter_value.blank? || parameter_value && parameter_value.deleted?
+            warnings.add(:base, "Parameter value has been deleted and has to be removed from the search")
+            return true
+          end
+          if search_parameter && search_parameter.parameter && search_parameter.parameter.parameter_type.name == 'date' && !validate_dates_format
+            warnings.add(:base, "Provided date is not valid")
+            return true
+          end
+          if parameter_value.blank? && search_parameter.parameter.parameter_type.name == 'combobox'
+            warnings.add(:base, "Parameter value has to be selected")
+            return true
+          end
+          warnings.clear
+          return false
+        end
+
+        def validate_dates_format
+          validate_date(value) && validate_date(additional_value)
+        end
+
+        private
+          def destroy_if_deleted_parameter_value
+            return if parameter_value.blank? || search_parameter.blank? || search_parameter.parameter.blank? || search_parameter.parameter.parameter_type.blank?
+            #return unless ['list', 'combobox'].include?(search_parameter.parameter.parameter_type.name)
+            destroy if parameter_value.deleted? && search_parameter.parameter.parameter_type.name == 'list' && !chosen?
+          end
+
+          def validate_date(date)
+            begin
+              unless date.blank?
+                parsed_date = date.to_date
+                #http://www.karaszi.com/sqlserver/info_datetime.asp#Why1753
+                return false if parsed_date.year < 1753
+              end
+            rescue => e
+              return false
+            end
+            return true
+          end
+
+          def cleanup_parameter_values
+            if operator && operator.operator_type == 'presence'
+              self.value = nil
+              self.additional_value = nil
+              self.parameter_value = nil
+            end
+          end
+
+          def validate_operator
+            if search_parameter && search_parameter.parameter && search_parameter.parameter.parameter_type && ['list', 'combobox'].include?(search_parameter.parameter.parameter_type.name)
+              self.operator = nil
+            else
+              errors.add(:base, "Operator has to be selected for parameter values that do not belong to list or combobox") if operator.blank?
+            end
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module Discerner
+  module Methods
+    module Models
+      module SoftDelete
+        def self.included(base)
+          attr_accessor :soft_delete
+          base.send(:scope, :not_deleted, -> { base.where(:deleted_at => nil) })
+        end
+
+        def process_soft_delete
+          self.deleted_at = Time.zone.now
+        end
+
+        def soft_delete=(removed)
+          if (removed.is_a?(TrueClass) || removed.to_s == 't' || removed.to_s == '1')
+            process_soft_delete
+          end
+        end
+
+        def soft_delete
+          !self.deleted_at.blank?
+        end
+
+        def soft_delete!
+          process_soft_delete
+          save!
+        end
+
+        def deleted?
+          !deleted_at.blank?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Discerner
+  module Methods
+    module Models
+      module Warning
+        def self.included(base)
+          attr_accessor :force_save
+        end
+
+        def warnings
+          @warnings ||= ActiveModel::Errors.new(self)
+        end
+      end
+    end
+  end
+end