gooddata 1.0.0-java

data/lib/gooddata/models/blueprint/to_wire.rb

@@ -0,0 +1,173 @@
+# 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
+  module Model
+    module ToWire
+      # Converts anchor to wire format. There is difference between datsets that
+      # do not have anchor and those that do. Even if there is no acnhor you
+      # stil have to generate. If there is anchor it behaves exactly like am
+      # attribute
+      #
+      # @param project [Hash] Project blueprint hash represenation
+      # @param dataset [Hash] Dataset blueprint hash represenation
+      # @return [Hash] Manifest for a particular reference
+      def self.anchor_to_wire(_project, dataset)
+        attribute_to_wire(dataset, DatasetBlueprint.anchor(dataset))
+      end
+
+      # Converts atttribute to wire format.
+      #
+      # @param project [Hash] Project blueprint hash represenation
+      # @param dataset [Hash] Dataset blueprint hash represenation
+      # @return [Hash] Manifest for a particular reference
+      def self.attributes_to_wire(_project, dataset)
+        DatasetBlueprint.attributes(dataset).map do |a|
+          attribute_to_wire(dataset, a)
+        end
+      end
+
+      # Converts atttribute to wire format.
+      #
+      # @param dataset [Hash] Dataset blueprint hash represenation
+      # @param attribute [Hash] Attribute
+      # @return [Hash] Manifest for a particular reference
+      def self.attribute_to_wire(dataset, attribute)
+        ls = DatasetBlueprint.labels_for_attribute(dataset, attribute)
+        labels = ls.map do |l|
+          {
+            label: {
+              identifier: l[:id],
+              title: GoodData::Model.title(l),
+              type: l[:gd_type] || Model::DEFAULT_TYPE,
+              dataType: GoodData::Model.normalize_gd_data_type(l[:gd_data_type]) || Model::DEFAULT_ATTRIBUTE_DATATYPE
+            }
+          }
+        end
+        {}.tap do |a|
+          a[:attribute] = {}
+          a[:attribute][:identifier] = attribute[:id]
+          a[:attribute][:title] = Model.title(attribute)
+          a[:attribute][:folder] = attribute[:folder] || dataset[:folder] || GoodData::Model.title(dataset)
+          a[:attribute][:labels] = labels unless labels.empty?
+          a[:attribute][:description] = GoodData::Model.description(attribute) if GoodData::Model.description(attribute)
+
+          if attribute[:order_by]
+            label, direction = attribute[:order_by].split(' - ')
+            a[:attribute][:sortOrder] = {
+              attributeSortOrder: {
+                label: label,
+                direction: direction
+              }
+            }
+          end
+
+          if attribute[:grain]
+            a[:attribute][:grain] = attribute[:grain].map do |g|
+              case g.keys.first
+              when :date
+                { dateDimension: g.values.first }
+              else
+                g
+              end
+            end
+          end
+
+          if attribute[:relations]
+            a[:attribute][:relations] = attribute[:relations]
+          end
+
+          default = ls.find { |l| l[:default_label] }
+          a[:attribute][:defaultLabel] = (default && default[:id]) || ls.first[:id] unless ls.empty?
+        end
+      end
+
+      # Converts dataset to wire format.
+      #
+      # @param project [Hash] Project blueprint hash represenation
+      # @param dataset [Hash] Dataset blueprint hash represenation
+      # @return [Hash] Manifest for a particular reference
+      def self.dataset_to_wire(project, dataset)
+        {
+          dataset: {
+            identifier: dataset[:id],
+            title: GoodData::Model.title(dataset),
+            anchor: anchor_to_wire(project, dataset),
+            attributes: attributes_to_wire(project, dataset),
+            facts: DatasetBlueprint.facts(dataset).map { |f| fact_to_wire(dataset, f) },
+            references: references_to_wire(project, dataset)
+          }
+        }
+      end
+
+      # Converts date dimension to wire format.
+      #
+      # @param project [Hash] Project blueprint hash represenation
+      # @param dataset [Hash] Dataset blueprint hash represenation
+      # @return [Hash] Manifest for a particular reference
+      def self.date_dimension_to_wire(_project, dataset)
+        payload = {}.tap do |dd|
+          dd[:name] = dataset[:id]
+          dd[:urn] = dataset[:urn] if dataset[:urn]
+          dd[:title] = GoodData::Model.title(dataset)
+          dd[:identifierPrefix] = dataset[:identifier_prefix] if dataset[:identifier_prefix]
+        end
+        { dateDimension: payload }
+      end
+
+      # Converts fact to wire format.
+      #
+      # @param dataset [Hash] Dataset blueprint hash represenation
+      # @param fact [Hash] Fact blueprint
+      # @return [Hash] Manifest for a particular reference
+      def self.fact_to_wire(dataset, fact)
+        payload = {
+          fact: {
+            identifier: fact[:id],
+            title: GoodData::Model.title(fact),
+            folder: fact[:folder] || dataset[:folder] || GoodData::Model.title(dataset),
+            dataType: GoodData::Model.normalize_gd_data_type(fact[:gd_data_type]) || DEFAULT_FACT_DATATYPE
+          }
+        }
+        payload.tap do |p|
+          p[:fact][:description] = GoodData::Model.description(fact) if GoodData::Model.description(fact)
+          p[:fact][:restricted] = fact[:restricted] if fact[:restricted]
+        end
+      end
+
+      # Converts references to wire format.
+      #
+      # @param fact [Hash] Project blueprint hash represenation
+      # @param dataset [Hash] Dataset blueprint hash represenation
+      # @return [Hash] Manifest for a particular reference
+      def self.references_to_wire(_project, dataset)
+        DatasetBlueprint.references(dataset).map do |r|
+          r[:dataset]
+        end
+      end
+
+      # Entry method. Converts ProjectBlueprint representation into wire format
+      # which is understood by the API
+      #
+      # @param fact [Hash] Project blueprint represenation
+      # @param dataset [Hash] Dataset blueprint hash represenation
+      # @return [Hash] Manifest for a particular reference
+      def self.to_wire(what)
+        {
+          diffRequest: {
+            targetModel: {
+              projectModel: {
+                modelMetadata: { containCA: what[:include_ca] },
+                datasets: (what[:datasets] || []).map { |d| dataset_to_wire(what, d) },
+                dateDimensions: (what[:date_dimensions] || []).map { |d| date_dimension_to_wire(what, d) }
+              }
+            }
+          }
+        }
+      end
+    end
+  end
+end

data/lib/gooddata/models/channel_configuration.rb

@@ -0,0 +1,112 @@
+# 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 ChannelConfiguration < Rest::Resource
+    CHANNEL_CONFIGURATION_PATH = '/gdc/account/profile/%s/channelConfigurations'
+
+    EMPTY_OBJECT = {
+      'channelConfiguration' => {
+        'configuration' => {
+          'emailConfiguration' => {
+            'to' => ''
+          }
+        },
+        'meta' => {
+          'title' => ''
+        }
+      }
+    }
+
+    attr_accessor :title, :to
+
+    class << self
+      def [](id = :all, opts = { client: GoodData.connection })
+        c = GoodData.get_client(opts)
+
+        uri = CHANNEL_CONFIGURATION_PATH % c.user.account_setting_id
+        if id == :all
+          data = c.get uri
+          data['channelConfigurations']['items'].map { |channel_data| c.create(ChannelConfiguration, channel_data) }
+        else
+          c.create(ChannelConfiguration, c.get("#{uri}/#{id}"))
+        end
+      end
+
+      def all(opts = { client: GoodData.connection })
+        ChannelConfiguration[:all, opts]
+      end
+
+      def create(opts = { client: GoodData.connection })
+        c = GoodData.get_client(opts)
+
+        options = { to: c.user.email, title: c.user.email }.merge(opts)
+        existing_channel = all.find { |channel| channel.to == options[:to] }
+        return existing_channel if existing_channel
+
+        channel = create_object(options)
+        channel.save
+        channel
+      end
+
+      def create_object(data = {})
+        c = GoodData.get_client(data)
+
+        new_data = GoodData::Helpers.deep_dup(EMPTY_OBJECT).tap do |d|
+          d['channelConfiguration']['configuration']['emailConfiguration']['to'] = data[:to]
+          d['channelConfiguration']['meta']['title'] = data[:title]
+        end
+
+        c.create(ChannelConfiguration, new_data)
+      end
+    end
+
+    # Initializes object instance from raw wire JSON
+    #
+    # @param json Json used for initialization
+    def initialize(json)
+      super
+      @json = json
+      @to = data['configuration']['emailConfiguration']['to']
+      @title = data['meta']['title']
+    end
+
+    def save
+      response = if uri
+                   data_to_send = GoodData::Helpers.deep_dup(raw_data).tap do |d|
+                     d['channelConfiguration']['configuration']['emailConfiguration']['to'] = to
+                     d['channelConfiguration']['meta']['title'] = title
+                   end
+                   client.put(uri, data_to_send)
+                 else
+                   client.post(CHANNEL_CONFIGURATION_PATH % client.user.account_setting_id, raw_data)
+                 end
+      @json = client.get response['channelConfiguration']['meta']['uri']
+      self
+    end
+
+    def delete
+      client.delete uri
+    end
+
+    def uri
+      data['meta']['uri'] if data && data['meta'] && data['meta']['uri']
+    end
+
+    def obj_id
+      uri.split('/').last
+    end
+
+    alias_method :channel_id, :obj_id
+
+    def ==(other)
+      return false unless [:to, :title].all? { |m| other.respond_to?(m) }
+      @to == other.to && @title == other.title
+    end
+  end
+end

data/lib/gooddata/models/client.rb

@@ -0,0 +1,236 @@
+# 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 '../mixins/data_property_reader'
+require_relative '../mixins/links'
+require_relative '../mixins/rest_resource'
+require_relative '../mixins/uri_getter'
+
+module GoodData
+  class Client < Rest::Resource
+    data_property_reader 'id'
+
+    attr_accessor :domain
+
+    include Mixin::Links
+    include Mixin::UriGetter
+
+    CLIENT_TEMPLATE = {
+      client: {
+        id: nil,
+        segment: nil,
+        project: nil
+      }
+    }
+
+    class << self
+      def [](id, opts = {})
+        domain = opts[:domain]
+        segment = opts[:segment]
+        fail ArgumentError, 'No :domain specified' if domain.nil?
+        client = domain.client
+        fail ArgumentError, 'No client specified' if client.nil?
+        data_product = opts[:data_product] || (segment ? segment.data_product : nil)
+
+        if id == :all
+          tenants_uri = base_uri(domain, data_product)
+          tenants_uri += "?segment=#{CGI.escape(segment.segment_id)}" if segment
+          Enumerator.new do |y|
+            loop do
+              res = client.get tenants_uri
+              res['clients']['paging']['next']
+              res['clients']['items'].each do |i|
+                p = i['client']['project']
+                tenant = client.create(GoodData::Client, i.merge('domain' => domain))
+                tenant.project = p
+                y << tenant
+              end
+              url = res['clients']['paging']['next']
+              break unless url
+            end
+          end
+        else
+          id = id.respond_to?(:client_id) ? id.client_id : id
+          tenant_uri = base_uri(domain, data_product)
+          data = client.get(tenant_uri + "/#{CGI.escape(id)}")
+          client.create(GoodData::Client, data.merge('domain' => domain))
+        end
+      end
+
+      # Creates new client from parameters passed.
+      #
+      # Should not be called directly. Use GoodData::Segment#create_client.
+      #
+      # @param data [Hash] Data required to create the client
+      # @option data id [String]
+      # @option data project [GoodData::Project]
+      # @param options [Hash] Options
+      # @option options segment [GoodData::Segment]
+      # @option options client [GoodData::Rest::Client]
+      # @return [GoodData::Client] New GoodData::Client instance
+      def create(data, options)
+        segment = options[:segment]
+        domain = segment.domain
+        tenant = client.create(GoodData::Client, GoodData::Helpers.stringify_keys(CLIENT_TEMPLATE.merge(domain: domain)), domain: domain)
+        tenant.tap do |s|
+          s.project = data[:project]
+          s.client_id = data[:id]
+          s.segment = segment.uri
+        end
+      end
+      alias_method :associate, :create
+
+      def update_setting(name, value, opts = {})
+        return nil unless value
+        domain = opts[:domain]
+        client_id = opts[:client_id]
+        data_product_id = opts[:data_product_id]
+        uri = data_product_id ? GoodData::DataProduct::ONE_DATA_PRODUCT_PATH % { domain_name: domain.name, id: data_product_id } : domain.segments_uri
+        body = {
+          setting: {
+            name: "#{name}",
+            value: "#{value}"
+          }
+        }
+        domain.client.put(uri + "/clients/#{client_id}/settings/#{name}", body)
+        nil
+      end
+      alias_method :add_setting, :update_setting
+
+      def base_uri(domain, data_product)
+        if data_product
+          uri = GoodData::DataProduct::ONE_DATA_PRODUCT_PATH % { domain_name: domain.name, id: data_product.data_product_id }
+        else
+          uri = domain.segments_uri
+        end
+        uri + '/clients'
+      end
+    end
+
+    def initialize(data)
+      super(data)
+      @domain = data.delete('domain')
+      @json = data
+    end
+
+    # Segment id getter for the Segment. Called segment_id since id is a reserved word in ruby world
+    #
+    # @return [String] Segment id
+    def client_id
+      data['id']
+    end
+
+    def client_id=(a_name)
+      data['id'] = a_name
+      self
+    end
+
+    # Setter for the project this client has set
+    #
+    # @param a_project [String|GoodData::Project] Id or an instance of a project
+    # @return [GoodData::Cliet] Returns the instance of the client
+    def project=(a_project)
+      data['project'] = a_project.respond_to?(:uri) ? a_project.uri : a_project
+      self
+    end
+
+    # Project URI this client has set
+    #
+    # @return [String] Returns the URI of the project this client has set
+    def project_uri
+      data['project']
+    end
+
+    # Project this client has set
+    #
+    # @return [GoodData::Project] Returns the instance of the client's project
+    def project
+      client.projects(project_uri) if project?
+    end
+
+    # Returns boolean if client has a project provisioned
+    #
+    # @return [Boolean] Returns true if client has a project provisioned. False otherwise
+    def project?
+      project_uri != nil
+    end
+
+    # Reloads the client from the URI
+    #
+    # @return [GoodData::Client] Returns the updated client object
+    def reload!
+      res = client.get(uri)
+      @json = res
+      self
+    end
+
+    # Segment id setter which this client is connected to.
+    #
+    # @param a_segment [String] Id of the segment.
+    # @return [GoodData::Client] Returns the instance of the client
+    def segment=(a_segment)
+      data['segment'] = a_segment.respond_to?(:uri) ? a_segment.uri : a_segment
+      self
+    end
+
+    # Segment this client is connected to.
+    #
+    # @return [GoodData::Segment] Segment
+    def segment
+      segment_res = client.get(data['segment'])
+      client.create(GoodData::Segment, segment_res)
+    end
+
+    # Segment URI this client is connected to.
+    #
+    # @return [String] Segment URI
+    def segment_uri
+      data['segment']
+    end
+
+    # Creates or updates a client instance on the API.
+    #
+    # @return [GoodData::Client] Client instance
+    def save
+      if uri
+        client.put(uri, json)
+      else
+        data_product = segment.data_product
+        res = client.post(self.class.base_uri(domain, data_product), json)
+        @json = res
+      end
+      self
+    end
+
+    # Deletes a client instance on the API.
+    #
+    # @return [GoodData::Client] Segment instance
+    def delete
+      project.delete if project && !project.deleted?
+      dissociate
+    end
+
+    # Deletes a client but maintain their project
+    def dissociate
+      client.delete(uri) if uri
+    end
+
+    def settings
+      data_product = segment.data_product
+      res = client.get(self.class.base_uri(domain, data_product) + "/#{client_id}/settings")
+      settings = GoodData::Helpers.get_path(res, %w(settingsList items))
+      settings.map do |setting|
+        setting = setting['setting']
+        {
+          name: setting['name'],
+          value: setting['value']
+        }
+      end
+    end
+  end
+end