gooddata 1.0.0-java

data/lib/gooddata/models/segment.rb

@@ -0,0 +1,274 @@
+# 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 './client'
+require_relative './domain'
+require_relative '../models/client_synchronization_result'
+
+require_relative '../mixins/data_property_reader'
+require_relative '../mixins/links'
+require_relative '../mixins/rest_resource'
+require_relative '../mixins/uri_getter'
+
+module GoodData
+  class Segment < Rest::Resource
+    SYNCHRONIZE_URI = '/gdc/domains/%s/dataproducts/%s/segments/%s/synchronizeClients'
+
+    #
+    ProvisioningResult = Struct.new('ProvisioningResult', :id, :status, :project_uri, :error)
+
+    attr_accessor :domain
+
+    attr_writer :data_product
+
+    data_property_reader 'id'
+
+    include Mixin::Links
+    include Mixin::UriGetter
+
+    SEGMENT_TEMPLATE = {
+      :segment => {
+        :id => nil,
+        :masterProject => nil
+      }
+    }
+
+    class << self
+      # Returns list of all segments or a particular segment
+      #
+      # @param id [String|Symbol] Uri of the segment required or :all for all segments.
+      # @return [Array<GoodData::Segment>] List of segments for a particular domain
+      def [](id, opts = {})
+        domain = opts[:domain]
+        fail ArgumentError, 'No :domain specified' if domain.nil?
+
+        client = domain.client
+        fail ArgumentError, 'No client specified' if client.nil?
+
+        data_product = opts[:data_product]
+
+        if id == :all
+          GoodData::Segment.all(opts)
+        else
+          result = client.get(base_uri(domain, data_product) + "/segments/#{CGI.escape(id)}")
+          client.create(GoodData::Segment, result.merge('domain' => domain))
+        end
+      end
+
+      # Returns list of all segments for domain
+      #
+      # @param opts [Hash] Options. Should contain :domain for which you want to get the segments.
+      # @return [Array<GoodData::Segment>] List of segments for a particular domain
+      def all(opts = {})
+        domain = opts[:domain]
+        fail 'Domain has to be passed in options' unless domain
+        client = domain.client
+
+        data_product = opts[:data_product]
+        results = client.get(base_uri(domain, data_product) + '/segments')
+        GoodData::Helpers.get_path(results, %w(segments items)).map { |i| client.create(GoodData::Segment, i, domain: domain) }
+      end
+
+      def base_uri(domain, data_product)
+        if data_product
+          GoodData::DataProduct::ONE_DATA_PRODUCT_PATH % { domain_name: domain.name, id: data_product.data_product_id }
+        else
+          domain.segments_uri
+        end
+      end
+
+      # Creates new segment from parameters passed
+      #
+      # @param data [Hash] Data for segment namely :segment_id and :master_project is accepted. Master_project can be given as either a PID or a Project instance
+      # @param options [Hash] Trigger of schedule. Can be cron string or reference to another schedule.
+      # @return [GoodData::Segment] New Segment instance
+      def create(data = {}, options = {})
+        segment_id = data[:segment_id]
+        fail 'segment_id has to be provided' if segment_id.blank?
+        client = options[:client]
+        segment = client.create(GoodData::Segment, GoodData::Helpers.stringify_keys(SEGMENT_TEMPLATE), options)
+        segment.tap do |s|
+          s.segment_id = segment_id
+          s.master_project = data[:master_project]
+        end
+      end
+    end
+
+    def initialize(data)
+      super
+      @domain = data.delete('domain')
+      @data_product = nil
+      @json = data
+    end
+
+    def data_product
+      if @data_product
+        @data_product
+      else
+        json = client.get(data['links']['dataProduct'])
+        @data_product = client.create(GoodData::DataProduct, json)
+      end
+    end
+
+    # Segment id getter for the Segment. Called segment_id since id is a reserved word in ruby world
+    #
+    # @return [String] Segment id
+    def segment_id
+      data['id']
+    end
+
+    # Segment id setter for the Segment. Called segment_id since id is a reserved word in ruby world
+    #
+    # @param an_id [String] Id of the segment.
+    # @return [String] Segment id
+    def segment_id=(an_id)
+      data['id'] = an_id
+      self
+    end
+
+    # Master project id getter for the Segment.
+    #
+    # @return [String] Segment id
+    def master_project=(a_project)
+      data['masterProject'] = a_project.respond_to?(:uri) ? a_project.uri : a_project
+      self
+    end
+
+    alias_method :master=, :master_project=
+
+    # Master project id getter for the Segment.
+    #
+    # @return [String] Project uri
+    def master_project_id
+      GoodData::Helpers.last_uri_part(master_project_uri)
+    end
+
+    alias_method :master_id, :master_project_id
+
+    # Master project uri getter for the Segment.
+    #
+    # @return [String] Project uri
+    def master_project_uri
+      data['masterProject']
+    end
+
+    alias_method :master_uri, :master_project_uri
+
+    # Master project getter for the Segment. It returns the instance not just the URI
+    #
+    # @return [GoodData::Project] Project associated with the segment
+    def master_project
+      client.projects(master_project_uri)
+    end
+
+    alias_method :master, :master_project
+
+    def create_client(data)
+      client = GoodData::Client.create(data, client: self.client, segment: self)
+      client.save
+    end
+
+    # Returns all the clients associated with the segment. Since this is potentially paging operation it returns an Enumerable.
+    #
+    # @return [Enumerable] Clients associated with the segment
+    def clients(tenant_id = :all)
+      GoodData::Client[tenant_id, domain: domain, segment: self]
+    end
+
+    # Creates or updates a segment instance on the API.
+    #
+    # @return [GoodData::Segment] Segment instance
+    def save
+      if uri
+        client.put(uri, json)
+      else
+        res = client.post(self.class.base_uri(domain, @data_product ? data_product : nil) + '/segments', json)
+        @json = res
+      end
+      self
+    end
+
+    # Runs async process that walks through segments and provisions projects if necessary.
+    #
+    # @return [Array] Returns array of results
+    def synchronize_clients
+      sync_uri = SYNCHRONIZE_URI % [domain.obj_id, data_product.data_product_id, id]
+      res = client.post sync_uri, nil
+
+      # wait until the instance is created
+      res = client.poll_on_response(res['asyncTask']['links']['poll'], :sleep_interval => 1) do |r|
+        r['synchronizationResult'].nil?
+      end
+
+      client.create(ClientSynchronizationResult, res)
+    end
+
+    def synchronize_processes(projects = [])
+      projects = [projects] unless projects.is_a?(Array)
+      projects = projects.map do |p|
+        p = p.pid if p.respond_to?('pid')
+        fail('wrong type of argument. Should be either project ID or path') unless GoodData::Project.project_id_or_path?(p)
+        p.split('/').last
+      end
+
+      unless projects.empty?
+        body = {
+          syncConfig: {
+            filters: {
+              projectIdFilter: projects
+            }
+          }
+        }
+      end
+
+      uri = '/gdc/internal/lcm/domains/%{domain}/dataproducts/%{dataproduct}/segments/%{segment}/syncProcesses'
+      uri = uri % { domain: domain.name, dataproduct: data_product.data_product_id, segment: segment_id }
+      res = client.post(uri, body)
+
+      client.poll_on_response(GoodData::Helpers.get_path(res, %w(asyncTask link poll)), sleep_interval: 1) do |r|
+        r['syncedResult'].nil?
+      end
+    end
+
+    # Deletes a segment instance on the API.
+    #
+    # @return [GoodData::Segment] Segment instance
+    def delete(options = {})
+      force = options[:force] == true ? true : false
+      clients.peach(&:delete) if force
+      client.delete(uri) if uri
+      self
+    rescue RestClient::BadRequest => e
+      payload = GoodData::Helpers.parse_http_exception(e)
+      e = SegmentNotEmpty if GoodData::Helpers.get_path(payload) == 'gdc.c4.conflict.domain.segment.contains_clients'
+      raise e
+    end
+
+    def provision_client_projects(segments = [])
+      body = {
+        provisionClientProjects: {
+          segments: segments.empty? ? [segment_id] : segments
+        }
+      }
+      res = client.post(GoodData::DataProduct::ONE_DATA_PRODUCT_PATH % { domain_name: domain.name, id: data_product.data_product_id } + '/provisionClientProjects', body)
+      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?
+      Enumerator.new do |y|
+        uri = GoodData::Helpers.get_path(res, %w(clientProjectProvisioningResult links details))
+        loop do
+          result = client.get(uri)
+          (GoodData::Helpers.get_path(result, %w(clientProjectProvisioningResultDetails items)) || []).each do |item|
+            y << ProvisioningResult.new(item['id'], item['status'], item['project'], item['error'])
+          end
+          uri = GoodData::Helpers.get_path(res, %w(clientProjectProvisioningResultDetails paging next))
+          break if uri.nil?
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/models/style_setting.rb

@@ -0,0 +1,62 @@
+# 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'
+
+module GoodData
+  class StyleSetting < Rest::Resource
+    STYLE_SETTING_PATH = '/gdc/projects/%s/styleSettings'
+
+    EMPTY_OBJECT = {
+      'styleSettings' => {
+        'chartPalette' => []
+      }
+    }
+
+    attr_reader :colors
+
+    class << self
+      def current(opts = { client: GoodData.connection, project: GoodData.project })
+        client, project = GoodData.get_client_and_project(opts)
+        uri = STYLE_SETTING_PATH % project.pid
+        data = client.get(uri)
+        client.create(StyleSetting, data)
+      end
+
+      def create(colors, opts = { client: GoodData.connection, project: GoodData.project })
+        client, project = GoodData.get_client_and_project(opts)
+        if colors.is_a?(StyleSetting)
+          colors = colors.colors
+        else
+          colors = colors.uniq
+        end
+        uri = STYLE_SETTING_PATH % project.pid
+        data_to_send = GoodData::Helpers.deep_dup(EMPTY_OBJECT).tap do |d|
+          d['styleSettings']['chartPalette'] = colors.map { |color| GoodData::Helpers.stringify_keys(color) }
+        end
+        style = client.create(StyleSetting, data_to_send)
+        client.put(uri, data_to_send)
+        style
+      end
+
+      def reset(opts = { client: GoodData.connection, project: GoodData.project })
+        client, project = GoodData.get_client_and_project(opts)
+        uri = STYLE_SETTING_PATH % project.pid
+        client.delete(uri)
+      end
+    end
+
+    def initialize(json)
+      super
+      @json = json
+      @colors = json ? data['chartPalette'] : []
+    end
+
+    def empty?
+      colors.empty?
+    end
+  end
+end

data/lib/gooddata/models/subscription.rb

@@ -0,0 +1,188 @@
+# 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 '../mixins/rest_resource'
+
+module GoodData
+  class Subscription < Rest::Resource
+    SUBSCRIPTION_PATH = '/gdc/projects/%s/users/%s/subscriptions'
+
+    EMPTY_OBJECT = {
+      'subscription' => {
+        'triggers' => [],
+        'condition' => {
+          'condition' => {
+            'expression' => 'true'
+          }
+        },
+        'message' => {
+          'template' => {
+            'expression' => ''
+          }
+        },
+        'subject' => {
+          'template' => {
+            'expression' => ''
+          }
+        },
+        'channels' => [],
+        'meta' => {
+          'title' => ''
+        }
+      }
+    }
+
+    set_const :PROCESS_SCHEDULED_EVENT, 'dataload.process.schedule'
+    set_const :PROCESS_STARTED_EVENT, 'dataload.process.start'
+    set_const :PROCESS_SUCCESS_EVENT, 'dataload.process.finish.ok'
+    set_const :PROCESS_FAILED_EVENT, 'dataload.process.finish.error'
+
+    attr_accessor :title, :process, :channels, :message, :subject, :project_events, :timer_event
+
+    class << self
+      def [](id = :all, opts = { client: GoodData.connection })
+        c = GoodData.get_client(opts)
+        pid = (opts[:project].respond_to?(:pid) && opts[:project].pid) || opts[:project]
+        uri = SUBSCRIPTION_PATH % [pid, c.user.account_setting_id]
+        if id == :all
+          data = c.get uri
+          data['subscriptions']['items'].map { |subscription_data| c.create(Subscription, subscription_data, project: pid) }
+        else
+          c.create(Subscription, c.get("#{uri}/#{id}"), project: pid)
+        end
+      end
+
+      def all(opts = { client: GoodData.connection })
+        Subscription[:all, opts]
+      end
+
+      def create(opts = { client: GoodData.connection })
+        c = GoodData.get_client(opts)
+
+        [:project, :channels, :process, :project_events].each { |key| fail "No #{key.inspect} specified" unless opts[key] }
+
+        pid = (opts[:project].respond_to?(:pid) && opts[:project].pid) || opts[:project]
+        project_events = (opts[:project_events].respond_to?(:each) && opts[:project_events]) || [opts[:project_events]]
+
+        process_id = (opts[:process].respond_to?(:process_id) && opts[:process].process_id) || opts[:process]
+        condition = "params.PROCESS_ID=='#{process_id}'"
+
+        channels = (opts[:channels].respond_to?(:each) && opts[:channels]) || [opts[:channels]]
+        channel_uris = channels.map { |channel| channel.respond_to?(:uri) && channel.uri || channel }
+
+        options = { message: 'Email body', subject: 'Email subject', title: c.user.email }.merge(opts)
+        subscription = create_object(options.merge(channels: channel_uris, project_events: project_events, condition: condition, project: pid))
+        subscription.save
+        subscription
+      end
+
+      def create_object(data = {})
+        c = GoodData.get_client(data)
+
+        new_data = GoodData::Helpers.deep_dup(EMPTY_OBJECT).tap do |d|
+          d['subscription']['condition']['condition']['expression'] = data[:condition]
+          d['subscription']['message']['template']['expression'] = data[:message]
+          d['subscription']['subject']['template']['expression'] = data[:subject]
+          d['subscription']['meta']['title'] = data[:title]
+          d['subscription']['channels'] = data[:channels]
+
+          triggers = []
+          triggers << {
+            'projectEventTrigger' => {
+              'types' => data[:project_events]
+            }
+          }
+          if data[:timer_event]
+            triggers << {
+              'timerEvent' => {
+                'cronExpression' => data[:timer_event]
+              }
+            }
+          end
+          d['subscription']['triggers'] = triggers
+        end
+
+        c.create(Subscription, new_data, data)
+      end
+    end
+
+    # Initializes object instance from raw wire JSON
+    #
+    # @param json Json used for initialization
+    def initialize(json)
+      super
+      @json = json
+
+      @title = data['meta']['title']
+      @message = data['message']['template']['expression']
+      @subject = data['subject']['template']['expression']
+      @process = data['condition']['condition']['expression'][/'(.*)'/, 1]
+      @channels = data['channels']
+      @project_events = data['triggers'].find { |h| h.keys.first == 'projectEventTrigger' }['projectEventTrigger']['types']
+
+      timer_events = data['triggers'].select { |h| h.keys.first == 'timerEvent' }
+      timer_events && @timer_events = timer_events.map { |_, v| v }
+    end
+
+    def save
+      response = if uri
+                   data_to_send = GoodData::Helpers.deep_dup(raw_data).tap do |d|
+                     d['subscription']['condition']['condition']['expression'] = "params.PROCESS_ID=='#{(process.respond_to?(:process_id) && process.process_id) || process}'"
+                     d['subscription']['message']['template']['expression'] = message
+                     d['subscription']['subject']['template']['expression'] = subject
+                     d['subscription']['meta']['title'] = title
+                     d['subscription']['channels'] = ((channels.respond_to?(:each) && channels) || [channels]).map { |channel| channel.respond_to?(:uri) && channel.uri || channel }
+
+                     triggers = []
+                     triggers << {
+                       'projectEventTrigger' => {
+                         'types' => (project_events.respond_to?(:each) && project_events) || [project_events]
+                       }
+                     }
+                     if timer_event
+                       triggers << {
+                         'timerEvent' => {
+                           'cronExpression' => timer_event
+                         }
+                       }
+                     end
+                     d['subscription']['triggers'] = triggers
+                   end
+                   client.put(uri, data_to_send)
+                 else
+                   client.post(SUBSCRIPTION_PATH % [project, client.user.account_setting_id], raw_data)
+                 end
+      @json = client.get response['subscription']['meta']['uri']
+      self
+    end
+
+    def uri
+      data['meta']['uri'] if data && data['meta'] && data['meta']['uri']
+    end
+
+    def obj_id
+      uri.split('/').last
+    end
+
+    alias_method :subscription_id, :obj_id
+
+    def delete
+      client.delete uri
+    end
+
+    def ==(other)
+      return false unless [:project, :title, :process, :channels, :message, :subject, :project_events, :timer_event].all? { |m| other.respond_to?(m) }
+      @project == other.project &&
+        @title == other.title &&
+        @process == other.process &&
+        @channels == other.channels &&
+        @message == other.message &&
+        @subject == other.subject &&
+        @project_events == other.project_events &&
+        @timer_event == other.timer_event
+    end
+  end
+end