gooddata 0.6.51 → 0.6.52

data/lib/gooddata/lcm/actions/apply_custom_maql.rb

@@ -17,6 +17,15 @@ module GoodData
       DESCRIPTION = 'Apply Custom MAQL DDL'
 
       PARAMS = define_params(self) do
+        description 'Client Used for Connecting to GD'
+        param :gdc_gd_client, instance_of(Type::GdClientType), required: true
+
+        description 'Organization Name'
+        param :organization, instance_of(Type::StringType), required: true
+
+        description 'Segments to manage'
+        param :segments, array_of(instance_of(Type::SegmentType)), required: true
+
         description 'Should be custom MAQL DDL Applied'
         param :apply_maql_ddl, instance_of(Type::BooleanType), required: false, default: false
       end

data/lib/gooddata/lcm/actions/associate_clients.rb

@@ -14,6 +14,21 @@ module GoodData
       PARAMS = define_params(self) do
         description 'Client Used for Connecting to GD'
         param :gdc_gd_client, instance_of(Type::GdClientType), required: true
+
+        description 'Organization Name'
+        param :organization, instance_of(Type::StringType), required: true
+
+        description 'Delete Extra Clients'
+        param :delete_extra, instance_of(Type::BooleanType), required: false, default: false
+
+        description 'Physically Delete Client Projects'
+        param :delete_projects, instance_of(Type::BooleanType), required: false, default: false
+
+        description 'Clients'
+        param :clients, array_of(instance_of(Type::HashType)), required: true, generated: true
+
+        description 'Segments to provision'
+        param :segments_filter, array_of(instance_of(Type::StringType)), required: false
       end
 
       RESULT_HEADER = [
@@ -26,14 +41,18 @@ module GoodData
 
       class << self
         def call(params)
-          # Check if all required parameters were passed
-          BaseAction.check_params(PARAMS, params)
-
           client = params.gdc_gd_client
 
           domain_name = params.organization || params.domain
           domain = client.domain(domain_name) || fail("Invalid domain name specified - #{domain_name}")
 
+          params.clients.group_by { |data| data[:segment] }.each do |segment_name, clients|
+            segment = domain.segments(segment_name)
+            (clients.map(&:id) - segment.clients.map(&:id)).each do |c|
+              segment.create_client(id: c)
+            end
+          end
+
           domain.update_clients_settings(params.clients)
 
           delete_projects = GoodData::Helpers.to_boolean(params.delete_projects)
@@ -50,7 +69,7 @@ module GoodData
           if params.segments_filter && params.segments_filter.any?
             { delete_extra_in_segments: params.segments_filter }
           else
-            { delete_extra: delete_extra }
+            { delete_extra: GoodData::Helpers.to_boolean(params.delete_extra) }
           end
         end
       end

data/lib/gooddata/lcm/actions/collect_attrs.rb

@@ -0,0 +1,56 @@
+# 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_action'
+
+module GoodData
+  module LCM2
+    class CollectAttributes < BaseAction
+      DESCRIPTION = "Collect all attributes (include CAs) to transfer label type and drill path"
+
+      PARAMS = define_params(self) do
+        description 'Development Client Used for Connecting to GD'
+        param :development_client, instance_of(Type::GdClientType), required: true
+
+        description 'Synchronization Info'
+        param :synchronize, array_of(instance_of(Type::SynchronizationInfoType)), required: true, generated: true
+      end
+
+      class << self
+        def call(params)
+          results = []
+
+          development_client = params.development_client
+
+          synchronize = params.synchronize.pmap do |info|
+            from = info.from
+            from_project = development_client.projects(from) || fail("Invalid 'from' project specified - '#{from}'")
+            objects = (from_project.attributes.to_a + from_project.labels.to_a).map(&:uri)
+
+            info[:transfer_uris] ||= []
+            info[:transfer_uris] += objects
+
+            results += objects.map do |uri|
+              {
+                project: from,
+                transfer_uri: uri
+              }
+            end
+
+            info
+          end
+
+          {
+            results: results,
+            params: {
+              synchronize: synchronize
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/lcm/actions/collect_ca_metrics.rb

@@ -0,0 +1,53 @@
+# 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_action'
+
+module GoodData
+  module LCM2
+    class CollectComputedAttributeMetrics < BaseAction
+      DESCRIPTION = 'Collect all metrics which is used in computed attributes in development projects'
+
+      PARAMS = define_params(self) do
+        description 'Client Used for Connecting to GD'
+        param :gdc_gd_client, instance_of(Type::GdClientType), required: true
+      end
+
+      class << self
+        def call(params)
+          results = []
+          development_client = params.development_client
+
+          synchronize = params.synchronize.pmap do |info|
+            from = info.from
+            from_project = development_client.projects(from) || fail("Invalid 'from' project specified - '#{from}'")
+
+            metric_uris = from_project.computed_attributes.flat_map { |a| a.using('metric').map { |m| m['link'] } }
+
+            info[:transfer_uris] ||= []
+            info[:transfer_uris] += metric_uris
+
+            results += metric_uris.map do |uri|
+              {
+                project: from,
+                transfer_uri: uri
+              }
+            end
+
+            info
+          end
+
+          {
+            results: results,
+            params: {
+              synchronize: synchronize
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/lcm/actions/collect_clients.rb

@@ -14,6 +14,27 @@ module GoodData
       PARAMS = define_params(self) do
         description 'Client Used for Connecting to GD'
         param :gdc_gd_client, instance_of(Type::GdClientType), required: true
+
+        description 'Segments to manage'
+        param :segments, array_of(instance_of(Type::SegmentType)), required: true
+
+        description 'Client Id Column'
+        param :client_id_column, instance_of(Type::StringType), required: false
+
+        description 'Segment Id Column'
+        param :segment_id_column, instance_of(Type::StringType), required: false
+
+        description 'Project Id Column'
+        param :project_id_column, instance_of(Type::StringType), required: false
+
+        description 'Client Project Title Column'
+        param :project_title_column, instance_of(Type::StringType), required: false
+
+        description 'Client Project Token Column'
+        param :project_token_column, instance_of(Type::StringType), required: false
+
+        description 'Input Source'
+        param :input_source, instance_of(Type::HashType), required: true
       end
 
       RESULT_HEADER = [
@@ -24,9 +45,6 @@ module GoodData
 
       class << self
         def call(params)
-          # Check if all required parameters were passed
-          BaseAction.check_params(PARAMS, params)
-
           segment_names = params.segments.map(&:segment_id)
 
           clients = collect_clients(params, segment_names)
@@ -58,8 +76,12 @@ module GoodData
           clients = []
           data_source = GoodData::Helpers::DataSource.new(params.input_source)
           input_data = File.open(data_source.realize(params), 'r:UTF-8')
+          GoodData.logger.debug("Input data: #{input_data.read}")
+          GoodData.logger.debug("Segment names: #{segment_names}")
           CSV.foreach(input_data, :headers => true, :return_headers => false, encoding: 'utf-8') do |row|
+            GoodData.logger.debug("Processing row: #{row}")
             segment_name = row[segment_id_column]
+            GoodData.logger.debug("Segment name: #{segment_name}")
             if segment_names.nil? || segment_names.include?(segment_name)
               clients << {
                 id: row[client_id_column],

data/lib/gooddata/lcm/actions/collect_meta.rb

@@ -0,0 +1,83 @@
+# 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_action'
+
+module GoodData
+  module LCM2
+    class CollectMeta < BaseAction
+      DESCRIPTION = "Collect tagged dashboards (or all dashboards if not specify production tag) \
+      with objects inside dashboards (reports, metrics ...) from development projects"
+
+      PARAMS = define_params(self) do
+        description 'Production Tag Name'
+        param :production_tag, instance_of(Type::StringType), required: false
+
+        description 'Development Client Used for Connecting to GD'
+        param :development_client, instance_of(Type::GdClientType), required: true
+
+        description 'Synchronization Info'
+        param :synchronize, array_of(instance_of(Type::SynchronizationInfoType)), required: true, generated: true
+
+        description 'Segments to search for segment-specific production tags'
+        param :segments, array_of(instance_of(Type::SegmentType)), required: false
+
+        description 'Flag to mark if we need to transfer all objects'
+        param :transfer_all, instance_of(Type::BooleanType), required: false, default: false
+      end
+
+      class << self
+        def call(params)
+          results = []
+
+          development_client = params.development_client
+          segments_to_tags = Helpers.segment_production_tags(params.segments)
+          transfer_all = GoodData::Helpers.to_boolean(params.transfer_all)
+
+          synchronize = params.synchronize.pmap do |info|
+            from = info.from
+            from_project = development_client.projects(from) || fail("Invalid 'from' project specified - '#{from}'")
+
+            segment_tags = segments_to_tags[info.segment]
+            production_tags = Helpers.parse_production_tags(params.production_tag, segment_tags)
+
+            if transfer_all || production_tags.empty?
+              objects = GoodData::Dashboard.all(
+                project: from_project,
+                client: development_client
+              )
+            else
+              objects = GoodData::Dashboard.find_by_tag(
+                production_tags,
+                project: from_project,
+                client: development_client
+              )
+            end
+
+            info[:transfer_uris] ||= []
+            info[:transfer_uris] += objects.map(&:uri)
+
+            results += objects.map do |uri|
+              {
+                project: from,
+                transfer_uri: uri
+              }
+            end
+
+            info
+          end
+
+          {
+            results: results,
+            params: {
+              synchronize: synchronize
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/lcm/actions/collect_segment_clients.rb

@@ -20,6 +20,12 @@ module GoodData
 
         description 'ADS Client'
         param :ads_client, instance_of(Type::AdsClientType), required: true
+
+        description 'Segments to manage'
+        param :segments, array_of(instance_of(Type::SegmentType)), required: true
+
+        description 'Table Name'
+        param :release_table_name, instance_of(Type::StringType), required: false
       end
 
       RESULT_HEADER = [
@@ -33,9 +39,6 @@ module GoodData
 
       class << self
         def call(params)
-          # Check if all required parameters were passed
-          BaseAction.check_params(PARAMS, params)
-
           client = params.gdc_gd_client
 
           domain_name = params.organization || params.domain
@@ -50,6 +53,11 @@ module GoodData
 
           results = []
           synchronize_clients = segments.map do |segment|
+            segment_clients = segment.clients
+            missing_project_clients = segment_clients.reject(&:project?).map(&:client_id)
+
+            raise "Client(s) missing workspace: #{missing_project_clients.join(', ')}. Please make sure all clients have workspace." unless missing_project_clients.empty?
+
             replacements = {
               table_name: params.release_table_name || DEFAULT_TABLE_NAME,
               segment_id: segment.segment_id
@@ -68,7 +76,7 @@ module GoodData
             sync_info = {
               segment_id: segment.segment_id,
               from: master_pid,
-              to: segment.clients.map do |segment_client|
+              to: segment_clients.map do |segment_client|
                 client_project = segment_client.project
                 to_pid = client_project.pid
                 results << {

data/lib/gooddata/lcm/actions/collect_segments.rb

@@ -17,13 +17,13 @@ module GoodData
 
         description 'Organization Name'
         param :organization, instance_of(Type::StringType), required: true
+
+        description 'Segments to provision'
+        param :segments_filter, array_of(instance_of(Type::StringType)), required: false
       end
 
       class << self
         def call(params)
-          # Check if all required parameters were passed
-          BaseAction.check_params(PARAMS, params)
-
           client = params.gdc_gd_client
 
           domain_name = params.organization || params.domain
@@ -36,7 +36,7 @@ module GoodData
             end
           end
 
-          segments = domain_segments.map do |segment|
+          segments = domain_segments.pmap do |segment|
             project = nil
 
             begin

data/lib/gooddata/lcm/actions/collect_tagged_objects.rb

@@ -0,0 +1,74 @@
+# 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_action'
+require_relative '../helpers/helpers'
+
+module GoodData
+  module LCM2
+    class CollectTaggedObjects < BaseAction
+      DESCRIPTION = 'Collect all objects tagged with the +$PRODUCTION_TAG+ from development projects'
+
+      PARAMS = define_params(self) do
+        description 'Development Client Used for Connecting to GD'
+        param :development_client, instance_of(Type::GdClientType), required: true
+
+        description 'Synchronization Info'
+        param :synchronize, array_of(instance_of(Type::SynchronizationInfoType)), required: true, generated: true
+
+        description 'Tag Name'
+        param :production_tag, instance_of(Type::StringType), required: false
+
+        description 'Segments to search for segment-specific production tags'
+        param :segments, array_of(instance_of(Type::SegmentType)), required: false
+
+        description 'Flag to mark if we need to transfer all objects'
+        param :transfer_all, instance_of(Type::BooleanType), required: false, default: false
+      end
+
+      class << self
+        def call(params)
+          results = []
+          segments_to_tags = Helpers.segment_production_tags(params.segments)
+          transfer_all = GoodData::Helpers.to_boolean(params.transfer_all)
+          return results unless params.production_tag || segments_to_tags.any? || transfer_all
+          development_client = params.development_client
+
+          synchronize = params.synchronize.pmap do |info|
+            from = info.from
+            from_project = development_client.projects(from) || fail("Invalid 'from' project specified - '#{from}'")
+
+            segment_tags = segments_to_tags[info.segment]
+            production_tags = Helpers.parse_production_tags(params.production_tag, segment_tags)
+            if production_tags.any?
+              objects = from_project.find_by_tag(production_tags)
+            else
+              objects = (from_project.reports.to_a + from_project.metrics.to_a + from_project.variables.to_a).map(&:uri)
+            end
+
+            info[:transfer_uris] ||= []
+            info[:transfer_uris] += objects
+
+            results += objects.map do |uri|
+              {
+                project: from,
+                transfer_uri: uri
+              }
+            end
+
+            info
+          end
+          {
+            results: results,
+            params: {
+              synchronize: synchronize
+            }
+          }
+        end
+      end
+    end
+  end
+end