active_scaffold 3.6.20 → 3.7.1

data/lib/active_scaffold/finder.rb

@@ -110,26 +110,57 @@ module ActiveScaffold
             end
           return nil unless sql
 
-          conditions = [column.search_sql.collect { |search_sql| sql % {:search_sql => search_sql} }.join(' OR ')]
-          conditions += values * column.search_sql.size if values.present?
-          conditions
+          where_values = []
+          sql_conditions = []
+          column.search_sql.each do |search_sql|
+            if search_sql.is_a?(Hash)
+              subquery_sql, *subquery_values = subquery_condition(column, sql, search_sql, values)
+              sql_conditions << subquery_sql
+              where_values.concat subquery_values
+            else
+              sql_conditions << sql % {:search_sql => search_sql}
+              where_values.concat values
+            end
+          end
+          [sql_conditions.join(' OR '), *where_values]
         rescue StandardError => e
           Rails.logger.error "#{e.class.name}: #{e.message} -- on the ActiveScaffold column :#{column.name}, search_ui = #{search_ui} in #{name}"
           raise e
         end
       end
 
+      def subquery_condition(column, sql, options, values)
+        relation, *columns = options[:subquery]
+        conditions = [columns.map { |search_sql| sql % {:search_sql => search_sql} }.join(' OR ')]
+        conditions += values * columns.size if values.present?
+        subquery = relation.where(conditions)
+        subquery = subquery.select(relation.primary_key) if subquery.select_values.blank?
+
+        conditions = [["#{options[:field] || column.field} IN (?)", options[:conditions]&.first].compact.join(' AND ')]
+        conditions << subquery
+        conditions.concat options[:conditions][1..-1] if options[:conditions]
+        if column.association&.polymorphic?
+          conditions[0] << " AND #{column.quoted_foreign_type} = ?"
+          conditions << relation.name
+        end
+        conditions
+      end
+
       def condition_for_search_ui(column, value, like_pattern, search_ui)
         case search_ui
         when :boolean, :checkbox
-          ['%<search_sql>s = ?', column.column ? ActiveScaffold::Core.column_type_cast(value, column.column) : value]
+          if value == 'null'
+            condition_for_null_type(column, value)
+          else
+            ['%<search_sql>s = ?', column.column ? ActiveScaffold::Core.column_type_cast(value, column.column) : value]
+          end
         when :integer, :decimal, :float
           condition_for_numeric(column, value)
         when :string, :range
           condition_for_range(column, value, like_pattern)
         when :date, :time, :datetime, :timestamp
           condition_for_datetime(column, value)
-        when :select, :multi_select, :country, :usa_state, :chosen, :multi_chosen
+        when :select, :select_multiple, :draggable, :multi_select, :country, :usa_state, :chosen, :multi_chosen
           values = Array(value).select(&:present?)
           ['%<search_sql>s in (?)', values] if values.present?
         else
@@ -167,7 +198,10 @@ module ActiveScaffold
         elsif value[:from].blank?
           nil
         elsif ActiveScaffold::Finder::STRING_COMPARATORS.values.include?(value[:opt])
-          ["%<search_sql>s #{ActiveScaffold::Finder.like_operator} ?", value[:opt].sub('?', value[:from])]
+          [
+            "%<search_sql>s #{'NOT ' if value[:opt].start_with?('not_')}#{ActiveScaffold::Finder.like_operator} ?",
+            value[:opt].sub('not_', '').sub('?', value[:from])
+          ]
         elsif value[:opt] == 'BETWEEN'
           ['(%<search_sql>s BETWEEN ? AND ?)', value[:from], value[:to]]
         elsif ActiveScaffold::Finder::NUMERIC_COMPARATORS.include?(value[:opt])
@@ -237,14 +271,19 @@ module ActiveScaffold
         nil
       end
 
-      def parse_date_with_format(value, format_name)
-        format = I18n.t("date.formats.#{format_name || :default}")
-        format.gsub!(/%-d|%-m|%_m/) { |s| s.gsub(/[-_]/, '') } # strptime fails with %-d, %-m, %_m
-        en_value = I18n.locale == :en ? value : translate_days_and_months(value, format)
-        Date.strptime(en_value, format)
+      def format_for_date(column, value, format_name = column.options[:format])
+        if format_name
+          format = I18n.t("date.formats.#{format_name}")
+          format.gsub!(/%-d|%-m|%_m/) { |s| s.gsub(/[-_]/, '') } # strptime fails with %-d, %-m, %_m
+          en_value = I18n.locale == :en ? value : translate_days_and_months(value, format)
+        end
+        [en_value || value, format]
+      end
+
+      def parse_date_with_format(value, format)
+        Date.strptime(value, *format)
       rescue StandardError => e
-        message = "Error parsing date from #{en_value}"
-        message << " (#{value})" if en_value != value
+        message = "Error parsing date from #{value}"
         message << ", with format #{format}" if format
         Rails.logger.warn "#{message}:\n#{e.message}\n#{e.backtrace.join("\n")}"
         nil
@@ -276,7 +315,7 @@ module ActiveScaffold
             value.send(conversion)
           end
         elsif conversion == :to_date
-          parse_date_with_format(value, column.options[:format])
+          parse_date_with_format(*format_for_date(column, value))
         elsif value.include?('T')
           Time.zone.parse(value)
         else # datetime
@@ -288,7 +327,7 @@ module ActiveScaffold
       def condition_value_for_numeric(column, value)
         return value if value.nil?
         value = column.number_to_native(value) if column.options[:format] && column.search_ui != :number
-        case (column.search_ui || column.column.type)
+        case (column.search_ui || column.column_type)
         when :integer   then
           if value.is_a?(TrueClass) || value.is_a?(FalseClass)
             value ? 1 : 0
@@ -296,8 +335,7 @@ module ActiveScaffold
             value.to_i
           end
         when :float     then value.to_f
-        when :decimal
-          ::ActiveRecord::Type::Decimal.new.send(Rails.version < '5.0' ? :type_cast_from_user : :cast, value)
+        when :decimal   then ::ActiveRecord::Type::Decimal.new.cast(value)
         else
           value
         end
@@ -305,28 +343,102 @@ module ActiveScaffold
 
       def datetime_conversion_for_condition(column)
         if column.column
-          column.column.type == :date ? :to_date : :to_time
+          column.column_type == :date ? :to_date : :to_time
         else
           :to_time
         end
       end
 
       def condition_for_datetime(column, value, like_pattern = nil)
+        operator = ActiveScaffold::Finder::NUMERIC_COMPARATORS.include?(value['opt']) && value['opt'] != 'BETWEEN' ? value['opt'] : nil
+        from_value, to_value = datetime_from_to(column, value)
+
+        if column.search_sql.is_a? Proc
+          column.search_sql.call(from_value, to_value, operator)
+        elsif operator.nil?
+          ['%<search_sql>s BETWEEN ? AND ?', from_value, to_value] unless from_value.nil? || to_value.nil?
+        else
+          ["%<search_sql>s #{value['opt']} ?", from_value] unless from_value.nil?
+        end
+      end
+
+      def datetime_from_to(column, value)
         conversion = datetime_conversion_for_condition(column)
-        from_value = condition_value_for_datetime(column, value[:from], conversion)
-        to_value = condition_value_for_datetime(column, value[:to], conversion)
+        case value['opt']
+        when 'RANGE'
+          values = datetime_from_to_for_range(column, value)
+          # Avoid calling to_time, not needed and broken on rails >= 4, because return local time instead of UTC
+          values.collect!(&conversion) if conversion != :to_time
+          values
+        when 'PAST', 'FUTURE'
+          values = datetime_from_to_for_trend(column, value)
+          # Avoid calling to_time, not needed and broken on rails >= 4, because return local time instead of UTC
+          values.collect!(&conversion) if conversion != :to_time
+          values
+        else
+          %w[from to].collect { |field| condition_value_for_datetime(column, value[field], conversion) }
+        end
+      end
 
-        if from_value.nil? && to_value.nil?
-          nil
-        elsif !from_value
-          ['%<search_sql>s <= ?', to_value]
-        elsif !to_value
-          ['%<search_sql>s >= ?', from_value]
+      def datetime_now
+        Time.zone.now
+      end
+
+      def datetime_from_to_for_trend(column, value)
+        case value['opt']
+        when 'PAST'
+          trend_number = [value['number'].to_i, 1].max
+          now = datetime_now
+          if datetime_column_date?(column)
+            from = now.beginning_of_day.ago(trend_number.send(value['unit'].downcase.singularize.to_sym))
+            to = now.end_of_day
+          else
+            from = now.ago(trend_number.send(value['unit'].downcase.singularize.to_sym))
+            to = now
+          end
+          [from, to]
+        when 'FUTURE'
+          trend_number = [value['number'].to_i, 1].max
+          now = datetime_now
+          if datetime_column_date?(column)
+            from = now.beginning_of_day
+            to = now.end_of_day.in(trend_number.send(value['unit'].downcase.singularize.to_sym))
+          else
+            from = now
+            to = now.in(trend_number.send(value['unit'].downcase.singularize.to_sym))
+          end
+          [from, to]
+        end
+      end
+
+      def datetime_from_to_for_range(column, value)
+        case value['range']
+        when 'TODAY'
+          [datetime_now.beginning_of_day, datetime_now.end_of_day]
+        when 'YESTERDAY'
+          [datetime_now.ago(1.day).beginning_of_day, datetime_now.ago(1.day).end_of_day]
+        when 'TOMORROW'
+          [datetime_now.in(1.day).beginning_of_day, datetime_now.in(1.day).end_of_day]
         else
-          ['%<search_sql>s BETWEEN ? AND ?', from_value, to_value]
+          range_type, range = value['range'].downcase.split('_')
+          raise ArgumentError unless %w[week month year].include?(range)
+          case range_type
+          when 'this'
+            return datetime_now.send("beginning_of_#{range}".to_sym), datetime_now.send("end_of_#{range}")
+          when 'prev'
+            return datetime_now.ago(1.send(range.to_sym)).send("beginning_of_#{range}".to_sym), datetime_now.ago(1.send(range.to_sym)).send("end_of_#{range}".to_sym)
+          when 'next'
+            return datetime_now.in(1.send(range.to_sym)).send("beginning_of_#{range}".to_sym), datetime_now.in(1.send(range.to_sym)).send("end_of_#{range}".to_sym)
+          else
+            return nil, nil
+          end
         end
       end
 
+      def datetime_column_date?(column)
+        column.column&.type == :date
+      end
+
       def condition_for_record_select_type(column, value, like_pattern = nil)
         if value.is_a?(Array)
           ['%<search_sql>s IN (?)', value]
@@ -357,9 +469,16 @@ module ActiveScaffold
     STRING_COMPARATORS = {
       :contains    => '%?%',
       :begins_with => '?%',
-      :ends_with   => '%?'
+      :ends_with   => '%?',
+      :doesnt_contain    => 'not_%?%',
+      :doesnt_begin_with => 'not_?%',
+      :doesnt_end_with   => 'not_%?'
     }.freeze
     NULL_COMPARATORS = %w[null not_null].freeze
+    DATE_COMPARATORS = %w[PAST FUTURE RANGE].freeze
+    DATE_UNITS = %w[DAYS WEEKS MONTHS YEARS].freeze
+    TIME_UNITS = %w[SECONDS MINUTES HOURS].freeze
+    DATE_RANGES = %w[TODAY YESTERDAY TOMORROW THIS_WEEK PREV_WEEK NEXT_WEEK THIS_MONTH PREV_MONTH NEXT_MONTH THIS_YEAR PREV_YEAR NEXT_YEAR].freeze
 
     def self.included(klass)
       klass.extend ClassMethods

data/lib/active_scaffold/helpers/action_link_helpers.rb

@@ -212,7 +212,7 @@ module ActiveScaffold
       end
 
       def column_in_params_conditions?(key)
-        if key =~ /!$/
+        if key.match?(/!$/)
           conditions_from_params[1..-1].any? { |node| node.left.name.to_s == key[0..-2] }
         else
           conditions_from_params[0].include?(key)

data/lib/active_scaffold/helpers/controller_helpers.rb

@@ -25,17 +25,22 @@ module ActiveScaffold
       end
 
       def generate_temporary_id(record = nil, generated_id = nil)
-        (generated_id || (Time.now.to_f * 1000).to_i.to_s).tap do |id|
-          cache_generated_id record, id
+        unless generated_id
+          temp_id = (Time.now.to_f * 1_000_000).to_i.to_s
+          temp_id.succ! while @temporary_ids&.dig(record.class.name)&.include?(temp_id)
+          generated_id = temp_id
         end
+        cache_generated_id record, generated_id
+        generated_id
       end
 
       def cache_generated_id(record, generated_id)
-        (@temporary_ids ||= {})[record.class.name] = generated_id if record && generated_id
+        # cache all generated ids for the same class, so generate_temporary_id can check and ensure ids are unique
+        ((@temporary_ids ||= {})[record.class.name] ||= []) << generated_id if record && generated_id
       end
 
       def generated_id(record)
-        @temporary_ids[record.class.name] if record && @temporary_ids
+        @temporary_ids[record.class.name]&.last if record && @temporary_ids
       end
 
       # These params should not propagate: