gooddata 1.0.0-java

data/lib/gooddata/models/project_role.rb

@@ -0,0 +1,79 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2017 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 'pmap'
+
+require_relative 'profile'
+
+require_relative '../rest/rest'
+
+require_relative '../mixins/rest_resource'
+
+module GoodData
+  class ProjectRole < Rest::Resource
+    include Mixin::Author
+    include Mixin::Contributor
+    include Mixin::Timestamps
+
+    EMPTY_OBJECT = {
+      'projectRole' => {
+        'permissions' => {},
+        'links' => {},
+        'meta' => {}
+      }
+    }
+
+    def self.create_object(data)
+      meta_data = {}.tap do |d|
+        d[:created] = data[:created] || Time.now
+        d[:identifier] = data[:identifier]
+        d[:updated] = data[:updated] || d[:created] || Time.now
+        d[:title] = data[:title]
+        d[:summary] = data[:summary]
+      end
+      new_data = GoodData::Helpers.deep_dup(EMPTY_OBJECT).tap do |d|
+        d['projectRole']['links']['self'] = data[:uri] if data[:uri]
+        d['projectRole']['meta'] = d['projectRole']['meta'].merge(GoodData::Helpers.stringify_keys(meta_data))
+        d['projectRole']['permissions'] = d['projectRole']['permissions'].merge(GoodData::Helpers.stringify_keys(data[:permissions] || {}))
+      end
+      new(new_data)
+    end
+
+    def initialize(json)
+      @json = json
+    end
+
+    data_property_reader :permissions
+
+    metadata_property_reader :identifier, :title, :summary
+
+    # Gets Users with this Role
+    #
+    # @return [Array<GoodData::Profile>] List of users
+    def users
+      url = data['links']['roleUsers']
+      tmp = client.get url
+      tmp['associatedUsers']['users'].pmap do |user_url|
+        url = user_url
+        user = client.get url
+        client.create(GoodData::Profile, user)
+      end
+    end
+
+    # Gets Raw object URI
+    #
+    # @return [string] URI of this project role
+    def uri
+      return @json['projectRole']['links']['self'] if @json['projectRole']['links']['self']
+      return nil unless @json['projectRole']['links']['roleUsers']
+      @json['projectRole']['links']['roleUsers'].split('/')[0...-1].join('/')
+    end
+
+    def ==(other)
+      uri == other.uri
+    end
+  end
+end

data/lib/gooddata/models/report_data_result.rb

@@ -0,0 +1,270 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2017 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 ReportDataResult < Rest::Resource
+    class << self
+      # Does all the needed parsing on the apyload coming from the API and returns an instance of ReportDataResult
+      #
+      # @param [Hash] data Data coming from the API
+      # @return [GoodData::ReportDataResult] Returns new report data result
+      def from_xtab(data)
+        top = top_headers(data)
+        left = left_headers(data)
+        jank = GoodData::Helpers.zeroes(rows(top), cols(left), nil)
+        d = data(data)
+        stuff = d.empty? ? GoodData::Helpers.zeroes(rows(left), cols(top), nil) : d
+
+        a = jank.zip(top).map { |x, y| x + y }
+        b = left.zip(stuff).map { |x, y| x + y }
+        result = a + b
+        ReportDataResult.new(data: result, top: rows(top), left: cols(left))
+      end
+
+      private
+
+      def line(child)
+        children = child['children'] || []
+        return (child['first']..child['last']).to_a.map { [child['id']] } if children.empty?
+        children.flat_map { |c| line(c) }.map do |x|
+          child['id'].nil? ? x : [child['id']] + x
+        end
+      end
+
+      def root_line(root)
+        lookups = root['lookups']
+        header = line(root['tree'])
+        header.map { |l| l.each_with_index.map { |item, index| lookups[index][item] } }
+      end
+
+      def top_headers(data)
+        root = data['xtab_data']['columns']
+        root_line(root).transpose
+      end
+
+      def left_headers(data)
+        root = data['xtab_data']['rows']
+        root_line(root)
+      end
+
+      def cols(stuff)
+        stuff.first.count
+      end
+
+      def rows(stuff)
+        stuff.count
+      end
+
+      def data(data)
+        data['xtab_data']['data'].map { |row| row.map { |i| i ? BigDecimal(i) : i } }
+      end
+    end
+
+    # Returns
+    #
+    # @param [Hash] opts Data for the report
+    # @option opts [Array<Array>] :data The data as a matrix. First rows then cols
+    # @option opts [Number] :top Number of rows that are representing the top header
+    # @option opts [Number] :left Number of cols that are representing the left header
+    # @return [GoodData::ReportDataResult] Returns new report data result
+    def initialize(opts)
+      @data = opts[:data]
+      @top_headers_rows_nums = opts[:top]
+      @left_headers_cols_nums = opts[:left]
+    end
+
+    # Gives you new report result with top headers removed
+    #
+    # @return [GoodData::ReportDataResult] Returns new report data result
+    def without_top_headers
+      slice(@top_headers_rows_nums, 0)
+    end
+
+    # Gives you new report result with left headers removed
+    #
+    # @return [GoodData::ReportDataResult] Returns new report data result
+    def without_left_headers
+      slice(0, @left_headers_cols_nums)
+    end
+
+    # Gives you left headers as an Array
+    #
+    # @return [Array] Return left headers as Array of Arrays. The notation is of a matrix. First rows then cols.
+    def left_headers
+      return nil if @left_headers_cols_nums.zero?
+      top = @left_headers_cols_nums - 1
+      without_top_headers.slice(0, [0, top]).to_a
+    end
+
+    # Gives you right headers as an Array
+    #
+    # @return [Array] Return top headers as Array of Arrays. The notation is of a matrix. First rows then cols.
+    def top_headers
+      return nil if @top_headers_rows_nums.zero?
+      top = @top_headers_rows_nums - 1
+      without_left_headers.slice([0, top], 0).to_a
+    end
+
+    # Gives you data as a new ReportDataResult
+    #
+    # @return [Array] Return left headers as Array of Arrays. The notation is of a matrix. First rows then cols.
+    def data
+      slice(@top_headers_rows_nums, @left_headers_cols_nums)
+    end
+
+    def each
+      to_a.each
+    end
+    alias_method :each_line, :each
+    alias_method :each_row, :each
+
+    def each_column
+      size.last.times.map do |i|
+        col = map { |row| row[i] }
+        yield(col)
+      end
+    end
+
+    # Gives you data as a new ReportDataResult
+    #
+    # @return [Array] Return left headers as Array of Arrays. The notation is of a matrix. First rows then cols.
+    def to_a
+      @data
+    end
+    alias_method :to_table, :to_a
+
+    # Gives report as a table suitable for printing out
+    #
+    # @return [String]
+    def to_s(options = {})
+      with_indices = options[:index]
+
+      a = to_table.to_a
+      data = a.transpose
+      data.unshift((1..a.length).to_a) if with_indices
+      processed_data = data.each_with_index.map do |col, i|
+        col.unshift(i.zero? ? nil : i) if with_indices # inserts row labels #
+        w = col.map { |cell| cell.to_s.length }.max # w = "column width" #
+        col.each_with_index.map do |cell, j|
+          j.zero? ? cell.to_s.center(w) : cell.to_s.ljust(w)
+        end # alligns the column #
+      end
+      processed_data.transpose.map { |row| "[#{row.join(' | ')}]" }.unshift('').join("\n")
+    end
+
+    # Allows to pick particular row inside the report result
+    #
+    # @return [Array] Returns a row of data
+    def [](index)
+      @data[index]
+    end
+    alias_method :row, :[]
+
+    # Allows to pick particular column inside the report result
+    #
+    # @return [Array] Returns a column of data. The column is returned transposed
+    def column(index)
+      transpose[index]
+    end
+
+    # Is the report without any data? This can be caused by the fact that the filters are too restrictive or data are not loaded in
+    #
+    # @return [Array] Returns true if data result is empty
+    def empty?
+      row, cols = size
+      row.zero? && cols.zero?
+    end
+
+    # Allows you to test if a report contains a row.
+    #
+    # @param [Array<String | Number>] row Row that you want to test.
+    # It is looking for the whole row. If the headers are getting in the way
+    # use #without_left_headers or #without_top_headers
+    # @return [Array] Returns true if data are inside a report
+    def include_row?(row)
+      @data.include?(row)
+    end
+
+    # Allows you to test if a report contains a column.
+    #
+    # @param [Array<String | Number>] row Row that you want to test.
+    # It is looking for the whole row. If the headers are getting in the way
+    # use #without_left_headers or #without_top_headers
+    # @return [Array] Returns true if data are inside a report
+    def include_column?(col)
+      transpose.include_row?(col)
+    end
+
+    # Returns the size of the report
+    #
+    # @return [Array<Number>] The size of the report result as an array. First element is rows second is columns
+    def size
+      [@data.size, @data.empty? ? 0 : @data.first.size]
+    end
+
+    # Transposes data and returns as new data result
+    #
+    # @return [GoodData::ReportDataResult] Returns new report data result with flipped columns and rows
+    def transpose
+      ReportDataResult.new(data: to_a.transpose, top: @left_headers_cols_nums, left: @top_headers_rows_nums)
+    end
+
+    # Gives you report result with a subset of data starting at position rows, cols
+    #
+    # @param [Number] rows Position where you want to slice your row. Currently accepts only number
+    # @param [Number] cols Position where you want to slice your row. Currently accepts only number
+    # @return [GoodData::ReportDataResult] Returns new report data result sliced data
+    def slice(rows, cols)
+      rows = rows.is_a?(Enumerable) ? rows : [rows, size.first]
+      cols = cols.is_a?(Enumerable) ? cols : [cols, size.last]
+      new_data = @data[rows.first..rows.last].map { |col| col[cols.first..cols.last] }
+      if client
+        client.create(ReportDataResult, data: new_data, top: @top_headers_rows_nums - rows.first, left: @left_headers_cols_nums - cols.first, project: project)
+      else
+        ReportDataResult.new(data: new_data, top: @top_headers_rows_nums - rows.first, left: @left_headers_cols_nums - cols.first, project: project)
+      end
+    end
+
+    # Returns the size of the the data portion of report
+    #
+    # @return [Array<Number>] The size of the report result as an array. First element is rows second is columns
+    def data_size
+      data.size
+    end
+
+    def ==(other)
+      return false if size != other.size
+      @data == other.to_a
+    end
+
+    def eq?(other)
+      self == other
+    end
+
+    # Implements subtraction. Works only on reports that have same number of columns. Gives you columns that are not in other.
+    #
+    # @param [GoodData::ReportDataResult] other The other report result
+    # @return [Array<Array>] Returns rows that are not contained in other
+    def -(other)
+      fail 'Seems you are not using a data result as a parameter' unless other.respond_to?(:size)
+      message = 'Results do not have compatible sizes. Subtracting the dataresults works row wise so you have to have the same number of columns'
+      fail message if size.last != other.size.last
+      to_a - other.to_a
+    end
+
+    # Implements diff. Works only on reports that have same number of columns (because it uses #- behind the scene).
+    #
+    # @param [GoodData::ReportDataResult] other The other report result
+    # @return [Hash] Returns a hash that gives you the differences in the report results
+    def diff(other)
+      {
+        added: other - self,
+        removed: self - other,
+        same: @data & other.to_a
+      }
+    end
+  end
+end

data/lib/gooddata/models/schedule.rb

@@ -0,0 +1,538 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2017 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 '../rest/resource'
+require_relative '../extensions/hash'
+require_relative '../mixins/rest_resource'
+require_relative '../helpers/global_helpers'
+
+require_relative 'execution'
+
+module GoodData
+  class Schedule < Rest::Resource
+    attr_reader :dirty, :json
+
+    SCHEDULE_TEMPLATE = {
+      :schedule => {
+        :type => nil,
+        :timezone => nil,
+        :params => {},
+        :hiddenParams => {},
+        # :reschedule => nil
+      }
+    }
+
+    class << self
+      # Looks for schedule
+      # @param id [String] URL, ID of schedule or :all
+      # @return [GoodData::Schedule|Array<GoodData::Schedule>] List of schedules
+      def [](id, opts = { :client => GoodData.connection, :project => GoodData.project })
+        c, project = GoodData.get_client_and_project(opts)
+
+        if id == :all
+          GoodData::Schedule.all(opts)
+        else
+          if id =~ %r{\/gdc\/projects\/[a-zA-Z\d]+\/schedules\/?[a-zA-Z\d]*}
+            url = id
+            tmp = c.get url
+            return c.create(GoodData::Schedule, tmp)
+          end
+
+          tmp = c.get "/gdc/projects/#{project.pid}/schedules/#{id}"
+          c.create(GoodData::Schedule, tmp, project: project)
+        end
+      end
+
+      # Returns list of all schedules for active project
+      # @return [Array<GoodData::Schedule>] List of schedules
+      def all(opts = { :client => GoodData.connection, :project => GoodData.project })
+        c, project = GoodData.get_client_and_project(opts)
+
+        tmp = c.get "/gdc/projects/#{project.pid}/schedules"
+        tmp['schedules']['items'].map { |schedule| c.create(GoodData::Schedule, schedule, project: project) }
+      end
+
+      # Creates new schedules from parameters passed
+      #
+      # @param process_id [String] Process ID
+      # @param trigger [String|GoodData::Schedule] Trigger of schedule. Can be cron string or reference to another schedule.
+      # @param executable [String] Execution executable
+      # @param options [Hash] Optional options
+      # @return [GoodData::Schedule] New GoodData::Schedule instance
+      def create(process_id, trigger, executable, options = {})
+        c, project = GoodData.get_client_and_project(options)
+
+        fail 'Process ID has to be provided' if process_id.blank?
+
+        is_dataload_process = Process[process_id, project: project, client: c].type == :dataload
+
+        if is_dataload_process
+          dataload_datasets = options[:dataload_datasets] || options['GDC_DATALOAD_DATASETS']
+          dataload_datasets = '[]' unless dataload_datasets
+
+          de_synchronize_all = options[:de_synchronize_all] || options['GDC_DE_SYNCHRONIZE_ALL']
+        else
+          fail 'Executable has to be provided' if executable.blank?
+        end
+        fail 'Trigger schedule has to be provided' if trigger.blank?
+
+        schedule = c.create(GoodData::Schedule, GoodData::Helpers.stringify_keys(GoodData::Helpers.deep_dup(SCHEDULE_TEMPLATE)), client: c, project: project)
+
+        params = { 'PROCESS_ID' => process_id }
+        if is_dataload_process
+          params['GDC_DATALOAD_DATASETS'] = dataload_datasets
+          params['GDC_DE_SYNCHRONIZE_ALL'] = de_synchronize_all if de_synchronize_all
+        else
+          params['EXECUTABLE'] = executable
+        end
+
+        default_opts = {
+          :type => 'MSETL',
+          :timezone => 'UTC',
+          :state => 'ENABLED',
+          :params => params,
+          # :reschedule => nil
+        }
+
+        schedule.name = options[:name]
+        schedule.set_trigger(trigger)
+        schedule.params = default_opts[:params].merge(options[:params] || {})
+        schedule.hidden_params = options[:hidden_params] || {}
+        schedule.timezone = options[:timezone] || default_opts[:timezone]
+        schedule.state = options[:state] || default_opts[:state]
+        schedule.schedule_type = options[:type] || default_opts[:type]
+        schedule.reschedule = options[:reschedule] if options[:reschedule]
+        schedule
+      end
+    end
+
+    # Initializes object from raw json
+    #
+    # @param json [Object] Raw JSON
+    # @return [GoodData::Schedule] New GoodData::Schedule instance
+    def initialize(json)
+      json = GoodData::Helpers.stringify_keys(json)
+      super
+      @json = json
+      self.params = GoodData::Helpers.decode_params(json['schedule']['params'] || {})
+      self.hidden_params = GoodData::Helpers.decode_params(json['schedule']['hiddenParams'] || {})
+    end
+
+    def after
+      project.schedules(trigger_id) if trigger_id
+    end
+
+    def after=(schedule)
+      fail 'After trigger has to be a schedule object' unless schedule.is_a?(Schedule)
+      json['schedule']['triggerScheduleId'] = schedule.obj_id
+      @json['schedule']['cron'] = nil
+      @dirty = true
+    end
+
+    # Deletes schedule
+    def delete
+      saved? ? client.delete(uri) : nil
+    end
+
+    # Disables the schedule.
+    #
+    # @return [GoodData::Schedule]
+    def disable
+      @json['schedule']['state'] = 'DISABLED'
+      @dirty = true
+      self
+    end
+
+    # Disables and saves the schedule.
+    #
+    # @return [Boolean]
+    def disable!
+      disable
+      save
+    end
+
+    # Is schedule disabled?
+    #
+    # @return [Boolean]
+    def disabled?
+      state == 'DISABLED'
+    end
+
+    # Is schedule enabled?
+    #
+    # @return [Boolean]
+    def enabled?
+      !disabled?
+    end
+
+    # Enables the schedule
+    #
+    # @return [GoodData::Schedule]
+    def enable
+      @json['schedule']['state'] = 'ENABLED'
+      @dirty = true
+      self
+    end
+
+    # Enables and saves the schedule
+    #
+    # @return [GoodData::Schedule]
+    def enable!
+      enable
+      save
+    end
+
+    # Executes schedule
+    #
+    # @param [Hash] opts execution options.
+    # @option opts [Boolean] :wait Wait for execution result
+    # @return [Object] Raw Response
+    def execute(opts = {})
+      return nil unless saved?
+      opts = { :wait => true }.merge(opts)
+      data = {
+        :execution => {}
+      }
+      res = client.post(execution_url, data)
+      execution = client.create(GoodData::Execution, res, client: client, project: project)
+
+      return execution unless opts[:wait]
+      execution.wait_for_result(opts)
+    end
+
+    # Returns execution URL
+    #
+    # @return [String] Executions URL
+    def execution_url
+      saved? ? @json['schedule']['links']['executions'] : nil
+    end
+
+    # Returns execution state
+    #
+    # @return [String] Execution state
+    def state
+      @json['schedule']['state']
+    end
+
+    def state=(a_state)
+      @json['schedule']['state'] = a_state
+    end
+
+    # Returns execution timezone
+    #
+    # @return [String] Execution timezone
+    def timezone
+      @json['schedule']['timezone']
+    end
+
+    # Assigns execution timezone
+    #
+    # @param new_timezone [String] Timezone to be set
+    def timezone=(new_timezone)
+      @json['schedule']['timezone'] = new_timezone
+      @dirty = true
+    end
+
+    # Returns execution type
+    #
+    # @return [String] Execution type
+    def type
+      @json['schedule']['type']
+    end
+
+    # Assigns execution type
+    #
+    # @param new_type [String] Execution type to be set
+    def type=(new_type)
+      @json['schedule']['type'] = new_type
+      @dirty = true
+    end
+
+    # Returns execution cron settings
+    #
+    # @return [String] Cron settings
+    def cron
+      @json['schedule']['cron']
+    end
+
+    # Assigns execution cron settings
+    #
+    # @param new_cron [String] Cron settings to be set
+    def cron=(new_cron)
+      @json['schedule']['cron'] = new_cron
+      @json['schedule']['triggerScheduleId'] = nil
+      @dirty = true
+    end
+
+    # Returns reschedule settings
+    #
+    # @return [Integer] Reschedule settings
+    def reschedule
+      @json['schedule']['reschedule']
+    end
+
+    # Assigns execution reschedule settings
+    #
+    # @param new_reschedule [Integer] Reschedule settings to be set
+    def reschedule=(new_reschedule)
+      @json['schedule']['reschedule'] = new_reschedule
+      @dirty = true
+    end
+
+    # Returns execution process related to this schedule
+    #
+    # @return [GoodData::Process] Process ID
+    def process
+      project.processes(process_id)
+    end
+
+    # Returns execution process ID
+    #
+    # @return [String] Process ID
+    def process_id
+      @json['schedule']['params']['PROCESS_ID']
+    end
+
+    def process_id=(new_project_id)
+      @json['schedule']['params']['PROCESS_ID'] = new_project_id
+      @dirty = true
+    end
+
+    # Returns execution executable
+    #
+    # @return [String] Executable (graph) name
+    def executable
+      @json['schedule']['params']['EXECUTABLE']
+    end
+
+    # Assigns execution executable
+    #
+    # @param new_executable [String] Executable to be set.
+    def executable=(new_executable)
+      @json['schedule']['params']['EXECUTABLE'] = new_executable
+      @dirty = true
+    end
+
+    # Returns enumerator of executions
+    #
+    # @return [Array] Raw Executions JSON
+    def executions
+      return nil unless @json
+      url = @json['schedule']['links']['executions']
+      Enumerator.new do |y|
+        loop do
+          res = client.get url
+          res['executions']['paging']['next']
+          res['executions']['items'].each do |execution|
+            y << client.create(Execution, execution, :project => project)
+          end
+          url = res['executions']['paging']['next']
+          break unless url
+        end
+      end
+    end
+
+    # Returns hidden_params as Hash
+    #
+    # @return [Hash] Hidden Parameters
+    def hidden_params
+      @json['schedule']['hiddenParams']
+    end
+
+    # Updates params by merging the current params with new ones
+    #
+    # @param params_to_merge [Hash] params
+    # @return [GoodData::Schedule] Returns self
+    def update_params(params_to_merge)
+      params_to_merge.each do |k, v|
+        set_parameter(k, v)
+      end
+      @dirty = true
+      self
+    end
+
+    # Updates hidden params by merging the current params with new ones
+    #
+    # @param params_to_merge [Hash] params
+    # @return [GoodData::Schedule] Returns self
+    def update_hidden_params(params_to_merge)
+      params_to_merge.each do |k, v|
+        set_hidden_parameter(k, v)
+      end
+      @dirty = true
+      self
+    end
+
+    # Assigns hidden parameters
+    #
+    # @param new_hidden_param [String] Hidden parameters to be set
+    def hidden_params=(new_hidden_params = {})
+      @json['schedule']['hiddenParams'] = GoodData::Helpers.stringify_values(new_hidden_params)
+      @dirty = true
+      self
+    end
+
+    # Returns params as Hash
+    #
+    # @return [Hash] Parameters
+    def params
+      @json['schedule']['params']
+    end
+
+    # Assigns execution parameters
+    #
+    # @param params [String] Params to be set
+    def params=(new_params = {})
+      default_params = {
+        'PROCESS_ID' => process_id,
+        'EXECUTABLE' => executable
+      }
+      @json['schedule']['params'] = default_params.merge(GoodData::Helpers.stringify_values(new_params))
+      @dirty = true
+      self
+    end
+
+    def rewrite_deprecated_params
+      params['EXECUTABLE'] = params.delete('GRAPH') if params['GRAPH']
+    end
+
+    # Saves object if dirty
+    #
+    # @return [Boolean] True if saved
+    def save
+      fail 'trigger schedule has to be provided' if cron.blank? && trigger_id.blank?
+      fail 'A timezone has to be provided' if timezone.blank?
+      fail 'Schedule type has to be provided' if schedule_type.blank?
+      rewrite_deprecated_params
+      if @dirty
+        if saved?
+          res = client.put(uri, to_update_payload)
+          @json = Schedule.new(res).json
+        else
+          res = client.post "/gdc/projects/#{project.pid}/schedules", to_update_payload
+          fail 'Unable to create new schedule' if res.nil?
+          new_obj_json = client.get res['schedule']['links']['self']
+          @json = Schedule.new(new_obj_json).json
+        end
+        @dirty = false
+      end
+      self
+    end
+
+    # Updates params at key k with val v
+    #
+    # @param k [String] key
+    # @param v [Object] value
+    # @return [GoodData::Schedule] Returns self
+    def set_parameter(k, v)
+      params[k] = v
+      @dirty = true
+      self
+    end
+
+    # Updates hidden params at key k with val v
+    #
+    # @param k [String] key
+    # @param v [Object] value
+    # @return [GoodData::Schedule] Returns self
+    def set_hidden_parameter(k, v)
+      hidden_params[k] = v
+      @dirty = true
+      self
+    end
+
+    def schedule_type
+      json['schedule']['type']
+    end
+
+    def schedule_type=(type)
+      json['schedule']['type'] = type
+      @dirty = true
+      self
+    end
+
+    def time_based?
+      cron != nil
+    end
+
+    def to_hash
+      {
+        name: name,
+        type: type,
+        state: state,
+        params: params,
+        hidden_params: hidden_params,
+        cron: cron,
+        trigger_id: trigger_id,
+        timezone: timezone,
+        uri: uri,
+        reschedule: reschedule,
+        executable: executable,
+        process_id: process_id
+      }
+    end
+
+    def trigger_id
+      json['schedule']['triggerScheduleId']
+    end
+
+    def trigger_id=(a_trigger)
+      json['schedule']['triggerScheduleId'] = a_trigger
+      @dirty = true
+      self
+    end
+
+    def name
+      json['schedule']['name']
+    end
+
+    def name=(name)
+      json['schedule']['name'] = name
+      @dirty = true
+      self
+    end
+
+    def set_trigger(trigger) # rubocop:disable Style/AccessorMethodName
+      if trigger.is_a?(String) && trigger =~ /[a-fA-Z0-9]{24}/
+        self.trigger_id = trigger
+      elsif trigger.is_a?(GoodData::Schedule)
+        self.trigger_id = trigger.obj_id
+      else
+        self.cron = trigger
+      end
+    end
+
+    # Returns URL
+    #
+    # @return [String] Schedule URL
+    def uri
+      @json['schedule']['links']['self'] if @json && @json['schedule'] && @json['schedule']['links']
+    end
+
+    def ==(other)
+      other.respond_to?(:uri) && other.uri == uri && other.respond_to?(:to_hash) && other.to_hash == to_hash
+    end
+
+    def to_update_payload
+      res = {
+        'schedule' => {
+          'name' => name,
+          'type' => type,
+          'state' => state,
+          'timezone' => timezone,
+          'cron' => cron,
+          'triggerScheduleId' => trigger_id,
+          'params' => GoodData::Helpers.encode_public_params(params),
+          'hiddenParams' => GoodData::Helpers.encode_hidden_params(hidden_params)
+        }
+      }
+
+      res['schedule']['reschedule'] = reschedule if reschedule
+
+      res
+    end
+  end
+end