gooddata 2.2.0-java → 2.3.0-java

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,12 +84,27 @@ 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
@@ -92,6 +119,8 @@ module GoodData
               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 = {
@@ -102,6 +131,7 @@ module GoodData
                    }
               }
             end
+
             chunks = maql_diff['projectModelDiff']['updateScripts']
             if chunks.empty?
               GoodData.logger.info "Synchronize LDM to clients will not proceed in mode \
@@ -112,40 +142,55 @@ to force synchronize LDM to clients"
           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

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

@@ -121,7 +121,7 @@ module GoodData
             users_brick_input: params.users_brick_users
           }
           all_clients = domain.clients(:all, data_product).to_a
-          GoodData.gd_logger.info("Synchronizing in mode=#{mode}, number_of_clients=#{all_clients.size}, data_rows=#{user_filters.size}")
+          GoodData.gd_logger.info("Synchronizing in mode=#{mode}, number_of_clients=#{all_clients.size}, data_rows=#{user_filters.size} ,")
 
           GoodData.logger.info("Synchronizing in mode \"#{mode}\"")
           results = []
@@ -134,7 +134,7 @@ module GoodData
             end
             user_filters = user_filters.select { |f| f[:pid] == filter } if filter
 
-            GoodData.gd_logger.info("Synchronizing in mode=#{mode}, project_id=#{project.pid}, data_rows=#{user_filters.size}")
+            GoodData.gd_logger.info("Synchronizing in mode=#{mode}, project_id=#{project.pid}, data_rows=#{user_filters.size} ,")
             current_results = sync_user_filters(project, user_filters, run_params, symbolized_config)
 
             results.concat(current_results[:results]) unless current_results.nil? || current_results[:results].empty?
@@ -151,7 +151,7 @@ module GoodData
                 current_project = client.projects(id)
               end
 
-              GoodData.gd_logger.info("Synchronizing in mode=#{mode}, project_id=#{id}, data_rows=#{new_filters.size}")
+              GoodData.gd_logger.info("Synchronizing in mode=#{mode}, project_id=#{id}, data_rows=#{new_filters.size} ,")
               current_results = sync_user_filters(current_project, new_filters, run_params.merge(users_brick_input: users), symbolized_config)
 
               results.concat(current_results[:results]) unless current_results.nil? || current_results[:results].empty?
@@ -164,6 +164,7 @@ module GoodData
             end
 
             working_client_ids = []
+            semaphore = Mutex.new
 
             users_by_project = run_params[:users_brick_input].group_by { |u| u[:pid] }
             user_filters.group_by { |u| u[multiple_projects_column] }.flat_map.pmap do |client_id, new_filters|
@@ -182,23 +183,26 @@ module GoodData
               current_project = c.project
               fail "Client #{client_id} does not have project." unless current_project
 
-              working_client_ids << client_id
+              semaphore.synchronize do
+                working_client_ids << client_id.to_s
+              end
 
-              GoodData.gd_logger.info("Synchronizing in mode=#{mode}, client_id=#{client_id}, data_rows=#{new_filters.size}")
+              GoodData.gd_logger.info("Synchronizing in mode=#{mode}, client_id=#{client_id}, data_rows=#{new_filters.size} ,")
               partial_results = sync_user_filters(current_project, new_filters, run_params.merge(users_brick_input: users), symbolized_config)
               results.concat(partial_results[:results]) unless partial_results.nil? || partial_results[:results].empty?
             end
 
-            unless run_params[:do_not_touch_filters_that_are_not_mentioned]
-              domain_clients.peach do |c|
-                next if working_client_ids.include?(c.client_id)
+            GoodData.gd_logger.info("Synchronizing in mode=#{mode}, working_client_ids=#{working_client_ids.join(', ')} ,") if working_client_ids.size < 50
 
+            unless run_params[:do_not_touch_filters_that_are_not_mentioned]
+              to_be_deleted_clients = UserBricksHelper.non_working_clients(domain_clients, working_client_ids)
+              to_be_deleted_clients.peach do |c|
                 begin
                   current_project = c.project
                   users = users_by_project[c.client_id]
                   params.gdc_logger.info "Delete all filters in project #{current_project.pid} of client #{c.client_id}"
 
-                  GoodData.gd_logger.info("Delete all filters in project_id=#{current_project.pid}, client_id=#{c.client_id}")
+                  GoodData.gd_logger.info("Delete all filters in project_id=#{current_project.pid}, client_id=#{c.client_id} ,")
                   current_results = sync_user_filters(current_project, [], run_params.merge(users_brick_input: users), symbolized_config)
 
                   results.concat(current_results[:results]) unless current_results.nil? || current_results[:results].empty?
@@ -208,6 +212,7 @@ module GoodData
               end
             end
           end
+
           {
             results: results
           }

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

@@ -27,11 +27,22 @@ 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
         def call(params)
           results = ThreadSafe::Array.new
+          collect_synced_status = collect_synced_status(params)
+          failed_projects = ThreadSafe::Array.new
 
           client = params.gdc_gd_client
           development_client = params.development_client
@@ -40,17 +51,32 @@ 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
 
             to_projects.peach do |entry|
               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
 
-              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)
+              begin
+                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)
+              rescue StandardError => err
+                process_failed_project(pid, err.message, failed_projects, collect_synced_status)
+              end
             end
           end
 
+          process_failed_projects(failed_projects, short_name, params) if collect_synced_status
           results.uniq
         end
       end

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

@@ -190,7 +190,7 @@ module GoodData
             create_non_existing_user_groups: create_non_existing_user_groups,
             user_groups_cache: nil
           }
-          GoodData.gd_logger.info("Synchronizing in mode=#{mode}, data_rows=#{new_users.size}")
+          GoodData.gd_logger.info("Synchronizing in mode=#{mode}, data_rows=#{new_users.size} ,")
 
           GoodData.logger.info("Synchronizing in mode \"#{mode}\"")
           results = case mode
@@ -202,7 +202,7 @@ module GoodData
                       params.gdc_logger.info "#{user_ids.count - users.count} users were not found (or were deleted) in domain #{domain_name}" if user_ids.count > users.count
                       params.gdc_logger.warn "Deleting #{users.count} users from domain #{domain_name}"
 
-                      GoodData.gd_logger.info("Synchronizing in mode=#{mode}, domain=#{domain_name}, data_rows=#{users.count}")
+                      GoodData.gd_logger.info("Synchronizing in mode=#{mode}, domain=#{domain_name}, data_rows=#{users.count} ,")
                       users.map(&:delete)
                     when 'sync_project'
                       project.import_users(new_users, common_params)
@@ -211,7 +211,7 @@ module GoodData
                         begin
                           project = client.projects(project_id)
 
-                          GoodData.gd_logger.info("Synchronizing in mode=#{mode}, project_id=#{project_id}, data_rows=#{users.count}")
+                          GoodData.gd_logger.info("Synchronizing in mode=#{mode}, project_id=#{project_id}, data_rows=#{users.count} ,")
                           project.import_users(users, common_params)
                         rescue RestClient::ResourceNotFound
                           fail "Project \"#{project_id}\" was not found. Please check your project ids in the source file"
@@ -224,7 +224,7 @@ module GoodData
                     when 'sync_one_project_based_on_pid'
                       filtered_users = new_users.select { |u| u[:pid] == project.pid }
 
-                      GoodData.gd_logger.info("Synchronizing in mode=#{mode}, data_rows=#{filtered_users.count}")
+                      GoodData.gd_logger.info("Synchronizing in mode=#{mode}, data_rows=#{filtered_users.count} ,")
                       project.import_users(filtered_users, common_params)
                     when 'sync_one_project_based_on_custom_id'
                       filter_value = UserBricksHelper.resolve_client_id(domain, project, data_product)
@@ -245,7 +245,7 @@ module GoodData
                       end
 
                       GoodData.logger.info("Project #{project.pid} will receive #{filtered_users.count} from #{new_users.count} users")
-                      GoodData.gd_logger.info("Synchronizing in mode=#{mode}, project_id=#{project.pid}, filtered_users=#{filtered_users.count}, data_rows=#{new_users.count}")
+                      GoodData.gd_logger.info("Synchronizing in mode=#{mode}, project_id=#{project.pid}, filtered_users=#{filtered_users.count}, data_rows=#{new_users.count} ,")
                       project.import_users(filtered_users, common_params)
                     when 'sync_multiple_projects_based_on_custom_id'
                       all_clients = domain.clients(:all, data_product).to_a
@@ -260,7 +260,7 @@ module GoodData
 
                         GoodData.logger.info("Project #{project.pid} of client #{client_id} will receive #{users.count} users")
 
-                        GoodData.gd_logger.info("Synchronizing in mode=#{mode}, project_id=#{project.pid}, data_rows=#{users.count}")
+                        GoodData.gd_logger.info("Synchronizing in mode=#{mode}, project_id=#{project.pid}, data_rows=#{users.count} ,")
                         project.import_users(users, common_params)
                       end
                     when 'sync_domain_client_workspaces'
@@ -294,7 +294,7 @@ module GoodData
                         working_client_ids << client_id.to_s
                         GoodData.logger.info("Project #{project.pid} of client #{client_id} will receive #{users.count} users")
 
-                        GoodData.gd_logger.info("Synchronizing in mode=#{mode}, project_id=#{project.pid}, data_rows=#{users.count}")
+                        GoodData.gd_logger.info("Synchronizing in mode=#{mode}, project_id=#{project.pid}, data_rows=#{users.count} ,")
                         project.import_users(users, common_params)
                       end
 
@@ -319,17 +319,17 @@ module GoodData
                           end
                           GoodData.logger.info("Synchronizing all users in project #{project.pid} of client #{c.client_id}")
 
-                          GoodData.gd_logger.info("Synchronizing all users in project_id=#{project.pid}, client_id=#{c.client_id}")
+                          GoodData.gd_logger.info("Synchronizing all users in project_id=#{project.pid}, client_id=#{c.client_id} ,")
                           res += project.import_users([], common_params)
                         end
                       end
 
                       res
                     when 'sync_domain_and_project'
-                      GoodData.gd_logger.info("Create users in mode=#{mode}, data_rows=#{new_users.count}")
+                      GoodData.gd_logger.info("Create users in mode=#{mode}, data_rows=#{new_users.count} ,")
                       domain.create_users(new_users, ignore_failures: ignore_failures)
 
-                      GoodData.gd_logger.info("Import users in mode=#{mode}, data_rows=#{new_users.count}")
+                      GoodData.gd_logger.info("Import users in mode=#{mode}, data_rows=#{new_users.count} ,")
                       project.import_users(new_users, common_params)
                     end
 
@@ -390,6 +390,7 @@ module GoodData
 
             user_group = row[user_groups_column] || row[user_groups_column.to_sym]
             user_group = user_group.split(',').map(&:strip) if user_group
+            user_group = [] if row.headers.include?(user_groups_column) && !user_group
 
             ip_whitelist = row[ip_whitelist_column] || row[ip_whitelist_column.to_sym]
             ip_whitelist = ip_whitelist.split(',').map(&:strip) if ip_whitelist