class ShotgunApiRuby::Entities::Params

Public Class Methods

filters_are_simple?(filters) click to toggle source
# File lib/shotgun_api_ruby/entities/params.rb, line 111
def self.filters_are_simple?(filters)
  return false if filters.is_a? Array

  if filters.is_a?(Hash) &&
       (filters[:conditions] || filters['conditions'])
    return false
  end

  filters.values.all? do |filter_val|
    (
      filter_val.is_a?(Integer) || filter_val.is_a?(String) ||
        filter_val.is_a?(Symbol)
    ) ||
      (
        filter_val.is_a?(Array) && filter_val.all? do |val|
          val.is_a?(String) || val.is_a?(Symbol) || val.is_a?(Integer)
        end
      )
  end
end

Public Instance Methods

add_fields(fields) click to toggle source
# File lib/shotgun_api_ruby/entities/params.rb, line 32
def add_fields(fields)
  self[:fields] =
    fields && !fields.empty? ? [fields].flatten.join(',') : '*'
end
add_filter(filters, logical_operator = 'and') click to toggle source
# File lib/shotgun_api_ruby/entities/params.rb, line 46
def add_filter(filters, logical_operator = 'and')
  return unless filters

  self[:filter] =
    if (self.class.filters_are_simple?(filters))
      translate_simple_filters_to_sg(filters)
    elsif filters.is_a? Hash
      {
        conditions:
          filters[:conditions] || filters['conditions'] ||
            translate_complex_filters_to_sg(filters),
        logical_operator:
          filters[:logical_operator] || filters['logical_operator'] ||
            logical_operator,
      }
    else
      { conditions: filters, logical_operator: logical_operator }
    end
end
add_grouping(grouping) click to toggle source
# File lib/shotgun_api_ruby/entities/params.rb, line 66
def add_grouping(grouping)
  return unless grouping

  if grouping.is_a? Array
    self[:grouping] = grouping
    return
  end

  self[:grouping] =
    grouping
      .each
      .with_object([]) do |(key, options), result|
        if options.is_a? Hash
          result << {
            field: key.to_s,
            type:
              options[:type]&.to_s || options['type']&.to_s || 'exact',
            direction:
              options[:direction]&.to_s || options['direction']&.to_s ||
                'asc',
          }
        else
          result << {
            field: key.to_s,
            type: 'exact',
            direction: options.to_s,
          }
        end
      end
end
add_options(return_only, include_archived_projects) click to toggle source
# File lib/shotgun_api_ruby/entities/params.rb, line 37
def add_options(return_only, include_archived_projects)
  return if return_only.nil? && include_archived_projects.nil?

  self[:options] = {
    return_only: return_only ? 'retired' : 'active',
    include_archived_projects: !!include_archived_projects,
  }
end
add_page(page, page_size) click to toggle source
# File lib/shotgun_api_ruby/entities/params.rb, line 22
def add_page(page, page_size)
  return unless page || page_size

  page = page.to_i if page
  page_size = page_size.to_i if page_size

  page = 1 if page && page < 1
  self[:page] = { size: page_size || 20, number: page || 1 }
end
add_sort(sort) click to toggle source
# File lib/shotgun_api_ruby/entities/params.rb, line 9
def add_sort(sort)
  return unless sort

  self[:sort] =
    if sort.is_a?(Hash)
      sort.map do |field, direction|
        "#{direction.to_s.start_with?('desc') ? '-' : ''}#{field}"
      end.join(',')
    else
      [sort].flatten.join(',')
    end
end
add_summary_fields(summary_fields) click to toggle source
# File lib/shotgun_api_ruby/entities/params.rb, line 97
def add_summary_fields(summary_fields)
  return unless summary_fields

  if summary_fields.is_a? Array
    self[:summary_fields] = summary_fields
    return
  end

  if summary_fields.is_a? Hash
    self[:summary_fields] =
      summary_fields.map { |k, v| { field: k.to_s, type: v.to_s } }
  end
end

Private Instance Methods

translate_complex_filters_to_sg(filters) click to toggle source
# File lib/shotgun_api_ruby/entities/params.rb, line 143
def translate_complex_filters_to_sg(filters)
  # We don't know how to translate anything but hashes
  return filters if !filters.is_a?(Hash)

  filters
    .each
    .with_object([]) do |item, result|
      field, value = item
      case value
      when String, Symbol, Integer, Float
        result << [field.to_s, 'is', value]
      when Hash
        value.each do |subfield, subvalue|
          sanitized_subfield =
            if !subfield.to_s.include?('.')
              "#{field.capitalize}.#{subfield}"
            else
              subfield
            end
          case subvalue
          when String, Symbol, Integer, Float
            result << ["#{field}.#{sanitized_subfield}", 'is', subvalue]
          when Array
            result << ["#{field}.#{sanitized_subfield}", 'in', subvalue]
          else
            raise TooComplexFiltersError,
                  'This case is too complex to auto-translate. Please use shotgun query syntax.'
          end
        end
      when Array
        result << [field.to_s, 'in', value]
      else
        raise TooComplexFiltersError,
              'This case is too complex to auto-translate. Please use shotgun query syntax.'
      end
    end
end
translate_simple_filters_to_sg(filters) click to toggle source
# File lib/shotgun_api_ruby/entities/params.rb, line 134
def translate_simple_filters_to_sg(filters)
  filters.map do |field, value|
    [
      field.to_s,
      value.is_a?(Array) ? value.map(&:to_s).join(',') : value.to_s,
    ]
  end.to_h
end