gooddata 0.6.53 → 0.6.54

data/lib/gooddata/lcm/dsl/type_dsl.rb

@@ -6,6 +6,7 @@
 # LICENSE file in the root directory of this source tree.
 
 require_relative '../types/param'
+require_relative '../types/special/types'
 
 module GoodData
   module LCM2

data/lib/gooddata/lcm/helpers/check_helper.rb

@@ -25,6 +25,10 @@ module GoodData
                 fail "Expected parameter '#{param_name}' to be kind of '#{type}', got '#{value.class.name}'"
               end
 
+              if specification[param_name][:opts][:deprecated]
+                puts "WARNING: Parameter '#{param_name}' is deprecated. Please use '#{specification[param_name][:opts][:replacement]}' instead."
+              end
+
               unless type.check(value)
                 fail "Parameter '#{param_name}' has invalid type, expected: #{type}"
               end

data/lib/gooddata/lcm/helpers/tags_helper.rb

@@ -14,8 +14,8 @@ module GoodData
         def segment_production_tags(segments)
           return {} unless segments
           segments
-            .reject { |s| s.production_tag.nil? }
-            .map { |s| [s.segment_id, s.production_tag] }
+            .reject { |s| s.production_tags.nil? }
+            .map { |s| [s.segment_id, s.production_tags] }
             .to_h
         end
 
@@ -27,7 +27,8 @@ module GoodData
           separator = ','
           tags = segment_production_tags || production_tags
           return [] unless tags
-          tags.split(separator).map(&:strip)
+          tags = tags.split(separator).map(&:strip) unless tags.is_a?(Array)
+          tags
         end
       end
     end

data/lib/gooddata/lcm/lcm2.rb

@@ -80,12 +80,14 @@ module GoodData
 
       release: [
         EnsureReleaseTable,
+        EnsureDataProduct,
+        CollectDataProduct,
         SegmentsFilter,
         CreateSegmentMasters,
         EnsureTechnicalUsersDomain,
         EnsureTechnicalUsersProject,
         SynchronizeLdm,
-        CollectAttributes,
+        CollectLdmObjects,
         CollectMeta,
         CollectTaggedObjects,
         CollectComputedAttributeMetrics,
@@ -94,24 +96,30 @@ module GoodData
         SynchronizeProcesses,
         SynchronizeSchedules,
         SynchronizeColorPalette,
+        SynchronizeUserGroups,
         SynchronizeNewSegments,
         UpdateReleaseTable
       ],
 
       provision: [
         EnsureReleaseTable,
+        CollectDataProduct,
         CollectSegments,
+        CollectClientProjects,
         PurgeClients,
         CollectClients,
         AssociateClients,
+        RenameExistingClientProjects,
         ProvisionClients,
         EnsureTechnicalUsersDomain,
         EnsureTechnicalUsersProject,
+        CollectDymanicScheduleParams,
         SynchronizeETLsInSegment
       ],
 
       rollout: [
         EnsureReleaseTable,
+        CollectDataProduct,
         CollectSegments,
         CollectSegmentClients,
         EnsureTechnicalUsersDomain,
@@ -120,7 +128,23 @@ module GoodData
         ApplyCustomMaql,
         SynchronizeClients,
         SynchronizeComputedAttributes,
+        CollectDymanicScheduleParams,
         SynchronizeETLsInSegment
+      ],
+
+      users: [
+        CollectDataProduct,
+        CollectSegments,
+        SynchronizeUsers
+      ],
+
+      user_filters: [
+        CollectDataProduct,
+        SynchronizeUserFilters
+      ],
+
+      schedules_execution: [
+        ExecuteSchedules
       ]
     }
 
@@ -130,6 +154,12 @@ module GoodData
       def convert_params(params)
         # Symbolize all keys
         GoodData::Helpers.symbolize_keys!(params)
+        params.keys.each do |k|
+          params[k.downcase] = params[k]
+        end
+        params.reject! do |k, _|
+          k.downcase != k
+        end
         convert_to_smart_hash(params)
       end
 
@@ -278,6 +308,8 @@ module GoodData
 
           # Invoke action
           begin
+            GoodData.logger.info("Running #{action.name} action ...")
+
             # Check if all required parameters were passed
             BaseAction.check_params(action.const_get('PARAMS'), params)
 

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

@@ -26,6 +26,9 @@ module GoodData
 
           description 'Master Project Name'
           param :master_name, instance_of(Type::StringType), required: true
+
+          description 'Production Tag Names'
+          param :production_tags, array_of(instance_of(Type::StringType)), required: false
         end
 
         def check(value)

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

@@ -17,10 +17,16 @@ module GoodData
 
         PARAMS = define_type(self) do
           description 'Cascade Drop'
-          param :cascade_drops, instance_of(Type::BooleanType), required: false, default: nil
+          param :cascade_drops, instance_of(Type::BooleanType), required: false, default: nil, deprecated: true, replacement: :allow_cascade_drops
 
           description 'Preserve Data'
-          param :preserve_data, instance_of(Type::BooleanType), required: false, default: nil
+          param :preserve_data, instance_of(Type::BooleanType), required: false, default: nil, deprecated: true, replacement: :keep_data
+
+          description 'Allow Cascade Drop'
+          param :allow_cascade_drops, instance_of(Type::BooleanType), required: false, default: false
+
+          description 'Keep Data'
+          param :keep_data, instance_of(Type::BooleanType), required: false, default: true
         end
 
         def check(value)

data/lib/gooddata/lcm/types/special/array.rb

@@ -4,12 +4,10 @@
 # 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'
-
 module GoodData
   module LCM2
     module Type
-      class ArrayType < BaseType
+      class ArrayType
         CATEGORY = :special
 
         def initialize(type)

data/lib/gooddata/lcm/types/special/enum.rb

@@ -4,12 +4,10 @@
 # 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'
-
 module GoodData
   module LCM2
     module Type
-      class EnumType < BaseType
+      class EnumType
         CATEGORY = :special
       end
     end

data/lib/gooddata/mixins/md_id_to_uri.rb

@@ -9,7 +9,6 @@ module GoodData
     module MdIdToUri
       IDENTIFIERS_CFG = 'instance-identifiers'
 
-      # TODO: Add test
       def identifier_to_uri(opts = { :client => GoodData.connection, :project => GoodData.project }, *ids)
         client, project = GoodData.get_client_and_project(opts)
 

data/lib/gooddata/mixins/md_json.rb

@@ -7,8 +7,8 @@
 module GoodData
   module Mixin
     module MdJson
-      def to_json
-        json.to_json
+      def to_json(*args)
+        json.to_json(*args)
       end
     end
   end

data/lib/gooddata/models/blueprint/project_blueprint.rb

@@ -742,11 +742,26 @@ module GoodData
         stuff.map { |r| { type: :bad_reference, reference: r.data, referencing_dataset: r.data[:dataset] } }
       end
 
+      # Validate the blueprint in particular if all ids must be unique and valid.
+      #
+      # @return [Array] array of errors
+      def validate_identifiers
+        ids = datasets.flat_map { |dataset| dataset.columns.map(&:id) }.compact
+
+        duplicated_ids = ids.select { |id| ids.count(id) > 1 }.uniq
+        errors = duplicated_ids.map { |id| { type: :duplicated_identifier, id: id } } || []
+
+        ids.uniq.each { |id| errors << { type: :invalid_identifier, id: id } if id !~ /^[\w.]+$/ }
+
+        errors
+      end
+
       # Validate the blueprint and all its datasets return array of errors that are found.
       #
       # @return [Array] array of errors
       def validate
         errors = []
+        errors.concat validate_identifiers
         errors.concat validate_references
         errors.concat datasets.reduce([]) { |acc, elem| acc.concat(elem.validate) }
         errors.concat datasets.reduce([]) { |acc, elem| acc.concat(elem.validate_gd_data_type_errors) }

data/lib/gooddata/models/blueprint/to_wire.rb

@@ -113,6 +113,7 @@ module GoodData
           dd[:name] = dataset[:id]
           dd[:urn] = dataset[:urn] if dataset[:urn]
           dd[:title] = GoodData::Model.title(dataset)
+          dd[:identifierPrefix] = dataset[:identifier_prefix] if dataset[:identifier_prefix]
         end
         { dateDimension: payload }
       end

data/lib/gooddata/models/client.rb

@@ -33,13 +33,13 @@ module GoodData
         domain = opts[:domain]
         segment = opts[:segment]
         fail ArgumentError, 'No :domain specified' if domain.nil?
-        fail ArgumentError, 'No :segment specified' if domain.nil?
-
         client = domain.client
         fail ArgumentError, 'No client specified' if client.nil?
+        data_product = opts[:data_product] || (segment ? segment.data_product : nil)
 
         if id == :all
-          tenants_uri = domain.segments_uri + "/clients?segment=#{CGI.escape(segment.segment_id)}"
+          tenants_uri = base_uri(domain, data_product)
+          tenants_uri += "?segment=#{CGI.escape(segment.segment_id)}" if segment
           Enumerator.new do |y|
             loop do
               res = client.get tenants_uri
@@ -56,7 +56,8 @@ module GoodData
           end
         else
           id = id.respond_to?(:client_id) ? id.client_id : id
-          data = client.get(domain.segments_uri + "/clients/#{CGI.escape(id)}")
+          tenant_uri = base_uri(domain, data_product)
+          data = client.get(tenant_uri + "/#{CGI.escape(id)}")
           client.create(GoodData::Client, data.merge('domain' => domain))
         end
       end
@@ -88,17 +89,27 @@ module GoodData
         return nil unless value
         domain = opts[:domain]
         client_id = opts[:client_id]
-        uri = "#{domain.segments_uri}/clients/#{client_id}/settings/#{name}"
+        data_product_id = opts[:data_product_id]
+        uri = data_product_id ? GoodData::DataProduct::ONE_DATA_PRODUCT_PATH % { domain_name: domain.name, id: data_product_id } : domain.segments_uri
         body = {
           setting: {
             name: "#{name}",
             value: "#{value}"
           }
         }
-        domain.client.put(uri, body)
+        domain.client.put(uri + "/clients/#{client_id}/settings/#{name}", body)
         nil
       end
       alias_method :add_setting, :update_setting
+
+      def base_uri(domain, data_product)
+        if data_product
+          uri = GoodData::DataProduct::ONE_DATA_PRODUCT_PATH % { domain_name: domain.name, id: data_product.data_product_id }
+        else
+          uri = domain.segments_uri
+        end
+        uri + '/clients'
+      end
     end
 
     def initialize(data)
@@ -189,7 +200,8 @@ module GoodData
       if uri
         client.put(uri, json)
       else
-        res = client.post(domain.segments_uri + '/clients', json)
+        data_product = segment.data_product
+        res = client.post(self.class.base_uri(domain, data_product), json)
         @json = res
       end
       self
@@ -209,8 +221,8 @@ module GoodData
     end
 
     def settings
-      uri = "#{domain.segments_uri}/clients/#{client_id}/settings"
-      res = client.get(uri)
+      data_product = segment.data_product
+      res = client.get(self.class.base_uri(domain, data_product) + "/#{client_id}/settings")
       settings = GoodData::Helpers.get_path(res, %w(settingsList items))
       settings.map do |setting|
         setting = setting['setting']

data/lib/gooddata/models/data_product.rb

@@ -0,0 +1,149 @@
+# 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 '../rest/resource'
+
+module GoodData
+  class DataProduct < Rest::Resource
+    include Mixin::UriGetter
+
+    attr_accessor :domain
+
+    ALL_DATA_PRODUCTS_PATH = '/gdc/domains/%{domain_name}/dataproducts'
+    ONE_DATA_PRODUCT_PATH = '/gdc/domains/%{domain_name}/dataproducts/%{id}'
+
+    class << self
+      def [](id, opts)
+        domain = opts[:domain]
+        fail ArgumentError, 'No :domain specified' if domain.nil?
+
+        client = domain.client
+        fail ArgumentError, 'No client specified' if client.nil?
+
+        if id == :all
+          GoodData::DataProduct.all(opts)
+        else
+          data_products_uri = ONE_DATA_PRODUCT_PATH % { domain_name: domain.name, id: id }
+
+          result = client.get(data_products_uri)
+          client.create(GoodData::DataProduct, result.merge('domain' => domain))
+        end
+      end
+
+      def all(opts = {})
+        domain = opts[:domain]
+        fail ArgumentError, 'No :domain specified' if domain.nil?
+
+        client = domain.client
+        fail ArgumentError, 'No client specified' if client.nil?
+
+        data_products_uri = ALL_DATA_PRODUCTS_PATH % { domain_name: domain.name }
+
+        GoodData::Helpers.get_path(client.get(data_products_uri), %w(dataProducts items)).map do |i|
+          client.create(GoodData::DataProduct, i, domain: domain)
+        end
+      end
+
+      def create(data = {}, options = {})
+        fail 'id for data_product has to be provided' if data[:id].blank?
+        client = options[:client]
+        client.create(GoodData::DataProduct, GoodData::Helpers.stringify_keys(dataProduct: data), domain: options[:domain])
+      end
+    end
+
+    def initialize(json)
+      super
+      @json = json
+      @domain = json.delete('domain')
+    end
+
+    def clients
+      json = client.get(data['links']['clients'])
+
+      json['clients']['items'].map do |val|
+        client.create(GoodData::Client, val, domain: domain)
+      end
+    end
+
+    def segments
+      json = client.get(data['links']['segments'])
+
+      json['segments']['items'].map do |val|
+        client.create(GoodData::Segment, val, domain: domain, data_product: self)
+      end
+    end
+
+    def save
+      if @json[:uri]
+        client.put(uri, json)
+      else
+        data_products_uri = ALL_DATA_PRODUCTS_PATH % { domain_name: domain.name }
+        res = client.post(data_products_uri, json)
+        @json = res
+      end
+      self
+    end
+
+    def delete(options = {})
+      segments.peach { |s| s.delete(options) }
+      client.delete(uri) if uri
+      self
+    end
+
+    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
+
+      data_products_uri = ONE_DATA_PRODUCT_PATH % { domain_name: domain.name, id: data_product_id }
+
+      payload = data.map do |datum|
+        {
+          :client => {
+            :id => datum[:id],
+            :segment => data_products_uri + '/segments/' + datum[:segment]
+          }
+        }.tap do |h|
+          h[:client][:project] = datum[:project] if datum.key?(:project)
+        end
+      end
+
+      if options[:delete_extra]
+        res = client.post(data_products_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 = data_products_uri + "/updateClients?deleteExtraInSegments=#{segments_to_delete_in}"
+        res = client.post(uri, updateClients: { items: payload })
+      else
+        res = client.post(data_products_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 options[:delete_projects]
+        result
+      else
+        []
+      end
+    end
+
+    def data_product_id
+      data['id']
+    end
+
+    def data_product_id=(new_id)
+      data['id'] = new_id
+    end
+
+    def create_segment(data)
+      segment = GoodData::Segment.create(data, domain: domain, client: domain.client)
+      segment.data_product = self
+      segment.save
+    end
+  end
+end