gooddata 1.0.0-java

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

@@ -0,0 +1,67 @@
+# 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 SynchronizeColorPalette < BaseAction
+      DESCRIPTION = 'Synchronize Custom Color Palette'
+
+      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,
+        :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 |entry|
+              pid = entry[:pid]
+              to_project = client.projects(pid) || fail("Invalid 'to' project specified - '#{pid}'")
+
+              params.gdc_logger.info(
+                "Transferring Custom Color Palette, from project: " \
+                "'#{from.title}', PID: '#{from.pid}', to project: " \
+                "'#{to_project.title}', PID: '#{to_project.pid}'"
+              )
+              GoodData::Project.transfer_color_palette(from, to_project)
+
+              results << {
+                from: from_project,
+                to: pid,
+                status: 'ok'
+              }
+            end
+          end
+
+          results
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,155 @@
+# 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 SynchronizeETLsInSegment < BaseAction
+      DESCRIPTION = 'Synchronize ETLs (CC/Ruby) In Segment'
+
+      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 '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
+
+      # will be updated later based on the way etl synchronization
+      RESULT_HEADER = [
+        :segment,
+        :master_project,
+        :client_id,
+        :client_project,
+        :status
+      ]
+
+      class << self
+        def call(params)
+          client = params.gdc_gd_client
+          data_product = params.data_product
+          synchronize_segments = params.synchronize.group_by do |info|
+            info[:segment_id]
+          end
+
+          results = synchronize_segments.pmap do |segment_id, synchronize|
+            segment = data_product.segments.find { |s| s.segment_id == segment_id }
+            res = segment.synchronize_processes(
+              synchronize.flat_map do |info|
+                info[:to].flat_map do |to|
+                  to[:pid]
+                end
+              end
+            )
+
+            res = GoodData::Helpers.symbolize_keys(res)
+
+            if res[:syncedResult][:errors]
+              params.gdc_logger.error "Error: #{res[:syncedResult][:errors].pretty_inspect}"
+              fail "Failed to sync processes/schedules for segment #{segment_id}"
+            end
+
+            if res[:syncedResult][:clients]
+              res[:syncedResult][:clients].flat_map do |item|
+                item = item[:client]
+                {
+                  segment: segment_id,
+                  master_project: segment.master_project_id,
+                  client_id: item[:id],
+                  client_project: item[:project].split('/').last,
+                  status: 'ok'
+                }
+              end
+            else
+              []
+            end
+          end
+
+          delete_extra_process_schedule = GoodData::Helpers.to_boolean(params.delete_extra_process_schedule)
+          schedule_params = params.schedule_params || {}
+          params_for_all_projects = schedule_params[:all_clients] || {}
+          params_for_all_schedules_in_all_projects = params_for_all_projects[:all_schedules]
+
+          params.synchronize.peach do |info|
+            from_project_etl_names = get_process_n_schedule_names(client, info.from) if delete_extra_process_schedule
+
+            to_projects = info.to
+            to_projects.peach do |entry|
+              pid = entry[:pid]
+              to_project = client.projects(pid) || fail("Invalid 'to' project specified - '#{pid}'")
+
+              if delete_extra_process_schedule
+                to_project_process_id_names = {}
+                to_project.processes.each do |process|
+                  if from_project_etl_names[:processes].include?(process.name)
+                    to_project_process_id_names[process.process_id] = process.name
+                  else
+                    process.delete
+                  end
+                end
+              end
+
+              client_id = entry[:client_id]
+              params_for_this_client = schedule_params[client_id] || {}
+              params_for_all_schedules_in_this_client = params_for_this_client[nil]
+
+              to_project.set_metadata('GOODOT_CUSTOM_PROJECT_ID', client_id) # TMA-210
+
+              to_project.schedules.each do |schedule|
+                if delete_extra_process_schedule
+                  unless from_project_etl_names[:schedules].include?([schedule.name, to_project_process_id_names[schedule.process_id]])
+                    schedule.delete
+                    next
+                  end
+                end
+
+                schedule.update_params(params.additional_params) if params.additional_params
+                schedule.update_params(
+                  CLIENT_ID: client_id, # needed for ADD and CloudConnect ETL
+                  GOODOT_CUSTOM_PROJECT_ID: client_id # TMA-210
+                )
+
+                schedule.update_params(params_for_all_schedules_in_all_projects) if params_for_all_schedules_in_all_projects
+                schedule.update_params(params_for_all_projects[schedule.name]) if params_for_all_projects[schedule.name]
+                schedule.update_params(params_for_all_schedules_in_this_client) if params_for_all_schedules_in_this_client
+                schedule.update_params(params_for_this_client[schedule.name]) if params_for_this_client[schedule.name]
+
+                schedule.update_hidden_params(params.additional_hidden_params) if params.additional_hidden_params
+                schedule.enable
+                schedule.save
+              end
+            end
+          end
+
+          results.flatten
+        end
+
+        private
+
+        def get_process_n_schedule_names(client, project_id)
+          project = client.projects(project_id) || fail("Invalid 'from' project specified - '#{project_id}'")
+          processes = project.processes
+          process_id_names = Hash[processes.map { |process| [process.process_id, process.name] }]
+
+          {
+            processes: processes.map(&:name),
+            schedules: project.schedules.map { |schedule| [schedule.name, process_id_names[schedule.process_id]] }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/lcm/actions/synchronize_label_types.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 SynchronizeLabelTypes < BaseAction
+      DESCRIPTION = 'Synchronize Label Types'
+
+      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,
+        :status
+      ]
+
+      class << self
+        def call(params)
+          results = []
+
+          client = params.gdc_gd_client
+          development_client = params.development_client
+
+          params.synchronize.peach do |info|
+            from = info.from
+            to = info.to
+
+            from_project = development_client.projects(from) || fail("Invalid 'from' project specified - '#{from}'")
+            to_projects = to.pmap do |project|
+              client.projects(project.pid)
+            end
+
+            GoodData::LCM.transfer_label_types(from_project, to_projects)
+
+            to_projects.each do |project|
+              results << {
+                from: from,
+                to: project.pid,
+                status: 'ok'
+              }
+            end
+          end
+
+          # Return results
+          results
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# 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 SynchronizeLdm < BaseAction
+      DESCRIPTION = 'Synchronize Logical Data Model'
+
+      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 'LDM Update Preference'
+        param :update_preference, instance_of(Type::UpdatePreferenceType), required: false
+
+        description 'Specifies whether to transfer computed attributes'
+        param :include_computed_attributes, instance_of(Type::BooleanType), required: false, default: true
+      end
+
+      class << self
+        def call(params)
+          # set default value for include_computed_attributes
+          # (we won't have to do this after TMA-690)
+          include_ca = params.include_computed_attributes
+          include_ca = true if include_ca.nil?
+          include_ca = include_ca.to_b
+
+          results = []
+
+          client = params.gdc_gd_client
+          development_client = params.development_client
+
+          synchronize = params.synchronize.map do |info|
+            from_project = info.from
+            to_projects = info.to
+
+            from = development_client.projects(from_project) || fail("Invalid 'from' project specified - '#{from_project}'")
+            params.gdc_logger.info "Creating Blueprint, project: '#{from.title}', PID: #{from.pid}"
+
+            blueprint = from.blueprint(include_ca: include_ca)
+            info[:to] = to_projects.pmap do |entry|
+              pid = entry[:pid]
+              to_project = client.projects(pid) || fail("Invalid 'to' project specified - '#{pid}'")
+
+              params.gdc_logger.info "Updating from Blueprint, project: '#{to_project.title}', PID: #{pid}"
+              ca_scripts = to_project.update_from_blueprint(blueprint, update_preference: params.update_preference, execute_ca_scripts: false)
+
+              entry[:ca_scripts] = ca_scripts
+
+              results << {
+                from: from_project,
+                to: pid,
+                status: 'ok'
+              }
+              entry
+            end
+
+            info
+          end
+
+          {
+            results: results,
+            params: {
+              synchronize: synchronize
+            }
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# 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 SynchronizeMeta < BaseAction
+      DESCRIPTION = 'Synchronize Metadata'
+
+      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 = []
+
+          client = params.gdc_gd_client
+          development_client = params.development_client
+
+          params.synchronize.each do |info|
+            from = info.from
+            to = info.to
+
+            from_project = development_client.projects(from) || fail("Invalid 'from' project specified - '#{from}'")
+            to_projects = to.map do |entry|
+              client.projects(entry[:pid])
+            end
+
+            GoodData::LCM.transfer_meta(from_project, to_projects)
+
+            to_projects.each do |project|
+              results << {
+                from: from,
+                to: project.pid,
+                status: 'ok'
+              }
+            end
+          end
+
+          # Return results
+          results
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# 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 SynchronizeNewSegments < BaseAction
+      DESCRIPTION = 'Synchronize New Segments'
+
+      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
+      end
+
+      class << self
+        def call(params)
+          client = params.gdc_gd_client
+
+          domain_name = params.organization || params.domain
+          domain = client.domain(domain_name) || fail("Invalid domain name specified - #{domain_name}")
+          data_product = params.data_product
+          domain_segments = domain.segments(:all, data_product)
+
+          params.segments.pmap do |segment_in|
+            segment_id = segment_in.segment_id
+
+            segment = domain_segments.find do |ds|
+              ds.segment_id == segment_id
+            end
+
+            if segment_in.is_new
+              segment.synchronize_clients
+
+              {
+                segment: segment_id,
+                new: true,
+                synchronized: true
+              }
+            else
+              {
+                segment: segment_id,
+                new: false,
+                synchronized: false
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end