gooddata 0.6.24 → 0.6.25

data/lib/gooddata/mixins/rest_resource.rb

@@ -30,6 +30,7 @@ module GoodData
         base.send :include, GoodData::Mixin::NotAttribute
         base.send :include, GoodData::Mixin::NotExportable
         base.send :include, GoodData::Mixin::NotFact
+        base.send :include, GoodData::Mixin::NotUserGroup
         base.send :include, GoodData::Mixin::NotMetric
         base.send :include, GoodData::Mixin::NotLabel
         base.send :include, GoodData::Mixin::MdRelations

data/lib/gooddata/mixins/to_json.rb

@@ -0,0 +1,11 @@
+require 'multi_json'
+
+module GoodData
+  module Mixin
+    module ToJson
+      def to_json(pretty = false)
+        MultiJson.dump(json, pretty)
+      end
+    end
+  end
+end

data/lib/gooddata/mixins/uri_getter.rb

@@ -0,0 +1,9 @@
+module GoodData
+  module Mixin
+    module UriGetter
+      def uri
+        data && data['links'] && data['links']['self']
+      end
+    end
+  end
+end

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

@@ -16,6 +16,20 @@ module GoodData
         true
       end
 
+      # Returns true if grain is defined
+      #
+      # @return [Boolean] Returns true if grain is defined on the anchor
+      def grain?
+        !data[:grain].nil?
+      end
+
+      # Returns grain definition if the anchor has it. Nil otherwise
+      #
+      # @return [Array<Hash>] Returns grain definitions
+      def grain
+        data[:grain]
+      end
+
       # Removes all the labels from the anchor. This is a typical operation that people want to perform
       #
       # @return [GoodData::Model::ProjectBlueprint] Returns changed blueprint

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

@@ -92,6 +92,20 @@ module GoodData
         end
       end
 
+      # Returns blueprint with all references to one date dimensions changed to reference to the other. Changes the Blueprint in place.
+      #
+      # @param what [GoodData::Model::ReferenceBlueprintField | String] Date dimension reference field to be replaced.
+      # @param for_what [GoodData::Model::ReferenceBlueprintField | String] Date dimension reference field to be used as a replacement.
+      # @return [GoodData::Model::ProjectBlueprint]
+      def swap_date_dimension!(what, for_what)
+        what_id = what.respond_to?(:id) ? what.id : what
+        for_what_id = what.respond_to?(:id) ? for_what.id : for_what
+
+        fields = to_hash[:datasets].flat_map { |x| x[:columns] }.select { |x| x[:type] == :date }.select { |i| i[:dataset] == what_id }
+        fields.each { |f| f[:dataset] = for_what_id }
+        self
+      end
+
       # Returns true if a dataset contains a particular dataset false otherwise
       #
       # @param project [GoodData::Model::ProjectBlueprint | Hash] Project blueprint
@@ -536,7 +550,7 @@ module GoodData
             star, metrics = e
             metrics.each(&:save)
             reports_stubs = metrics.map do |m|
-              breaks = broken_by(star).map { |ds, aM| ds.identifier_for(aM) }
+              breaks = broken_by(star).map { |ds, a_m| ds.identifier_for(a_m) }
               [breaks, m]
             end
             a.concat(reports_stubs)

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

@@ -54,6 +54,16 @@ module GoodData
           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

data/lib/gooddata/models/client.rb

@@ -0,0 +1,178 @@
+# 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?
+
+        base_uri = domain.segments_uri + "/clients?segment=#{CGI.escape(segment.segment_id)}"
+        tenants_uri = id == :all ? base_uri : base_uri + "&name=#{CGI.escape(id)}"
+        e = 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
+        id == :all ? e : e.first
+      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

@@ -7,7 +7,7 @@
 require_relative '../rest/resource'
 
 module GoodData
-  class DataWarehouse < GoodData::Rest::Resource
+  class DataWarehouse < Rest::Resource
     class << self
       CREATE_URL = '/gdc/datawarehouse/instances'
 
@@ -51,10 +51,6 @@ module GoodData
         c.create(DataWarehouse, final_json)
       end
     end
-    attr_accessor :json
-
-    alias_method :to_json, :json
-    alias_method :raw_data, :json
 
     def initialize(json)
       super

data/lib/gooddata/models/domain.rb

@@ -11,7 +11,7 @@ require_relative '../extensions/enumerable'
 require_relative '../rest/object'
 
 module GoodData
-  class Domain < GoodData::Rest::Object
+  class Domain < Rest::Resource
     attr_reader :name
 
     class << self
@@ -274,12 +274,34 @@ module GoodData
       GoodData::Domain.add_user(data, name, { client: client }.merge(opts))
     end
 
+    def clients
+      clients_uri = "/gdc/domains/#{name}/clients"
+      res = client.get(clients_uri)
+      res_clients = (res['clients'] && res['clients']['items']) || []
+      res_clients.map do |res_client|
+        client.create(GoodData::Client, res_client)
+      end
+    end
+
     alias_method :create_user, :add_user
 
     def create_users(list, options = {})
       GoodData::Domain.create_users(list, name, { client: client }.merge(options))
     end
 
+    def segments(id = :all)
+      GoodData::Segment[id, domain: self]
+    end
+
+    # Creates new segment in current domain 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
+    # @return [GoodData::Segment] New Segment instance
+    def create_segment(data)
+      segment = GoodData::Segment.create(data, domain: self, client: client)
+      segment.save
+    end
+
     # Gets user by its login or uri in various shapes
     # It does not find by other information because that is not unique. If you want to search by name or email please
     # use fuzzy_get_user.
@@ -334,6 +356,65 @@ module GoodData
       profiles.map { |p| member?(p, list) }
     end
 
+    # Returns uri for segments on the domain. This will be removed soon. It is here that for segments the "account" portion of the URI was removed. And not for the rest
+    #
+    # @return [String] Uri of the segments
+    def segments_uri
+      "/gdc/domains/#{name}"
+    end
+
+    # Calls Segment#synchronize_clients on all segments and concatenates the results
+    #
+    # @return [Array] Returns array of results
+    def synchronize_clients
+      segments.flat_map(&:synchronize_clients)
+    end
+
+    # Runs async process that walks through segments and provisions projects if necessary.
+    #
+    # @return [Enumerator] Returns Enumerator of results
+    def provision_client_projects
+      res = client.post(segments_uri + '/provisionClientProjects', nil)
+      res = client.poll_on_code(res['asyncTask']['links']['poll'])
+      klass = Struct.new('ProvisioningResult', :id, :status, :project_uri)
+      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 << klass.new(item['id'], item['status'], item['project'])
+          end
+          uri = GoodData::Helpers.get_path(res, %w(clientProjectProvisioningResultDetails paging next))
+          break if uri.nil?
+        end
+      end
+    end
+
+    def update_clients(data, options = {})
+      payload = data.map do |datum|
+        {
+          :client => {
+            :id => datum[:id],
+            :segment => segments_uri + '/segments/' + datum[:segment],
+            :project => datum[:project]
+          }
+        }
+      end
+      if options[:delete_extra] == true
+        res = client.post(segments_uri + '/updateClients?deleteExtra=true', updateClients: { items: payload })
+      else
+        res = client.post(segments_uri + '/updateClients', updateClients: { items: payload })
+      end
+      data = GoodData::Helpers.get_path(res, ['updateClientsResponse'])
+      if data
+        result = data.flat_map { |k, v| v.map { |h| GoodData::Helpers.symbolize_keys(h.merge('type' => k)) } }
+        result.select { |r| r[:status] == 'DELETED' }.peach { |r| r[:originalProject] && client.delete(r[:originalProject]) }
+        result
+      else
+        []
+      end
+    end
+
     # Update user in domain
     #
     # @param opts [Hash] Data of the user to be updated
@@ -362,6 +443,9 @@ module GoodData
 
     alias_method :members, :users
 
+    # Returns uri for the domain.
+    #
+    # @return [String] Uri of the segments
     def uri
       "/gdc/account/domains/#{name}"
     end