gooddata 1.0.0-java

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

@@ -0,0 +1,66 @@
+# 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 SynchronizeProcesses < BaseAction
+      DESCRIPTION = 'Synchronize ETL (CC/Ruby) Processes'
+
+      PARAMS = define_params(self) do
+        description 'Client Used for Connecting to GD'
+        param :gdc_gd_client, instance_of(Type::GdClientType), required: true
+
+        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
+
+      RESULT_HEADER = [
+        :from,
+        :to,
+        :name,
+        :status
+      ]
+
+      class << self
+        def call(params)
+          results = []
+
+          client = params.gdc_gd_client
+          development_client = params.development_client
+
+          params.synchronize.peach do |info|
+            from_project = info.from
+            to_projects = info.to
+
+            from = development_client.projects(from_project) || fail("Invalid 'from' project specified - '#{from_project}'")
+
+            to_projects.peach do |to|
+              pid = to[:pid]
+              client_id = to[:client_id]
+
+              to_project = client.projects(pid) || fail("Invalid 'to' project specified - '#{pid}'")
+
+              params.gdc_logger.info "Transferring processes, from project: '#{from.title}', PID: '#{from.pid}', to project: '#{to_project.title}', PID: '#{to_project.pid}'"
+              res = GoodData::Project.transfer_processes(from, to_project, ads_output_stage_uri: info.ads_output_stage_uri)
+
+              to_project.add.output_stage.client_id = client_id if client_id && to_project.add.output_stage
+
+              results << res
+            end
+          end
+
+          # Return results
+          results.flatten
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+# 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 SynchronizeSchedules < BaseAction
+      DESCRIPTION = 'Synchronize ETL (CC/Ruby) Processes Schedules'
+
+      PARAMS = define_params(self) do
+        description 'Client Used for Connecting to GD'
+        param :gdc_gd_client, instance_of(Type::GdClientType), required: true
+
+        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 'Schedule Additional Parameters'
+        param :additional_params, instance_of(Type::HashType), required: false
+
+        description 'Schedule Additional Secure Parameters'
+        param :additional_hidden_params, instance_of(Type::HashType), required: false
+      end
+
+      RESULT_HEADER = [
+        :from,
+        :to,
+        :process_name,
+        :schedule_name,
+        :type,
+        :state
+      ]
+
+      class << self
+        def call(params)
+          results = []
+
+          client = params.gdc_gd_client
+          development_client = params.development_client
+
+          params.synchronize.peach do |info|
+            from_project = info.from
+            to_projects = info.to
+
+            from = development_client.projects(from_project) || fail("Invalid 'from' project specified - '#{from_project}'")
+            to_projects.peach do |entry|
+              pid = entry[:pid]
+              to_project = client.projects(pid) || fail("Invalid 'to' project specified - '#{pid}'")
+
+              params.gdc_logger.info "Transferring Schedules, from project: '#{from.title}', PID: '#{from.pid}', to project: '#{to_project.title}', PID: '#{to_project.pid}'"
+              res = GoodData::Project.transfer_schedules(from, to_project).sort_by do |item|
+                item[:status]
+              end
+
+              results += res.map do |item|
+                schedule = item[:schedule]
+
+                # TODO: Review this and remove if not required or duplicate (GOODOT_CUSTOM_PROJECT_ID vs CLIENT_ID)
+                # s.update_params('GOODOT_CUSTOM_PROJECT_ID' => c.id)
+                # s.update_params('CLIENT_ID' => c.id)
+                # s.update_params('SEGMENT_ID' => segment.id)
+                schedule.update_params(params.additional_params || {})
+                schedule.update_hidden_params(params.additional_hidden_params || {})
+                schedule.disable
+                schedule.save
+
+                {
+                  from: from.pid,
+                  to: to_project.pid,
+                  process_name: item[:process].name,
+                  schedule_name: schedule.name,
+                  type: item[:process].type,
+                  state: item[:state]
+                }
+              end
+            end
+          end
+
+          # Return results
+          results
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# 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 SynchronizeTagObjects < BaseAction
+      DESCRIPTION = "Synchronizes objects that have the production_tag even though they would normally be ignored \
+      (e.g. metrics that are not used in any dashboards)."
+
+      PARAMS = define_params(self) do
+        description 'Client Used for Connecting to GD'
+        param :gdc_gd_client, instance_of(Type::GdClientType), required: true
+
+        description 'Synchronization Info'
+        param :synchronize, array_of(instance_of(Type::SynchronizationInfoType)), required: true, generated: true
+
+        description 'Production Tag Names'
+        param :production_tags, array_of(instance_of(Type::StringType)), required: false
+
+        description 'Production Tag Names'
+        param :production_tag, instance_of(Type::StringType), required: false, deprecated: true, replacement: :production_tags
+      end
+
+      class << self
+        def call(params)
+          return [] unless params.production_tags || params.production_tag
+
+          results = []
+
+          client = params.gdc_gd_client
+          development_client = params.development_client
+
+          params.synchronize.each do |info|
+            from_project = info.from
+            to_projects = info.to
+
+            from = development_client.projects(from_project) || fail("Invalid 'from' project specified - '#{from_project}'")
+
+            to_projects.each do |entry|
+              pid = entry[:pid]
+              to_project = client.projects(pid) || fail("Invalid 'to' project specified - '#{pid}'")
+
+              GoodData::Project.transfer_tagged_stuff(from, to_project, params.production_tags || params.production_tag)
+
+              results << {
+                from: from_project,
+                to: pid,
+                tag: params.production_tags || params.production_tag,
+                status: 'ok'
+              }
+            end
+          end
+
+          results
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,210 @@
+# 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 SynchronizeUserFilters < BaseAction
+      DESCRIPTION = 'Synchronizes User Permissions Between Projects'
+
+      PARAMS = define_params(self) do
+        description 'Client Used For Connecting To GD'
+        param :gdc_gd_client, instance_of(Type::GdClientType), required: true
+
+        description 'Input Source'
+        param :input_source, instance_of(Type::HashType), required: true
+
+        description 'Synchronization Mode (e.g. sync_one_project_based_on_pid)'
+        param :sync_mode, instance_of(Type::StringType), required: false
+
+        description 'Column That Contains Target Project IDs'
+        param :multiple_projects_column, instance_of(Type::StringType), required: false
+
+        description 'Filters Config'
+        param :filters_config, instance_of(Type::HashType), required: true
+
+        description 'Input Source Contains CSV Headers?'
+        param :csv_headers, instance_of(Type::StringType), required: false
+
+        description 'Restrict If Missing Values In Input Source'
+        param :restrict_if_missing_all_values, instance_of(Type::StringType), required: false
+
+        description 'Ignore Missing Values In Input Source'
+        param :ignore_missing_values, instance_of(Type::StringType), required: false
+
+        description 'Do Not Touch Filters That Are Not Mentioned'
+        param :do_not_touch_filters_that_are_not_mentioned, instance_of(Type::StringType), required: false
+
+        description 'Restricts synchronization to specified segments'
+        param :segments_filter, array_of(instance_of(Type::StringType)), required: false
+
+        # gdc_project/gdc_project_id, required: true
+        # organization/domain, required: true
+      end
+
+      class << self
+        def call(params)
+          client = params.gdc_gd_client
+          domain_name = params.organization || params.domain
+          domain = client.domain(domain_name) if domain_name
+          project = client.projects(params.gdc_project) || client.projects(params.gdc_project_id)
+          data_product = params.data_product
+
+          data_source = GoodData::Helpers::DataSource.new(params.input_source)
+
+          config = params.filters_config
+          fail 'User filters brick requires configuration how the filter should be setup. For this use the param "filters_config"' if config.blank?
+          symbolized_config = GoodData::Helpers.deep_dup(config)
+          symbolized_config = GoodData::Helpers.symbolize_keys(symbolized_config)
+          symbolized_config[:labels] = symbolized_config[:labels].map { |l| GoodData::Helpers.symbolize_keys(l) }
+          headers_in_options = params.csv_headers == 'false' || true
+
+          mode = params.sync_mode || 'sync_project'
+          filters = []
+
+          csv_with_headers = if GoodData::UserFilterBuilder.row_based?(symbolized_config)
+                               false
+                             else
+                               headers_in_options
+                             end
+
+          multiple_projects_column = params.multiple_projects_column
+          unless multiple_projects_column
+            client_modes = %w(sync_domain_client_workspaces sync_one_project_based_on_custom_id sync_multiple_projects_based_on_custom_id)
+            multiple_projects_column = if client_modes.include?(mode)
+                                         'client_id'
+                                       else
+                                         'project_id'
+                                       end
+          end
+
+          run_params = {
+            restrict_if_missing_all_values: params.restrict_if_missing_all_values == 'true',
+            ignore_missing_values: params.ignore_missing_values == 'true',
+            do_not_touch_filters_that_are_not_mentioned: params.do_not_touch_filters_that_are_not_mentioned == 'true',
+            domain: domain,
+            dry_run: false,
+            users_brick_input: params.users_brick_users
+          }
+
+          puts "Synchronizing in mode \"#{mode}\""
+          case mode
+          when 'sync_project'
+            CSV.foreach(File.open(data_source.realize(params), 'r:UTF-8'), headers: csv_with_headers, return_headers: false, encoding: 'utf-8') do |row|
+              filters << row
+            end
+            filters_to_load = GoodData::UserFilterBuilder.get_filters(filters, symbolized_config)
+            puts "Synchronizing #{filters_to_load.count} filters"
+            project.add_data_permissions(filters_to_load, run_params)
+          when 'sync_one_project_based_on_pid'
+            CSV.foreach(File.open(data_source.realize(params), 'r:UTF-8'), headers: csv_with_headers, return_headers: false, encoding: 'utf-8') do |row|
+              filters << row if row[multiple_projects_column] == project.pid
+            end
+            filters_to_load = GoodData::UserFilterBuilder.get_filters(filters, symbolized_config)
+            puts "Synchronizing #{filters_to_load.count} filters"
+            project.add_data_permissions(filters_to_load, run_params)
+          when 'sync_multiple_projects_based_on_pid'
+            CSV.foreach(File.open(data_source.realize(params), 'r:UTF-8'), headers: csv_with_headers, return_headers: false, encoding: 'utf-8') do |row|
+              filters << row.to_hash
+            end
+            filters.group_by { |u| u[multiple_projects_column] }.flat_map do |project_id, new_filters|
+              fail "Project id cannot be empty" if project_id.blank?
+              project = client.projects(project_id)
+              filters_to_load = GoodData::UserFilterBuilder.get_filters(new_filters, symbolized_config)
+              puts "Synchronizing #{filters_to_load.count} filters in project #{project.pid}"
+              project.add_data_permissions(filters_to_load, run_params)
+            end
+          when 'sync_one_project_based_on_custom_id'
+            filter_value = UserBricksHelper.resolve_client_id(domain, project, data_product)
+
+            filepath = File.open(data_source.realize(params), 'r:UTF-8')
+            CSV.foreach(filepath, headers: csv_with_headers, return_headers: false, encoding: 'utf-8') do |row|
+              client_id = row[multiple_projects_column].to_s
+              filters << row if client_id == filter_value
+            end
+
+            if filters.empty?
+              params.gdc_logger.warn "Project \"#{project.pid}\" does not match with any client ids in input source (both GOODOT_CUSTOM_PROJECT_ID and SEGMENT/CLIENT). \
+                                      Unable to get the value to filter users."
+            end
+
+            filters_to_load = GoodData::UserFilterBuilder.get_filters(filters, symbolized_config)
+            puts "Synchronizing #{filters_to_load.count} filters"
+            project.add_data_permissions(filters_to_load, run_params)
+          when 'sync_multiple_projects_based_on_custom_id'
+            CSV.foreach(File.open(data_source.realize(params), 'r:UTF-8'), headers: csv_with_headers, return_headers: false, encoding: 'utf-8') do |row|
+              filters << row.to_hash
+            end
+            filters.group_by { |u| u[multiple_projects_column] }.flat_map do |client_id, new_filters|
+              fail "Client id cannot be empty" if client_id.blank?
+              project = domain.clients(client_id, data_product).project
+              fail "Client #{client_id} does not have project." unless project
+              filters_to_load = GoodData::UserFilterBuilder.get_filters(new_filters, symbolized_config)
+              puts "Synchronizing #{filters_to_load.count} filters in project #{project.pid} of client #{client_id}"
+              project.add_data_permissions(filters_to_load, run_params)
+            end
+          when 'sync_domain_client_workspaces'
+            CSV.foreach(File.open(data_source.realize(params), 'r:UTF-8'), headers: csv_with_headers, return_headers: false, encoding: 'utf-8') do |row|
+              filters << row.to_hash
+            end
+
+            domain_clients = domain.clients(:all, data_product)
+            if params.segments
+              segment_uris = params.segments.map(&:uri)
+              domain_clients = domain_clients.select { |c| segment_uris.include?(c.segment_uri) }
+            end
+
+            working_client_ids = []
+
+            filters.group_by { |u| u[multiple_projects_column] }.flat_map do |client_id, new_filters|
+              fail "Client id cannot be empty" if client_id.blank?
+              c = domain.clients(client_id, data_product)
+              if params.segments && !segment_uris.include?(c.segment_uri)
+                puts "Client #{client_id} is outside segments_filter #{params.segments}"
+                next
+              end
+              project = c.project
+              fail "Client #{client_id} does not have project." unless project
+              working_client_ids << client_id
+              filters_to_load = GoodData::UserFilterBuilder.get_filters(new_filters, symbolized_config)
+              puts "Synchronizing #{filters_to_load.count} filters in project #{project.pid} of client #{client_id}"
+              project.add_data_permissions(filters_to_load, run_params)
+            end
+
+            results = []
+            unless run_params[:do_not_touch_filters_that_are_not_mentioned]
+              domain_clients.each do |c|
+                next if working_client_ids.include?(c.client_id)
+                begin
+                  project = c.project
+                rescue => e
+                  puts "Error when accessing project of client #{c.client_id}. Error: #{e}"
+                  next
+                end
+                unless project
+                  puts "Client #{c.client_id} has no project."
+                  next
+                end
+                if project.deleted?
+                  puts "Project #{project.pid} of client #{c.client_id} is deleted."
+                  next
+                end
+
+                puts "Delete all filters in project #{project.pid} of client #{c.client_id}"
+                results << project.add_data_permissions([], run_params)
+              end
+            end
+
+            {
+              results: results
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/lcm/actions/synchronize_user_groups.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'
+require 'thread_safe'
+
+module GoodData
+  module LCM2
+    class SynchronizeUserGroups < BaseAction
+      DESCRIPTION = 'Synchronize User Groups'
+
+      PARAMS = define_params(self) do
+        description 'Client Used for Connecting to GD'
+        param :gdc_gd_client, instance_of(Type::GdClientType), required: true
+
+        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 = ThreadSafe::Array.new
+
+          client = params.gdc_gd_client
+          development_client = params.development_client
+
+          params.synchronize.peach do |info|
+            from_project = info.from
+            to_projects = info.to
+
+            from = development_client.projects(from_project) || fail("Invalid 'from' project specified - '#{from_project}'")
+
+            to_projects.peach do |entry|
+              pid = entry[:pid]
+              to_project = client.projects(pid) || fail("Invalid 'to' project specified - '#{pid}'")
+
+              params.gdc_logger.info "Transferring User Groups, from project: '#{from.title}', PID: '#{from.pid}', to project: '#{to_project.title}', PID: '#{to_project.pid}'"
+              results += GoodData::Project.transfer_user_groups(from, to_project)
+            end
+          end
+
+          results.uniq
+        end
+      end
+    end
+  end
+end