gooddata 0.6.54 → 1.0.0

data/lib/gooddata/lcm/lcm2.rb

@@ -140,6 +140,8 @@ module GoodData
 
       user_filters: [
         CollectDataProduct,
+        CollectUsersBrickUsers,
+        CollectSegments,
         SynchronizeUserFilters
       ],
 

data/lib/gooddata/lcm/types/complex/users_brick_config.rb

@@ -0,0 +1,32 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2017 GoodData Corporation. All rights reserved.
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+require_relative '../base_type'
+
+require_relative '../special/array'
+require_relative 'complex'
+
+module GoodData
+  module LCM2
+    module Type
+      class UsersBrickConfig < ComplexType
+        CATEGORY = :complex
+
+        PARAMS = define_type(self) do
+          description 'Source of the users table'
+          param :input_source, instance_of(Type::HashType), required: true
+
+          description 'Name of the column of user logins'
+          param :login_column, instance_of(Type::StringType), required: false
+        end
+
+        def check(value)
+          BaseType.check_params(PARAMS, value)
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/lcm/user_bricks_helper.rb

@@ -0,0 +1,32 @@
+module GoodData
+  module LCM2
+    # Contains code shared by Users Brick and User Filters Brick
+    class UserBricksHelper
+      class << self
+        def resolve_client_id(domain, project, data_product)
+          md = project.metadata
+          goodot_id = md['GOODOT_CUSTOM_PROJECT_ID'].to_s
+
+          client = domain.clients(:all, data_product).find do |c|
+            c.project_uri == project.uri
+          end
+          if goodot_id.empty? && client.nil?
+            fail "Project \"#{project.pid}\" metadata does not contain key " \
+                 "GOODOT_CUSTOM_PROJECT_ID neither is it mapped to a " \
+                 "client_id in LCM metadata. We are unable to get the " \
+                 "values for user filters."
+          end
+
+          unless goodot_id.empty? || client.nil? || (goodot_id == client.id)
+            fail "GOODOT_CUSTOM_PROJECT_ID metadata key is provided for " \
+                 "project \"#{project.pid}\" but doesn't match client id " \
+                 "assigned to the project in LCM metadata. " \
+                 "Please resolve the conflict."
+          end
+
+          goodot_id.empty? ? client.id : goodot_id
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/models/metadata/report.rb

@@ -174,6 +174,16 @@ module GoodData
       client.poll_on_code(result1['uri'], options.merge(process: false))
     end
 
+    # Exports a report too large to be computed on the UI. It executes in raw form.
+    # Saves the result into file.
+    #
+    # @param filename [String] Filename to save into
+    # @return [Net::HTTPResponse] Returns HTTP status
+    def export_raw(filename)
+      result = client.post("/gdc/app/projects/#{project.pid}/execute/raw", 'report_req' => { 'report' => uri })
+      client.download(result['uri'], filename, url_encode: false)
+    end
+
     # Returns the newest (current version) report definition uri
     #
     # @return [String] Returns uri of the newest report defintion

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

@@ -261,23 +261,19 @@ module GoodData
     #
     # @param filters [Array<Hash>] Filters definition
     # @return [Array] first is list of MAQL statements
-    def self.maqlify_filters(filters, options = {})
+    def self.maqlify_filters(filters, project_users, options = {})
       fail_early = options[:fail_early] == false ? false : true
       users_cache = options[:users_cache]
       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)
-      users = Hash[
-        options[:project].users.map do |user|
-          [user.login, user.profile_url]
-        end
-      ]
       create_filter_proc = proc do |login, f|
         expression, errors = create_expression(f, labels_cache, lookups_cache, attrs_cache, options)
         profiles_uri = if options[:type] == :muf
-                         uri = users[login]
-                         uri.nil? ? ('/gdc/account/profile/' + login) : uri
+                         project_user = project_users.find { |u| u.login == login }
+
+                         project_user.nil? ? ('/gdc/account/profile/' + login) : project_user.profile_url
                        elsif options[:type] == :variable
                          (users_cache[login] && users_cache[login].uri)
                        else
@@ -373,13 +369,16 @@ module GoodData
       dry_run = options[:dry_run]
       project_log_formatter = GoodData::ProjectLogFormatter.new(project)
 
+      project_users = project.users
       filters = normalize_filters(user_filters)
-      user_filters, errors = maqlify_filters(filters, options.merge(users_must_exist: users_must_exist, type: :muf))
+      user_filters, errors = maqlify_filters(filters, project_users, options.merge(users_must_exist: users_must_exist, type: :muf))
 
       fail GoodData::FilterMaqlizationError, errors if !ignore_missing_values && !errors.empty?
       filters = user_filters.map { |data| client.create(MandatoryUserFilter, data, project: project) }
       to_create, to_delete = resolve_user_filters(filters, project.data_permissions)
 
+      to_delete = sanitize_filters_to_delete(to_delete, options[:users_brick_input], project_users)
+
       if options[:do_not_touch_filters_that_are_not_mentioned]
         GoodData.logger.warn("Data permissions computed: #{to_create.count} to create")
       else
@@ -500,14 +499,14 @@ module GoodData
       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))
+                               maqlify_filters(filters, users, 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)
-                               maqlify_filters(filters, options.merge(users_cache: users_cache, users_must_exist: users_must_exist))
+                               maqlify_filters(filters, users, options.merge(users_cache: users_cache, users_must_exist: users_must_exist))
                              else
                                users_cache = create_cache(users, :login)
                                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))
+                               maqlify_filters(filters, users, options.merge(users_cache: users_cache, users_must_exist: users_must_exist))
                              end
 
       fail GoodData::FilterMaqlizationError, errors if !ignore_missing_values && !errors.empty?
@@ -537,5 +536,18 @@ module GoodData
         end
       end
     end
+
+    # Removes MUFs from to_delete unless in user is in users_brick_input
+    def self.sanitize_filters_to_delete(to_delete, users_brick_input, project_users)
+      return to_delete unless users_brick_input && users_brick_input.any?
+      user_profiles = users_brick_input.map do |user|
+        result = project_users.find { |u| u.login == user['login'] }
+        next unless result
+        result.profile_url
+      end.compact
+      to_delete.reject do |_, value|
+        user_profiles.none? { |profile| profile == value.first.json[:related] }
+      end
+    end
   end
 end

data/lib/gooddata/rest/connection.rb

@@ -59,6 +59,9 @@ end
 
 module GoodData
   module Rest
+    class RestRetryError < StandardError
+    end
+
     # Wrapper of low-level HTTP/REST client/library
     class Connection
       include MonitorMixin
@@ -250,6 +253,9 @@ module GoodData
         reset_headers!
       end
 
+      # @param what Address of the remote file.
+      # @param where Full path to the target file.
+      # @option [Bool] :url_encode ('true') URL encode the address.
       def download(what, where, options = {})
         # handle the path (directory) given in what
         ilast_slash = what.rindex('/')
@@ -278,7 +284,8 @@ module GoodData
         staging_uri = options[:staging_url].to_s
 
         base_url = dir.empty? ? staging_uri : URI.join("#{server}", staging_uri, "#{dir}/").to_s
-        url = URI.join("#{server}", base_url, CGI.escape(what)).to_s
+        sanitized_what = options[:url_encode] == false ? what : CGI.escape(what)
+        url = URI.join("#{server}", base_url, sanitized_what).to_s
 
         b = proc do |f|
           raw = {
@@ -288,14 +295,16 @@ module GoodData
             :verify_ssl => verify_ssl
           }
           RestClient::Request.execute(raw) do |chunk, _x, response|
-            if response.code.to_s != '200'
+            if response.code.to_s == '202'
+              fail RestRetryError, 'Got 202, retry'
+            elsif response.code.to_s != '200'
               fail ArgumentError, "Error downloading #{url}. Got response: #{response.code} #{response} #{response.body}"
             end
             f.write chunk
           end
         end
 
-        GoodData::Rest::Connection.retryable(:tries => Helpers::GD_MAX_RETRY, :refresh_token => proc { refresh_token }) do
+        GoodData::Rest::Connection.retryable(:tries => Helpers::GD_MAX_RETRY, :refresh_token => proc { refresh_token }, :on => RestRetryError) do
           if where.is_a?(IO) || where.is_a?(StringIO)
             b.call(where)
           else
@@ -590,6 +599,9 @@ ERR
         elsif content_type == 'application/zip'
           result = response
           GoodData.rest_logger.debug 'Response: a zipped stream'
+        elsif content_type == 'text/csv'
+          result = response
+          GoodData.rest_logger.debug 'Response: CSV text'
         elsif response.headers[:content_length].to_s == '0'
           result = nil
           GoodData.rest_logger.debug 'Response: Empty response possibly 204'