gooddata 0.6.24 → 0.6.25

data/lib/gooddata/models/project_creator.rb

@@ -38,17 +38,12 @@ module GoodData
 
         def migrate_datasets(spec, opts = {})
           opts = { client: GoodData.connection }.merge(opts)
-          client = opts[:client]
           dry_run = opts[:dry_run]
-          fail ArgumentError, 'No :client specified' if client.nil?
 
-          p = opts[:project]
-          fail ArgumentError, 'No :project specified' if p.nil?
+          client, project = GoodData.get_client_and_project(opts)
 
-          project = client.projects(p)
-          fail ArgumentError, 'Wrong :project specified' if project.nil?
           bp = ProjectBlueprint.new(spec)
-          uri = "/gdc/projects/#{project.pid}/model/diff"
+          uri = "/gdc/projects/#{project.pid}/model/diff?includeGrain=true"
           result = client.post(uri, bp.to_wire)
 
           link = result['asyncTask']['link']['poll']

data/lib/gooddata/models/project_metadata.rb

@@ -12,11 +12,7 @@ module GoodData
       end
 
       def [](key, opts = { :client => GoodData.connection, :project => GoodData.project })
-        client = opts[:client]
-        fail ArgumentError, 'No :client specified' if client.nil?
-
-        project = opts[:project]
-        fail ArgumentError, 'No :project specified' if project.nil?
+        client, project = GoodData.get_client_and_project(opts)
 
         if key == :all
           uri = "/gdc/projects/#{project.pid}/dataload/metadata"
@@ -43,11 +39,7 @@ module GoodData
       end
 
       def []=(key, opts = { :client => GoodData.connection, :project => GoodData.project }, val = nil)
-        client = opts[:client]
-        fail ArgumentError, 'No :client specified' if client.nil?
-
-        project = opts[:project]
-        fail ArgumentError, 'No :project specified' if project.nil?
+        client, project = GoodData.get_client_and_project(opts)
 
         data = {
           :metadataItem => {

data/lib/gooddata/models/project_role.rb

@@ -13,16 +13,10 @@ require_relative '../rest/rest'
 require_relative '../mixins/rest_resource'
 
 module GoodData
-  class ProjectRole < GoodData::Rest::Object
-    attr_accessor :json
-
-    include GoodData::Mixin::RestResource
-
-    root_key :projectRole
-
-    include GoodData::Mixin::Author
-    include GoodData::Mixin::Contributor
-    include GoodData::Mixin::Timestamps
+  class ProjectRole < Rest::Resource
+    include Mixin::Author
+    include Mixin::Contributor
+    include Mixin::Timestamps
 
     EMPTY_OBJECT = {
       'projectRole' => {

data/lib/gooddata/models/report_data_result.rb

@@ -5,15 +5,13 @@
 # LICENSE file in the root directory of this source tree.
 
 module GoodData
-  class ReportDataResult < Rest::Object
+  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, options = {})
-        client = options[:client]
-        project = options[:project]
+      def from_xtab(data)
         top = top_headers(data)
         left = left_headers(data)
         jank = GoodData::Helpers.zeroes(rows(top), cols(left), nil)
@@ -23,7 +21,7 @@ module GoodData
         a = jank.zip(top).map { |x, y| x + y }
         b = left.zip(stuff).map { |x, y| x + y }
         result = a + b
-        client ? client.create(ReportDataResult, data: result, top: rows(top), left: cols(left), project: project) : ReportDataResult.new(data: result, top: rows(top), left: cols(left))
+        ReportDataResult.new(data: result, top: rows(top), left: cols(left))
       end
 
       private

data/lib/gooddata/models/schedule.rb

@@ -15,12 +15,6 @@ module GoodData
   class Schedule < Rest::Resource
     attr_reader :dirty, :json
 
-    alias_method :data, :json
-    alias_method :raw_data, :json
-
-    include GoodData::Mixin::RestResource
-    root_key :schedule
-
     SCHEDULE_TEMPLATE = {
       :schedule => {
         :type => nil,
@@ -36,14 +30,7 @@ module GoodData
       # @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 = client(opts)
-        fail ArgumentError, 'No :client specified' if c.nil?
-
-        p = opts[:project]
-        fail ArgumentError, 'No :project specified' if p.nil?
-
-        project = GoodData::Project[p, opts]
-        fail ArgumentError, 'Wrong :project specified' if project.nil?
+        c, project = GoodData.get_client_and_project(opts)
 
         if id == :all
           GoodData::Schedule.all(opts)
@@ -62,14 +49,7 @@ module GoodData
       # 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 = client(opts)
-        fail ArgumentError, 'No :client specified' if c.nil?
-
-        p = opts[:project]
-        fail ArgumentError, 'No :project specified' if p.nil?
-
-        project = GoodData::Project[p, opts]
-        fail ArgumentError, 'Wrong :project specified' if project.nil?
+        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) }
@@ -83,20 +63,13 @@ module GoodData
       # @param options [Hash] Optional options
       # @return [GoodData::Schedule] New GoodData::Schedule instance
       def create(process_id, trigger, executable, options = {})
-        c = client(options)
-        fail ArgumentError, 'No :client specified' if c.nil?
-
-        p = options[:project]
-        fail ArgumentError, 'No :project specified' if p.nil?
-
-        project = GoodData::Project[p, options]
-        fail ArgumentError, 'Wrong :project specified' if project.nil?
+        c, project = GoodData.get_client_and_project(options)
 
         fail 'Process ID has to be provided' if process_id.blank?
         fail 'Executable has to be provided' if executable.blank?
         fail 'Trigger schedule has to be provided' if trigger.blank?
 
-        schedule = c.create(GoodData::Schedule, GoodData::Helpers.deep_stringify_keys(GoodData::Helpers.deep_dup(SCHEDULE_TEMPLATE)), client: c, project: p)
+        schedule = c.create(GoodData::Schedule, GoodData::Helpers.deep_stringify_keys(GoodData::Helpers.deep_dup(SCHEDULE_TEMPLATE)), client: c, project: project)
 
         default_opts = {
           :type => 'MSETL',

data/lib/gooddata/models/segment.rb

@@ -0,0 +1,192 @@
+# 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 './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/segments/%s/synchronizeClients'
+
+    attr_accessor :domain
+
+    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?
+
+        if id == :all
+          GoodData::Segment.all(opts)
+        else
+          result = client.get(domain.segments_uri + "/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
+
+        results = client.get(domain.segments_uri + '/segments')
+        GoodData::Helpers.get_path(results, %w(segments items)).map { |i| client.create(GoodData::Segment, i.merge('domain' => domain)) }
+      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 'Custom ID has to be provided' if segment_id.blank?
+        client = options[:client]
+        segment = client.create(GoodData::Segment, GoodData::Helpers.deep_stringify_keys(SEGMENT_TEMPLATE).merge('domain' => options[:domain]))
+        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')
+      @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 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_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, 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(domain.segments_uri + '/segments', json)
+        @json = res
+      end
+      self
+    end
+
+    # Runs async process that walks thorugh segments and provisions projects if necessary.
+    #
+    # @return [Array] Returns array of results
+    def synchronize_clients
+      sync_uri = SYNCHRONIZE_URI % [domain.obj_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
+
+    # 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)
+      case GoodData::Helpers.get_path(payload)
+      when 'gdc.c4.conflict.domain.segment.contains_clients'
+        throw SegmentNotEmpty
+      else
+        raise e
+      end
+    end
+  end
+end

data/lib/gooddata/models/user_filters/mandatory_user_filter.rb

@@ -21,11 +21,11 @@ module GoodData
         c = client(options)
         project = options[:project]
         filters = query('userFilter', nil, options)
-        count = 10_000
+        count = 1_000
         offset = 0
         user_lookup = {}
         loop do
-          result = c.get("/gdc/md/#{project.pid}/userfilters?count=1000&offset=#{offset}")
+          result = c.get("/gdc/md/#{project.pid}/userfilters?count=#{count}&offset=#{offset}")
           result['userFilters']['items'].each do |item|
             item['userFilters'].each do |f|
               user_lookup[f] = item['user']

data/lib/gooddata/models/user_filters/user_filter_builder.rb

@@ -186,7 +186,7 @@ module GoodData
     # so it precaches the values and still be able to function for larger ones even
     # though that would mean tons of requests
     def self.get_small_labels(labels_cache)
-      labels_cache.values.select { |label| label.values_count < 100_000 }
+      labels_cache.values.select { |label| label && label.values_count && label.values_count < 100_000 }
     end
 
     # Creates a MAQL expression(s) based on the filter defintion.

data/lib/gooddata/models/user_filters/variable_user_filter.rb

@@ -16,5 +16,16 @@ module GoodData
       @json[:uri] = res['uri']
       self
     end
+
+    # Method used for replacing values in their state according to mapping. Can be used to replace any values but it is typically used to replace the URIs. Returns a new object of the same type.
+    #
+    # @param [Array<Array>]Mapping specifying what should be exchanged for what. As mapping should be used output of GoodData::Helpers.prepare_mapping.
+    # @return [GoodData::VariableUserFilter]
+    def replace(mapping)
+      x = GoodData::MdObject.replace_quoted(self, mapping)
+      x = GoodData::MdObject.replace_bracketed(x, mapping)
+      vals = GoodData::MdObject.find_replaceable_values(x, mapping)
+      GoodData::MdObject.replace_bracketed(x, vals)
+    end
   end
 end

data/lib/gooddata/models/user_group.rb

@@ -0,0 +1,241 @@
+# 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/rest'
+require_relative '../rest/resource'
+require_relative '../mixins/author'
+require_relative '../mixins/contributor'
+require_relative '../mixins/links'
+require_relative '../mixins/rest_resource'
+require_relative '../mixins/uri_getter'
+
+module GoodData
+  # Representation of User Group
+  #
+  # Use user groups to manage user access to dashboards on the GoodData Portal.
+  # Create groups to more quickly manage permissions for users with
+  # the the same role or who need similar access to dashboards.
+  # Groups can be part of groups.
+  class UserGroup < Rest::Resource
+    include Mixin::Author
+    include Mixin::Contributor
+    include Mixin::Links
+    include Mixin::UriGetter
+
+    EMPTY_OBJECT = {
+      'userGroup' => {
+        'content' => {
+          'name' => nil,
+          'description' => nil,
+          'project' => 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 = {})
+        # TODO: Replace with GoodData.get_client_and_project(opts)
+        project = opts[:project]
+        fail 'Project has to be passed in options' unless project
+        fail 'Project has to be of type GoodData::Project' unless project.is_a?(GoodData::Project)
+        client = project.client
+
+        results = client.get('/gdc/userGroups', params: { :project => project.pid, :user => opts[:user] }.compact)
+        groups = GoodData::Helpers.get_path(results, %w(userGroups items)).map { |i| client.create(GoodData::UserGroup, i, :project => project) }
+        id == :all ? groups : groups.find { |g| g.obj_id == id || g.name == id }
+      end
+
+      # Create new user group
+      #
+      # @param data [Hash] Initial data
+      # @return [UserGroup] Newly created user group
+      def create(data)
+        new_data = GoodData::Helpers.deep_dup(EMPTY_OBJECT).tap do |d|
+          d['userGroup']['content']['name'] = data[:name]
+          d['userGroup']['content']['description'] = data[:description]
+          d['userGroup']['content']['project'] = data[:project].respond_to?(:uri) ? data[:project].uri : data[:project]
+        end
+
+        client.create(GoodData::UserGroup, GoodData::Helpers.deep_stringify_keys(new_data))
+      end
+
+      # Constructs payload for user management/manipulation
+      #
+      # @return [Hash] Created payload
+      def construct_payload(users, operation)
+        users = users.is_a?(Array) ? users : [users]
+
+        {
+          modifyMembers: {
+            operation: operation,
+            items: users.map do |user|
+              uri = user.respond_to?(:uri) ? user.uri : user
+              fail 'You cannot add group as member of another group as of now.' if uri =~ %r{^\/gdc\/userGroups\/}
+              uri
+            end
+          }
+        }
+      end
+
+      # URI used for membership manipulation/managementv
+      #
+      # @param client [Client] Client used for communication with platform
+      # @param users [User | String | Array<User> | Array<String>] User(s) to be modified
+      # @param operation [String] Operation to be performed - ADD, SET, REMOVE
+      # @param uri [String] URI to be used for operation
+      # @return [String] URI used for membership manipulation/management
+      def modify_users(client, users, operation, uri)
+        payload = construct_payload(users, operation)
+        client.post(uri, payload)
+      end
+    end
+
+    # Initialize object with json
+    #
+    # @return [UserGroup] User Group object initialized with json
+    def initialize(json)
+      @json = json
+      self
+    end
+
+    # Add member(s) to user group
+    #
+    # @param [String | User | Array<User>] Users to add to user group
+    # @return [nil] Nothing is returned
+    def add_members(user)
+      UserGroup.modify_users(client, user, 'ADD', uri_modify_members)
+    end
+
+    alias_method :add_member, :add_members
+
+    # Gets user group name
+    #
+    # @return [String] User group name
+    def name
+      content['name']
+    end
+
+    # Sets user group name
+    #
+    # @param name [String] New user group name
+    # @return [String] New user group name
+    def name=(name)
+      content['name'] = name
+      name
+    end
+
+    # Gets user group description
+    #
+    # @return [String] User group description
+    def description
+      content['description']
+    end
+
+    # Sets user group description
+    #
+    # @param name [String] New user group description
+    # @return [String] New user group description
+    def description=(name)
+      content['description'] = name
+    end
+
+    # Gets Users with this Role
+    #
+    # @return [Array<GoodData::Profile>] List of users
+    def members
+      url = GoodData::Helpers.get_path(data, %w(links members))
+      return [] unless url
+      Enumerator.new do |y|
+        loop do
+          res = client.get url
+          res['userGroupMembers']['paging']['next']
+          res['userGroupMembers']['items'].each do |member|
+            case member.keys.first
+            when 'user'
+              y << client.create(GoodData::Profile, client.get(GoodData::Helpers.get_path(member, %w(user links self))), :project => project)
+            when 'userGroup'
+              y << client.create(UserGroup, client.get(GoodData::Helpers.get_path(member, %w(userGroup links self))), :project => project)
+            end
+          end
+          url = res['userGroupMembers']['paging']['next']
+          break unless url
+        end
+      end
+    end
+
+    # Verifies if user is in a group or any nested group and returns true if it does
+    #
+    # @return [Boolean] Retruns true if member is member of the group or any of its members
+    def member?(a_member)
+      # could be better on API directly?
+      uri = a_member.respond_to?(:uri) ? a_member.uri : a_member
+      members.map(&:uri).include?(uri)
+    end
+
+    # Save user group
+    # New group is created if needed else existing one is updated
+    #
+    # @return [UserGroup] Created or updated user group
+    def save
+      res = if uri
+              # get rid of unsupprted keys
+              data = json['userGroup']
+              client.put(uri, 'userGroup' => data.except('meta', 'links'))
+            else
+              client.post('/gdc/userGroups', @json)
+            end
+      @json = client.get(res['uri'])
+      self
+    end
+
+    # Remove member(s) from user group
+    #
+    # @param [String | User | Array<User>] Users to remove from user group
+    # @return [nil] Nothing is returned
+    def remove_members(user)
+      UserGroup.modify_users(client, user, 'REMOVE', uri_modify_members)
+    end
+
+    alias_method :remove_member, :remove_members
+
+    # Set member(s) to user group.
+    # Only users passed to this call will be new members of user group.
+    # Old members not passed to this method will be removed!
+    #
+    # @param [String | User | Array<User>] Users to set as members of user group
+    # @return [nil] Nothing is returned
+    def set_members(user) # rubocop:disable Style/AccessorMethodName
+      UserGroup.modify_users(client, user, 'SET', uri_modify_members)
+    end
+
+    alias_method :set_member, :set_members
+
+    # URI used for membership manipulation/management
+    #
+    # @return [String] URI used for membership manipulation/management
+    def uri_modify_members
+      links['modifyMembers']
+    end
+
+    # Is it a user group?
+    #
+    # @return [Boolean] Return true if it is a user group
+    def user_group?
+      true
+    end
+
+    # Checks if two user groups are same
+    #
+    # @return [Boolean] Return true if the two groups are same
+    def ==(other)
+      uri == other.uri
+    end
+  end
+end