gooddata 2.2.0-java → 2.3.0-java

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

@@ -19,6 +19,18 @@ module GoodData
 
         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 'Logger'
+        param :gdc_logger, instance_of(Type::GdLogger), 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]
@@ -27,6 +39,8 @@ module GoodData
         def call(params)
           results = []
           params.synchronize.map do |segment_info|
+            next if sync_failed_segment(segment_info[:segment_id], params)
+
             result = migrate_date_dimension(params, segment_info)
             results.concat(result)
           end
@@ -47,8 +61,13 @@ module GoodData
           # check latest master and previous master
           master_upgrade_datasets = get_upgrade_dates(latest_blueprint, previous_blueprint) if params[:synchronize_ldm].downcase == 'diff_against_master' && previous_blueprint
           unless master_upgrade_datasets&.empty?
+            collect_synced_status = collect_synced_status(params)
+            failed_projects = ThreadSafe::Array.new
+
             segment_info[:to].pmap do |entry|
               pid = entry[:pid]
+              next if sync_failed_project(pid, params)
+
               to_project = client.projects(pid) || fail("Invalid 'to' project specified - '#{pid}'")
               GoodData.logger.info "Migrating date dimension, project: '#{to_project.title}', PID: #{pid}"
               to_blueprint = to_project.blueprint
@@ -56,13 +75,18 @@ module GoodData
               next if upgrade_datasets.empty?
 
               message = get_upgrade_message(upgrade_datasets)
+              failed_message = "Failed to migrate date dimension for project #{pid}"
+              update_status = to_project.upgrade_custom_v2(message)
+              process_failed_project(pid, failed_message, failed_projects, collect_synced_status) if collect_synced_status && update_status != 'OK'
 
               results << {
                 from: segment_info[:from],
                 to: pid,
-                status: to_project.upgrade_custom_v2(message)
+                status: update_status
               }
             end
+
+            process_failed_projects(failed_projects, short_name, params) if collect_synced_status
           end
 
           results
@@ -104,8 +128,10 @@ module GoodData
           get_date_dimensions(blueprint).any? { |e| e[:urn] == DATE_DIMENSION_CUSTOM_V2 }
         end
 
+        # Get date dimension from blue print. Return nil if date dimension not existing
         def get_date_dimension(blueprint, id)
-          GoodData::Model::ProjectBlueprint.find_date_dimension(blueprint, id)
+          date_dimensions = get_date_dimensions(blueprint)
+          date_dimensions.find { |d| d[:id] == id }
         end
 
         def get_date_dimensions(blueprint)

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

@@ -29,7 +29,16 @@ module GoodData
         param :data_product, instance_of(Type::GDDataProductType), required: false
 
         description 'Logger'
-        param :gdc_logger, instance_of(Type::GdLogger), required: true
+        param :gdc_logger, instance_of(Type::GdLogger), required: 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 = [
@@ -45,6 +54,8 @@ module GoodData
           synchronize_projects = []
           data_product = params.data_product
           client = params.gdc_gd_client
+          collect_synced_status = collect_synced_status(params)
+          continue_on_error = continue_on_error(params)
           domain_name = params.organization || params.domain
           fail "Either organisation or domain has to be specified in params" unless domain_name
           domain = client.domain(domain_name) || fail("Invalid domain name specified - #{domain_name}")
@@ -52,6 +63,8 @@ module GoodData
           invalid_client_ids = []
           begin
             results = params.segments.map do |segment|
+              next if sync_failed_segment(segment.segment_id, params)
+
               segment_object = domain.segments(segment.segment_id, data_product)
               tmp = segment_object.provision_client_projects.map do |m|
                 Hash[m.each_pair.to_a].merge(type: :provision_result)
@@ -65,10 +78,21 @@ module GoodData
                     unless entry[:project_uri]
                       error_message = "There was error during provisioning clients: #{entry[:error]}" unless error_message
                       invalid_client_ids << entry[:id]
+                      if collect_synced_status
+                        failed_message = "Failed to provision client #{entry[:id]} in segment #{segment.segment_id}. Error: #{entry[:error]}"
+                        add_failed_client(entry[:id], failed_message, short_name, params)
+                      end
                       next
                     end
+
+                    project_id = entry[:project_uri].split('/').last
+                    if collect_synced_status && entry[:status] == 'CREATED' && entry[:id]
+                      # Update project client mappings when there are create new clients during provision clients of the segment
+                      add_new_clients_to_project_client_mapping(project_id, entry[:id], segment.segment_id, params)
+                    end
+
                     {
-                      pid: entry[:project_uri].split('/').last,
+                      pid: project_id,
                       client_id: entry[:id]
                     }
                   end.compact
@@ -93,15 +117,20 @@ module GoodData
                 end
 
                 params.gdc_logger.debug "Deleted clients: #{deleted_client_ids.join(', ')}"
-                raise error_message unless error_message['TooManyProjectsCreatedException'] || error_message['Max number registered projects']
+                unless error_message['TooManyProjectsCreatedException'] || error_message['Max number registered projects']
+                  raise error_message unless continue_on_error
+
+                  next
+                end
+
                 break tmp
               end
 
               tmp
             end
           rescue => e
-            params.gdc_logger.error "Problem occurs when provisioning clients."
-            raise e
+            params.gdc_logger.error "Problem occurs when provisioning clients. Error: #{e}"
+            raise e unless continue_on_error
           end
 
           results.flatten! if results

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

@@ -32,6 +32,15 @@ module GoodData
 
         description 'Additional Hidden Parameters'
         param :additional_hidden_params, instance_of(Type::HashType), required: 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
@@ -46,6 +55,8 @@ module GoodData
           return results unless include_ca
 
           client = params.gdc_gd_client
+          collect_synced_status = collect_synced_status(params)
+          failed_projects = ThreadSafe::Array.new
 
           params.synchronize.each do |info|
             from = info.from
@@ -58,24 +69,33 @@ module GoodData
               next unless ca_scripts
 
               pid = entry[:pid]
+              next if sync_failed_project(pid, params)
+
               ca_chunks = ca_scripts[:maqlDdlChunks]
-              to_project = client.projects(pid) || fail("Invalid 'to' project specified - '#{pid}'")
-              params.gdc_logger.info "Synchronizing Computed Attributes to project: '#{to_project.title}', PID: #{pid}"
+              to_project = client.projects(pid)
+              unless to_project
+                process_failed_project(pid, "Invalid 'to' project specified - '#{pid}'", failed_projects, collect_synced_status)
+                next
+              end
 
+              params.gdc_logger.info "Synchronizing Computed Attributes to project: '#{to_project.title}', PID: #{pid}"
+              error_message = nil
               begin
                 ca_chunks.each { |chunk| to_project.execute_maql(chunk) }
               rescue => e
-                raise "Error occured when executing MAQL, project: \"#{to_project.title}\" reason: \"#{e.message}\", chunks: #{ca_chunks.inspect}"
+                error_message = "Error occurred when executing MAQL for project: \"#{to_project.title}\" reason: \"#{e.message}\", chunks: #{ca_chunks.inspect}"
+                process_failed_project(pid, error_message, failed_projects, collect_synced_status)
               end
 
               results << {
                 from: from,
                 to: pid,
-                status: 'ok'
+                status: error_message.nil? ? 'ok' : 'failed'
               }
             end
           end
 
+          process_failed_projects(failed_projects, short_name, params) if collect_synced_status
           results
         end
       end

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

@@ -38,6 +38,18 @@ module GoodData
 
         description 'Additional Hidden Parameters'
         param :additional_hidden_params, instance_of(Type::HashType), required: false
+
+        description 'Abort on error'
+        param :abort_on_error, instance_of(Type::StringType), required: false
+
+        description 'Logger'
+        param :gdc_logger, instance_of(Type::GdLogger), 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 = [
@@ -65,6 +77,8 @@ module GoodData
           end
 
           results = segments.map do |segment|
+            next if sync_failed_segment(segment.segment_id, params)
+
             if params.ads_client
               master_projects = GoodData::LCM2::Helpers.get_master_project_list_from_ads(params.release_table_name, params.ads_client, segment.segment_id)
             else
@@ -83,8 +97,7 @@ module GoodData
             failed_count = sync_result['failedClients']['count']
 
             if failed_count.to_i > 0
-              fail("#{failed_count} clients failed to synchronize. " \
-                   "Details: #{sync_result['links']['details']}")
+              error_handle(segment, res, collect_synced_status(params), params)
             end
 
             if keep_only_previous_masters_count >= 0
@@ -102,8 +115,8 @@ module GoodData
 
             {
               segment: segment.id,
-              master_pid: master.pid,
-              master_name: master.title,
+              master_pid: master.nil? ? '' : master.pid,
+              master_name: master.nil? ? '' : master.title,
               successful_count: sync_result['successfulClients']['count']
             }
           end
@@ -147,6 +160,45 @@ module GoodData
           end
         end
         # rubocop:enable Metrics/ParameterLists
+
+        private
+
+        def error_handle(segment, error_result, continue_on_error, params)
+          sync_result = error_result.json['synchronizationResult']
+          success_count = sync_result['successfulClients']['count'].to_i
+          failed_count = sync_result['failedClients']['count'].to_i
+
+          # Synchronize failure for all clients in segment
+          if continue_on_error && success_count.zero? && failed_count.positive?
+            segment_warning_message = "Failed to synchronize clients for #{segment.segment_id} segment. Details: #{sync_result['links']['details']}"
+            add_failed_segment(segment.segment_id, segment_warning_message, short_name, params)
+            return
+          end
+
+          summary_error_message = "#{failed_count} clients failed to synchronize. Details: #{sync_result['links']['details']}"
+          fail(summary_error_message) unless continue_on_error
+
+          GoodData.logger.warn summary_error_message
+          if error_result.details # rubocop:disable Style/SafeNavigation
+            error_result.details.items.each do |item|
+              next if item['status'] == 'OK'
+
+              error_client_id = item['id']
+              error_message = error_message(item, segment)
+              add_failed_client(error_client_id, error_message, short_name, params)
+            end
+          end
+        end
+
+        def error_message(error_item, segment)
+          error_client_id = error_item['id']
+          error_message = "Failed to synchronize #{error_client_id} client in #{segment.segment_id} segment."
+          error_message = "#{error_message}. Detail: #{error_item['error']['message']}" if error_item['error'] && error_item['error']['message']
+
+          error_message = "#{error_message}. Error items: #{error_item['error']['parameters']}" if error_item['error'] && error_item['error']['parameters']
+
+          error_message
+        end
       end
     end
   end

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

@@ -24,6 +24,15 @@ module GoodData
 
         description 'Logger'
         param :gdc_logger, instance_of(Type::GdLogger), required: 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 count status]
@@ -31,6 +40,8 @@ module GoodData
       class << self
         def call(params)
           results = []
+          collect_synced_status = collect_synced_status(params)
+          failed_projects = ThreadSafe::Array.new
 
           client = params.gdc_gd_client
           development_client = params.development_client
@@ -39,22 +50,36 @@ module GoodData
             from_project = info.from
             to_projects = info.to
 
-            from = development_client.projects(from_project) || fail("Invalid 'from' project specified - '#{from_project}'")
+            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
+
             dataset_mapping = from.dataset_mapping
             if dataset_mapping&.dig('datasetMappings', 'items').nil? || dataset_mapping['datasetMappings']['items'].empty?
               params.gdc_logger.info "Project: '#{from.title}', PID: '#{from.pid}' has no model mapping, skip synchronizing model mapping."
             else
               to_projects.peach do |to|
                 pid = to[:pid]
-                to_project = client.projects(pid) || fail("Invalid 'to' project specified - '#{pid}'")
+                next if sync_failed_project(pid, params)
+
+                to_project = client.projects(pid)
+                process_failed_project(pid, "Invalid 'to' project specified - '#{pid}'", failed_projects, collect_synced_status) unless to_project
 
-                params.gdc_logger.info "Transferring model mapping, from project: '#{from.title}', PID: '#{from.pid}', to project: '#{to_project.title}', PID: '#{to_project.pid}'"
+                message_to_project = "to project: '#{to_project.title}', PID: '#{to_project.pid}'"
+                params.gdc_logger.info "Transferring model mapping, from project: '#{from.title}', PID: '#{from.pid}', #{message_to_project}"
                 res = to_project.update_dataset_mapping(dataset_mapping)
                 res[:from] = from.pid
                 results << res
+
+                failed_message = "Failed to transfer model mapping from project '#{from.pid}' to project '#{to_project.pid}'"
+                process_failed_project(pid, failed_message, failed_projects, collect_synced_status) if collect_synced_status && res[:status] != 'OK'
               end
             end
           end
+
+          process_failed_projects(failed_projects, short_name, params) if collect_synced_status
           # Return results
           results.flatten
         end

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