gooddata 0.6.17 → 0.6.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0bbc18e2feb9dc7d8f7b2fcadfd4e26474b666d0
-  data.tar.gz: 0020310a69543fcea52bd5d0bee0ddbe25bae3ff
+  metadata.gz: f683852cdcca1c3ac58923b66d2875199f4941ca
+  data.tar.gz: c439059752871aa8edaaae9578ebb5d8070d055a
 SHA512:
-  metadata.gz: dc66e78d316ee699b2374f1885a8cd6736addd8040931400e7fab8c287327a322828480fbd0d25a5ebaea343c8b810e926afa174b2f39239d1aec0e9f504114a
-  data.tar.gz: 388b87c526902279fd6c01b5739f478e3d8d4787179e3062ae495caa0809ad58d47b3edaee21230425f373d5ab056097e20214b568038da7cdd07053f981b3c8
+  metadata.gz: 7645abe267313b36bcc9f5d9ae076be9a7b608860db6a7bd27a91919dab47af0e31d3a48a921521d546f28fe822312ff69007826886447ea0dd165b170f7e5bb
+  data.tar.gz: 319d48cffc079ce239e78ff4b8ab4d2c3911a5fb381a13d47fb8d91f58e7947dab7d7bbed9fbfa44a97d87689f6b1f3340612246a59c8ffcec581109e69c1765

data/lib/gooddata/models/domain.rb

@@ -168,7 +168,8 @@ module GoodData
         c = client(opts)
         escaped_login = CGI.escape(login)
         domain = c.domain(domain)
-        url = "/gdc/account/domains/#{domain.name}/users?login=#{escaped_login}"
+        GoodData.logger.warn("Retrieving particular user \"#{login.inspect}\" from domain #{domain.name}")
+        url = "#{domain.uri}/users?login=#{escaped_login}"
         tmp = c.get url
         items = tmp['accountSettings']['items'] if tmp['accountSettings']
         items && items.length > 0 ? c.factory.create(GoodData::Profile, items.first) : nil
@@ -180,23 +181,30 @@ module GoodData
       # @option opts [Number] :offset The subject
       # @option opts [Number] :limit From address
       # TODO: Review opts[:limit] functionality
-      def users(domain, opts = {})
-        result = []
-        page_limit = opts[:page_limit] || 1000
-        limit = opts[:limit] || Float::INFINITY
-        offset = opts[:offset]
-        uri = "/gdc/account/domains/#{domain}/users?offset=#{offset}&limit=#{page_limit}"
-        loop do
-          tmp = client(opts).get(uri)
-          tmp['accountSettings']['items'].each do |account|
-            result << client(opts).create(GoodData::Profile, account)
-          end
-          break if result.length >= limit
+      def users(domain, id = :all, opts = {})
+        c = client(opts)
+        domain = c.domain(domain)
+        if id == :all
+          GoodData.logger.warn("Retrieving all users from domain #{domain.name}")
+          result = []
+          page_limit = opts[:page_limit] || 1000
+          limit = opts[:limit] || Float::INFINITY
+          offset = opts[:offset]
+          uri = "#{domain.uri}/users?offset=#{offset}&limit=#{page_limit}"
+          loop do
+            tmp = client(opts).get(uri)
+            tmp['accountSettings']['items'].each do |account|
+              result << client(opts).create(GoodData::Profile, account)
+            end
+            break if result.length >= limit
 
-          uri = tmp['accountSettings']['paging']['next']
-          break unless uri
+            uri = tmp['accountSettings']['paging']['next']
+            break unless uri
+          end
+          result
+        else
+          find_user_by_login(domain, id)
         end
-        result
       end
 
       # Create users specified in list
@@ -264,8 +272,8 @@ module GoodData
     # @param [Array<GoodData::User>]user_list Optional cached list of users used for look-ups
     # @return [GoodDta::Membership] User
     def get_user(name, user_list = users)
-      return member(name) if name.instance_of?(GoodData::Membership)
-      return member(name) if name.instance_of?(GoodData::Profile)
+      return member(name, user_list) if name.instance_of?(GoodData::Membership)
+      return member(name, user_list) if name.instance_of?(GoodData::Profile)
       name = name.is_a?(Hash) ? name[:login] || name[:uri] : name
       return nil unless name
       name.downcase!
@@ -332,12 +340,16 @@ module GoodData
     # domain = GoodData::Domain['gooddata-tomas-korcak']
     # pp domain.users
     #
-    def users(opts = {})
-      GoodData::Domain.users(name, opts.merge(client: client))
+    def users(id = :all, opts = {})
+      GoodData::Domain.users(name, id, opts.merge(client: client))
     end
 
     alias_method :members, :users
 
+    def uri
+      "/gdc/account/domains/#{name}"
+    end
+
     private
 
     # Private setter of domain name. Used by constructor not available for external users.

data/lib/gooddata/models/process.rb

@@ -205,6 +205,7 @@ module GoodData
     # @return [IO] The stream of data that represents a zipped deployed process.
     def download
       link = links['source']
+      client.connection.refresh_token
       client.get(link, process: false) { |_, _, result| RestClient.get(result.to_hash['location'].first) }
     end
 

data/lib/gooddata/models/project.rb

@@ -350,8 +350,8 @@ module GoodData
       GoodData::Dashboard[id, project: self, client: client]
     end
 
-    def data_permissions
-      GoodData::MandatoryUserFilter.all(client: client, project: self)
+    def data_permissions(id = :all)
+      GoodData::MandatoryUserFilter[id, client: client, project: self]
     end
 
     # Deletes project
@@ -890,7 +890,7 @@ module GoodData
     # List of users in project
     #
     # @return [Array<GoodData::User>] List of users
-    def users(opts = { offset: 0, limit: 10_000 })
+    def users(opts = { offset: 0, limit: 1_000 })
       result = []
 
       # TODO: @korczis, review this after WA-3953 get fixed
@@ -933,9 +933,11 @@ module GoodData
     def import_users(new_users, options = {})
       domain = options[:domain]
       role_list = roles
-      users_list = users
+      users_list = users(all: true, offset: 0, limit: 1_000)
       new_users = new_users.map { |x| (x.is_a?(Hash) && x[:user] && x[:user].to_hash.merge(role: x[:role])) || x.to_hash }
 
+      GoodData.logger.warn("Importing users to project (#{pid})")
+
       whitelisted_new_users, whitelisted_users = whitelist_users(new_users.map(&:to_hash), users_list, options[:whitelists])
 
       # conform the role on list of new users so we can diff them with the users coming from the project
@@ -949,11 +951,12 @@ module GoodData
           role = get_role(r, role_list)
           role && role.uri
         end
+        u[:status] = 'ENABLED'
         u
       end
 
       # Diff users. Only login and role is important for the diff
-      diff = GoodData::Helpers.diff(whitelisted_users, diffable_new, key: :login, fields: [:login, :role])
+      diff = GoodData::Helpers.diff(whitelisted_users, diffable_new, key: :login, fields: [:login, :role, :status])
 
       results = []
       # Create new users
@@ -963,15 +966,19 @@ module GoodData
           role: x[:role]
         }
       end
-
-      results.concat create_users(u, roles: role_list, domain: domain, project_users: whitelisted_users)
+      # This is only creating users that were not in the proejcts so far. This means this will reach into domain
+      GoodData.logger.warn("Creating #{diff[:added].count} users in project (#{pid})")
+      results.concat create_users(u, roles: role_list, domain: domain, project_users: whitelisted_users, only_domain: true)
 
       # # Update existing users
+      GoodData.logger.warn("Updating #{diff[:changed].count} users in project (#{pid})")
       list = diff[:changed].map { |x| { user: x[:new_obj], role: x[:new_obj][:role] || x[:new_obj][:roles] } }
       results.concat(set_users_roles(list, roles: role_list, project_users: whitelisted_users))
 
       # Remove old users
-      results.concat(disable_users(diff[:removed]))
+      to_remove = diff[:removed].reject { |user| user[:status] == 'DISABLED' || user[:status] == :disabled }
+      GoodData.logger.warn("Removing #{to_remove.count} users in project (#{pid})")
+      results.concat(disable_users(to_remove))
       results
     end
 
@@ -982,7 +989,8 @@ module GoodData
         generate_user_payload(u[:uri], 'DISABLED')
       end
       payloads.each_slice(100).mapcat do |payload|
-        client.post(url, 'users' => payload)
+        result = client.post(url, 'users' => payload)
+        result['projectUsersUpdateResult'].mapcat { |k, v| v.map { |x| { type: k.to_sym, uri: x } } }
       end
     end
 
@@ -1033,7 +1041,16 @@ module GoodData
       role_list = options[:roles] || roles
       project_users = options[:project_users] || users
       domain = options[:domain] && client.domain(options[:domain])
-      domain_users = domain.nil? ? nil : domain.users
+      domain_users = if domain.nil?
+                       options[:domain_users]
+                     else
+                       if options[:only_domain] && list.count < 100
+                         list.map { |l| domain.find_user_by_login(l[:user][:login]) }
+                       else
+                         domain.users
+                       end
+                     end
+
       users_to_add = list.flat_map do |user_hash|
         user = user_hash[:user] || user_hash[:login]
         desired_roles = user_hash[:role] || user_hash[:roles] || 'readOnlyUser'
@@ -1049,7 +1066,7 @@ module GoodData
       results = payloads.each_slice(100).map do |payload|
         client.post(url, 'users' => payload)
       end
-      results.flat_map { |x| x['projectUsersUpdateResult'].flat_map { |k, v| v.map { |v_2| { status: k.to_sym, uri: v_2 } } } }
+      results.flat_map { |x| x['projectUsersUpdateResult'].flat_map { |k, v| v.map { |v_2| { type: k.to_sym, uri: v_2 } } } }
     end
 
     alias_method :add_users, :set_users_roles

data/lib/gooddata/models/user_filters/mandatory_user_filter.rb

@@ -30,19 +30,27 @@ module GoodData
           break if result['userFilters']['length'] < offset
           offset += count
         end
-        vars.map do |a|
-          uri = a['link']
-          data = c.get(uri)
-          payload = {
-            'expression' => data['userFilter']['content']['expression'],
-            'related' => user_lookup[a['link']],
-            'level' => :user,
-            'type'  => :filter,
-            'uri'   => a['link']
-          }
-          c.create(GoodData::MandatoryUserFilter, payload, project: project)
+        vars.each_slice(100).mapcat do |batch|
+          batch.pmap do |a|
+            uri = a['link']
+            data = c.get(uri)
+            payload = {
+              'expression' => data['userFilter']['content']['expression'],
+              'related' => user_lookup[a['link']],
+              'level' => :user,
+              'type'  => :filter,
+              'uri'   => a['link']
+            }
+            c.create(GoodData::MandatoryUserFilter, payload, project: project)
+          end
         end
       end
+
+      def count(options = { client: GoodData.connection, project: GoodData.project })
+        c = client(options)
+        project = options[:project]
+        c.get(project.md['query'] + '/userfilters/')['query']['entries'].count
+      end
     end
 
     # Creates or updates the mandatory user filter on the server

data/lib/gooddata/models/user_filters/user_filter_builder.rb

@@ -1,8 +1,5 @@
 # encoding: UTF-8
 
-require_relative 'user_filter_builder_create'
-require_relative 'user_filter_builder_execute'
-
 module GoodData
   module UserFilterBuilder
     # Main Entry function. Gets values and processes them to get filters
@@ -109,19 +106,168 @@ module GoodData
       end
     end
 
-    def self.verify_existing_users(filters, options = {})
-      project = options[:project]
+    def self.get_missing_users(filters, options = {})
+      users_cache = options[:users_cache]
+      filters.reject { |u| users_cache.key?(u[:login]) }
+    end
 
+    def self.verify_existing_users(filters, options = {})
       users_must_exist = options[:users_must_exist] == false ? false : true
-      users_cache = options[:users_cache] || create_cache(project.users, :login)
+      users_cache = options[:users_cache]
+      domain = options[:domain]
 
       if users_must_exist
-        list = users_cache.values
-        missing_users = filters.map { |x| x[:login] }.reject { |u| project.member?(u, list) }
+        missing_users = filters.reject do |u|
+          next true if users_cache.key?(u[:login])
+          domain_user = (domain && domain.find_user_by_login(u[:login]))
+          users_cache[domain_user.login] = domain_user if domain_user
+          next true if domain_user
+          false
+        end
         fail "#{missing_users.count} users are not part of the project and variable cannot be resolved since :users_must_exist is set to true (#{missing_users.join(', ')})" unless missing_users.empty?
       end
     end
 
+    def self.create_label_cache(result, options = {})
+      project = options[:project]
+
+      result.reduce({}) do |a, e|
+        e[:filters].map do |filter|
+          a[filter[:label]] = project.labels(filter[:label]) unless a.key?(filter[:label])
+        end
+        a
+      end
+    end
+
+    def self.create_lookups_cache(small_labels)
+      small_labels.reduce({}) do |a, e|
+        lookup = e.values(:limit => 1_000_000).reduce({}) do |a1, e1|
+          a1[e1[:value]] = e1[:uri]
+          a1
+        end
+        a[e.uri] = lookup
+        a
+      end
+    end
+
+    def self.create_attrs_cache(filters, options = {})
+      project = options[:project]
+
+      labels = filters.flat_map do |f|
+        f[:filters]
+      end
+
+      over_cache = labels.reduce({}) do |a, e|
+        a[e[:over]] = e[:over]
+        a
+      end
+      to_cache = labels.reduce({}) do |a, e|
+        a[e[:to]] = e[:to]
+        a
+      end
+      cache = over_cache.merge(to_cache)
+      attr_cache = {}
+      cache.each_pair do |k, v|
+        begin
+          attr_cache[k] = project.attributes(v)
+        rescue
+          nil
+        end
+      end
+      attr_cache
+    end
+
+    # Walks over provided labels and picks those that have fewer than certain amount of values
+    # This tries to balance for speed when working with small datasets (like users)
+    # so it precaches the values and still be able to function for larger ones even
+    # though that would mean tons of requests
+    def self.get_small_labels(labels_cache)
+      labels_cache.values.select { |label| label.values_count < 100_000 }
+    end
+
+    # Creates a MAQL expression(s) based on the filter defintion.
+    # Takes the filter definition looks up any necessary values and provides API executable MAQL
+    def self.create_expression(filter, labels_cache, lookups_cache, attr_cache, options = {})
+      errors = []
+      values = filter[:values]
+      label = labels_cache[filter[:label]]
+      element_uris = values.map do |v|
+        begin
+          if lookups_cache.key?(label.uri)
+            if lookups_cache[label.uri].key?(v)
+              lookups_cache[label.uri][v]
+            else
+              fail
+            end
+          else
+            label.find_value_uri(v)
+          end
+        rescue
+          errors << [label.title, v]
+          nil
+        end
+      end
+      expression = if element_uris.compact.empty? && options[:restrict_if_missing_all_values] && options[:type] == :muf
+                     '1 <> 1'
+                   elsif element_uris.compact.empty? && options[:restrict_if_missing_all_values] && options[:type] == :variable
+                     nil
+                   elsif element_uris.compact.empty?
+                     'TRUE'
+                   elsif filter[:over] && filter[:to]
+                     over = attr_cache[filter[:over]]
+                     to = attr_cache[filter[:to]]
+                     "([#{label.attribute_uri}] IN (#{ element_uris.compact.sort.map { |e| '[' + e + ']' }.join(', ') })) OVER [#{over && over.uri}] TO [#{to && to.uri}]"
+                   else
+                     "[#{label.attribute_uri}] IN (#{ element_uris.compact.sort.map { |e| '[' + e + ']' }.join(', ') })"
+                   end
+      [expression, errors]
+    end
+
+    # Encapuslates the creation of filter
+    def self.create_user_filter(expression, related)
+      {
+        'related' => related,
+        'level' => :user,
+        'expression' => expression,
+        'type' => :filter
+      }
+    end
+
+    # Resolves and creates maql statements from filter definitions.
+    # This method does not perform any modifications on API but
+    # collects all the information that is needed to do so.
+    # Method collects all info from the user and current state in project and compares.
+    # Returns suggestion of what should be deleted and what should be created
+    # If there is some discrepancies in the data (missing values, nonexistent users) it
+    # finishes and collects all the errors at once
+    #
+    # @param filters [Array<Hash>] Filters definition
+    # @return [Array] first is list of MAQL statements
+    def self.maqlify_filters(filters, options = {})
+      # project = options[:project]
+      users_cache = options[:users_cache] # || create_cache(project.users, :login)
+      labels_cache = create_label_cache(filters, options)
+      small_labels = get_small_labels(labels_cache)
+      lookups_cache = create_lookups_cache(small_labels)
+      attrs_cache = create_attrs_cache(filters, options)
+
+      errors = []
+      results = filters.pmapcat do |filter|
+        login = filter[:login]
+        filter[:filters].pmapcat do |f|
+          expression, error = create_expression(f, labels_cache, lookups_cache, attrs_cache, options)
+          errors << error unless error.empty?
+          profiles_uri = (users_cache[login] && users_cache[login].uri)
+          if profiles_uri && expression
+            [create_user_filter(expression, profiles_uri)]
+          else
+            []
+          end
+        end
+      end
+      [results, errors]
+    end
+
     def self.resolve_user_filter(user = [], project = [])
       user ||= []
       project ||= []
@@ -150,6 +296,83 @@ module GoodData
       [to_create, to_delete]
     end
 
+    # Executes the update for variables. It resolves what is new and needed to update.
+    # @param filters [Array<Hash>] Filter Definitions
+    # @param filters [Variable] Variable instance to be updated
+    # @param options [Hash]
+    # @option options [Boolean] :dry_run If dry run is true. No changes to he proejct are made but list of changes is provided
+    # @return [Array] list of filters that needs to be created and deleted
+    def self.execute_variables(filters, var, options = {})
+      client = options[:client]
+      project = options[:project]
+      dry_run = options[:dry_run]
+      to_create, to_delete = execute(filters, var.user_values, VariableUserFilter, options.merge(type: :variable))
+      return [to_create, to_delete] if dry_run
+
+      # TODO: get values that are about to be deleted and created and update them.
+      # This will make sure there is no downitme in filter existence
+      unless options[:do_not_touch_filters_that_are_not_mentioned]
+        to_delete.each { |_, group| group.each(&:delete) }
+      end
+      data = to_create.values.flatten.map(&:to_hash).map { |var_val| var_val.merge(prompt: var.uri) }
+      data.each_slice(200) do |slice|
+        client.post("/gdc/md/#{project.obj_id}/variables/user", :variables => slice)
+      end
+      [to_create, to_delete]
+    end
+
+    def self.execute_mufs(filters, options = {})
+      client = options[:client]
+      project = options[:project]
+
+      dry_run = options[:dry_run]
+      to_create, to_delete = execute(filters, project.data_permissions, MandatoryUserFilter, options.merge(type: :muf))
+      GoodData.logger.warn("Data permissions computed: #{to_create.count} to create and #{to_delete.count} to delete")
+      return [to_create, to_delete] if dry_run
+
+      to_create.each_slice(100).flat_map do |batch|
+        batch.peach do |related_uri, group|
+          group.each(&:save)
+
+          res = client.get("/gdc/md/#{project.pid}/userfilters?users=#{related_uri}")
+          items = res['userFilters']['items'].empty? ? [] : res['userFilters']['items'].first['userFilters']
+
+          payload = {
+            'userFilters' => {
+              'items' => [{
+                'user' => related_uri,
+                'userFilters' => items.concat(group.map(&:uri))
+              }]
+            }
+          }
+          client.post("/gdc/md/#{project.pid}/userfilters", payload)
+        end
+      end
+      unless options[:do_not_touch_filters_that_are_not_mentioned]
+        to_delete.each_slice(100).flat_map do |batch|
+          batch.peach do |related_uri, group|
+            if related_uri
+              res = client.get("/gdc/md/#{project.pid}/userfilters?users=#{related_uri}")
+              items = res['userFilters']['items'].empty? ? [] : res['userFilters']['items'].first['userFilters']
+              payload = {
+                'userFilters' => {
+                  'items' => [
+                    {
+                      'user' => related_uri,
+                      'userFilters' => items - group.map(&:uri)
+                    }
+                  ]
+                }
+              }
+              client.post("/gdc/md/#{project.pid}/userfilters", payload)
+            end
+            group.peach(&:delete)
+          end
+        end
+      end
+      [to_create, to_delete]
+    end
+
     private
 
     # Reads values from File/Array. Abstracts away the fact if it is column based,
@@ -175,5 +398,70 @@ module GoodData
       end
       memo
     end
+
+    # Executes the procedure necessary for loading user filters. This method has what
+    # is common for both implementations. Funcion
+    #   * makes sure that filters are in normalized form.
+    #   * verifies that users are in the project (and domain)
+    #   * creates maql expressions of the filters provided
+    #   * resolves the filters against current values in the project
+    # @param user_filters [Array] Filters that user is trying to set up
+    # @param project_filters [Array] List of filters currently in the project
+    # @param klass [Class] Class can be aither UserFilter or VariableFilter
+    # @param options [Hash] Filter definitions
+    # @return [Array<Hash>]
+    def self.execute(user_filters, project_filters, klass, options = {})
+      client = options[:client]
+      project = options[:project]
+
+      ignore_missing_values = options[:ignore_missing_values]
+      users_must_exist = options[:users_must_exist] == false ? false : true
+      filters = normalize_filters(user_filters)
+      domain = options[:domain]
+      users = project.users
+      # users = domain ? project.users : project.users
+      users_cache = create_cache(users, :login)
+      missing_users = get_missing_users(filters, options.merge(users_cache: users_cache))
+      user_filters, errors = if missing_users.empty?
+                               verify_existing_users(filters, project: project, users_must_exist: users_must_exist, users_cache: users_cache)
+                               maqlify_filters(filters, options.merge(users_cache: users_cache, users_must_exist: users_must_exist))
+                             elsif missing_users.count < 100
+                               verify_existing_users(filters, project: project, users_must_exist: users_must_exist, users_cache: users_cache,  domain: domain)
+                               maqlify_filters(filters, options.merge(users_cache: users_cache, users_must_exist: users_must_exist, domain: domain))
+                             else
+                               users += domain.users
+                               users_cache = create_cache(users, :login)
+                               verify_existing_users(filters, project: project, users_must_exist: users_must_exist, users_cache: users_cache,  domain: domain)
+                               maqlify_filters(filters, options.merge(users_cache: users_cache, users_must_exist: users_must_exist, domain: domain))
+                             end
+
+      fail "Validation failed #{errors}" if !ignore_missing_values && !errors.empty?
+
+      filters = user_filters.map { |data| client.create(klass, data, project: project) }
+      resolve_user_filters(filters, project_filters)
+    end
+
+    # Gets definition of filters from user. They might either come in the full definition
+    # as hash or a simplified version. The simplified version do not cover all the possible
+    # features but it is much simpler to remember and suitable for quick hacking around
+    # @param filters [Array<Array | Hash>]
+    # @return [Array<Hash>]
+    def self.normalize_filters(filters)
+      filters.map do |filter|
+        if filter.is_a?(Hash)
+          filter
+        else
+          {
+            :login => filter.first,
+            :filters => [
+              {
+                :label => filter[1],
+                :values => filter[2..-1]
+              }
+            ]
+          }
+        end
+      end
+    end
   end
 end

data/lib/gooddata/rest/client.rb

@@ -153,6 +153,10 @@ module GoodData
         GoodData::Domain[domain_name, :client => self]
       end
 
+      def project_is_accessible?(id)
+        projects(id) && true rescue false
+      end
+
       def projects(id = :all)
         GoodData::Project[id, client: self]
       end

data/lib/gooddata/version.rb

@@ -2,7 +2,7 @@
 
 # GoodData Module
 module GoodData
-  VERSION = '0.6.17'
+  VERSION = '0.6.18'
 
   class << self
     # Version

data/spec/unit/models/domain_spec.rb

@@ -63,7 +63,7 @@ describe GoodData::Domain do
     end
 
     it 'Accepts pagination options - limit' do
-      users = @domain.users(limit: 10)
+      users = @domain.users(:all, limit: 10)
       expect(users).to be_instance_of(Array)
       users.each do |user|
         expect(user).to be_an_instance_of(GoodData::Profile)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gooddata
 version: !ruby/object:Gem::Version
-  version: 0.6.17
+  version: 0.6.18
 platform: ruby
 authors:
 - Pavel Kolesnikov
@@ -759,8 +759,6 @@ files:
 - lib/gooddata/models/user_filters/mandatory_user_filter.rb
 - lib/gooddata/models/user_filters/user_filter.rb
 - lib/gooddata/models/user_filters/user_filter_builder.rb
-- lib/gooddata/models/user_filters/user_filter_builder_create.rb
-- lib/gooddata/models/user_filters/user_filter_builder_execute.rb
 - lib/gooddata/models/user_filters/user_filters.rb
 - lib/gooddata/models/user_filters/variable_user_filter.rb
 - lib/gooddata/rest/README.md

data/lib/gooddata/models/user_filters/user_filter_builder_create.rb

@@ -1,115 +0,0 @@
-# encoding: UTF-8
-
-module GoodData
-  module UserFilterBuilder
-    def self.create_label_cache(result, options = {})
-      project = options[:project]
-
-      result.reduce({}) do |a, e|
-        e[:filters].map do |filter|
-          a[filter[:label]] = project.labels(filter[:label]) unless a.key?(filter[:label])
-        end
-        a
-      end
-    end
-
-    def self.create_lookups_cache(small_labels)
-      small_labels.reduce({}) do |a, e|
-        lookup = e.values(:limit => 1_000_000).reduce({}) do |a1, e1|
-          a1[e1[:value]] = e1[:uri]
-          a1
-        end
-        a[e.uri] = lookup
-        a
-      end
-    end
-
-    # Walks over provided labels and picks those that have fewer than certain amount of values
-    # This tries to balance for speed when working with small datasets (like users)
-    # so it precaches the values and still be able to function for larger ones even
-    # though that would mean tons of requests
-    def self.get_small_labels(labels_cache)
-      labels_cache.values.select { |label| label.values_count < 100_000 }
-    end
-
-    # Creates a MAQL expression(s) based on the filter defintion.
-    # Takes the filter definition looks up any necessary values and provides API executable MAQL
-    def self.create_expression(filter, labels_cache, lookups_cache, options = {})
-      errors = []
-      values = filter[:values]
-      label = labels_cache[filter[:label]]
-      element_uris = values.map do |v|
-        begin
-          if lookups_cache.key?(label.uri)
-            if lookups_cache[label.uri].key?(v)
-              lookups_cache[label.uri][v]
-            else
-              fail
-            end
-          else
-            label.find_value_uri(v)
-          end
-        rescue
-          errors << [label.title, v]
-          nil
-        end
-      end
-      expression = if element_uris.compact.empty? && options[:restrict_if_missing_all_values] && options[:type] == :muf
-                     '1 <> 1'
-                   elsif element_uris.compact.empty? && options[:restrict_if_missing_all_values] && options[:type] == :variable
-                     nil
-                   elsif element_uris.compact.empty?
-                     'TRUE'
-                   elsif filter[:over] && filter[:to]
-                     "([#{label.attribute_uri}] IN (#{ element_uris.compact.sort.map { |e| '[' + e + ']' }.join(', ') })) OVER [#{filter[:over]}] TO [#{filter[:to]}]"
-                   else
-                     "[#{label.attribute_uri}] IN (#{ element_uris.compact.sort.map { |e| '[' + e + ']' }.join(', ') })"
-                   end
-      [expression, errors]
-    end
-
-    # Encapuslates the creation of filter
-    def self.create_user_filter(expression, related)
-      {
-        'related' => related,
-        'level' => :user,
-        'expression' => expression,
-        'type' => :filter
-      }
-    end
-
-    # Resolves and creates maql statements from filter definitions.
-    # This method does not perform any modifications on API but
-    # collects all the information that is needed to do so.
-    # Method collects all info from the user and current state in project and compares.
-    # Returns suggestion of what should be deleted and what should be created
-    # If there is some discrepancies in the data (missing values, nonexistent users) it
-    # finishes and collects all the errors at once
-    #
-    # @param filters [Array<Hash>] Filters definition
-    # @return [Array] first is list of MAQL statements
-    def self.maqlify_filters(filters, options = {})
-      project = options[:project]
-      users_cache = options[:users_cache] || create_cache(project.users, :login)
-      labels_cache = create_label_cache(filters, options)
-      small_labels = get_small_labels(labels_cache)
-      lookups_cache = create_lookups_cache(small_labels)
-
-      errors = []
-      results = filters.mapcat do |filter|
-        login = filter[:login]
-        filter[:filters].mapcat do |f|
-          expression, error = create_expression(f, labels_cache, lookups_cache, options)
-          errors << error unless error.empty?
-          profiles_uri = (users_cache[login] && users_cache[login].uri)
-          if profiles_uri && expression
-            [create_user_filter(expression, profiles_uri)]
-          else
-            []
-          end
-        end
-      end
-      [results, errors]
-    end
-  end
-end

data/lib/gooddata/models/user_filters/user_filter_builder_execute.rb

@@ -1,133 +0,0 @@
-# encoding: UTF-8
-
-module GoodData
-  module UserFilterBuilder
-    # Executes the update for variables. It resolves what is new and needed to update.
-    # @param filters [Array<Hash>] Filter Definitions
-    # @param filters [Variable] Variable instance to be updated
-    # @param options [Hash]
-    # @option options [Boolean] :dry_run If dry run is true. No changes to he proejct are made but list of changes is provided
-    # @return [Array] list of filters that needs to be created and deleted
-    def self.execute_variables(filters, var, options = {})
-      client = options[:client]
-      project = options[:project]
-      dry_run = options[:dry_run]
-      to_create, to_delete = execute(filters, var.user_values, VariableUserFilter, options.merge(type: :variable))
-      return [to_create, to_delete] if dry_run
-
-      # TODO: get values that are about to be deleted and created and update them.
-      # This will make sure there is no downitme in filter existence
-      unless options[:do_not_touch_filters_that_are_not_mentioned]
-        to_delete.each { |_, group| group.each(&:delete) }
-      end
-      data = to_create.values.flatten.map(&:to_hash).map { |var_val| var_val.merge(prompt: var.uri) }
-      data.each_slice(200) do |slice|
-        client.post("/gdc/md/#{project.obj_id}/variables/user", :variables => slice)
-      end
-      [to_create, to_delete]
-    end
-
-    def self.execute_mufs(filters, options = {})
-      client = options[:client]
-      project = options[:project]
-
-      dry_run = options[:dry_run]
-      to_create, to_delete = execute(filters, project.data_permissions, MandatoryUserFilter, options.merge(type: :muf))
-      return [to_create, to_delete] if dry_run
-
-      to_create.peach do |related_uri, group|
-        group.each(&:save)
-
-        res = client.get("/gdc/md/#{project.pid}/userfilters?users=#{related_uri}")
-        items = res['userFilters']['items'].empty? ? [] : res['userFilters']['items'].first['userFilters']
-
-        payload = {
-          'userFilters' => {
-            'items' => [{
-              'user' => related_uri,
-              'userFilters' => items.concat(group.map(&:uri))
-            }]
-          }
-        }
-        client.post("/gdc/md/#{project.pid}/userfilters", payload)
-      end
-      unless options[:do_not_touch_filters_that_are_not_mentioned]
-        to_delete.peach do |related_uri, group|
-          if related_uri
-            res = client.get("/gdc/md/#{project.pid}/userfilters?users=#{related_uri}")
-            items = res['userFilters']['items'].empty? ? [] : res['userFilters']['items'].first['userFilters']
-            payload = {
-              'userFilters' => {
-                'items' => [
-                  {
-                    'user' => related_uri,
-                    'userFilters' => items - group.map(&:uri)
-                  }
-                ]
-              }
-            }
-            client.post("/gdc/md/#{project.pid}/userfilters", payload)
-          end
-          group.each(&:delete)
-        end
-      end
-      [to_create, to_delete]
-    end
-
-    private
-
-    # Executes the procedure necessary for loading user filters. This method has what
-    # is common for both implementations. Funcion
-    #   * makes sure that filters are in normalized form.
-    #   * verifies that users are in the project (and domain)
-    #   * creates maql expressions of the filters provided
-    #   * resolves the filters against current values in the project
-    # @param user_filters [Array] Filters that user is trying to set up
-    # @param project_filters [Array] List of filters currently in the project
-    # @param klass [Class] Class can be aither UserFilter or VariableFilter
-    # @param options [Hash] Filter definitions
-    # @return [Array<Hash>]
-    def self.execute(user_filters, project_filters, klass, options = {})
-      client = options[:client]
-      project = options[:project]
-
-      ignore_missing_values = options[:ignore_missing_values]
-      users_must_exist = options[:users_must_exist] == false ? false : true
-      filters = normalize_filters(user_filters)
-      domain = options[:domain]
-      users = domain ? project.users + domain.users : project.users
-      users_cache = create_cache(users, :login)
-      verify_existing_users(filters, options.merge(users_must_exist: users_must_exist, users_cache: users_cache))
-      user_filters, errors = maqlify_filters(filters, options.merge(users_cache: users_cache, users_must_exist: users_must_exist))
-      fail "Validation failed #{errors}" if !ignore_missing_values && !errors.empty?
-
-      filters = user_filters.map { |data| client.create(klass, data, project: project) }
-      resolve_user_filters(filters, project_filters)
-    end
-
-    private
-
-    # Gets definition of filters from user. They might either come in the full definition
-    # as hash or a simplified version. The simplified version do not cover all the possible
-    # features but it is much simpler to remember and suitable for quick hacking around
-    # @param filters [Array<Array | Hash>]
-    # @return [Array<Hash>]
-    def self.normalize_filters(filters)
-      filters.map do |filter|
-        if filter.is_a?(Hash)
-          filter
-        else
-          {
-            :login => filter.first,
-            :filters => [
-              {
-                :label => filter[1],
-                :values => filter[2..-1]
-              }
-            ]
-          }
-        end
-      end
-    end
-  end
-end