gooddata 2.1.19 → 2.3.0

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

@@ -44,6 +44,15 @@ module GoodData
 
         description 'Delete extra process schedule flag'
         param :delete_extra_process_schedule, instance_of(Type::BooleanType), required: false, default: true
+
+        description 'Abort on error'
+        param :abort_on_error, instance_of(Type::StringType), required: false
+
+        description 'Collect synced status'
+        param :collect_synced_status, instance_of(Type::BooleanType), required: false
+
+        description 'Sync failed list'
+        param :sync_failed_list, instance_of(Type::HashType), required: false
       end
 
       # will be updated later based on the way etl synchronization
@@ -59,6 +68,8 @@ module GoodData
         def call(params)
           client = params.gdc_gd_client
           data_product = params.data_product
+          collect_synced_status = collect_synced_status(params)
+          failed_projects = ThreadSafe::Array.new
 
           schedule_additional_params = params.schedule_additional_params || params.additional_params
           schedule_additional_hidden_params = params.schedule_additional_hidden_params || params.additional_hidden_params
@@ -68,6 +79,8 @@ module GoodData
           end
 
           results = synchronize_segments.pmap do |segment_id, synchronize|
+            next if collect_synced_status && sync_failed_segment(segment_id, params)
+
             segment = data_product.segments.find { |s| s.segment_id == segment_id }
             res = segment.synchronize_processes(
               synchronize.flat_map do |info|
@@ -80,7 +93,11 @@ module GoodData
             res = GoodData::Helpers.symbolize_keys(res)
 
             if res[:syncedResult][:errors]
-              fail "Failed to sync processes/schedules for segment #{segment_id}. Error: #{res[:syncedResult][:errors].pretty_inspect}"
+              error_message = "Failed to sync processes/schedules for segment #{segment_id}. Error: #{res[:syncedResult][:errors].pretty_inspect}"
+              fail error_message unless collect_synced_status
+
+              add_failed_segment(segment_id, error_message, short_name, params)
+              next
             end
 
             if res[:syncedResult][:clients]
@@ -111,12 +128,19 @@ module GoodData
           hidden_params_for_all_schedules_in_all_projects = hidden_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
+            from_project_etl_names = get_process_n_schedule_names(client, info.from, failed_projects, collect_synced_status) if delete_extra_process_schedule
+            next if delete_extra_process_schedule && from_project_etl_names.nil?
 
             to_projects = info.to
             to_projects.peach do |entry|
               pid = entry[:pid]
-              to_project = client.projects(pid) || fail("Invalid 'to' project specified - '#{pid}'")
+              next if collect_synced_status && sync_failed_project(pid, params)
+
+              to_project = client.projects(pid)
+              unless to_project
+                process_failed_project(pid, "Invalid 'to' project specified - '#{pid}'", failed_projects, collect_synced_status)
+                next
+              end
 
               if delete_extra_process_schedule
                 to_project_process_id_names = {}
@@ -140,24 +164,31 @@ module GoodData
               to_project.set_metadata('GOODOT_CUSTOM_PROJECT_ID', client_id) # TMA-210
 
               to_project.schedules.each do |schedule|
+                schedule_name = schedule.name
                 if delete_extra_process_schedule
-                  unless from_project_etl_names[:schedules].include?([schedule.name, to_project_process_id_names[schedule.process_id]])
+                  schedule_project_info = [schedule_name, to_project_process_id_names[schedule.process_id]]
+                  unless from_project_etl_names[:schedules].include?(schedule_project_info)
                     schedule.delete
                     next
                   end
                 end
 
+                params_for_all_projects_schedule_name = params_for_all_projects[schedule_name]
+                params_for_this_client_schedule_name = params_for_this_client[schedule_name]
+                hidden_params_for_all_projects_schedule_name = hidden_params_for_all_projects[schedule_name]
+                hidden_params_for_this_client_schedule_name = hidden_params_for_this_client[schedule_name]
+
                 schedule.update_params(schedule_additional_params) if schedule_additional_params
-                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_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_params(**params_for_this_client_schedule_name) if params_for_this_client_schedule_name
 
                 schedule.update_hidden_params(schedule_additional_hidden_params) if schedule_additional_hidden_params
                 schedule.update_hidden_params(hidden_params_for_all_schedules_in_all_projects) if hidden_params_for_all_schedules_in_all_projects
-                schedule.update_hidden_params(hidden_params_for_all_projects[schedule.name]) if hidden_params_for_all_projects[schedule.name]
+                schedule.update_hidden_params(hidden_params_for_all_projects_schedule_name) if hidden_params_for_all_projects_schedule_name
                 schedule.update_hidden_params(hidden_params_for_all_schedules_in_this_client) if hidden_params_for_all_schedules_in_this_client
-                schedule.update_hidden_params(hidden_params_for_this_client[schedule.name]) if hidden_params_for_this_client[schedule.name]
+                schedule.update_hidden_params(hidden_params_for_this_client_schedule_name) if hidden_params_for_this_client_schedule_name
 
                 schedule.enable
                 schedule.save
@@ -165,13 +196,19 @@ module GoodData
             end
           end
 
+          process_failed_projects(failed_projects, short_name, params) if collect_synced_status
           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}'")
+        def get_process_n_schedule_names(client, project_id, failed_projects, continue_on_error)
+          project = client.projects(project_id)
+          unless project
+            process_failed_project(project_id, "Invalid 'from' project specified - '#{project_id}'", failed_projects, continue_on_error)
+            return nil
+          end
+
           processes = project.processes
           process_id_names = Hash[processes.map { |process| [process.process_id, process.name] }]
 

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

@@ -0,0 +1,103 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+#
+# Copyright (c) 2010-2021 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 SynchronizeKDDashboardPermissions < BaseAction
+      DESCRIPTION = 'Synchronize KD Dashboard Permission'
+
+      PARAMS = define_params(self) do
+        description 'Client used to connecting to development domain'
+        param :development_client, instance_of(Type::GdClientType), required: true
+
+        description 'Client Used for Connecting to GD'
+        param :gdc_gd_client, instance_of(Type::GdClientType), required: true
+
+        description 'Logger'
+        param :gdc_logger, instance_of(Type::GdLogger), required: true
+
+        description 'Additional Hidden Parameters'
+        param :additional_hidden_params, instance_of(Type::HashType), required: false
+
+        description 'Synchronization Info'
+        param :synchronize, array_of(instance_of(Type::SynchronizationInfoType)), required: true, generated: true
+
+        description 'Disable synchronizing dashboard permissions for AD/KD dashboards.'
+        param :disable_kd_dashboard_permission, instance_of(Type::BooleanType), required: false, default: false
+
+        description 'Abort on error'
+        param :abort_on_error, instance_of(Type::StringType), required: false
+
+        description 'Collect synced status'
+        param :collect_synced_status, instance_of(Type::BooleanType), required: false
+
+        description 'Sync failed list'
+        param :sync_failed_list, instance_of(Type::HashType), required: false
+      end
+
+      class << self
+        def call(params)
+          results = ThreadSafe::Array.new
+          collect_synced_status = collect_synced_status(params)
+          failed_projects = ThreadSafe::Array.new
+
+          disable_kd_dashboard_permission = GoodData::Helpers.to_boolean(params.disable_kd_dashboard_permission)
+
+          # rubocop:disable Style/UnlessElse
+          unless disable_kd_dashboard_permission
+            dashboard_type = "KD"
+            dev_client = params.development_client
+            gdc_client = params.gdc_gd_client
+
+            params.synchronize.peach do |param_info|
+              from_project_info = param_info.from
+              to_projects_info = param_info.to
+
+              from_project = dev_client.projects(from_project_info)
+              unless from_project
+                process_failed_project(from_project_info, "Invalid 'from' project specified - '#{from_project_info}'", failed_projects, collect_synced_status)
+                next
+              end
+
+              from_dashboards = from_project.analytical_dashboards
+
+              params.gdc_logger.info "Transferring #{dashboard_type} Dashboard permission, from project: '#{from_project.title}', PID: '#{from_project.pid}' for dashboard(s): #{from_dashboards.map { |d| "#{d.title.inspect}" }.join(', ')}" # rubocop:disable Metrics/LineLength
+              to_projects_info.peach do |item|
+                to_project_pid = item[:pid]
+                next if sync_failed_project(to_project_pid, params)
+
+                to_project = gdc_client.projects(to_project_pid)
+                unless to_project
+                  process_failed_project(to_project_pid, "Invalid 'to' project specified - '#{to_project_pid}'", failed_projects, collect_synced_status)
+                  next
+                end
+
+                to_dashboards = to_project.analytical_dashboards
+                GoodData::Project.transfer_dashboard_permission(from_project, to_project, from_dashboards, to_dashboards)
+              end
+
+              results << {
+                from_project_name: from_project.title,
+                from_project_pid: from_project.pid,
+                status: 'ok'
+              }
+            end
+          else
+            params.gdc_logger.info "Skip synchronize KD dashboard permission."
+          end
+
+          process_failed_projects(failed_projects, short_name, params) if collect_synced_status
+          results
+          # rubocop:enable Style/UnlessElse
+        end
+      end
+    end
+  end
+end

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

@@ -5,6 +5,7 @@
 # LICENSE file in the root directory of this source tree.
 
 require_relative 'base_action'
+require_relative '../helpers/helpers'
 
 using TrueExtensions
 using FalseExtensions
@@ -47,6 +48,15 @@ module GoodData
 
         description 'Enables handling of deprecated objects in the logical data model.'
         param :include_deprecated, instance_of(Type::BooleanType), required: false, default: false
+
+        description 'Abort on error'
+        param :abort_on_error, instance_of(Type::StringType), required: false
+
+        description 'Collect synced status'
+        param :collect_synced_status, instance_of(Type::BooleanType), required: false
+
+        description 'Sync failed list'
+        param :sync_failed_list, instance_of(Type::HashType), required: false
       end
 
       RESULT_HEADER = %i[from to status]
@@ -56,6 +66,8 @@ module GoodData
           results = []
           synchronize = []
           params.synchronize.map do |segment_info|
+            next if sync_failed_segment(segment_info[:segment_id], params)
+
             new_segment_info, segment_results = sync_segment_ldm(params, segment_info)
             results.concat(segment_results)
             synchronize << new_segment_info
@@ -72,69 +84,113 @@ module GoodData
         private
 
         def sync_segment_ldm(params, segment_info)
-          results = []
+          collect_synced_status = collect_synced_status(params)
+          failed_projects = ThreadSafe::Array.new
+          results = ThreadSafe::Array.new
           client = params.gdc_gd_client
           exclude_fact_rule = params.exclude_fact_rule.to_b
           include_deprecated = params.include_deprecated.to_b
+          update_preference = params[:update_preference]
+          exist_fallback_to_hard_sync_config = !update_preference.nil? && !update_preference[:fallback_to_hard_sync].nil?
+          include_maql_fallback_hard_sync = exist_fallback_to_hard_sync_config && Helpers.to_bool('fallback_to_hard_sync', update_preference[:fallback_to_hard_sync])
+
           from_pid = segment_info[:from]
-          from = params.development_client.projects(from_pid) || fail("Invalid 'from' project specified - '#{from_pid}'")
+          from = params.development_client.projects(from_pid)
+          unless from
+            segment_id = segment_info[:segment_id]
+            error_message = "Failed to sync LDM for segment #{segment_id}. Error: Invalid 'from' project specified - '#{from_pid}'"
+            fail(error_message) unless collect_synced_status
+
+            add_failed_segment(segment_id, error_message, short_name, params)
+            return [segment_info, results]
+          end
+
           GoodData.logger.info "Creating Blueprint, project: '#{from.title}', PID: #{from_pid}"
           blueprint = from.blueprint(include_ca: params.include_computed_attributes.to_b)
           segment_info[:from_blueprint] = blueprint
           maql_diff = nil
           previous_master = segment_info[:previous_master]
+          synchronize_ldm_mode = params[:synchronize_ldm].downcase
           diff_against_master = %w(diff_against_master_with_fallback diff_against_master)
-            .include?(params[:synchronize_ldm].downcase)
-          GoodData.logger.info "Synchronize LDM mode: '#{params[:synchronize_ldm].downcase}'"
-          if previous_master && diff_against_master
-            maql_diff_params = [:includeGrain]
-            maql_diff_params << :excludeFactRule if exclude_fact_rule
-            maql_diff_params << :includeDeprecated if include_deprecated
-            maql_diff = previous_master.maql_diff(blueprint: blueprint, params: maql_diff_params)
+            .include?(synchronize_ldm_mode)
+          GoodData.logger.info "Synchronize LDM mode: '#{synchronize_ldm_mode}'"
+          if segment_info.key?(:previous_master) && diff_against_master
+            if previous_master
+              maql_diff_params = [:includeGrain]
+              maql_diff_params << :excludeFactRule if exclude_fact_rule
+              maql_diff_params << :includeDeprecated if include_deprecated
+              maql_diff_params << :includeMaqlFallbackHardSync if include_maql_fallback_hard_sync
+
+              maql_diff = previous_master.maql_diff(blueprint: blueprint, params: maql_diff_params)
+            else
+              maql_diff = {
+                "projectModelDiff" =>
+                   {
+                     "updateOperations" => [],
+                     "updateScripts" => []
+                   }
+              }
+            end
+
             chunks = maql_diff['projectModelDiff']['updateScripts']
             if chunks.empty?
               GoodData.logger.info "Synchronize LDM to clients will not proceed in mode \
-'#{params[:synchronize_ldm].downcase}' due to no LDM changes in the new master project. \
+'#{synchronize_ldm_mode}' due to no LDM changes in the segment master project. \
 If you had changed LDM of clients manually, please use mode 'diff_against_clients' \
 to force synchronize LDM to clients"
             end
           end
 
           segment_info[:to] = segment_info[:to].pmap do |entry|
+            update_status = true
             pid = entry[:pid]
-            to_project = client.projects(pid) || fail("Invalid 'to' project specified - '#{pid}'")
+            next if sync_failed_project(pid, params)
+
+            to_project = client.projects(pid)
+            unless to_project
+              process_failed_project(pid, "Invalid 'to' project specified - '#{pid}'", failed_projects, collect_synced_status)
+              next
+            end
 
             GoodData.logger.info "Updating from Blueprint, project: '#{to_project.title}', PID: #{pid}"
             begin
               entry[:ca_scripts] = to_project.update_from_blueprint(
                 blueprint,
-                update_preference: params[:update_preference],
+                update_preference: update_preference,
                 exclude_fact_rule: exclude_fact_rule,
                 execute_ca_scripts: false,
                 maql_diff: maql_diff,
                 include_deprecated: include_deprecated
               )
             rescue MaqlExecutionError => e
-              GoodData.logger.info("Applying MAQL to project #{to_project.title} - #{pid} failed. Reason: #{e}")
-              fail e unless previous_master && params[:synchronize_ldm] == 'diff_against_master_with_fallback'
-              GoodData.logger.info("Restoring the client project #{to_project.title} from master.")
-              entry[:ca_scripts] = to_project.update_from_blueprint(
-                blueprint,
-                update_preference: params[:update_preference],
-                exclude_fact_rule: exclude_fact_rule,
-                execute_ca_scripts: false,
-                include_deprecated: include_deprecated
-              )
+              if collect_synced_status
+                update_status = false
+                failed_message = "Applying MAQL to project #{to_project.title} - #{pid} failed. Reason: #{e}"
+                process_failed_project(pid, failed_message, failed_projects, collect_synced_status)
+              else
+                fail e unless previous_master && params[:synchronize_ldm] == 'diff_against_master_with_fallback'
+
+                GoodData.logger.info("Restoring the client project #{to_project.title} from master.")
+                entry[:ca_scripts] = to_project.update_from_blueprint(
+                  blueprint,
+                  update_preference: update_preference,
+                  exclude_fact_rule: exclude_fact_rule,
+                  execute_ca_scripts: false,
+                  include_deprecated: include_deprecated
+                )
+              end
             end
 
             results << {
               from: from_pid,
               to: pid,
               status: 'ok'
-            }
+            } if update_status
+
             entry
           end
 
+          process_failed_projects(failed_projects, short_name, params) if collect_synced_status
           [segment_info, results]
         end
       end

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

@@ -0,0 +1,98 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+#
+# Copyright (c) 2022 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 SynchronizeLdmLayout < BaseAction
+      DESCRIPTION = 'Synchronize LDM Layout'
+
+      PARAMS = define_params(self) do
+        description 'Logger'
+        param :gdc_logger, instance_of(Type::GdLogger), required: true
+
+        description 'Client Used for Connecting to GD'
+        param :gdc_gd_client, instance_of(Type::GdClientType), required: true
+
+        description 'Client used to connecting to development domain'
+        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 'Abort on error'
+        param :abort_on_error, instance_of(Type::StringType), required: false
+
+        description 'Collect synced status'
+        param :collect_synced_status, instance_of(Type::BooleanType), required: false
+
+        description 'Sync failed list'
+        param :sync_failed_list, instance_of(Type::HashType), required: false
+      end
+
+      RESULT_HEADER = %i[from to status]
+
+      class << self
+        def call(params)
+          results = []
+
+          client = params.gdc_gd_client
+          development_client = params.development_client
+          gdc_logger = params.gdc_logger
+          collect_synced_status = collect_synced_status(params)
+          failed_projects = ThreadSafe::Array.new
+
+          params.synchronize.peach do |info|
+            from_project = info.from
+            to_projects = info.to
+
+            from = development_client.projects(from_project)
+            unless from
+              process_failed_project(from_project, "Invalid 'from' project specified - '#{from_project}'", failed_projects, collect_synced_status)
+              next
+            end
+
+            from_pid = from.pid
+            from_title = from.title
+            from_ldm_layout = from.ldm_layout
+
+            if from_ldm_layout&.dig('ldmLayout', 'layout').nil? || from_ldm_layout['ldmLayout']['layout'].empty?
+              gdc_logger.info "Project: '#{from_title}', PID: '#{from_pid}' has no ldm layout, skip synchronizing ldm layout."
+            else
+              to_projects.peach do |to|
+                pid = to[:pid]
+                to_project = client.projects(pid)
+                unless to_project
+                  process_failed_project(pid, "Invalid 'from' project specified - '#{pid}'", failed_projects, collect_synced_status)
+                  next
+                end
+
+                next if sync_failed_project(pid, params)
+
+                gdc_logger.info "Transferring ldm layout, from project: '#{from_title}', PID: '#{from_pid}', to project: '#{to_project.title}', PID: '#{to_project.pid}'"
+                res = to_project.save_ldm_layout(from_ldm_layout)
+
+                if res[:status] == 'OK' || !collect_synced_status
+                  res[:from] = from_pid
+                  results << res
+                else
+                  warning_message = "Failed to transfer ldm layout from project: '#{from_pid}' to project: '#{to_project.title}'"
+                  process_failed_project(pid, warning_message, failed_projects, collect_synced_status)
+                end
+              end
+            end
+          end
+
+          process_failed_projects(failed_projects, short_name, params) if collect_synced_status
+          # Return results
+          results.flatten
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+#
+# Copyright (c) 2010-2021 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'
+require 'json'
+
+module GoodData
+  module LCM2
+    class SynchronizePPDashboardPermissions < BaseAction
+      DESCRIPTION = 'Synchronize Pixel Perfect Dashboard Permission'
+
+      PARAMS = define_params(self) do
+        description 'Client Used for Connecting to GD'
+        param :gdc_gd_client, instance_of(Type::GdClientType), required: true
+
+        description 'Client used to connecting to development domain'
+        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 'Logger'
+        param :gdc_logger, instance_of(Type::GdLogger), required: true
+
+        description 'Additional Hidden Parameters'
+        param :additional_hidden_params, instance_of(Type::HashType), required: false
+
+        description 'Disable synchronizing dashboard permissions for Pixel Perfect dashboards'
+        param :disable_pp_dashboard_permission, instance_of(Type::BooleanType), required: false, default: false
+
+        description 'Abort on error'
+        param :abort_on_error, instance_of(Type::StringType), required: false
+
+        description 'Collect synced status'
+        param :collect_synced_status, instance_of(Type::BooleanType), required: false
+
+        description 'Sync failed list'
+        param :sync_failed_list, instance_of(Type::HashType), required: false
+      end
+
+      class << self
+        def call(params)
+          results = []
+          disable_pp_dashboard_permission = GoodData::Helpers.to_boolean(params.disable_pp_dashboard_permission)
+          collect_synced_status = collect_synced_status(params)
+          failed_projects = ThreadSafe::Array.new
+
+          if disable_pp_dashboard_permission
+            params.gdc_logger.info "Skip synchronize Pixel Perfect dashboard permission."
+          else
+            client = params.gdc_gd_client
+            development_client = params.development_client
+            failed_projects = ThreadSafe::Array.new
+
+            params.synchronize.peach do |info|
+              from_project = info.from
+              to_projects = info.to
+              sync_success = false
+
+              from = development_client.projects(from_project)
+              unless from
+                process_failed_project(from_project, "Invalid 'from' project specified - '#{from_project}'", failed_projects, collect_synced_status)
+                next
+              end
+
+              source_dashboards = from.dashboards
+
+              params.gdc_logger.info "Transferring Pixel Perfect Dashboard permission, from project: '#{from.title}', PID: '#{from.pid}' for dashboard(s): #{source_dashboards.map { |d| "#{d.title.inspect}" }.join(', ')}" # rubocop:disable Metrics/LineLength
+              to_projects.peach do |entry|
+                pid = entry[:pid]
+                next if sync_failed_project(pid, params)
+
+                to_project = client.projects(pid)
+                unless to_project
+                  process_failed_project(pid, "Invalid 'to' project specified - '#{pid}'", failed_projects, collect_synced_status)
+                  next
+                end
+
+                target_dashboards = to_project.dashboards
+                begin
+                  GoodData::Project.transfer_dashboard_permission(from, to_project, source_dashboards, target_dashboards)
+                  sync_success = true
+                rescue StandardError => err
+                  process_failed_project(pid, err.message, failed_projects, collect_synced_status)
+                end
+              end
+
+              results << {
+                from_project_name: from.title,
+                from_project_pid: from.pid,
+                status: 'ok'
+              } if sync_success
+            end
+          end
+
+          process_failed_projects(failed_projects, short_name, params) if collect_synced_status
+          results
+        end
+      end
+    end
+  end
+end

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

@@ -61,12 +61,13 @@ module GoodData
             to_projects = info.to
 
             from = development_client.projects(from_project) || fail("Invalid 'from' project specified - '#{from_project}'")
+            has_cycle_trigger = exist_cycle_trigger(from)
             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|
+              res = GoodData::Project.transfer_schedules(from, to_project, has_cycle_trigger).sort_by do |item|
                 item[:status]
               end
 
@@ -97,6 +98,35 @@ module GoodData
           # Return results
           results
         end
+
+        private
+
+        def exist_cycle_trigger(project)
+          schedules = project.schedules
+          triggers = {}
+          schedules.each do |schedule|
+            triggers[schedule.obj_id] = schedule.trigger_id if schedule.trigger_id
+          end
+
+          triggers.each do |schedule_id, trigger_id|
+            checking_id = trigger_id
+            if checking_id == schedule_id
+              return true
+            else
+              max_step = triggers.length
+              count = 1
+              loop do
+                checking_id = triggers[checking_id]
+                count += 1
+                break if !checking_id || count > max_step
+
+                return true if checking_id == schedule_id
+              end
+            end
+          end
+
+          false
+        end
       end
     end
   end