gooddata 2.1.19-java → 2.3.0-java

data/lib/gooddata/models/project.rb

@@ -30,6 +30,8 @@ require_relative 'process'
 require_relative 'project_log_formatter'
 require_relative 'project_role'
 require_relative 'blueprint/blueprint'
+require_relative 'dataset_mapping'
+require_relative 'ldm_layout'
 
 require_relative 'metadata/scheduled_mail'
 require_relative 'metadata/scheduled_mail/dashboard_attachment'
@@ -255,6 +257,45 @@ module GoodData
         transfer_schedules(from_project, to_project)
       end
 
+      def get_dataset_mapping(from_project)
+        GoodData::DatasetMapping.get(:client => from_project.client, :project => from_project)
+      end
+
+      def update_dataset_mapping(model_mapping_json, to_project)
+        dataset_mapping = GoodData::DatasetMapping.new(model_mapping_json)
+        res = dataset_mapping.save(:client => to_project.client, :project => to_project)
+        status = res&.dig('datasetMappings', 'items').nil? ? "Failed" : "OK"
+        count = "OK".eql?(status) ? res['datasetMappings']['items'].length : 0
+        {
+          to: to_project.pid,
+          count: count,
+          status: status
+        }
+      end
+
+      def get_ldm_layout(from_project)
+        GoodData::LdmLayout.get(:client => from_project.client, :project => from_project)
+      rescue StandardError => e
+        GoodData.logger.warn "An unexpected error when get ldm layout. Error: #{e.message}"
+        GoodData::LdmLayout::DEFAULT_EMPTY_LDM_LAYOUT
+      end
+
+      def save_ldm_layout(ldm_layout_json, to_project)
+        ldm_layout = GoodData::LdmLayout.new(ldm_layout_json)
+        begin
+          ldm_layout.save(:client => to_project.client, :project => to_project)
+          status = "OK"
+        rescue StandardError => e
+          GoodData.logger.warn "An unexpected error when save ldm layout. Error: #{e.message}"
+          status = "Failed"
+        end
+
+        {
+          to: to_project.pid,
+          status: status
+        }
+      end
+
       # @param from_project The source project
       # @param to_project The target project
       # @param options Optional parameters
@@ -337,20 +378,16 @@ module GoodData
       def get_data_source_alias(data_source_id, client, aliases)
         unless aliases[data_source_id]
           data_source = GoodData::DataSource.from_id(data_source_id, client: client)
-          if data_source&.dig('dataSource', 'alias')
+          if data_source&.alias
             aliases[data_source_id] = {
-              :type => get_data_source_type(data_source),
-              :alias => data_source['dataSource']['alias']
+              :type => data_source.type,
+              :alias => data_source.alias
             }
           end
         end
         aliases[data_source_id]
       end
 
-      def get_data_source_type(data_source_data)
-        data_source_data&.dig('dataSource', 'connectionInfo') ? data_source_data['dataSource']['connectionInfo'].first[0].upcase : ""
-      end
-
       def replace_process_data_source_ids(process_data, client, aliases)
         component = process_data.dig(:process, :component)
         if component&.dig(:configLocation, :dataSourceConfig)
@@ -403,16 +440,6 @@ module GoodData
           new_group.project = to_project
           new_group.description = ug.description
           new_group.save
-          # migrate dashboard "grantees"
-          dashboards = from_project.dashboards
-          dashboards.each do |dashboard|
-            new_dashboard = to_project.dashboards.select { |dash| dash.title == dashboard.title }.first
-            next unless new_dashboard
-            grantee = dashboard.grantees['granteeURIs']['items'].select { |item| item['aclEntryURI']['grantee'].split('/').last == ug.links['self'].split('/').last }.first
-            next unless grantee
-            permission = grantee['aclEntryURI']['permission']
-            new_dashboard.grant(:member => new_group, :permission => permission)
-          end
 
           {
             from: from_project.pid,
@@ -423,6 +450,68 @@ module GoodData
         end
       end
 
+      def transfer_dashboard_permission(from_project, to_project, source_dashboards, target_dashboards)
+        source_user_groups = from_project.user_groups
+        target_user_groups = to_project.user_groups
+
+        source_dashboards.each do |source_dashboard|
+          target_dashboard = target_dashboards.select { |dash| dash.title == source_dashboard.title }.first
+          next unless target_dashboard
+
+          begin
+            source_group_dashboards = dashboard_user_groups(source_user_groups, source_dashboard)
+            target_group_dashboards = dashboard_user_groups(target_user_groups, target_dashboard)
+
+            common_group_names = source_group_dashboards.flat_map { |s| target_group_dashboards.select { |t| t[:name] == s[:name] } }.map { |x| [x[:name], true] }.to_h
+
+            remove_user_groups_from_dashboard(target_group_dashboards, target_dashboard, common_group_names)
+            add_user_groups_to_dashboard(source_group_dashboards, target_dashboard, common_group_names, target_user_groups)
+          rescue StandardError => e
+            GoodData.logger.warn "Failed to synchronize dashboard permission from project: '#{from_project.title}', PID: '#{from_project.pid}' to project: '#{to_project.title}', PID: '#{to_project.pid}', dashboard: '#{target_dashboard.title}', dashboard uri: '#{target_dashboard.uri}' . Error: #{e.message} - #{e}" # rubocop:disable Metrics/LineLength
+          end
+        end
+      end
+
+      def dashboard_user_groups(user_groups, dashboard)
+        group_dashboards = []
+        dashboard_grantees = dashboard.grantees['granteeURIs']['items'].select { |item| item['aclEntryURI']['grantee'].include?('/usergroups/') }
+
+        dashboard_grantees.each do |dashboard_grantee|
+          permission = dashboard_grantee['aclEntryURI']['permission']
+          group_id = dashboard_grantee['aclEntryURI']['grantee'].split('/').last
+          user_group = user_groups.select { |group| group.links['self'].split('/').last == group_id }.first
+          next unless user_group
+
+          group_dashboards << {
+            name: user_group.name,
+            user_group: user_group,
+            permission: permission
+          }
+        end
+        group_dashboards
+      end
+
+      def remove_user_groups_from_dashboard(group_dashboards, dashboard, common_group_names)
+        group_dashboards.each do |group_dashboard|
+          group_name = group_dashboard[:name]
+          next if common_group_names && common_group_names[group_name]
+
+          dashboard.revoke(:member => group_dashboard[:user_group], :permission => group_dashboard[:permission])
+        end
+      end
+
+      def add_user_groups_to_dashboard(group_dashboards, dashboard, common_group_names, target_user_groups)
+        group_dashboards.each do |group_dashboard|
+          group_name = group_dashboard[:name]
+          next if common_group_names && common_group_names[group_name]
+
+          target_user_group = target_user_groups.select { |group| group.name == group_name }.first
+          next unless target_user_group
+
+          dashboard.grant(:member => target_user_group, :permission => group_dashboard[:permission])
+        end
+      end
+
       # Clones project along with etl and schedules.
       #
       # @param client [GoodData::Rest::Client] GoodData client to be used for connection
@@ -430,7 +519,7 @@ module GoodData
       # Object to be cloned from. Can be either segment in which case we take
       # the master, client in which case we take its project, string in which
       # case we treat is as an project object or directly project.
-      def transfer_schedules(from_project, to_project)
+      def transfer_schedules(from_project, to_project, has_cycle_trigger = false)
         to_project_processes = to_project.processes.sort_by(&:name)
         from_project_processes = from_project.processes.sort_by(&:name)
         from_project_processes.reject!(&:add_v2_component?)
@@ -460,7 +549,9 @@ module GoodData
         local_stuff = local_schedules.map do |s|
           v = s.to_hash
           after_schedule = local_schedules.find { |s2| s.trigger_id == s2.obj_id }
-          v[:after] = s.trigger_id && after_schedule && after_schedule.name
+          after_process_schedule = from_project_processes.find { |p| after_schedule && p.obj_id == after_schedule.process_id }
+          v[:after] = s.trigger_id && after_process_schedule && after_schedule && after_schedule.name
+          v[:trigger_execution_status] = s.trigger_execution_status
           v[:remote_schedule] = s
           v[:params] = v[:params].except("EXECUTABLE", "PROCESS_ID")
           v.compact
@@ -481,15 +572,23 @@ module GoodData
         end
 
         results = []
+        update_trigger_schedules = []
         loop do # rubocop:disable Metrics/BlockLength
           break if stack.empty?
           state, changed_schedule = stack.shift
+          lazy_update_trigger_info = false
           if state == :added
             schedule_spec = changed_schedule
             if schedule_spec[:after] && !schedule_cache[schedule_spec[:after]]
-              stack << [state, schedule_spec]
-              next
+              if has_cycle_trigger
+                # The schedule is triggered by another schedule
+                lazy_update_trigger_info = true
+              else
+                stack << [state, schedule_spec]
+                next
+              end
             end
+
             remote_process, process_spec = cache.find do |_remote, local, schedule|
               (schedule_spec[:process_id] == local.process_id) && (schedule.name == schedule_spec[:name])
             end
@@ -502,8 +601,21 @@ module GoodData
             if process_spec.type != :dataload
               executable = schedule_spec[:executable] || (process_spec.type == :ruby ? 'main.rb' : 'main.grf')
             end
+
             params = schedule_parameters(schedule_spec)
-            created_schedule = remote_process.create_schedule(schedule_spec[:cron] || schedule_cache[schedule_spec[:after]], executable, params)
+
+            if lazy_update_trigger_info
+              # Temporary update nil for trigger info. The trigger info will be update late after transfer all schedules
+              created_schedule = remote_process.create_schedule(nil, executable, params)
+              update_trigger_schedules << {
+                state: :added,
+                schedule: created_schedule,
+                after: schedule_spec[:after]
+              }
+            else
+              created_schedule = remote_process.create_schedule(schedule_spec[:cron] || schedule_cache[schedule_spec[:after]], executable, params)
+            end
+
             schedule_cache[created_schedule.name] = created_schedule
 
             results << {
@@ -514,8 +626,13 @@ module GoodData
           else
             schedule_spec = changed_schedule[:new_obj]
             if schedule_spec[:after] && !schedule_cache[schedule_spec[:after]]
-              stack << [state, schedule_spec]
-              next
+              if has_cycle_trigger
+                # The schedule is triggered by another schedule
+                lazy_update_trigger_info = true
+              else
+                stack << [state, schedule_spec]
+                next
+              end
             end
 
             remote_process, process_spec = cache.find do |i|
@@ -528,7 +645,12 @@ module GoodData
 
             schedule.params = (schedule_spec[:params] || {})
             schedule.cron = schedule_spec[:cron] if schedule_spec[:cron]
-            schedule.after = schedule_cache[schedule_spec[:after]] if schedule_spec[:after]
+
+            unless lazy_update_trigger_info
+              schedule.after = schedule_cache[schedule_spec[:after]] if schedule_spec[:after]
+              schedule.trigger_execution_status = schedule_cache[schedule_spec[:trigger_execution_status]] if schedule_spec[:after]
+            end
+
             schedule.hidden_params = schedule_spec[:hidden_params] || {}
             if process_spec.type != :dataload
               schedule.executable = schedule_spec[:executable] || (process_spec.type == :ruby ? 'main.rb' : 'main.grf')
@@ -540,6 +662,15 @@ module GoodData
             schedule.save
             schedule_cache[schedule.name] = schedule
 
+            if lazy_update_trigger_info
+              update_trigger_schedules << {
+                state: :changed,
+                schedule: schedule,
+                after: schedule_spec[:after],
+                trigger_execution_status: schedule_spec[:trigger_execution_status]
+              }
+            end
+
             results << {
               state: :changed,
               process: remote_process,
@@ -548,6 +679,22 @@ module GoodData
           end
         end
 
+        if has_cycle_trigger
+          update_trigger_schedules.each do |update_trigger_schedule|
+            working_schedule = update_trigger_schedule[:schedule]
+            working_schedule.after = schedule_cache[update_trigger_schedule[:after]]
+            working_schedule.trigger_execution_status = schedule_cache[update_trigger_schedule[:trigger_execution_status]] if update_trigger_schedule[:state] == :changed
+
+            # Update trigger info
+            working_schedule.save
+
+            # Update transfer result
+            results.each do |transfer_result|
+              transfer_result[:schedule] = working_schedule if transfer_result[:schedule].obj_id == working_schedule.obj_id
+            end
+          end
+        end
+
         diff[:removed].each do |removed_schedule|
           GoodData.logger.info("Removing schedule #{removed_schedule[:name]}")
 
@@ -589,7 +736,8 @@ module GoodData
           hidden_params: schedule_spec[:hidden_params],
           name: schedule_spec[:name],
           reschedule: schedule_spec[:reschedule],
-          state: schedule_spec[:state]
+          state: schedule_spec[:state],
+          trigger_execution_status: schedule_spec[:trigger_execution_status]
         }
       end
     end
@@ -854,6 +1002,14 @@ module GoodData
       GoodData::Dashboard[id, project: self, client: client]
     end
 
+    # Helper for getting analytical dashboards (KD dashboards) of a project
+    #
+    # @param id [String | Number | Object] Anything that you can pass to GoodData::Dashboard[id]
+    # @return [GoodData::AnalyticalDashboard | Array<GoodData::AnalyticalDashboard>] dashboard instance or list
+    def analytical_dashboards(id = :all)
+      GoodData::AnalyticalDashboard[id, project: self, client: client]
+    end
+
     def data_permissions(id = :all)
       GoodData::MandatoryUserFilter[id, client: client, project: self]
     end
@@ -1780,15 +1936,15 @@ module GoodData
       end
 
       # reassign to groups
+      removal_user_group_members = []
       mappings = new_users.map(&:to_hash).flat_map do |user|
+        removal_user_group_members << user[:login] if user[:user_group]&.empty?
         groups = user[:user_group] || []
         groups.map { |g| [user[:login], g] }
       end
+
       unless mappings.empty?
-        users_lookup = users.reduce({}) do |a, e|
-          a[e.login] = e
-          a
-        end
+        users_lookup = login_users
         mappings.group_by { |_, g| g }.each do |g, mapping|
           remote_users = mapping.map { |user, _| user }.map { |login| users_lookup[login] && users_lookup[login].uri }.reject(&:nil?)
           GoodData.logger.info("Assigning users #{remote_users} to group #{g}")
@@ -1802,14 +1958,42 @@ module GoodData
         end
         mentioned_groups = mappings.map(&:last).uniq
         groups_to_cleanup = user_groups_cache.reject { |g| mentioned_groups.include?(g.name) }
+
         # clean all groups not mentioned with exception of whitelisted users
         groups_to_cleanup.each do |g|
           g.set_members(whitelist_users(g.members.map(&:to_hash), [], options[:whitelists], :include).first.map { |x| x[:uri] })
         end
       end
+
+      remove_member_from_group(users_lookup, removal_user_group_members, user_groups_cache)
       GoodData::Helpers.join(results, diff_results, [:user], [:login_uri])
     end
 
+    def remove_member_from_group(users_lookup, removal_user_group_members, user_groups_cache)
+      unless removal_user_group_members.empty?
+        users_lookup ||= login_users
+        current_user_groups = user_groups_cache || user_groups
+        removal_user_group_members.uniq.each do |login|
+          user_uri = users_lookup[login]&.uri
+
+          # remove user from group if exists as group member
+          current_user_groups.each do |user_group|
+            if user_group.member?(user_uri)
+              GoodData.logger.info("Removing #{user_uri} user from group #{user_group.name}")
+              user_group.remove_members(user_uri)
+            end
+          end
+        end
+      end
+    end
+
+    def login_users
+      users.reduce({}) do |a, e|
+        a[e.login] = e
+        a
+      end
+    end
+
     def disable_users(list, options = {})
       list = list.map(&:to_hash)
       url = "#{uri}/users"
@@ -2022,6 +2206,22 @@ module GoodData
       GoodData::Project.transfer_etl(client, self, target)
     end
 
+    def dataset_mapping
+      GoodData::Project.get_dataset_mapping(self)
+    end
+
+    def update_dataset_mapping(model_mapping_json)
+      GoodData::Project.update_dataset_mapping(model_mapping_json, self)
+    end
+
+    def ldm_layout
+      GoodData::Project.get_ldm_layout(self)
+    end
+
+    def save_ldm_layout(ldm_layout_json)
+      GoodData::Project.save_ldm_layout(ldm_layout_json, self)
+    end
+
     def transfer_processes(target)
       GoodData::Project.transfer_processes(self, target)
     end

data/lib/gooddata/models/project_creator.rb

@@ -39,6 +39,9 @@ module GoodData
           opts = { client: GoodData.connection }.merge(opts)
           dry_run = opts[:dry_run]
           replacements = opts['maql_replacements'] || opts[:maql_replacements] || {}
+          update_preference = opts[: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 && GoodData::Helpers.to_boolean(update_preference[:fallback_to_hard_sync])
 
           _, project = GoodData.get_client_and_project(opts)
 
@@ -48,6 +51,7 @@ module GoodData
             maql_diff_params = [:includeGrain]
             maql_diff_params << :excludeFactRule if opts[:exclude_fact_rule]
             maql_diff_params << :includeDeprecated if opts[:include_deprecated]
+            maql_diff_params << :includeMaqlFallbackHardSync if include_maql_fallback_hard_sync
 
             maql_diff_time = Benchmark.realtime do
               response = project.maql_diff(blueprint: bp, params: maql_diff_params)
@@ -62,7 +66,7 @@ module GoodData
           ca_maql = response['projectModelDiff']['computedAttributesScript'] if response['projectModelDiff']['computedAttributesScript']
           ca_chunks = ca_maql && ca_maql['maqlDdlChunks']
 
-          maqls = pick_correct_chunks(chunks, opts)
+          maqls = include_maql_fallback_hard_sync ? pick_correct_chunks_hard_sync(chunks, opts) : pick_correct_chunks(chunks, opts)
           replaced_maqls = apply_replacements_on_maql(maqls, replacements)
           apply_maqls(ca_chunks, project, replaced_maqls, opts) unless dry_run
           [replaced_maqls, ca_maql]
@@ -72,9 +76,11 @@ module GoodData
           errors = []
           replaced_maqls.each do |replaced_maql_chunks|
             begin
+              fallback_hard_sync = replaced_maql_chunks['updateScript']['fallbackHardSync'].nil? ? false : replaced_maql_chunks['updateScript']['fallbackHardSync']
               replaced_maql_chunks['updateScript']['maqlDdlChunks'].each do |chunk|
                 GoodData.logger.debug(chunk)
-                project.execute_maql(chunk)
+                execute_maql_result = project.execute_maql(chunk)
+                process_fallback_hard_sync_result(execute_maql_result, project) if fallback_hard_sync
               end
             rescue => e
               GoodData.logger.error("Error occured when executing MAQL, project: \"#{project.title}\" reason: \"#{e.message}\", chunks: #{replaced_maql_chunks.inspect}")
@@ -140,8 +146,8 @@ module GoodData
           preference = Hash[preference.map { |k, v| [k, GoodData::Helpers.to_boolean(v)] }]
 
           # will use new parameters instead of the old ones
-          if preference.empty? || [:allow_cascade_drops, :keep_data].any? { |k| preference.key?(k) }
-            if [:cascade_drops, :preserve_data].any? { |k| preference.key?(k) }
+          if preference.empty? || %i[allow_cascade_drops keep_data].any? { |k| preference.key?(k) }
+            if %i[cascade_drops preserve_data].any? { |k| preference.key?(k) }
               fail "Please do not mix old parameters (:cascade_drops, :preserve_data) with the new ones (:allow_cascade_drops, :keep_data)."
             end
             preference = { allow_cascade_drops: false, keep_data: true }.merge(preference)
@@ -174,8 +180,8 @@ module GoodData
           results_from_api = GoodData::Helpers.join(
             rules,
             stuff,
-            [:cascade_drops, :preserve_data],
-            [:cascade_drops, :preserve_data],
+            %i[cascade_drops preserve_data],
+            %i[cascade_drops preserve_data],
             inner: true
           ).sort_by { |l| l[:priority] } || []
 
@@ -204,6 +210,53 @@ module GoodData
           end
         end
 
+        def pick_correct_chunks_hard_sync(chunks, opts = {})
+          preference = GoodData::Helpers.symbolize_keys(opts[:update_preference] || {})
+          preference = Hash[preference.map { |k, v| [k, GoodData::Helpers.to_boolean(v)] }]
+
+          # Old configure using cascade_drops and preserve_data parameters. New configure using allow_cascade_drops and
+          # keep_data parameters. Need translate from new configure to old configure before processing
+          if preference.empty? || %i[allow_cascade_drops keep_data].any? { |k| preference.key?(k) }
+            if %i[cascade_drops preserve_data].any? { |k| preference.key?(k) }
+              fail "Please do not mix old parameters (:cascade_drops, :preserve_data) with the new ones (:allow_cascade_drops, :keep_data)."
+            end
+
+            # Default allow_cascade_drops=false and keep_data=true
+            preference = { allow_cascade_drops: false, keep_data: true }.merge(preference)
+
+            new_preference = {}
+            new_preference[:cascade_drops] = preference[:allow_cascade_drops]
+            new_preference[:preserve_data] = preference[:keep_data]
+            preference = new_preference
+          end
+          preference[:fallback_to_hard_sync] = true
+
+          # Filter chunk with fallbackHardSync = true
+          result = chunks.select do |chunk|
+            chunk['updateScript']['maqlDdlChunks'] && !chunk['updateScript']['fallbackHardSync'].nil? && chunk['updateScript']['fallbackHardSync']
+          end
+
+          # The API model/diff only returns one result for MAQL fallback hard synchronize
+          result = pick_chunks_hard_sync(result[0], preference) if !result.nil? && !result.empty?
+
+          if result.nil? || result.empty?
+            available_chunks = chunks
+                                   .map do |chunk|
+                                     {
+                                       cascade_drops: chunk['updateScript']['cascadeDrops'],
+                                       preserve_data: chunk['updateScript']['preserveData'],
+                                       fallback_hard_sync: chunk['updateScript']['fallbackHardSync'].nil? ? false : chunk['updateScript']['fallbackHardSync']
+                                     }
+                                   end
+                                   .map(&:to_s)
+                                   .join(', ')
+
+            fail "Synchronize LDM cannot proceed. Adjust your update_preferences and try again. Available chunks with preference: #{available_chunks}"
+          end
+
+          result
+        end
+
         private
 
         def apply_replacements_on_maql(maqls, replacements = {})
@@ -215,6 +268,30 @@ module GoodData
             end
           end
         end
+
+        # Fallback hard synchronize although execute result success but some cases there are errors during executing.
+        # In this cases, then export the errors to execution log as warning
+        def process_fallback_hard_sync_result(result, project)
+          messages = result['wTaskStatus']['messages']
+          if !messages.nil? && messages.size.positive?
+            warning_message = GoodData::Helpers.interpolate_error_messages(messages)
+            log_message = "Project #{project.pid} failed to preserve data, truncated data of some datasets. MAQL diff execution messages: \"#{warning_message}\""
+            GoodData.logger.warn(log_message)
+          end
+        end
+
+        # In case fallback hard synchronize, then the API model/diff only returns one result with preserve_data is always false and
+        # cascade_drops is true or false. So pick chunk for fallback hard synchronize, we will ignore the preserve_data parameter
+        # and only check the cascade_drops parameter in preference.
+        def pick_chunks_hard_sync(chunk, preference)
+          # Make sure default values for cascade_drops
+          working_preference = { cascade_drops: false }.merge(preference)
+          if working_preference[:cascade_drops] || chunk['updateScript']['cascadeDrops'] == working_preference[:cascade_drops]
+            [chunk]
+          else
+            []
+          end
+        end
       end
     end
   end

data/lib/gooddata/models/schedule.rb

@@ -101,6 +101,7 @@ module GoodData
 
         schedule.name = options[:name]
         schedule.set_trigger(trigger)
+        schedule.trigger_execution_status = options[:trigger_execution_status]
         schedule.params = default_opts[:params].merge(options[:params] || {})
         schedule.hidden_params = options[:hidden_params] || {}
         schedule.timezone = options[:timezone] || default_opts[:timezone]
@@ -468,6 +469,7 @@ module GoodData
         hidden_params: hidden_params,
         cron: cron,
         trigger_id: trigger_id,
+        trigger_execution_status: trigger_execution_status,
         timezone: timezone,
         uri: uri,
         reschedule: reschedule,
@@ -486,6 +488,16 @@ module GoodData
       self
     end
 
+    def trigger_execution_status
+      json['schedule']['triggerExecutionStatus']
+    end
+
+    def trigger_execution_status=(trigger_execution_status)
+      json['schedule']['triggerExecutionStatus'] = trigger_execution_status
+      @dirty = true
+      self # rubocop:disable Lint/Void
+    end
+
     def name
       json['schedule']['name']
     end
@@ -530,7 +542,7 @@ module GoodData
           'hiddenParams' => GoodData::Helpers.encode_hidden_params(hidden_params)
         }
       }
-
+      res['schedule']['triggerExecutionStatus'] = trigger_execution_status if trigger_execution_status
       res['schedule']['reschedule'] = reschedule if reschedule
 
       res

data/lib/gooddata/models/segment.rb

@@ -257,7 +257,8 @@ module GoodData
       res = client.poll_on_code(res['asyncTask']['links']['poll'])
       failed_count = GoodData::Helpers.get_path(res, %w(clientProjectProvisioningResult failed count), 0)
       created_count = GoodData::Helpers.get_path(res, %w(clientProjectProvisioningResult created count), 0)
-      return Enumerator.new([]) if (failed_count + created_count).zero?
+      return [].to_enum if (failed_count + created_count).zero?
+
       Enumerator.new do |y|
         uri = GoodData::Helpers.get_path(res, %w(clientProjectProvisioningResult links details))
         loop do