gooddata 2.1.19-java → 2.2.0-java

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

@@ -124,6 +124,7 @@ module GoodData
           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 = []
           case mode
           when 'sync_project', 'sync_one_project_based_on_pid', 'sync_one_project_based_on_custom_id'
             if mode == 'sync_one_project_based_on_pid'
@@ -134,7 +135,9 @@ module GoodData
             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}")
-            sync_user_filters(project, user_filters, run_params, symbolized_config)
+            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?
           when 'sync_multiple_projects_based_on_pid', 'sync_multiple_projects_based_on_custom_id'
             users_by_project = run_params[:users_brick_input].group_by { |u| u[:pid] }
             user_filters.group_by { |u| u[:pid] }.flat_map.pmap do |id, new_filters|
@@ -149,7 +152,9 @@ module GoodData
               end
 
               GoodData.gd_logger.info("Synchronizing in mode=#{mode}, project_id=#{id}, data_rows=#{new_filters.size}")
-              sync_user_filters(current_project, new_filters, run_params.merge(users_brick_input: users), symbolized_config)
+              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?
             end
           when 'sync_domain_client_workspaces'
             domain_clients = all_clients
@@ -161,7 +166,6 @@ module GoodData
             working_client_ids = []
 
             users_by_project = run_params[:users_brick_input].group_by { |u| u[:pid] }
-            results = []
             user_filters.group_by { |u| u[multiple_projects_column] }.flat_map.pmap do |client_id, new_filters|
               users = users_by_project[client_id]
               fail "Client id cannot be empty" if client_id.blank?
@@ -182,7 +186,7 @@ module GoodData
 
               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])
+              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]
@@ -197,17 +201,16 @@ module GoodData
                   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])
+                  results.concat(current_results[:results]) unless current_results.nil? || current_results[:results].empty?
                 rescue StandardError => e
                   params.gdc_logger.error "Failed to clear filters of  #{c.client_id} due to: #{e.inspect}"
                 end
               end
             end
-
-            {
-              results: results
-            }
           end
+          {
+            results: results
+          }
         end
 
         def sync_user_filters(project, filters, params, filters_config)

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

@@ -0,0 +1,185 @@
+# 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'
+
+module GoodData
+  module LCM2
+    class UpdateMetricFormats < BaseAction
+      DESCRIPTION = 'Localize Metric Formats'
+
+      PARAMS = define_params(self) do
+        description 'Synchronization Info'
+        param :synchronize, array_of(instance_of(Type::SynchronizationInfoType)), required: true, generated: true
+
+        description 'Client Used for Connecting to GD'
+        param :gdc_gd_client, instance_of(Type::GdClientType), required: true
+
+        description 'Organization Name'
+        param :organization, instance_of(Type::StringType), required: false
+
+        description 'DataProduct to manage'
+        param :data_product, instance_of(Type::GDDataProductType), required: false
+
+        description 'Logger'
+        param :gdc_logger, instance_of(Type::GdLogger), required: true
+
+        description 'ADS Client'
+        param :ads_client, instance_of(Type::AdsClientType), required: false
+
+        description 'Input Source'
+        param :input_source, instance_of(Type::HashType), required: false
+
+        description 'Localization query'
+        param :localization_query, instance_of(Type::StringType), required: false
+      end
+
+      RESULT_HEADER = %i[action ok_clients error_clients]
+
+      class << self
+        def load_metric_data(params)
+          if params&.dig(:input_source, :metric_format) && params[:input_source][:metric_format].present?
+            metric_input_source = validate_input_source(params[:input_source])
+          else
+            return nil
+          end
+
+          metric_data_source = GoodData::Helpers::DataSource.new(metric_input_source)
+          begin
+            temp_csv = without_check(PARAMS, params) do
+              File.open(metric_data_source.realize(params), 'r:UTF-8')
+            end
+          rescue StandardError => e
+            GoodData.logger.warn("Unable to get metric input source, skip updating metric formats. Error: #{e.message} - #{e}")
+            return nil
+          end
+
+          metrics_hash = GoodData::Helpers::Csv.read_as_hash temp_csv
+          return nil if metrics_hash.empty?
+
+          expected_keys = %w[tag client_id format]
+          unless expected_keys.map(&:to_sym).all? { |s| metrics_hash.first.key? s }
+            GoodData.logger.warn("The input metric data is incorrect, expecting the following fields: #{expected_keys}")
+            return nil
+          end
+          metrics_hash
+        end
+
+        def validate_input_source(input_source)
+          type = input_source[:type] if input_source&.dig(:type)
+          metric_format = input_source[:metric_format]
+          raise "Incorrect configuration: 'type' of 'input_source' is required" if type.blank?
+
+          modified_input_source = input_source
+          case type
+          when 'ads', 'redshift', 'snowflake', 'bigquery', 'postgresql', 'mssql', 'mysql'
+            if metric_format[:query].blank?
+              GoodData.logger.warn("The metric input_source '#{type}' is missing property 'query'")
+              return nil
+            end
+
+            modified_input_source[:query] = metric_format[:query]
+            return modified_input_source
+          when 's3'
+            if metric_format[:file].blank?
+              GoodData.logger.warn("The metric input_source '#{type}' is missing property 'file'")
+              return nil
+            end
+
+            if modified_input_source.key?(:key)
+              modified_input_source[:key] = metric_format[:file]
+            else
+              modified_input_source[:file] = metric_format[:file]
+            end
+            return modified_input_source
+          when 'blobStorage'
+            if metric_format[:file].blank?
+              GoodData.logger.warn("The metric input_source '#{type}' is missing property 'file'")
+              return nil
+            end
+
+            modified_input_source[:file] = metric_format[:file]
+            return modified_input_source
+          when 'staging'
+            if metric_format[:file].blank?
+              GoodData.logger.warn("The metric input_source '#{type}' is missing property 'file'")
+              return nil
+            end
+
+            modified_input_source[:path] = metric_format[:file]
+            return modified_input_source
+          when 'web'
+            if metric_format[:url].blank?
+              GoodData.logger.warn("The metric input_source '#{type}' is missing property 'url'")
+              return nil
+            end
+
+            modified_input_source[:url] = metric_format[:url]
+            return modified_input_source
+          else
+            return nil
+          end
+        end
+
+        def get_clients_metrics(metric_data)
+          return {} if metric_data.nil?
+
+          metric_groups = {}
+          clients = metric_data.map { |row| row[:client_id] }.uniq
+          clients.each do |client|
+            next if client.blank?
+
+            formats = {}
+            metric_data.select { |row| row[:client_id] == client && row[:tag].present? && row[:format].present? }.each { |row| formats[row[:tag]] = row[:format] }
+            metric_groups[client.to_s] ||= formats
+          end
+          metric_groups
+        end
+
+        def call(params)
+          data = load_metric_data(params)
+          result = []
+          return result if data.nil?
+
+          metric_group = get_clients_metrics(data)
+          return result if metric_group.empty?
+
+          GoodData.logger.debug("Clients have metrics which will be modified: #{metric_group.keys}")
+          updated_clients = params.synchronize.map { |segment| segment.to.map { |client| client[:client_id] } }.flatten.uniq
+          GoodData.logger.debug("Updating clients: #{updated_clients}")
+          data_product = params.data_product
+          data_product_clients = data_product.clients
+          number_client_ok = 0
+          number_client_error = 0
+          metric_group.each do |client_id, formats|
+            next unless updated_clients.include?(client_id)
+
+            client = data_product_clients.find { |c| c.id == client_id }
+            begin
+              GoodData.logger.info("Start updating metric format for client: '#{client_id}'")
+              metrics = client.project.metrics.to_a
+              formats.each do |tag, format|
+                next if tag.blank? || format.blank?
+
+                metrics_to_be_updated = metrics.select { |metric| metric.tags.include?(tag) }
+                metrics_to_be_updated.each do |metric|
+                  metric.format = format
+                  metric.save
+                end
+              end
+              number_client_ok += 1
+              GoodData.logger.info("Finished updating metric format for client: '#{client_id}'")
+            rescue StandardError => e
+              number_client_error += 1
+              GoodData.logger.warn("Failed to update metric format for client: '#{client_id}'. Error: #{e.message} - #{e}")
+            end
+          end
+          [{ :action => 'Update metric format', :ok_clients => number_client_ok, :error_clients => number_client_error }]
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/lcm/data/delete_from_lcm_release.sql.erb

@@ -0,0 +1,5 @@
+DELETE FROM "<%= table_name || 'LCM_RELEASE' %>"
+WHERE
+  segment_id = '<%= segment_id %>'
+  AND master_project_id IN (<%= master_project_ids %>)
+;

data/lib/gooddata/lcm/helpers/release_table_helper.rb

@@ -12,6 +12,21 @@ module GoodData
 
       class << self
         def latest_master_project_from_ads(release_table_name, ads_client, segment_id)
+          sorted = get_master_project_list_from_ads(release_table_name, ads_client, segment_id)
+          sorted.last
+        end
+
+        def latest_master_project_from_nfs(domain_id, data_product_id, segment_id)
+          file_path = path_to_release_table_file(domain_id, data_product_id, segment_id)
+          sorted = get_master_project_list_from_nfs(domain_id, data_product_id, segment_id)
+          latest_master_project = sorted.last
+
+          version_info = latest_master_project ? "master_pid=#{latest_master_project[:master_project_id]} version=#{latest_master_project[:version]}" : ""
+          GoodData.gd_logger.info "Getting latest master project: file=#{file_path} domain=#{domain_id} data_product=#{data_product_id} segment=#{segment_id} #{version_info}"
+          latest_master_project
+        end
+
+        def get_master_project_list_from_ads(release_table_name, ads_client, segment_id)
           replacements = {
             table_name: release_table_name || DEFAULT_TABLE_NAME,
             segment_id: segment_id
@@ -22,18 +37,27 @@ module GoodData
 
           res = ads_client.execute_select(query)
           sorted = res.sort_by { |row| row[:version] }
-          sorted.last
+          sorted
         end
 
-        def latest_master_project_from_nfs(domain_id, data_product_id, segment_id)
+        def delete_master_project_from_ads(release_table_name, ads_client, segment_id, removal_master_project_ids)
+          replacements = {
+            table_name: release_table_name || DEFAULT_TABLE_NAME,
+            segment_id: segment_id,
+            master_project_ids: removal_master_project_ids.map { |x| "'#{x}'" } * ', '
+          }
+
+          path = File.expand_path('../data/delete_from_lcm_release.sql.erb', __dir__)
+          query = GoodData::Helpers::ErbHelper.template_file(path, replacements)
+
+          ads_client.execute(query)
+        end
+
+        def get_master_project_list_from_nfs(domain_id, data_product_id, segment_id)
           file_path = path_to_release_table_file(domain_id, data_product_id, segment_id)
           data = GoodData::Helpers::Csv.read_as_hash(file_path)
-          latest_master_project = data.sort_by { |master| master[:version] }
-              .reverse.first
-
-          version_info = latest_master_project ? "master_pid=#{latest_master_project[:master_project_id]} version=#{latest_master_project[:version]}" : ""
-          GoodData.gd_logger.info "Getting latest master project: file=#{file_path} domain=#{domain_id} data_product=#{data_product_id} segment=#{segment_id} #{version_info}"
-          latest_master_project
+          sorted = data.sort_by { |master| master[:version] }
+          sorted
         end
 
         def update_latest_master_to_nfs(domain_id, data_product_id, segment_id, master_pid, version)
@@ -46,6 +70,16 @@ module GoodData
           )
         end
 
+        def update_master_project_to_nfs(domain_id, data_product_id, segment_id, data)
+          file_path = path_to_release_table_file(domain_id, data_product_id, segment_id)
+          FileUtils.mkpath(file_path.split('/')[0...-1].join('/'))
+          CSV.open(file_path, 'w', write_headers: true, headers: data.first.keys) do |csv|
+            data.each do |r|
+              csv << r.values
+            end
+          end
+        end
+
         def path_to_release_table_file(domain_id, data_prod_id, segment_id)
           nsf_directory = ENV['RELEASE_TABLE_NFS_DIRECTORY'] || DEFAULT_NFS_DIRECTORY
           [nsf_directory, domain_id, data_prod_id + '-' + segment_id + '.csv'].join('/')

data/lib/gooddata/lcm/lcm2.rb

@@ -96,6 +96,7 @@ module GoodData
         CollectComputedAttributeMetrics,
         ImportObjectCollections,
         SynchronizeComputedAttributes,
+        SynchronizeDataSetMapping,
         SynchronizeProcesses,
         SynchronizeSchedules,
         SynchronizeColorPalette,
@@ -122,9 +123,11 @@ module GoodData
         AssociateClients,
         RenameExistingClientProjects,
         ProvisionClients,
+        UpdateMetricFormats,
         EnsureTechnicalUsersDomain,
         EnsureTechnicalUsersProject,
         CollectDymanicScheduleParams,
+        SynchronizeDataSetMapping,
         SynchronizeETLsInSegment
       ],
 
@@ -136,8 +139,10 @@ module GoodData
         EnsureTechnicalUsersDomain,
         EnsureTechnicalUsersProject,
         SynchronizeLdm,
+        SynchronizeDataSetMapping,
         MigrateGdcDateDimension,
         SynchronizeClients,
+        UpdateMetricFormats,
         SynchronizeComputedAttributes,
         CollectDymanicScheduleParams,
         SynchronizeETLsInSegment

data/lib/gooddata/mixins/md_object_query.rb

@@ -54,6 +54,7 @@ module GoodData
               y << (klass ? client.create(klass, item, project: project) : item)
             end
             break if result['objects']['paging']['count'] < page_limit
+
             offset += page_limit
           end
         end

data/lib/gooddata/models/data_source.rb

@@ -34,7 +34,7 @@ module GoodData
             c.create(DataSource, ds_data)
           end
         else
-          c.create(DataSource, c.get("#{DATA_SOURCES_URL}/#{id}"))
+          c.create(DataSource, c.get(DATA_SOURCES_URL + '/' + id))
         end
       end
 
@@ -177,6 +177,10 @@ module GoodData
       @json['dataSource']['connectionInfo'][type]
     end
 
+    def type
+      @json['dataSource']['connectionInfo'].first[0].upcase
+    end
+
     private
 
     def build_connection_info

data/lib/gooddata/models/dataset_mapping.rb

@@ -0,0 +1,36 @@
+# 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.
+
+module GoodData
+  class DatasetMapping
+    DATASET_MAPPING_GET_URI = '/gdc/dataload/projects/%<project_id>s/modelMapping/datasets'
+    DATASET_MAPPING_UPDATE_URI = '/gdc/dataload/projects/%<project_id>s/modelMapping/datasets/bulk/upsert'
+
+    class << self
+      def [](opts = { :client => GoodData.connection, :project => GoodData.project })
+        client, project = GoodData.get_client_and_project(opts)
+        get_uri = DATASET_MAPPING_GET_URI % { project_id: project.pid }
+        res = client.get(get_uri)
+        res
+      end
+
+      alias_method :get, :[]
+    end
+
+    def initialize(data)
+      @data = data
+    end
+
+    def save(opts)
+      client, project = GoodData.get_client_and_project(opts)
+
+      post_uri = DATASET_MAPPING_UPDATE_URI % { project_id: project.pid }
+      res = client.post(post_uri, @data, opts)
+      res
+    end
+  end
+end

data/lib/gooddata/models/metadata/label.rb

@@ -40,22 +40,20 @@ module GoodData
       end
     end
 
-    # Gets valid elements using /validElements? API
+    # Gets valid elements of a label for a specific paging (:offset and :limit) or get validElements of a specific value (:filter).
+    # In the case filter a specific value, because the API /validElements only filter by partial match, we need to filter again at client side for exact match.
     # @return [Array] Results
     def get_valid_elements(*args)
-      results, params = valid_elements(*args)
-      # TMA-775 - the validElements API can possibly return more matches than requested (usually 1)
-      # so we do a preliminary first request to check and then increase the limit if needed
-      if results['validElements']['paging']['total'].to_i != params[:limit]
+      if args && !args.empty? && args.first[:filter]
+        params = args.first
         params[:limit] = 100_000
         results, = valid_elements params
-        if params[:filter]
-          results['validElements']['items'] = results['validElements']['items'].reject do |i|
-            i['element']['title'] != params[:filter]
-          end
+        results['validElements']['items'] = results['validElements']['items'].select do |i|
+          i['element']['title'] == params[:filter]
         end
+      else
+        results, = valid_elements(*args)
       end
-
       results
     end
 
@@ -74,24 +72,25 @@ module GoodData
     # @option options [Number] :limit limits the number of values to certain number. Default is 100
     # @return [Array]
     def values(options = {})
-      Enumerator.new do |y|
-        offset = options[:offset] || 0
-        page_limit = options[:limit] || 100
-        loop do
-          results = get_valid_elements(limit: page_limit, offset: offset)
-
-          elements = results['validElements']
-          elements['items'].map do |el|
-            v = el['element']
-            y << {
-              :value => v['title'],
-              :uri => v['uri']
-            }
-          end
-          break if elements['items'].count < page_limit
-          offset += page_limit
+      all_values = []
+      offset = options[:offset] || 0
+      page_limit = options[:limit] || 100
+      loop do
+        results = get_valid_elements(limit: page_limit, offset: offset)
+
+        elements = results['validElements']
+        elements['items'].map do |el|
+          v = el['element']
+          all_values << {
+            :value => v['title'],
+            :uri => v['uri']
+          }
         end
+        break if elements['items'].count < page_limit
+
+        offset += page_limit
       end
+      all_values
     end
 
     def values_count
@@ -136,7 +135,7 @@ module GoodData
       if status_url
         results = client.poll_on_response(status_url) do |body|
           status = body['taskState'] && body['taskState']['status']
-          status == 'RUNNING' || status == 'PREPARED'
+          status == 'RUNNING' || status == 'PREPARED' || body['uri']
         end
       end
 

data/lib/gooddata/models/project.rb

@@ -30,6 +30,7 @@ require_relative 'process'
 require_relative 'project_log_formatter'
 require_relative 'project_role'
 require_relative 'blueprint/blueprint'
+require_relative 'dataset_mapping'
 
 require_relative 'metadata/scheduled_mail'
 require_relative 'metadata/scheduled_mail/dashboard_attachment'
@@ -255,6 +256,22 @@ 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
+
       # @param from_project The source project
       # @param to_project The target project
       # @param options Optional parameters
@@ -337,20 +354,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)
@@ -460,7 +473,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
@@ -529,6 +544,7 @@ 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]
+            schedule.trigger_execution_status = schedule_cache[schedule_spec[:trigger_execution_status]] if schedule_spec[:after]
             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')
@@ -589,7 +605,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
@@ -2022,6 +2039,14 @@ 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 transfer_processes(target)
       GoodData::Project.transfer_processes(self, target)
     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