insights-api-common 3.8.0 → 3.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d2889f1fb8a92c64f95de6f5d4a97f111d35e796a2ab4fb6a6b54ade5bbef05
-  data.tar.gz: 951defb8fb43a566b3f16b49e76f340d95d68f839831c1d6896b72c91dd0428d
+  metadata.gz: 484591366a853923b1456ad224f13ea7462cf54c7e2e50091307ab3f6e70dffd
+  data.tar.gz: 0cfbc0b28162bcf862173cd1a4941a6cd406e9ca301316be1adb4856dcd834d6
 SHA512:
-  metadata.gz: 37ea90782a5dad4f376bcc9b99f051394e855b02f4689c93c8049f7a292cf373da4e4f20f8730efd4f8830e6a680b14e61849c2bf3c5198104b5efb9c167b9ef
-  data.tar.gz: 8d331fdbfa57116010b32374e8dfc0ef016249336db7e86dc40d5f685f2f382ff2277064aea57dc9eca451e8be1248f40039828f97762358f3d0d7f9c121f9ed
+  metadata.gz: 3632e7ccbe7eea9360829aef22960d5605235d95a01b725e7113392787836adb73272ac5280853ea78d610b0bd3b731a507845fd4aecf9dfa2e68d1f5830c72f
+  data.tar.gz: 18460ede94fc0d761284dd1b497e31dd9a0993caa17cc949a982098a6faca24b54d1efb3daf78f776a0f0e2ef79f63eeaeb46940fbf1892de99472cba0d06f6a

data/README.md

@@ -49,43 +49,76 @@ Or install it yourself as:
 
 After implementing filtering in your application, this is the way to filter via parameters on index functions:
 
-| Query Parameter | Ruby Client Parameter <br> **GraphQL filter: Parameter** |
-| --------------- | -------------------------------------------------------- |
-|"?filter[name]=reviews"|`{:filter => { :name => "reviews" }}`<br> **`filter: { name: "reviews" }`**|
-|"?filter[name][eq]=reviews"|`{:filter => { :name => { :eq => "reviews" } }}` <br> **`filter: { name: { eq: "reviews" } }`**|
-|"?filter[name][starts_with]=a"|`{:filter => { :name => { :starts_with => "a" } }}` <br> **`filter: { name: { starts_with: "a" } }`**|
-|"?filter[name][ends_with]=manager"|`{:filter => { :name => { :ends_with => "manager" } }}` <br> **`filter: { name: { ends_with: "manager" } }`**|
-|"?filter[name][contains]=openshift"|`{:filter => { :name => { :contains => "openshift" } }}` <br> **`filter: { name: { contains: "openshift" } }`**|
-|"?filter[id]=5"|`{:filter => { :id => "5" }}` <br> **`filter: { id: "5" }`**|
-|"?filter[id][eq]=5"|`{:filter => { :id => { :eq => "5" }}}` <br> **`filter: { id: { eq: "5" } }`**|
-|"?filter[id][gt]=180"|`{:filter => { :id => { :gt => "180" }}}` <br> **`filter: { id: { gt: "180" } }`**|
-|"?filter[id][gte]=190"|`{:filter => { :id => { :gte => "190" }}}` <br> **`filter: { id: { gte: "190" } }`**|
-|"?filter[id][lt]=5"|`{:filter => { :id => { :lt => "5" }}} ` <br> **`filter: { id: { lt: "5" } }`**|
-|"?filter[id][lte]=5"|`{:filter => { :id => { :lte => "5" }}}` <br> **`filter: { id: { lte: "5" } }`**|
-|"?filter[id][]=5&filter[id][]=10&filter[id][]=15&filter[id][]=20"|`{:filter => { :id => ["5", "10", "15", "20"]}}` <br> **`filter: { id: ["5", "10", "15", "20"] }`**|
-|"?filter[id][eq][]=5&filter[id][eq][]=10&filter[id][eq][]=15&filter[id][eq][]=20"|`{:filter => { :id => { :eq => ["5", "10", "15", "20"]}}}` <br> **`filter: { id: { eq: ["5", "10", "15", "20"] }`**|
+| Query Parameter | Ruby Client Parameter | GraphQL Parameter |
+| --------------- | --------------------- | ----------------- |
+| "?filter[name]=reviews" | { :filter => { :name => "reviews" } } | filter: { name: "reviews" } |
+| "?filter[name][eq]=reviews" | { :filter => { :name => { :eq => "reviews" } } } | filter: { name: { eq: "reviews" } } |
+| "?filter[name][starts_with]=a" | { :filter => { :name => { :starts_with => "a" } } } | filter: { name: { starts_with: "a" } } |
+| "?filter[name][ends_with]=manager" | { :filter => { :name => { :ends_with => "manager" } } } | filter: { name: { ends_with: "manager" } } |
+| "?filter[name][contains]=openshift" | { :filter => { :name => { :contains => "openshift" } } } | filter: { name: { contains: "openshift" } } |
+| "?filter[id]=5" | { :filter => { :id => "5" } } | filter: { id: "5" } |
+| "?filter[id][eq]=5" | { :filter => { :id => { :eq => "5" } } } | filter: { id: { eq: "5" } } |
+| "?filter[id][gt]=180" | { :filter => { :id => { :gt => "180" } } } | filter: { id: { gt: "180" } } |
+| "?filter[id][gte]=190" | { :filter => { :id => { :gte => "190" } } } | filter: { id: { gte: "190" } } |
+| "?filter[id][lt]=5" | { :filter => { :id => { :lt => "5" } } } | filter: { id: { lt: "5" } } |
+| "?filter[id][lte]=5" | { :filter => { :id => { :lte => "5" } } } | filter: { id: { lte: "5" } } |
+| "?filter[id][]=5&filter[id][]=10&filter[id][]=15&filter[id][]=20" | { :filter => { :id => ["5", "10", "15", "20"] } } | filter: { id: ["5", "10", "15", "20"] } |
+| "?filter[id][eq][]=5&filter[id][eq][]=10&filter[id][eq][]=15&filter[id][eq][]=20" | { :filter => { :id => { :eq => ["5", "10", "15", "20"] } } } | filter: { id: { eq: ["5", "10", "15", "20"] } |
 
 #### Sorting Results
 
 Sorting query results is controlled via the _sort_by_ query parameter. The _sort_by_ parameter is available for both REST API and GraphQL requests.
 
-The syntax for the _sort_by_ parameter supports:
+The _sort_by_ parameter specifies which attribute name to sort the results by, and may include a sort order of ascending _asc_ or descending _desc_. The default behavior when no sorting order is specified is to sort by ascending order.
+
+The syntax for the _sort_by_ parameter is as follows:
 
-- a single string representing the attribute name to sort by which may be followed by :asc or :desc
-  - **attribute**   (_default order is ascending_)
-  - **attribute:asc** (_ascending order_)
-  - **attribute:desc** (_descending order_)
-- an array of strings of the above syntax
+- One or more object keys representing the attribute name(s) to sort by which may be assigned the **asc** or **desc** value for the sort order.
+
+  - [**attribute**]   (_default order is ascending_)
+  - [**attribute**]=**asc** (_ascending order_)
+  - [**attribute**]=**desc** (_descending order_)
 
 ##### Sort_by Examples:
 
-- GET /api/v1.0/sources?sort_by=name
-- GET /api/v1.0/vms?sort_by[]=power_state\&sort_by[]=memory:desc
+- GET /api/v2.0/sources?sort_by[name]
+- GET /api/v2.0/vms?sort_by[power_state]&sort_by[memory]=desc
+
+| Query Parameter | Ruby Client Parameter | GraphQL Parameter |
+| --------------- | --------------------- | ----------------- |
+| "?sort_by[name]" | { :sort_by => { :name => nil } } | sort_by: { name: null } |
+| "?sort_by[name]=asc" | { :sort_by => { :name => "asc" } } | sort_by: { name: "asc" } |
+| "?sort_by[power_state]&sort_by[memory]=desc" | { :sort_by => { :power_state => nil, :memory => "desc" } } | sort_by: { power_state: null, memory: "desc" } |
+
+#### Filtering and Sorting by Association attribute
+
+Requests can also be filtered by assocation attribute and sorted by association attribute and count in addition to the direct attribute specified as in the above examples.
+
+Single level association can be specified as follows:
+
+##### Filter by association attribute:
+
+| Query Parameter | Ruby Client Parameter | GraphQL Parameter |
+| --------------- | --------------------- | ----------------- |
+| "?filter[association][name]=reviews" | { :filter => { :association => { :name => "reviews" } } } | filter: { association: { name: "reviews" } } |
+| "?filter[association][name][eq]=reviews" | { :filter => { :association => { :name => { :eq => "reviews" } } } } | filter: { association: { name: { eq: "reviews" } } } |
+
+##### Sort by association attributes and count:
+
+The _sort_by_ parameter can also be used to choose to sort by attributes of association objects as well as sorting by
+the count of association records by specifying the **__count** special attribute as follows:
+
+| Query Parameter | Ruby Client Parameter | GraphQL Parameter |
+| --------------- | --------------------- | ----------------- |
+| "?sort_by[association][name]" | { :sort_by => { :association => { :name => nil } } } | sort_by: { association: { name: null } } |
+| "?sort_by[association][name]=desc" | { :sort_by => { :association => { :name => "desc" } } } | sort_by: { association: { name: "desc" } } |
+| "?sort_by[association][__count]=asc" | { :sort_by => { :association => { :__count => "asc" } } } | sort_by: { association: { __count: "asc" } } |
+
+##### Combined Filtering and Sorting example:
 
 | Query Parameter | Ruby Client Parameter | GraphQL Parameter |
 | --------------- | --------------------- | ----------------- |
-| "?sort_by=name" | { :sort_by => "name" } | sort_by: "name" |
-| "?sort_by[]=power_state\&sort_by[]=memory:desc" | { :sort_by => ["power_state", "memory:desc"] } |  sort_by: ["power_state, "memory:desc"] |
+| "?filter[name][starts_with]=sample_&sort_by[application_types][__count]=desc&sort_by[name]=asc" | { :filter => { :name => { :starts_with => "sample_" } }, :sort_by => { :application_types => { :__count => "desc" }, :name => "asc" } } | filter: { name: { starts_with: "sample_" } }, sort_by: { application_types: { __count: "desc" }, name: "asc" } |
 
 ## Development
 

data/lib/insights/api/common/application_controller_mixins/api_doc.rb

@@ -17,6 +17,10 @@ module Insights
             self.class.send(:api_doc_definition)
           end
 
+          def api_doc_definitions
+            self.class.send(:api_doc_definitions)
+          end
+
           module ClassMethods
             private
 
@@ -28,6 +32,10 @@ module Insights
               @api_doc_definition ||= api_doc.definitions[name.split("::").last[0..-11].singularize]
             end
 
+            def api_doc_definitions
+              @api_doc_definitions ||= api_doc.definitions
+            end
+
             def api_version
               @api_version ||= name.split("::")[1].downcase
             end

data/lib/insights/api/common/application_controller_mixins/parameters.rb

@@ -90,7 +90,11 @@ module Insights
 
           def filtered
             check_if_openapi_enabled
-            Insights::API::Common::Filter.new(model, safe_params_for_list[:filter], api_doc_definition, extra_attributes_for_filtering).apply
+            association_attribute_properties =
+              Insights::API::Common::Filter.association_attribute_properties(api_doc_definitions, safe_params_for_list[:filter])
+            extra_attribute_properties = extra_attributes_for_filtering.merge(association_attribute_properties)
+
+            Insights::API::Common::Filter.new(model, safe_params_for_list[:filter], api_doc_definition, extra_attribute_properties).apply
           end
 
           def extra_attributes_for_filtering

data/lib/insights/api/common/filter.rb

@@ -4,6 +4,7 @@ module Insights
       class Filter
         INTEGER_COMPARISON_KEYWORDS = ["eq", "gt", "gte", "lt", "lte", "nil", "not_nil"].freeze
         STRING_COMPARISON_KEYWORDS  = ["contains", "contains_i", "eq", "eq_i", "starts_with", "starts_with_i", "ends_with", "ends_with_i", "nil", "not_nil"].freeze
+        ALL_COMPARISON_KEYWORDS     = (INTEGER_COMPARISON_KEYWORDS + STRING_COMPARISON_KEYWORDS).uniq.freeze
 
         attr_reader :apply, :arel_table, :api_doc_definition, :extra_filterable_attributes, :model
 
@@ -23,18 +24,23 @@ module Insights
         # A new Filter object, call #apply to get the filtered set of results.
         #
         def initialize(model, raw_filter, api_doc_definition, extra_filterable_attributes = {})
-          self.query                   = model
+          @raw_filter                  = raw_filter
           @api_doc_definition          = api_doc_definition
           @arel_table                  = model.arel_table
           @extra_filterable_attributes = extra_filterable_attributes
           @model                       = model
-          @raw_filter                  = raw_filter
         end
 
+        def query
+          @query ||= filter_associations.present? ? model.left_outer_joins(filter_associations) : model
+        end
+        attr_writer :query
+
         def apply
           return query if @raw_filter.blank?
-          @raw_filter.each do |k, v|
-            next unless attribute = attribute_for_key(k)
+
+          self.class.compact_filter(@raw_filter).each do |k, v|
+            next unless (attribute = attribute_for_key(k))
 
             if attribute["type"] == "string"
               type = determine_string_attribute_type(attribute)
@@ -48,13 +54,86 @@ module Insights
           query
         end
 
+        # Compact filters to support association filtering
+        #
+        #   Input:  {"source_type"=>{"name"=>{"eq"=>"rhev"}}}
+        #   Output: {"source_type.name"=>{"eq"=>"rhev"}}
+        #
+        #   Input:  {"source_type"=>{"name"=>{"eq"=>["openstack", "openshift"]}}}
+        #   Output: {"source_type.name"=>{"eq"=>["openstack", "openshift"]}}
+        #
+        def self.compact_filter(filter)
+          result = {}
+          return result if filter.blank?
+          return filter unless filter.kind_of?(Hash) || filter.kind_of?(ActionController::Parameters)
+
+          filter = Hash(filter.permit!) if filter.kind_of?(ActionController::Parameters)
+
+          filter.each do |ak, av|
+            if av.kind_of?(Hash)
+              av.each do |atk, atv|
+                if !ALL_COMPARISON_KEYWORDS.include?(atk)
+                  result["#{ak}.#{atk}"] = atv
+                else
+                  result[ak] = av
+                end
+              end
+            else
+              result[ak] = av
+            end
+          end
+          result
+        end
+
+        def self.association_attribute_properties(api_doc_definitions, raw_filter)
+          return {} if raw_filter.blank?
+
+          association_attributes = compact_filter(raw_filter).keys.select { |key| key.include?('.') }.compact.uniq
+          return {} if association_attributes.blank?
+
+          association_attributes.each_with_object({}) do |key, hash|
+            association, attr = key.split('.')
+            hash[key] = api_doc_definitions[association.singularize.classify].properties[attr.to_s]
+          end
+        end
+
         private
 
-        attr_accessor :query
         delegate(:arel_attribute, :to => :model)
 
         class Error < ArgumentError; end
 
+        def key_model_attribute(key)
+          if key.include?('.')
+            association, attr = key.split('.')
+            [association.classify.constantize, attr]
+          else
+            [model, key]
+          end
+        end
+
+        def model_arel_attribute(key)
+          key_model, attr = key_model_attribute(key)
+          key_model.arel_attribute(attr)
+        end
+
+        def model_arel_table(key)
+          key_model, attr = key_model_attribute(key)
+          key_model.arel_table
+        end
+
+        def filter_associations
+          return nil if @raw_filter.blank?
+
+          @filter_associations ||= begin
+            self.class.compact_filter(@raw_filter).keys.collect do |key|
+              next unless key.include?('.')
+
+              key.split('.').first.to_sym
+            end.compact.uniq
+          end
+        end
+
         def attribute_for_key(key)
           attribute = api_doc_definition.properties[key.to_s]
           attribute ||= extra_filterable_attributes[key.to_s]
@@ -74,7 +153,7 @@ module Insights
         end
 
         def string(k, val)
-          if val.kind_of?(ActionController::Parameters)
+          if val.kind_of?(Hash)
             val.each do |comparator, value|
               add_filter(comparator, STRING_COMPARISON_KEYWORDS, k, value)
             end
@@ -99,7 +178,7 @@ module Insights
         end
 
         def timestamp(k, val)
-          if val.kind_of?(ActionController::Parameters)
+          if val.kind_of?(Hash)
             val.each do |comparator, value|
               add_filter(comparator, INTEGER_COMPARISON_KEYWORDS, k, value)
             end
@@ -118,7 +197,7 @@ module Insights
         end
 
         def integer(k, val)
-          if val.kind_of?(ActionController::Parameters)
+          if val.kind_of?(Hash)
             val.each do |comparator, value|
               add_filter(comparator, INTEGER_COMPARISON_KEYWORDS, k, value)
             end
@@ -128,69 +207,69 @@ module Insights
         end
 
         def arel_lower(key)
-          Arel::Nodes::NamedFunction.new("LOWER", [arel_attribute(key)])
+          Arel::Nodes::NamedFunction.new("LOWER", [model_arel_attribute(key)])
         end
 
         def comparator_contains(key, value)
           return value.each { |v| comparator_contains(key, v) } if value.kind_of?(Array)
 
-          self.query = query.where(arel_attribute(key).matches("%#{query.sanitize_sql_like(value)}%", nil, true))
+          self.query = query.where(model_arel_attribute(key).matches("%#{query.sanitize_sql_like(value)}%", nil, true))
         end
 
         def comparator_contains_i(key, value)
           return value.each { |v| comparator_contains_i(key, v) } if value.kind_of?(Array)
 
-          self.query = query.where(arel_table.grouping(arel_lower(key).matches("%#{query.sanitize_sql_like(value.downcase)}%", nil, true)))
+          self.query = query.where(model_arel_table(key).grouping(arel_lower(key).matches("%#{query.sanitize_sql_like(value.downcase)}%", nil, true)))
         end
 
         def comparator_starts_with(key, value)
-          self.query = query.where(arel_attribute(key).matches("#{query.sanitize_sql_like(value)}%", nil, true))
+          self.query = query.where(model_arel_attribute(key).matches("#{query.sanitize_sql_like(value)}%", nil, true))
         end
 
         def comparator_starts_with_i(key, value)
-          self.query = query.where(arel_table.grouping(arel_lower(key).matches("#{query.sanitize_sql_like(value.downcase)}%", nil, true)))
+          self.query = query.where(model_arel_table(key).grouping(arel_lower(key).matches("#{query.sanitize_sql_like(value.downcase)}%", nil, true)))
         end
 
         def comparator_ends_with(key, value)
-          self.query = query.where(arel_attribute(key).matches("%#{query.sanitize_sql_like(value)}", nil, true))
+          self.query = query.where(model_arel_attribute(key).matches("%#{query.sanitize_sql_like(value)}", nil, true))
         end
 
         def comparator_ends_with_i(key, value)
-          self.query = query.where(arel_table.grouping(arel_lower(key).matches("%#{query.sanitize_sql_like(value.downcase)}", nil, true)))
+          self.query = query.where(model_arel_table(key).grouping(arel_lower(key).matches("%#{query.sanitize_sql_like(value.downcase)}", nil, true)))
         end
 
         def comparator_eq(key, value)
-          self.query = query.where(arel_attribute(key).eq_any(Array(value)))
+          self.query = query.where(model_arel_attribute(key).eq_any(Array(value)))
         end
 
         def comparator_eq_i(key, value)
           values = Array(value).map { |v| query.sanitize_sql_like(v.downcase) }
 
-          self.query = query.where(arel_table.grouping(arel_lower(key).matches_any(values)))
+          self.query = query.where(model_arel_table(key).grouping(arel_lower(key).matches_any(values)))
         end
 
         def comparator_gt(key, value)
-          self.query = query.where(arel_attribute(key).gt(value))
+          self.query = query.where(model_arel_attribute(key).gt(value))
         end
 
         def comparator_gte(key, value)
-          self.query = query.where(arel_attribute(key).gteq(value))
+          self.query = query.where(model_arel_attribute(key).gteq(value))
         end
 
         def comparator_lt(key, value)
-          self.query = query.where(arel_attribute(key).lt(value))
+          self.query = query.where(model_arel_attribute(key).lt(value))
         end
 
         def comparator_lte(key, value)
-          self.query = query.where(arel_attribute(key).lteq(value))
+          self.query = query.where(model_arel_attribute(key).lteq(value))
         end
 
         def comparator_nil(key, _value = nil)
-          self.query = query.where(arel_attribute(key).eq(nil))
+          self.query = query.where(model_arel_attribute(key).eq(nil))
         end
 
         def comparator_not_nil(key, _value = nil)
-          self.query = query.where.not(arel_attribute(key).eq(nil))
+          self.query = query.where.not(model_arel_attribute(key).eq(nil))
         end
       end
     end

data/lib/insights/api/common/graphql/templates/query_type.erb

@@ -34,10 +34,13 @@ QueryType = ::GraphQL::ObjectType.define do
         if args[:filter]
           openapi_doc = ::Insights::API::Common::OpenApi::Docs.instance["<%= api_version %>"]
           openapi_schema_name, _schema = ::Insights::API::Common::GraphQL::Generator.openapi_schema(openapi_doc, klass_name)
+          association_attribute_properties =
+            Insights::API::Common::Filter.association_attribute_properties(openapi_doc.definitions, ActionController::Parameters.new(args[:filter]))
           scope = ::Insights::API::Common::Filter.new(
             scope,
             ActionController::Parameters.new(args[:filter]),
-            openapi_doc.definitions[openapi_schema_name]).apply
+            openapi_doc.definitions[openapi_schema_name],
+            association_attribute_properties).apply
         end
         scope = ::Insights::API::Common::GraphQL.search_options(scope, args)
         if <%= graphql_options[:use_pagination_v2] %> == true

data/lib/insights/api/common/rbac/validate_groups.rb

@@ -12,7 +12,7 @@ module Insights
 
             Service.call(RBACApiClient::GroupApi) do |api|
               uuids = SortedSet.new
-              Service.paginate(api, :list_groups, {}).each { |group| uuids << group.uuid }
+              Service.paginate(api, :list_groups, {:uuid => @group_uuids.to_a}).each { |group| uuids << group.uuid }
               missing = @group_uuids - uuids
               raise Insights::API::Common::InvalidParameter, "The following group uuids are missing #{missing.to_a.join(",")}" unless missing.empty?
             end

data/lib/insights/api/common/version.rb

@@ -1,7 +1,7 @@
 module Insights
   module API
     module Common
-      VERSION = "3.8.0".freeze
+      VERSION = "3.9.0".freeze
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: insights-api-common
 version: !ruby/object:Gem::Version
-  version: 3.8.0
+  version: 3.9.0
 platform: ruby
 authors:
 - Insights Authors
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-24 00:00:00.000000000 Z
+date: 2020-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: acts_as_tenant
@@ -134,14 +134,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.1
+        version: 0.10.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.1
+        version: 0.10.0
 - !ruby/object:Gem::Dependency
   name: graphql
   requirement: !ruby/object:Gem::Requirement