forest_liana 3.3.0 → 4.0.0.pre.beta.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d23c0e51c9b7da5f7e2b09400b9b2e76c5152cd6
-  data.tar.gz: e0e7bee4717ba84f70c6c2603a4250b6b3671a2c
+  metadata.gz: dafadb3ed7cf1c34d0010729e459c13ba38e22de
+  data.tar.gz: 6dff3ee72a4aa231b68508e3d87b0931fb16d718
 SHA512:
-  metadata.gz: 0f65c9b9cc4ee79d2df3bcb89cf549d1985d626a008ba7504459018414e30339b63f9769fbd828d8cf7e03f32bd1d92cec5ee4373ce46ba9a588e7319528cccf
-  data.tar.gz: 4b91d89dcc180d49f38b73604e0c69fe052fc0ac10fc14cbda60ed6c8eb33c84e9736c917317d6f315649934cc3a0aa9d2177642d79a949e31d479809f25d71a
+  metadata.gz: 48338ecfc6319ca9ab824fa47771167e9203e3bbe567b3d38ff907b0ae067dc01f20e5830ed7079bdeb67115d54ede8570ce53125a738a016874b90bbc76979f
+  data.tar.gz: 052c0e82c436681276c2982480002adcc107b7e0b0018f1bd7056af1e6f6d5f3e281e9f9022d6b432b798224d08595bf9da81da04ab5c1fb52a87c2071c56d08

data/app/controllers/forest_liana/application_controller.rb

@@ -25,10 +25,11 @@ module ForestLiana
       # NOTICE: The Forest user email is returned to track changes made using
       #         Forest with Papertrail.
       define_method :user_for_paper_trail do
-        forest_user['data']['data']['email']
+        @jwt_decoded_token['email']
       end
     end
 
+    # NOTICE: Helper method for Smart Routes logic based on current user info.
     def forest_user
       @jwt_decoded_token
     end
@@ -69,7 +70,13 @@ module ForestLiana
 
           @jwt_decoded_token = JWT.decode(token, ForestLiana.auth_secret, true,
             { algorithm: 'HS256' }).try(:first)
-          @rendering_id = @jwt_decoded_token['data']['relationships']['renderings']['data'][0]['id']
+
+          # NOTICE: Automatically logs out the users that use tokens having an old data format.
+          if @jwt_decoded_token['data']
+            raise ForestLiana::Errors::HTTP401Error.new("Your token format is invalid, please login again.")
+          end
+
+          @rendering_id = @jwt_decoded_token['rendering_id']
         else
           head :unauthorized
         end

data/app/services/forest_liana/filters_parser.rb

@@ -0,0 +1,266 @@
+module ForestLiana
+  class FiltersParser
+    AGGREGATOR_OPERATOR = %w(and or)
+
+    def initialize(filters, resource, timezone)
+      begin
+        @filters = JSON.parse(filters)
+      rescue JSON::ParserError
+        raise ForestLiana::Errors::HTTP422Error.new('Invalid filters JSON format')
+      end
+
+      @resource = resource
+      @operator_date_parser = OperatorDateIntervalParser.new(timezone)
+      @joins = []
+    end
+
+    def apply_filters
+      return @resource unless @filters
+
+      where = parse_aggregation(@filters)
+      return @resource unless where
+
+      @joins.each do |join|
+        current_resource = @resource.reflect_on_association(join.name).klass
+        current_resource.include(ArelHelpers::Aliases)
+        current_resource.aliased_as(join.name) do |aliased_resource|
+          @resource = @resource.joins(ArelHelpers.join_association(@resource, join.name, Arel::Nodes::OuterJoin, aliases: [aliased_resource]))
+        end
+      end
+
+      @resource.where(where)
+    end
+
+    def parse_aggregation(node)
+      ensure_valid_aggregation(node)
+
+      return parse_condition(node) unless node['aggregator']
+
+      conditions = []
+      node['conditions'].each do |condition|
+        conditions.push(parse_aggregation(condition))
+      end
+
+      operator = parse_aggregation_operator(node['aggregator'])
+
+      conditions.empty? ? nil : "(#{conditions.join(" #{operator} ")})"
+    end
+
+    def parse_condition(condition)
+      ensure_valid_condition(condition)
+
+      operator = condition['operator']
+      value = condition['value']
+      field = condition['field']
+
+      if @operator_date_parser.is_date_operator?(operator)
+        condition = @operator_date_parser.get_date_filter(operator, value)
+        return "#{parse_field_name(field)} #{condition}"
+      end
+
+      if is_belongs_to(field)
+        association = field.partition(':').first.to_sym
+        association_field = field.partition(':').last
+
+        unless @resource.reflect_on_association(association)
+          raise ForestLiana::Errors::HTTP422Error.new("Association '#{association}' not found")
+        end
+
+        current_resource = @resource.reflect_on_association(association).klass
+      else
+        association_field = field
+        current_resource = @resource
+      end
+
+      # NOTICE: Set the integer value instead of a string if "enum" type
+      # NOTICE: Rails 3 do not have a defined_enums method
+      if current_resource.respond_to?(:defined_enums) && current_resource.defined_enums.has_key?(association_field)
+        value = current_resource.defined_enums[association_field][value]
+      end
+
+      parsed_field = parse_field_name(field)
+      parsed_operator = parse_operator(operator)
+      parsed_value = parse_value(operator, value)
+
+      if Rails::VERSION::MAJOR >= 5
+        ActiveRecord::Base.sanitize_sql(["#{parsed_field} #{parsed_operator} ?", parsed_value])
+      else
+        "#{parsed_field} #{parsed_operator} #{ActiveRecord::Base.sanitize(parsed_value)}"
+      end
+    end
+
+    def parse_aggregation_operator(aggregator_operator)
+      unless AGGREGATOR_OPERATOR.include?(aggregator_operator)
+        raise_unknown_operator_error(aggregator_operator)
+      end
+
+      aggregator_operator.upcase
+    end
+
+    def parse_operator(operator)
+      case operator
+      when 'not'
+        'NOT'
+      when 'greater_than', 'after'
+        '>'
+      when 'less_than', 'before'
+        '<'
+      when 'contains', 'starts_with', 'ends_with'
+        'LIKE'
+      when 'not_contains'
+        'NOT LIKE'
+      when 'not_equal'
+        '!='
+      when 'equal'
+        '='
+      when 'blank'
+        'IS'
+      when 'present'
+        'IS NOT'
+      else
+        raise_unknown_operator_error(operator)
+      end
+    end
+
+    def parse_value(operator, value)
+      case operator
+      when 'not', 'greater_than', 'less_than', 'not_equal', 'equal', 'before', 'after'
+        value
+      when 'contains', 'not_contains'
+        "%#{value}%"
+      when 'starts_with'
+        "#{value}%"
+      when 'ends_with'
+        "%#{value}"
+      when 'present', 'blank'
+      else
+        raise_unknown_operator_error(operator)
+      end
+    end
+
+    def parse_field_name(field)
+      if is_belongs_to(field)
+        current_resource = @resource.reflect_on_association(field.split(':').first.to_sym)&.klass
+        raise ForestLiana::Errors::HTTP422Error.new("Field '#{field}' not found") unless current_resource
+
+        association = get_association_name_for_condition(field)
+        quoted_table_name = ActiveRecord::Base.connection.quote_column_name(association)
+        quoted_field_name = ActiveRecord::Base.connection.quote_column_name(field.split(':')[1])
+      else
+        quoted_table_name = @resource.quoted_table_name
+        quoted_field_name = ActiveRecord::Base.connection.quote_column_name(field)
+        current_resource = @resource
+      end
+
+      column_found = current_resource.columns.find { |column| column.name == field.split(':').last }
+
+      if column_found.nil?
+        raise ForestLiana::Errors::HTTP422Error.new("Field '#{field}' not found")
+      end
+
+      "#{quoted_table_name}.#{quoted_field_name}"
+    end
+
+    def is_belongs_to(field)
+      field.include?(':')
+    end
+
+    def get_association_name_for_condition(field)
+      field, subfield = field.split(':')
+
+      association = @resource.reflect_on_association(field.to_sym)
+      return nil if association.blank?
+
+      @joins << association unless @joins.include? association
+
+      association.name
+    end
+
+    # NOTICE: Look for a previous interval condition matching the following:
+    #         - If the filter is a simple condition at the root the check is done right away.
+    #         - There can't be a previous interval condition if the aggregator is 'or' (no meaning).
+    #         - The condition's operator has to be elligible for a previous interval.
+    #         - There can't be two previous interval condition.
+    def get_previous_interval_condition
+      current_previous_interval = nil
+      # NOTICE: Leaf condition at root
+      unless @filters['aggregator']
+        return @filters if @operator_date_parser.has_previous_interval?(@filters['operator'])
+      end
+
+      if @filters['aggregator'] === 'and'
+        @filters['conditions'].each do |condition|
+          # NOTICE: Nested conditions
+          return nil if condition['aggregator']
+
+          if @operator_date_parser.has_previous_interval?(condition['operator'])
+            # NOTICE: There can't be two previous_interval.
+            return nil if current_previous_interval
+
+            current_previous_interval = condition
+          end
+        end
+      end
+
+      current_previous_interval
+    end
+
+    def apply_filters_on_previous_interval(previous_condition)
+      # Ressource should have already been joined
+      where = parse_aggregation_on_previous_interval(@filters, previous_condition)
+
+      @resource.where(where)
+    end
+
+    def parse_aggregation_on_previous_interval(node, previous_condition)
+      raise_empty_condition_in_filter_error unless node
+
+      return parse_previous_interval_condition(node) unless node['aggregator']
+
+      conditions = []
+      node['conditions'].each do |condition|
+        if condition == previous_condition
+          conditions.push(parse_previous_interval_condition(condition))
+        else
+          conditions.push(parse_aggregation(condition))
+        end
+      end
+
+      operator = parse_aggregation_operator(node['aggregator'])
+
+      conditions.empty? ? nil : "(#{conditions.join(" #{operator} ")})"
+    end
+
+    def parse_previous_interval_condition(condition)
+      raise_empty_condition_in_filter_error unless condition
+
+      parsed_condition = @operator_date_parser.get_date_filter_for_previous_interval(
+        condition['operator'],
+        condition['value']
+      )
+
+      "#{parse_field_name(condition['field'])} #{parsed_condition}"
+    end
+
+    def raise_unknown_operator_error(operator)
+      raise ForestLiana::Errors::HTTP422Error.new("Unknown provided operator '#{operator}'")
+    end
+
+    def raise_empty_condition_in_filter_error
+      raise ForestLiana::Errors::HTTP422Error.new('Empty condition in filter')
+    end
+
+    def ensure_valid_aggregation(node)
+      raise ForestLiana::Errors::HTTP422Error.new('Filters cannot be a raw value') unless node.is_a?(Hash)
+      raise_empty_condition_in_filter_error if node.empty?
+    end
+
+    def ensure_valid_condition(condition)
+      raise_empty_condition_in_filter_error if condition.empty?
+      raise ForestLiana::Errors::HTTP422Error.new('Condition cannot be a raw value') unless condition.is_a?(Hash)
+      unless condition['field'].is_a?(String) and condition['operator'].is_a?(String)
+        raise ForestLiana::Errors::HTTP422Error.new('Invalid condition format')
+      end
+    end
+  end
+end

data/app/services/forest_liana/line_stat_getter.rb

@@ -22,17 +22,8 @@ module ForestLiana
     def perform
       value = get_resource().eager_load(@includes)
 
-      if @params[:filterType] && @params[:filters]
-        conditions = []
-        filter_operator = " #{@params[:filterType]} ".upcase
-
-        @params[:filters].try(:each) do |filter|
-          operator, filter_value = OperatorValueParser.parse(filter[:value])
-          conditions << OperatorValueParser.get_condition(filter[:field],
-            operator, filter_value, @resource, @params[:timezone])
-        end
-
-        value = value.where(conditions.join(filter_operator))
+      if @params[:filters]
+        value = FiltersParser.new(@params[:filters], value, @params[:timezone]).apply_filters
       end
 
       value = value.send(time_range, group_by_date_field, {

data/app/services/forest_liana/login_handler.rb

@@ -94,25 +94,13 @@ module ForestLiana
 
     def create_token(user, rendering_id)
       JWT.encode({
-        exp: Time.now.to_i + 2.weeks.to_i,
-        data: {
-          id: user['id'],
-          type: 'users',
-          data: {
-            email: user['email'],
-            first_name: user['first_name'],
-            last_name: user['last_name'],
-            teams: user['teams']
-          },
-          relationships: {
-            renderings: {
-              data: [{
-                type: 'renderings',
-                id: rendering_id
-              }]
-            }
-          }
-        }
+        id: user['id'],
+        email: user['email'],
+        first_name: user['first_name'],
+        last_name: user['last_name'],
+        team: user['teams'][0],
+        rendering_id: rendering_id,
+        exp: Time.now.to_i + 2.weeks.to_i
       }, ForestLiana.auth_secret, 'HS256')
     end
   end

data/app/services/forest_liana/operator_date_interval_parser.rb

@@ -1,67 +1,68 @@
 module ForestLiana
   class OperatorDateIntervalParser
+    OPERATOR_PAST = 'past'
+    OPERATOR_FUTURE = 'future'
+    OPERATOR_TODAY = 'today'
+
+    OPERATOR_YESTERDAY = 'yesterday'
+    OPERATOR_PREVIOUS_WEEK = 'previous_week'
+    OPERATOR_PREVIOUS_MONTH = 'previous_month'
+    OPERATOR_PREVIOUS_QUARTER = 'previous_quarter'
+    OPERATOR_PREVIOUS_YEAR = 'previous_year'
+    OPERATOR_PREVIOUS_WEEK_TO_DATE = 'previous_week_to_date'
+    OPERATOR_PREVIOUS_MONTH_TO_DATE = 'previous_month_to_date'
+    OPERATOR_PREVIOUS_QUARTER_TO_DATE = 'previous_quarter_to_date'
+    OPERATOR_PREVIOUS_YEAR_TO_DATE = 'previous_year_to_date'
+
+    OPERATOR_PREVIOUS_X_DAYS = 'previous_x_days'
+    OPERATOR_PREVIOUS_X_DAYS_TO_DATE = 'previous_x_days_to_date'
+    OPERATOR_BEFORE_X_HOURS_AGO = 'before_x_hours_ago'
+    OPERATOR_AFTER_X_HOURS_AGO = 'after_x_hours_ago'
+
     PERIODS = {
-      :$yesterday => { duration: 1, period: 'day' },
-      :$previousWeek => { duration: 1, period: 'week' },
-      :$previousMonth => { duration: 1, period: 'month' },
-      :$previousQuarter => { duration: 3, period: 'month',
-                            period_of_time: 'quarter' },
-      :$previousYear => { duration: 1, period: 'year' },
-      :$weekToDate => { duration: 1, period: 'week', to_date: true },
-      :$monthToDate => { duration: 1, period: 'month', to_date: true },
-      :$quarterToDate => { duration: 3, period: 'month',
-                          period_of_time: 'quarter', to_date: true },
-      :$yearToDate => { duration: 1, period: 'year', to_date: true }
+      OPERATOR_YESTERDAY => { duration: 1, period: 'day' },
+      OPERATOR_PREVIOUS_WEEK => { duration: 1, period: 'week' },
+      OPERATOR_PREVIOUS_WEEK_TO_DATE => { duration: 1, period: 'week', to_date: true },
+      OPERATOR_PREVIOUS_MONTH => { duration: 1, period: 'month' },
+      OPERATOR_PREVIOUS_MONTH_TO_DATE => { duration: 1, period: 'month', to_date: true },
+      OPERATOR_PREVIOUS_QUARTER => { duration: 3, period: 'month', period_of_time: 'quarter' },
+      OPERATOR_PREVIOUS_QUARTER_TO_DATE => { duration: 3, period: 'month', period_of_time: 'quarter', to_date: true },
+      OPERATOR_PREVIOUS_YEAR => { duration: 1, period: 'year' },
+      OPERATOR_PREVIOUS_YEAR_TO_DATE => { duration: 1, period: 'year', to_date: true }
     }
 
-    PERIODS_PAST = '$past';
-    PERIODS_FUTURE = '$future';
-    PERIODS_TODAY = '$today';
-
-    PERIODS_PREVIOUS_X_DAYS = /^\$previous(\d+)Days$/;
-    PERIODS_X_DAYS_TO_DATE = /^\$(\d+)DaysToDate$/;
-    PERIODS_X_HOURS_BEFORE = /^\$(\d+)HoursBefore$/;
-    PERIODS_X_HOURS_AFTER = /^\$(\d+)HoursAfter$/;
-
-    def initialize(value, timezone)
-      @value = value
+    DATE_OPERATORS_HAVING_PREVIOUS_INTERVAL = [
+      OPERATOR_TODAY,
+      OPERATOR_YESTERDAY,
+      OPERATOR_PREVIOUS_WEEK,
+      OPERATOR_PREVIOUS_MONTH,
+      OPERATOR_PREVIOUS_QUARTER,
+      OPERATOR_PREVIOUS_YEAR,
+      OPERATOR_PREVIOUS_WEEK_TO_DATE,
+      OPERATOR_PREVIOUS_MONTH_TO_DATE,
+      OPERATOR_PREVIOUS_QUARTER_TO_DATE,
+      OPERATOR_PREVIOUS_YEAR_TO_DATE,
+      OPERATOR_PREVIOUS_X_DAYS,
+      OPERATOR_PREVIOUS_X_DAYS_TO_DATE
+    ]
+
+    DATE_OPERATORS = DATE_OPERATORS_HAVING_PREVIOUS_INTERVAL.concat [
+      OPERATOR_FUTURE,
+      OPERATOR_PAST,
+      OPERATOR_BEFORE_X_HOURS_AGO,
+      OPERATOR_AFTER_X_HOURS_AGO
+    ]
+
+    def initialize(timezone)
       @timezone_offset = Time.now.in_time_zone(timezone).utc_offset / 3600
     end
 
-    def is_interval_date_value
-      return false if @value.nil?
-      return true if PERIODS[@value.to_sym]
-
-      return true if [PERIODS_PAST, PERIODS_FUTURE, PERIODS_TODAY].include? @value
-
-      match = PERIODS_PREVIOUS_X_DAYS.match(@value)
-      return true if match && match[1]
-
-      match = PERIODS_X_DAYS_TO_DATE.match(@value)
-      return true if match && match[1]
-
-      match = PERIODS_X_HOURS_BEFORE.match(@value)
-      return true if match && match[1]
-
-      match = PERIODS_X_HOURS_AFTER.match(@value)
-      return true if match && match[1]
-
-      false
+    def is_date_operator?(operator)
+      DATE_OPERATORS.include? operator
     end
 
-    def has_previous_interval
-      return false if @value.nil?
-      return true if PERIODS[@value.to_sym]
-
-      return true if PERIODS_TODAY == @value
-
-      match = PERIODS_PREVIOUS_X_DAYS.match(@value)
-      return true if match && match[1]
-
-      match = PERIODS_X_DAYS_TO_DATE.match(@value)
-      return true if match && match[1]
-
-      false
+    def has_previous_interval?(operator)
+      DATE_OPERATORS_HAVING_PREVIOUS_INTERVAL.include? operator
     end
 
     def to_client_timezone(date)
@@ -69,46 +70,39 @@ module ForestLiana
       date - @timezone_offset.hours
     end
 
-    def get_interval_date_filter
-      return nil unless is_interval_date_value()
-
-      return ">= '#{Time.now}'" if @value == PERIODS_FUTURE
-      return "<= '#{Time.now}'" if @value == PERIODS_PAST
+    def get_date_filter(operator, value)
+      return nil unless is_date_operator? operator
 
-      if @value == PERIODS_TODAY
+      case operator
+      when OPERATOR_FUTURE
+        return ">= '#{Time.now}'"
+      when OPERATOR_PAST
+        return "<= '#{Time.now}'"
+      when OPERATOR_TODAY
         return "BETWEEN '#{to_client_timezone(Time.now.beginning_of_day)}' " +
           "AND '#{to_client_timezone(Time.now.end_of_day)}'"
-      end
-
-      match = PERIODS_PREVIOUS_X_DAYS.match(@value)
-      if match && match[1]
+      when OPERATOR_PREVIOUS_X_DAYS
+        ensure_integer_value(value)
         return "BETWEEN '" +
-          "#{to_client_timezone(Integer(match[1]).day.ago.beginning_of_day)}'" +
+          "#{to_client_timezone(Integer(value).day.ago.beginning_of_day)}'" +
           " AND '#{to_client_timezone(1.day.ago.end_of_day)}'"
-      end
-
-      match = PERIODS_X_DAYS_TO_DATE.match(@value)
-      if match && match[1]
+      when OPERATOR_PREVIOUS_X_DAYS_TO_DATE
+        ensure_integer_value(value)
         return "BETWEEN '" +
-          "#{to_client_timezone((Integer(match[1]) - 1).day.ago.beginning_of_day)}'" +
+          "#{to_client_timezone((Integer(value) - 1).day.ago.beginning_of_day)}'" +
           " AND '#{Time.now}'"
+      when OPERATOR_BEFORE_X_HOURS_AGO
+        ensure_integer_value(value)
+        return "< '#{to_client_timezone((Integer(value)).hour.ago)}'"
+      when OPERATOR_AFTER_X_HOURS_AGO
+        ensure_integer_value(value)
+        return "> '#{to_client_timezone((Integer(value)).hour.ago)}'"
       end
 
-      match = PERIODS_X_HOURS_BEFORE.match(@value)
-      if match && match[1]
-        return "< '#{to_client_timezone((Integer(match[1])).hour.ago)}'"
-      end
-
-      match = PERIODS_X_HOURS_AFTER.match(@value)
-      if match && match[1]
-        return "> '#{to_client_timezone((Integer(match[1])).hour.ago)}'"
-      end
-
-      duration = PERIODS[@value.to_sym][:duration]
-      period = PERIODS[@value.to_sym][:period]
-      period_of_time = PERIODS[@value.to_sym][:period_of_time] ||
-        PERIODS[@value.to_sym][:period]
-      to_date = PERIODS[@value.to_sym][:to_date]
+      duration = PERIODS[operator][:duration]
+      period = PERIODS[operator][:period]
+      period_of_time = PERIODS[operator][:period_of_time] || period
+      to_date = PERIODS[operator][:to_date]
 
       if to_date
         from = to_client_timezone(Time.now.send("beginning_of_#{period_of_time}"))
@@ -122,45 +116,47 @@ module ForestLiana
       "BETWEEN '#{from}' AND '#{to}'"
     end
 
-    def get_interval_date_filter_for_previous_interval
-      return nil unless has_previous_interval()
+    def get_date_filter_for_previous_interval(operator, value)
+      return nil unless has_previous_interval? operator
 
-      if @value == PERIODS_TODAY
+      case operator
+      when OPERATOR_TODAY
         return "BETWEEN '#{to_client_timezone(1.day.ago.beginning_of_day)}' AND " +
           "'#{to_client_timezone(1.day.ago.end_of_day)}'"
-      end
-
-      match = PERIODS_PREVIOUS_X_DAYS.match(@value)
-      if match && match[1]
+      when OPERATOR_PREVIOUS_X_DAYS
+        ensure_integer_value(value)
         return "BETWEEN '" +
-          "#{to_client_timezone((Integer(match[1]) * 2).day.ago.beginning_of_day)}'" +
-          " AND '#{to_client_timezone((Integer(match[1]) + 1).day.ago.end_of_day)}'"
-      end
-
-      match = PERIODS_X_DAYS_TO_DATE.match(@value)
-      if match && match[1]
+          "#{to_client_timezone((Integer(value) * 2).day.ago.beginning_of_day)}'" +
+          " AND '#{to_client_timezone((Integer(value) + 1).day.ago.end_of_day)}'"
+      when OPERATOR_PREVIOUS_X_DAYS_TO_DATE
+        ensure_integer_value(value)
         return "BETWEEN '" +
-          "#{to_client_timezone(((Integer(match[1]) * 2) - 1).day.ago.beginning_of_day)}'" +
-          " AND '#{to_client_timezone(Integer(match[1]).day.ago)}'"
+          "#{to_client_timezone(((Integer(value) * 2) - 1).day.ago.beginning_of_day)}'" +
+          " AND '#{to_client_timezone(Integer(value).day.ago)}'"
       end
 
-      duration = PERIODS[@value.to_sym][:duration]
-      period = PERIODS[@value.to_sym][:period]
-      period_of_time = PERIODS[@value.to_sym][:period_of_time] ||
-        PERIODS[@value.to_sym][:period]
-      to_date = PERIODS[@value.to_sym][:to_date]
+      duration = PERIODS[operator][:duration]
+      period = PERIODS[operator][:period]
+      period_of_time = PERIODS[operator][:period_of_time] || period
+      to_date = PERIODS[operator][:to_date]
 
       if to_date
-        from = to_client_timezone((duration).send(period).ago
-                 .send("beginning_of_#{period_of_time}"))
+        from = to_client_timezone((duration)
+          .send(period).ago.send("beginning_of_#{period_of_time}"))
         to = to_client_timezone((duration).send(period).ago)
       else
         from = to_client_timezone((duration * 2).send(period).ago
-                 .send("beginning_of_#{period_of_time}"))
+          .send("beginning_of_#{period_of_time}"))
         to = to_client_timezone((1 + duration).send(period).ago
-              .send("end_of_#{period_of_time}"))
+          .send("end_of_#{period_of_time}"))
       end
       "BETWEEN '#{from}' AND '#{to}'"
     end
+
+    def ensure_integer_value(value)
+      unless value.is_a?(Integer) || /\A[-+]?\d+\z/.match(value)
+        raise ForestLiana::Errors::HTTP422Error.new('\'value\' should be an Integer')
+      end
+    end
   end
 end