gooddata-edge 0.6.27.edge

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

@@ -0,0 +1,154 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2015 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[:grain]
+            a[:attribute][:grain] = attribute[:grain].map do |g|
+              case g.keys.first
+              when :date
+                { dateDimension: g.values.first }
+              else
+                g
+              end
+            end
+          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)
+        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)
+        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: {
+                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/client.rb

@@ -0,0 +1,182 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2015 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?
+        fail ArgumentError, 'No :segment specified' if domain.nil?
+
+        client = domain.client
+        fail ArgumentError, 'No client specified' if client.nil?
+
+        if id == :all
+          tenants_uri = domain.segments_uri + "/clients?segment=#{CGI.escape(segment.segment_id)}"
+          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
+          data = client.get(domain.segments_uri + "/clients/#{CGI.escape(id)}")
+          client.create(GoodData::Client, data.merge('domain' => domain))
+        end
+      end
+
+      # Creates new client from parameters passed
+      #
+      # @param options [Hash] Optional options
+      # @return [GoodData::Schedule] New GoodData::Schedule instance
+      def create(data = {}, options = {})
+        segment = options[:segment]
+        domain = segment.domain
+        tenant = client.create(GoodData::Client, GoodData::Helpers.deep_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
+    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
+        res = client.post(domain.segments_uri + '/clients', 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?
+      client.delete(uri) if uri
+    end
+  end
+end

data/lib/gooddata/models/client_synchronization_result.rb

@@ -0,0 +1,31 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2015 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_synchronization_result_details'
+
+require_relative '../mixins/data_property_reader'
+require_relative '../mixins/links'
+
+require_relative '../rest/resource'
+
+module GoodData
+  class ClientSynchronizationResult < Rest::Resource
+    include Mixin::Links
+
+    # Initializes object instance from raw wire JSON
+    #
+    # @param json Json used for initialization
+    def initialize(json, opts = {})
+      super(opts)
+      @json = json
+    end
+
+    def details
+      res = client.get(links['details'])
+      client.create(GoodData::ClientSynchronizationResultDetails, res) if res
+    end
+  end
+end

data/lib/gooddata/models/client_synchronization_result_details.rb

@@ -0,0 +1,41 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2015 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 '../mixins/data_property_reader'
+require_relative '../mixins/links'
+
+require_relative '../rest/resource'
+
+module GoodData
+  class ClientSynchronizationResultDetails < Rest::Resource
+    include Mixin::Links
+
+    attr_accessor :synchronization_result
+
+    # Initializes object instance from raw wire JSON
+    #
+    # @param json Json used for initialization
+    def initialize(json, opts = { :synchronization_result => nil })
+      super(opts)
+      @json = json
+      @synchronization_result = opts[:synchronization_result]
+    end
+
+    def items
+      data['items']
+    end
+
+    def next
+      paging && paging['next']
+    end
+
+    def paging
+      data['paging']
+    end
+  end
+end

data/lib/gooddata/models/datawarehouse.rb

@@ -0,0 +1,92 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2015 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 DataWarehouse < Rest::Resource
+    class << self
+      CREATE_URL = '/gdc/datawarehouse/instances'
+
+      # Create a data warehouse from given attributes
+      # Expected keys:
+      # - :title (mandatory)
+      # - :auth_token (mandatory)
+      # - :summary
+      def create(opts)
+        GoodData.logger.info "Creating warehouse #{opts[:title]}"
+
+        c = client(opts)
+        fail ArgumentError, 'No :client specified' if c.nil?
+
+        opts = { :auth_token => Helpers::AuthHelper.read_token }.merge(opts)
+        auth_token = opts[:auth_token] || opts[:token]
+        fail ArgumentError, 'You have to provide your token for creating projects as :auth_token parameter' if auth_token.nil? || auth_token.empty?
+
+        title = opts[:title]
+        fail ArgumentError, 'You have to provide a title for creating warehouse as :title parameter' if title.nil? || title.empty?
+
+        json = {
+          'instance' => {
+            'title' => title,
+            'description' => opts[:description] || opts[:summary] || 'No summary',
+            'authorizationToken' => auth_token
+          }
+        }
+        # do the first post
+        res = c.post(CREATE_URL, json)
+
+        # wait until the instance is created
+        final_res = c.poll_on_response(res['asyncTask']['links']['poll'], opts.merge(sleep_interval: 3)) do |r|
+          r['asyncTask']['links']['instance'].nil?
+        end
+
+        # get the json of the created instance
+        final_json = c.get(final_res['asyncTask']['links']['instance'])
+
+        # create the public facing object
+        c.create(DataWarehouse, final_json)
+      end
+    end
+
+    def initialize(json)
+      super
+      @json = json
+    end
+
+    def title
+      json['instance']['title']
+    end
+
+    def summary
+      json['instance']['description']
+    end
+
+    def status
+      json['instance']['status']
+    end
+
+    def uri
+      json['instance']['links']['self']
+    end
+
+    def id
+      uri.split('/')[-1]
+    end
+
+    def delete
+      if state == 'DELETED'
+        fail "Warehouse '#{title}' with id #{uri} is already deleted"
+      end
+      client.delete(uri)
+    end
+
+    # alias methods to prevent confusion and support the same keys
+    # project has.
+    alias_method :state, :status
+    alias_method :description, :summary
+  end
+end