gooddata 0.6.53 → 0.6.54

data/lib/gooddata/models/domain.rb

@@ -14,8 +14,6 @@ module GoodData
   class Domain < Rest::Resource
     attr_reader :name
 
-    ProvisioningResult = Struct.new('ProvisioningResult', :id, :status, :project_uri, :error)
-
     USER_LANGUAGES = {
       'en-US' => 'English',
       'nl-NL' => 'Dutch',
@@ -95,6 +93,10 @@ module GoodData
         tmp = user_data[:timezone]
         data[:timezone] = tmp if tmp && !tmp.empty?
 
+        # Optional ip whitelist
+        tmp = user_data[:ip_whitelist]
+        data[:ipWhitelist] = tmp if tmp
+
         c = client(opts)
 
         # TODO: It will be nice if the API will return us user just newly created
@@ -323,19 +325,11 @@ Available values for setting language are: #{available_languages}."
     # if it exists.
     #
     # @param id [String] Id of client that you are looking for
+    # @param data_product [DataProduct] data product object in which the clients are located
     # @return [Object] Raw response
     #
-    def clients(id = :all)
-      if id == :all
-        res = client.get("/gdc/domains/#{name}/clients")
-        res_clients = (res['clients'] && res['clients']['items']) || []
-        res_clients.map { |res_client| client.create(GoodData::Client, res_client) }
-      else
-        res = client.get("/gdc/domains/#{name}/clients/#{id}")
-        error = GoodData::Helpers.interpolate_error_message(res)
-        raise error if error
-        client.create(GoodData::Client, res)
-      end
+    def clients(id = :all, data_product = nil)
+      GoodData::Client[id, data_product: data_product, domain: self]
     end
 
     alias_method :create_user, :add_user
@@ -344,8 +338,17 @@ Available values for setting language are: #{available_languages}."
       GoodData::Domain.create_users(list, name, { client: client }.merge(options))
     end
 
-    def segments(id = :all)
-      GoodData::Segment[id, domain: self]
+    def data_products(id = :all)
+      GoodData::DataProduct[id, domain: self]
+    end
+
+    def create_data_product(data)
+      data_product = GoodData::DataProduct.create(data, domain: self, client: client)
+      data_product.save
+    end
+
+    def segments(id = :all, data_product = nil)
+      GoodData::Segment[id, data_product: data_product, domain: self]
     end
 
     # Creates new segment in current domain from parameters passed
@@ -429,29 +432,10 @@ Available values for setting language are: #{available_languages}."
     #
     # @return [Enumerator] Returns Enumerator of results
     def provision_client_projects(segments = nil)
-      body = if segments
-               {
-                 provisionClientProjects: {
-                   segments: segments.is_a?(Array) ? segments : [segments]
-                 }
-               }
-             end
-
-      res = client.post(segments_uri + '/provisionClientProjects', body)
-      res = client.poll_on_code(res['asyncTask']['links']['poll'])
-      failed_count = GoodData::Helpers.get_path(res, %w(clientProjectProvisioningResult failed count), 0)
-      created_count = GoodData::Helpers.get_path(res, %w(clientProjectProvisioningResult created count), 0)
-      return Enumerator.new([]) if failed_count + created_count == 0 # rubocop:disable Style/NumericPredicate
-      Enumerator.new do |y|
-        uri = GoodData::Helpers.get_path(res, %w(clientProjectProvisioningResult links details))
-        loop do
-          result = client.get(uri)
-          (GoodData::Helpers.get_path(result, %w(clientProjectProvisioningResultDetails items)) || []).each do |item|
-            y << ProvisioningResult.new(item['id'], item['status'], item['project'], item['error'])
-          end
-          uri = GoodData::Helpers.get_path(res, %w(clientProjectProvisioningResultDetails paging next))
-          break if uri.nil?
-        end
+      segments = segments.is_a?(Array) ? segments : [segments]
+      segments.each do |segment_id|
+        segment = segments(segment_id)
+        segment.provision_client_projects
       end
     end
 
@@ -460,7 +444,7 @@ Available values for setting language are: #{available_languages}."
         client_id = datum[:id]
         settings = datum[:settings]
         settings.each do |setting|
-          GoodData::Client.update_setting(setting[:name], setting[:value], domain: self, client_id: client_id)
+          GoodData::Client.update_setting(setting[:name], setting[:value], domain: self, client_id: client_id, data_product_id: datum[:data_product_id])
         end
       end
       nil
@@ -468,39 +452,9 @@ Available values for setting language are: #{available_languages}."
     alias_method :add_clients_settings, :update_clients_settings
 
     def update_clients(data, options = {})
-      if options[:delete_extra] && options[:delete_extra_in_segments]
-        fail 'Options delete_extra and delete_extra_in_segments are mutually exclusive.'
-      end
-
-      delete_projects = options[:delete_projects] == false ? false : true
-      payload = data.map do |datum|
-        {
-          :client => {
-            :id => datum[:id],
-            :segment => segments_uri + '/segments/' + datum[:segment]
-          }
-        }.tap do |h|
-          h[:client][:project] = datum[:project] if datum.key?(:project)
-        end
-      end
-      if options[:delete_extra] == true
-        res = client.post(segments_uri + '/updateClients?deleteExtra=true', updateClients: { items: payload })
-      elsif options[:delete_extra_in_segments]
-        segments_to_delete_in = options[:delete_extra_in_segments]
-          .map { |segment| CGI.escape(segment) }
-          .join(',')
-        uri = segments_uri + "/updateClients?deleteExtraInSegments=#{segments_to_delete_in}"
-        res = client.post(uri, updateClients: { items: payload })
-      else
-        res = client.post(segments_uri + '/updateClients', updateClients: { items: payload })
-      end
-      data = GoodData::Helpers.get_path(res, ['updateClientsResponse'])
-      if data
-        result = data.flat_map { |k, v| v.map { |h| GoodData::Helpers.symbolize_keys(h.merge('type' => k)) } }
-        result.select { |r| r[:status] == 'DELETED' }.peach { |r| r[:originalProject] && client.delete(r[:originalProject]) } if delete_projects
-        result
-      else
-        []
+      data.group_by(&:data_product_id).each do |data_product_id, client_update_data|
+        data_product = data_products(data_product_id)
+        data_product.update_clients(client_update_data, options)
       end
     end
 

data/lib/gooddata/models/from_wire.rb

@@ -108,6 +108,7 @@ module GoodData
           d[:id] = date_dim['dateDimension']['name']
           d[:title] = date_dim['dateDimension']['title']
           d[:urn] = date_dim['dateDimension']['urn']
+          d[:identifier_prefix] = date_dim['dateDimension']['identifierPrefix']
         end
       end
 
@@ -125,6 +126,7 @@ module GoodData
             f[:description] = fact['fact']['description'] if fact['fact']['description']
             f[:folder] = fact['fact']['folder']
             f[:gd_data_type] = fact['fact']['dataType'] || GoodData::Model::DEFAULT_FACT_DATATYPE
+            f[:restricted] = fact['fact']['restricted'] if fact['fact']['restricted']
           end
         end
       end

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

@@ -72,7 +72,7 @@ module GoodData
           end
         end
 
-        if result.empty?
+        if result.to_s.empty?
           ReportDataResult.new(data: [], top: 0, left: 0)
         else
           ReportDataResult.from_xtab(result)
@@ -144,10 +144,16 @@ module GoodData
 
     # Computes the report and returns the result. If it is not computable returns nil.
     #
+    # @option options [Time] :time Force the platform to simutale the result at this time
     # @return [GoodData::DataResult] Returns the result
     def execute(options = {})
+      time = options[:time]
+
+      report_req = { 'report' => uri }
+      report_req['timestamp'] = time.to_i if time
+
       fail 'You have to save the report before executing. If you do not want to do that please use GoodData::ReportDefinition' unless saved?
-      result = client.post '/gdc/xtab2/executor3', 'report_req' => { 'report' => uri }
+      result = client.post "/gdc/projects/#{project.pid}/execute", 'report_req' => report_req
       GoodData::Report.data_result(result, options.merge(client: client))
     end
 
@@ -163,7 +169,7 @@ module GoodData
     #
     # @return [String] Returns data
     def export(format, options = {})
-      result = client.post('/gdc/xtab2/executor3', 'report_req' => { 'report' => uri })
+      result = client.post("/gdc/projects/#{project.pid}/execute", 'report_req' => { 'report' => uri })
       result1 = client.post('/gdc/exporter/executor', :result_req => { :format => format, :result => result })
       client.poll_on_code(result1['uri'], options.merge(process: false))
     end

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

@@ -228,7 +228,7 @@ module GoodData
                  pars = {
                    'report_req' => { 'reportDefinition' => uri }
                  }
-                 client.post '/gdc/xtab2/executor3', pars
+                 client.post "/gdc/projects/#{project.pid}/execute", pars
                else
                  data = {
                    report_req: {
@@ -238,7 +238,7 @@ module GoodData
                      }
                    }
                  }
-                 uri = "/gdc/app/projects/#{project.pid}/execute"
+                 uri = "/gdc/projects/#{project.pid}/execute"
                  client.post(uri, data)
                end
       GoodData::Report.data_result(result, opts.merge(client: client))

data/lib/gooddata/models/model.rb

@@ -86,7 +86,7 @@ module GoodData
       'GDC.time.day_us_noleading', # M/d/yy
     ]
 
-    GD_DATA_TYPES = ['BIGINT', 'DOUBLE', 'INTEGER', 'INT', /^VARCHAR\(\d{1,4}\)$/i, /^DECIMAL\(\d{1,3},\s*\d{1,3}\)$/i]
+    GD_DATA_TYPES = ['BIGINT', 'DOUBLE', 'INTEGER', 'INT', /^VARCHAR\(([1-9]\d{0,3}|10000)\)$/i, /^DECIMAL\(\d{1,3},\s*\d{1,3}\)$/i]
 
     DEFAULT_FACT_DATATYPE = 'DECIMAL(12,2)'
     DEFAULT_ATTRIBUTE_DATATYPE = 'VARCHAR(128)'

data/lib/gooddata/models/process.rb

@@ -125,6 +125,10 @@ module GoodData
 
         File.delete(deployed_path) if File.exist?(deployed_path)
 
+        if res['asyncTask']
+          res = client.poll_on_response(res['asyncTask']['links']['poll']) { |body| body['asyncTask'] }
+        end
+
         process = client.create(Process, res, project: project)
         puts HighLine.color("Deploy DONE #{path}", HighLine::GREEN) if verbose
         process

data/lib/gooddata/models/project.rb

@@ -256,39 +256,60 @@ module GoodData
       def transfer_processes(from_project, to_project, options = {})
         options = GoodData::Helpers.symbolize_keys(options)
         to_project_processes = to_project.processes
-        from_project.processes.uniq(&:name).each do |process|
+        result = from_project.processes.uniq(&:name).map do |process|
           fail "The process name #{process.name} must be unique in transfered project #{to_project}" if to_project_processes.count { |p| p.name == process.name } > 1
+          next if process.type == :dataload
           to_process = to_project_processes.find { |p| p.name == process.name }
 
-          if process.path
-            to_process.delete if to_process
-            GoodData::Process.deploy_from_appstore(process.path, name: process.name, client: to_project.client, project: to_project)
-          elsif process.type != :dataload
-            Dir.mktmpdir('etl_transfer') do |dir|
-              dir = Pathname(dir)
-              filename = dir + 'process.zip'
-              File.open(filename, 'w') do |f|
-                f << process.download
-              end
-
-              to_process ? to_process.deploy(filename, type: process.type, name: process.name) : to_project.deploy_process(filename, type: process.type, name: process.name)
-            end
-          end
+          to_process = if process.path
+                         to_process.delete if to_process
+                         GoodData::Process.deploy_from_appstore(process.path, name: process.name, client: to_project.client, project: to_project)
+                       else
+                         Dir.mktmpdir('etl_transfer') do |dir|
+                           dir = Pathname(dir)
+                           filename = dir + 'process.zip'
+                           File.open(filename, 'w') do |f|
+                             f << process.download
+                           end
+
+                           if to_process
+                             to_process.deploy(filename, type: process.type, name: process.name)
+                           else
+                             to_project.deploy_process(filename, type: process.type, name: process.name)
+                           end
+                         end
+                       end
+
+          {
+            from: from_project.pid,
+            to: to_project.pid,
+            name: process.name,
+            status: to_process ? 'successful' : 'failed'
+          }
         end
 
         transfer_output_stage(from_project, to_project, options)
+        result << {
+          from: from_project.pid,
+          to: to_project.pid,
+          name: 'Automated Data Distribution',
+          status: 'successful'
+        }
 
         res = (from_project.processes + to_project.processes).map { |p| [p, p.name, p.type] }
         res.group_by { |x| [x[1], x[2]] }
           .select { |_, procs| procs.length == 1 && procs[2] != :dataload }
           .flat_map { |_, procs| procs.select { |p| p[0].project.pid == to_project.pid }.map { |p| p[0] } }
           .peach(&:delete)
+
+        result.compact
       end
 
       def transfer_user_groups(from_project, to_project)
-        from_project.user_groups.each do |ug|
+        from_project.user_groups.map do |ug|
           # migrate groups
           new_group = to_project.user_groups.select { |group| group.name == ug.name }.first
+          new_group_status = new_group ? 'modified' : 'created'
           new_group ||= UserGroup.create(:name => ug.name, :description => ug.description, :project => to_project)
           new_group.project = to_project
           new_group.description = ug.description
@@ -303,6 +324,13 @@ module GoodData
             permission = grantee['aclEntryURI']['permission']
             new_dashboard.grant(:member => new_group, :permission => permission)
           end
+
+          {
+            from: from_project.pid,
+            to: to_project.pid,
+            user_group: new_group.name,
+            status: new_group_status
+          }
         end
       end
 
@@ -314,9 +342,14 @@ module GoodData
       # the master, client in which case we take its project, string in which
       # case we treat is as an project object or directly project.
       def transfer_schedules(from_project, to_project)
-        cache = to_project
-                  .processes.sort_by(&:name)
-                  .zip(from_project.processes.sort_by(&:name))
+        to_project_processes = to_project.processes.sort_by(&:name)
+        from_project_processes = from_project.processes.sort_by(&:name)
+
+        GoodData.logger.debug("Processes in from project #{from_project.pid}: #{from_project_processes.map(&:name).join(', ')}")
+        GoodData.logger.debug("Processes in to project #{to_project.pid}: #{to_project_processes.map(&:name).join(', ')}")
+
+        cache = to_project_processes
+                  .zip(from_project_processes)
                   .flat_map do |remote, local|
                     local.schedules.map do |schedule|
                       [remote, local, schedule]
@@ -574,10 +607,11 @@ module GoodData
     #
     # @return [GoodData::ProjectRole] Project role if found
     def blueprint(options = {})
-      result = client.get("/gdc/projects/#{pid}/model/view", params: { includeDeprecated: true, includeGrain: true, includeCA: true })
+      options = { include_ca: true }.merge(options)
+      result = client.get("/gdc/projects/#{pid}/model/view", params: { includeDeprecated: true, includeGrain: true, includeCA: options[:include_ca] })
       polling_url = result['asyncTask']['link']['poll']
       model = client.poll_on_code(polling_url, options)
-      bp = GoodData::Model::FromWire.from_wire(model, { include_ca: true }.merge(options))
+      bp = GoodData::Model::FromWire.from_wire(model, options)
       bp.title = title
       bp
     end
@@ -730,6 +764,7 @@ module GoodData
     def data_permissions(id = :all)
       GoodData::MandatoryUserFilter[id, client: client, project: self]
     end
+    alias_method :user_filters, :data_permissions
 
     # Deletes project
     def delete
@@ -1075,7 +1110,7 @@ module GoodData
     # @param [String] key key of the value to be stored
     # @return [String] val value to be stored
     def set_metadata(key, val)
-      GoodData::ProjectMetadata[key, client: client, project: self] = val
+      GoodData::ProjectMetadata.[]=(key, { client: client, project: self }, val)
     end
 
     # Helper for getting metrics of a project
@@ -1185,7 +1220,7 @@ module GoodData
         :partialMDImport => {
           :token => token,
           :overwriteNewer => '1',
-          :updateLDMObjects => '0',
+          :updateLDMObjects => '1',
           :importAttributeProperties => '1'
         }
       }
@@ -1512,18 +1547,6 @@ module GoodData
       data['links']['self'] if data && data['links'] && data['links']['self']
     end
 
-    # List of user filters within this project
-    #
-    # @return [Array<GoodData::MandatoryUserFilter>] List of mandatory user
-    def user_filters
-      url = "/gdc/md/#{pid}/userfilters"
-
-      tmp = client.get(url)
-      tmp['userFilters']['items'].pmap do |filter|
-        client.create(GoodData::MandatoryUserFilter, filter, project: self)
-      end
-    end
-
     # List of users in project
     #
     #

data/lib/gooddata/models/project_creator.rb

@@ -127,6 +127,19 @@ module GoodData
           preference = GoodData::Helpers.symbolize_keys(opts[:update_preference] || {})
           preference = Hash[preference.map { |k, v| [k, GoodData::Helpers.to_boolean(v)] }]
 
+          # will use new parameters instead of the old ones
+          if preference.empty? || [:allow_cascade_drops, :keep_data].any? { |k| preference.key?(k) }
+            if [:cascade_drops, :preserve_data].any? { |k| preference.key?(k) }
+              fail "Please do not mix old parameters (:cascade_drops, :preserve_data) with the new ones (:allow_cascade_drops, :keep_data)."
+            end
+            preference = { allow_cascade_drops: false, keep_data: true }.merge(preference)
+
+            new_preference = {}
+            new_preference[:cascade_drops] = false unless preference[:allow_cascade_drops]
+            new_preference[:preserve_data] = true if preference[:keep_data]
+            preference = new_preference
+          end
+
           # first is cascadeDrops, second is preserveData
           rules = [
             { priority: 1, cascade_drops: false, preserve_data: true },

data/lib/gooddata/models/segment.rb

@@ -15,10 +15,15 @@ require_relative '../mixins/uri_getter'
 
 module GoodData
   class Segment < Rest::Resource
-    SYNCHRONIZE_URI = '/gdc/domains/%s/segments/%s/synchronizeClients'
+    SYNCHRONIZE_URI = '/gdc/domains/%s/dataproducts/%s/segments/%s/synchronizeClients'
+
+    #
+    ProvisioningResult = Struct.new('ProvisioningResult', :id, :status, :project_uri, :error)
 
     attr_accessor :domain
 
+    attr_writer :data_product
+
     data_property_reader 'id'
 
     include Mixin::Links
@@ -43,10 +48,12 @@ module GoodData
         client = domain.client
         fail ArgumentError, 'No client specified' if client.nil?
 
+        data_product = opts[:data_product]
+
         if id == :all
           GoodData::Segment.all(opts)
         else
-          result = client.get(domain.segments_uri + "/segments/#{CGI.escape(id)}")
+          result = client.get(base_uri(domain, data_product) + "/segments/#{CGI.escape(id)}")
           client.create(GoodData::Segment, result.merge('domain' => domain))
         end
       end
@@ -60,8 +67,17 @@ module GoodData
         fail 'Domain has to be passed in options' unless domain
         client = domain.client
 
-        results = client.get(domain.segments_uri + '/segments')
-        GoodData::Helpers.get_path(results, %w(segments items)).map { |i| client.create(GoodData::Segment, i.merge('domain' => domain)) }
+        data_product = opts[:data_product]
+        results = client.get(base_uri(domain, data_product) + '/segments')
+        GoodData::Helpers.get_path(results, %w(segments items)).map { |i| client.create(GoodData::Segment, i, domain: domain) }
+      end
+
+      def base_uri(domain, data_product)
+        if data_product
+          GoodData::DataProduct::ONE_DATA_PRODUCT_PATH % { domain_name: domain.name, id: data_product.data_product_id }
+        else
+          domain.segments_uri
+        end
       end
 
       # Creates new segment from parameters passed
@@ -71,9 +87,9 @@ module GoodData
       # @return [GoodData::Segment] New Segment instance
       def create(data = {}, options = {})
         segment_id = data[:segment_id]
-        fail 'Custom ID has to be provided' if segment_id.blank?
+        fail 'segment_id has to be provided' if segment_id.blank?
         client = options[:client]
-        segment = client.create(GoodData::Segment, GoodData::Helpers.stringify_keys(SEGMENT_TEMPLATE).merge('domain' => options[:domain]))
+        segment = client.create(GoodData::Segment, GoodData::Helpers.stringify_keys(SEGMENT_TEMPLATE), options)
         segment.tap do |s|
           s.segment_id = segment_id
           s.master_project = data[:master_project]
@@ -84,9 +100,19 @@ module GoodData
     def initialize(data)
       super
       @domain = data.delete('domain')
+      @data_product = nil
       @json = data
     end
 
+    def data_product
+      if @data_product
+        @data_product
+      else
+        json = client.get(data['links']['dataProduct'])
+        @data_product = client.create(GoodData::DataProduct, json)
+      end
+    end
+
     # Segment id getter for the Segment. Called segment_id since id is a reserved word in ruby world
     #
     # @return [String] Segment id
@@ -159,17 +185,17 @@ module GoodData
       if uri
         client.put(uri, json)
       else
-        res = client.post(domain.segments_uri + '/segments', json)
+        res = client.post(self.class.base_uri(domain, @data_product ? data_product : nil) + '/segments', json)
         @json = res
       end
       self
     end
 
-    # Runs async process that walks thorugh segments and provisions projects if necessary.
+    # Runs async process that walks through segments and provisions projects if necessary.
     #
     # @return [Array] Returns array of results
     def synchronize_clients
-      sync_uri = SYNCHRONIZE_URI % [domain.obj_id, id]
+      sync_uri = SYNCHRONIZE_URI % [domain.obj_id, data_product.data_product_id, id]
       res = client.post sync_uri, nil
 
       # wait until the instance is created
@@ -180,7 +206,7 @@ module GoodData
       client.create(ClientSynchronizationResult, res)
     end
 
-    def synchronize_processes(projects = [], options = { dataproduct: 'default' })
+    def synchronize_processes(projects = [])
       projects = [projects] unless projects.is_a?(Array)
       projects = projects.map do |p|
         p = p.pid if p.respond_to?('pid')
@@ -198,7 +224,8 @@ module GoodData
         }
       end
 
-      uri = '/gdc/internal/lcm/domains/%s/dataproducts/%s/segments/%s/syncProcesses' % [domain.obj_id, options[:dataproduct], id]
+      uri = '/gdc/internal/lcm/domains/%{domain}/dataproducts/%{dataproduct}/segments/%{segment}/syncProcesses'
+      uri = uri % { domain: domain.name, dataproduct: data_product.data_product_id, segment: segment_id }
       res = client.post(uri, body)
 
       client.poll_on_response(GoodData::Helpers.get_path(res, %w(asyncTask link poll)), sleep_interval: 1) do |r|
@@ -216,11 +243,31 @@ module GoodData
       self
     rescue RestClient::BadRequest => e
       payload = GoodData::Helpers.parse_http_exception(e)
-      case GoodData::Helpers.get_path(payload)
-      when 'gdc.c4.conflict.domain.segment.contains_clients'
-        throw SegmentNotEmpty
-      else
-        raise e
+      e = SegmentNotEmpty if GoodData::Helpers.get_path(payload) == 'gdc.c4.conflict.domain.segment.contains_clients'
+      raise e
+    end
+
+    def provision_client_projects(segments = [])
+      body = {
+        provisionClientProjects: {
+          segments: segments.empty? ? [segment_id] : segments
+        }
+      }
+      res = client.post(GoodData::DataProduct::ONE_DATA_PRODUCT_PATH % { domain_name: domain.name, id: data_product.data_product_id } + '/provisionClientProjects', body)
+      res = client.poll_on_code(res['asyncTask']['links']['poll'])
+      failed_count = GoodData::Helpers.get_path(res, %w(clientProjectProvisioningResult failed count), 0)
+      created_count = GoodData::Helpers.get_path(res, %w(clientProjectProvisioningResult created count), 0)
+      return Enumerator.new([]) if (failed_count + created_count).zero?
+      Enumerator.new do |y|
+        uri = GoodData::Helpers.get_path(res, %w(clientProjectProvisioningResult links details))
+        loop do
+          result = client.get(uri)
+          (GoodData::Helpers.get_path(result, %w(clientProjectProvisioningResultDetails items)) || []).each do |item|
+            y << ProvisioningResult.new(item['id'], item['status'], item['project'], item['error'])
+          end
+          uri = GoodData::Helpers.get_path(res, %w(clientProjectProvisioningResultDetails paging next))
+          break if uri.nil?
+        end
       end
     end
   end