gooddata 0.6.15 → 0.6.16

data/lib/gooddata/models/profile.rb

@@ -73,14 +73,19 @@ module GoodData
       # @param attributes [Hash] Hash with initial attributes
       # @return [GoodData::Profile] New profile instance
       def create(attributes)
-        json = EMPTY_OBJECT.dup
+        res = create_object(attributes)
+        res.save!
+        res
+      end
+
+      def create_object(attributes)
+        json = EMPTY_OBJECT.deep_dup
+        json['accountSetting']['links']['self'] = attributes[:uri] if attributes[:uri]
         res = client.create(GoodData::Profile, json)
 
         attributes.each do |k, v|
           res.send("#{k}=", v) if ASSIGNABLE_MEMBERS.include? k
         end
-
-        res.save!
         res
       end
 
@@ -347,7 +352,6 @@ module GoodData
     # @return [String] Resource URI
     def uri
       GoodData::Helpers.get_path(@json, %w(accountSetting links self))
-      # @json['accountSetting']['links']['self']
     end
 
     def data

data/lib/gooddata/models/project.rb

@@ -25,6 +25,18 @@ module GoodData
     SLIS_PATH = '/ldm/singleloadinterface'
     DEFAULT_INVITE_MESSAGE = 'Join us!'
 
+    EMPTY_OBJECT = {
+      'project' => {
+        'meta' => {
+          'summary' => 'No summary'
+        },
+        'content' => {
+          'guidedNavigation' => 1,
+          'driver' => 'Pg'
+        }
+      }
+    }
+
     attr_accessor :connection, :json
 
     alias_method :to_json, :json
@@ -71,6 +83,19 @@ module GoodData
         end
       end
 
+      def create_object(data = {})
+        c = client(data)
+        new_data = EMPTY_OBJECT.deep_dup.tap do |d|
+          d['project']['meta']['title'] = data[:title]
+          d['project']['meta']['summary'] = data[:summary] if data[:summary]
+          d['project']['meta']['projectTemplate'] = data[:template] if data[:template]
+          d['project']['content']['guidedNavigation'] = data[:guided_navigation] if data[:guided_navigation]
+          d['project']['content']['authorizationToken'] = data[:auth_token] if data[:auth_token]
+          d['project']['content']['driver'] = data[:driver] if data[:driver]
+        end
+        c.create(Project, new_data)
+      end
+
       # Create a project from a given attributes
       # Expected keys:
       # - :title (mandatory)
@@ -86,23 +111,7 @@ module GoodData
         auth_token = opts[:auth_token]
         fail ArgumentError, 'You have to provide your token for creating projects as :auth_token parameter' if auth_token.nil? || auth_token.empty?
 
-        json = {
-          'project' =>
-            {
-              'meta' => {
-                'title' => opts[:title],
-                'summary' => opts[:summary] || 'No summary'
-              },
-              'content' => {
-                'guidedNavigation' => opts[:guided_navigation] || 1,
-                'authorizationToken' => auth_token,
-                'driver' => opts[:driver] || 'Pg'
-              }
-            }
-        }
-
-        json['project']['meta']['projectTemplate'] = opts[:template] if opts[:template] && !opts[:template].empty?
-        project = c.create(Project, json)
+        project = create_object(opts)
         project.save
         # until it is enabled or deleted, recur. This should still end if there is a exception thrown out from RESTClient. This sometimes happens from WebApp when request is too long
         while project.state.to_s != 'enabled'
@@ -421,7 +430,7 @@ module GoodData
 
     # Get WebDav directory for project data
     # @return [String]
-    def get_project_webdav_path(_file)
+    def project_webdav_path
       u = URI(links['uploads'])
       URI.join(u.to_s.chomp(u.path.to_s), '/project-uploads/', "#{pid}/")
     end
@@ -503,11 +512,19 @@ module GoodData
 
     # Get WebDav directory for user data
     # @return [String]
-    def get_user_webdav_path(_file)
+    def user_webdav_path
       u = URI(links['uploads'])
       URI.join(u.to_s.chomp(u.path.to_s), '/uploads/')
     end
 
+    def upload_file(file)
+      GoodData.upload_to_project_webdav(file, project: self)
+    end
+
+    def download_file(file, where)
+      GoodData.download_from_project_webdav(file, where, project: self)
+    end
+
     # Gets user by its email, full_name, login or uri
     alias_method :member, :get_user
 
@@ -900,93 +917,109 @@ module GoodData
     alias_method :members, :users
 
     def whitelist_users(new_users, users_list, whitelist)
-      # whitelist_users
       return [new_users, users_list] unless whitelist
 
-      whitelist_proc = proc do |user|
+      new_whitelist_proc = proc do |user|
         whitelist.any? { |wl| wl.is_a?(Regexp) ? user[:login] =~ wl : user[:login].include?(wl) }
       end
 
-      [new_users.reject(&whitelist_proc), users_list.reject(&whitelist_proc)]
+      whitelist_proc = proc do |user|
+        whitelist.any? { |wl| wl.is_a?(Regexp) ? user.login =~ wl : user.login.include?(wl) }
+      end
+
+      [new_users.reject(&new_whitelist_proc), users_list.reject(&whitelist_proc)]
     end
 
     # Imports users
     def import_users(new_users, options = {})
       domain = options[:domain]
-      users_list = users.map(&:to_hash)
+      role_list = roles
+      users_list = users
       new_users = new_users.map { |x| (x.is_a?(Hash) && x[:user] && x[:user].to_hash.merge(role: x[:role])) || x.to_hash }
 
       whitelisted_new_users, whitelisted_users = whitelist_users(new_users.map(&:to_hash), users_list, options[:whitelists])
 
-      # Diff users
-      diff = GoodData::Helpers.diff(whitelisted_users, whitelisted_new_users, key: :login)
-      results = []
-      # Create domain users
-      results.concat domain.create_users(diff[:added])
+      # conform the role on list of new users so we can diff them with the users coming from the project
+      diffable_new_with_default_role = whitelisted_new_users.map do |u|
+        u[:role] = Array(u[:role] || u[:roles] || 'readOnlyUser')
+        u
+      end
 
-      # Update domain users
-      domain.create_users(diff[:changed].map { |u| u[:new_obj] })
+      diffable_new = diffable_new_with_default_role.map do |u|
+        u[:role] = u[:role].map do |r|
+          role = get_role(r, role_list)
+          role && role.uri
+        end
+        u
+      end
+
+      # Diff users. Only login and role is important for the diff
+      diff = GoodData::Helpers.diff(whitelisted_users, diffable_new, key: :login, fields: [:login, :role])
 
+      results = []
       # Create new users
-      role_list = roles
       u = diff[:added].map do |x|
         {
           user: x,
-          role: x[:role] || x[:roles]
+          role: x[:role]
         }
       end
-      results.concat create_users(u, roles: role_list, domain: domain)
+
+      results.concat create_users(u, roles: role_list, domain: domain, project_users: whitelisted_users)
 
       # # Update existing users
       list = diff[:changed].map { |x| { user: x[:new_obj], role: x[:new_obj][:role] || x[:new_obj][:roles] } }
-      results.concat set_users_roles(list, roles: role_list)
+      results.concat(set_users_roles(list, roles: role_list, project_users: whitelisted_users))
 
       # Remove old users
       results.concat(disable_users(diff[:removed]))
       results
     end
 
-    def disable_users(list, options = {})
-      project_users = options[:project_users] || users
-      list.map { |u| get_user(u, project_users) }.pmap(&:disable)
+    def disable_users(list)
+      list = list.map(&:to_hash)
+      url = "#{uri}/users"
+      payloads = list.map do |u|
+        generate_user_payload(u[:uri], 'DISABLED')
+      end
+      payloads.each_slice(100).mapcat do |payload|
+        client.post(url, 'users' => payload)
+      end
     end
 
-    # Update user
-    #
-    # @param user User to be updated
-    # @param desired_roles Roles to be assigned to user
-    # @param role_list Optional cached list of roles used for lookups
-    def set_user_roles(login, desired_roles, options = {})
+    def verify_user_to_add(login, desired_roles, options = {})
+      user = login if login.respond_to?(:uri) && !login.uri.nil?
       role_list = options[:roles] || roles
+      desired_roles = Array(desired_roles)
+      roles = desired_roles.map do |role_name|
+        role = get_role(role_name, role_list)
+        fail ArgumentError, "Invalid role '#{role_name}' specified for user '#{user.email}'" if role.nil?
+        role.uri
+      end
+      return [user.uri, roles] if user
+
       domain = client.domain(options[:domain]) if options[:domain]
-      project_users = options[:project_users] || users
       domain_users = options[:domain_users] || (domain && domain.users)
+      project_users = options[:project_users] || users
 
       project_user = get_user(login, project_users)
-      domain_user = domain.get_user(login, domain_users) if domain && !project_user
+      domain_user = if domain && !project_user && !user
+                      domain.get_user(login, domain_users) if domain && !project_user
+                    end
       user = project_user || domain_user
       fail ArgumentError, "Invalid user '#{login}' specified" unless user
+      [user.uri, roles]
+    end
 
-      desired_roles = [desired_roles] unless desired_roles.is_a? Array
-      roles = desired_roles.map do |role_name|
-        role = get_role(role_name, role_list)
-        fail ArgumentError, "Invalid role '#{role_name}' specified for user '#{user.email}'" if role.nil?
-        role.uri
-      end
-
+    # Update user
+    #
+    # @param user User to be updated
+    # @param desired_roles Roles to be assigned to user
+    # @param role_list Optional cached list of roles used for lookups
+    def set_user_roles(login, desired_roles, options = {})
+      user_uri, roles = verify_user_to_add(login, desired_roles, options)
       url = "#{uri}/users"
-      payload = {
-        'user' => {
-          'content' => {
-            'status' => 'ENABLED',
-            'userRoles' => roles
-          },
-          'links' => {
-            'self' => user.uri
-          }
-        }
-      }
-
+      payload = generate_user_payload(user_uri, 'ENABLED', roles)
       client.post(url, payload)
     end
 
@@ -997,29 +1030,27 @@ module GoodData
     # @param list List of users to be updated
     # @param role_list Optional list of cached roles to prevent unnecessary server round-trips
     def set_users_roles(list, options = {})
+      return [] if list.empty?
       role_list = options[:roles] || roles
       project_users = options[:project_users] || users
       domain = options[:domain] && client.domain(options[:domain])
       domain_users = domain.nil? ? nil : domain.users
-
-      list.pmap do |user_hash|
+      users_to_add = list.flat_map do |user_hash|
+        user = user_hash[:user] || user_hash[:login]
+        desired_roles = user_hash[:role] || user_hash[:roles] || 'readOnlyUser'
         begin
-          user = user_hash[:user]
-          desired_roles = user_hash[:role] || user_hash[:roles] || 'readOnlyUser'
-          result = add_user(user, desired_roles, options.merge(domain: domain,
-                                                               domain_users: domain_users,
-                                                               roles: role_list,
-                                                               project_users: project_users))
-
-          {
-            type: :role_set,
-            user: user,
-            result: result
-          }
-        rescue ArgumentError, RuntimeError => e
-          { type: :error, reason: e }
+          login, roles = verify_user_to_add(user, desired_roles, options.merge(domain_users: domain_users, project_users: project_users, roles: role_list))
+          [{ login: login, roles: roles }]
+        rescue
+          []
         end
       end
+      payloads = users_to_add.map { |u| generate_user_payload(u[:login], 'ENABLED', u[:roles]) }
+      url = "#{uri}/users"
+      results = payloads.each_slice(100).map do |payload|
+        client.post(url, 'users' => payload)
+      end
+      results.flat_map { |x| x['projectUsersUpdateResult'].flat_map { |k, v| v.map { |v_2| { status: k.to_sym, uri: v_2 } } } }
     end
 
     alias_method :add_users, :set_users_roles
@@ -1051,5 +1082,22 @@ module GoodData
     def variables(id = :all, options = { client: client, project: self })
       GoodData::Variable[id, options]
     end
+
+    private
+
+    def generate_user_payload(user_uri, status = 'ENABLED', roles_uri = nil)
+      payload = {
+        'user' => {
+          'content' => {
+            'status' => status
+          },
+          'links' => {
+            'self' => user_uri
+          }
+        }
+      }
+      payload['user']['content']['userRoles'] = roles_uri if roles_uri
+      payload
+    end
   end
 end

data/lib/gooddata/models/project_role.rb

@@ -20,6 +20,30 @@ module GoodData
     include GoodData::Mixin::Contributor
     include GoodData::Mixin::Timestamps
 
+    EMPTY_OBJECT = {
+      'projectRole' => {
+        'permissions' => {},
+        'links' => {},
+        'meta' => {}
+      }
+    }
+
+    def self.create_object(data)
+      meta_data = {}.tap do |d|
+        d[:created] = data[:created] || Time.now
+        d[:identifier] = data[:identifier]
+        d[:updated] = data[:updated] || d[:created] || Time.now
+        d[:title] = data[:title]
+        d[:summary] = data[:summary]
+      end
+      new_data = EMPTY_OBJECT.deep_dup.tap do |d|
+        d['projectRole']['links']['self'] = data[:uri] if data[:uri]
+        d['projectRole']['meta'] = d['projectRole']['meta'].merge(meta_data.stringify_keys)
+        d['projectRole']['permissions'] = d['projectRole']['permissions'].merge((data[:permissions] || {}).stringify_keys)
+      end
+      new(new_data)
+    end
+
     def initialize(json)
       @json = json
     end
@@ -45,6 +69,8 @@ module GoodData
     #
     # @return [string] URI of this project role
     def uri
+      return @json['projectRole']['links']['self'] if @json['projectRole']['links']['self']
+      return nil unless @json['projectRole']['links']['roleUsers']
       @json['projectRole']['links']['roleUsers'].split('/')[0...-1].join('/')
     end
 

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

@@ -33,6 +33,7 @@ module GoodData
     def self.read_file(file, options = {})
       memo = {}
       params = row_based?(options) ? { headers: false } : { headers: true }
+
       CSV.foreach(file, params.merge(return_headers: false)) do |e|
         key, data = process_line(e, options)
         memo[key] = [] unless memo.key?(key)
@@ -105,7 +106,7 @@ module GoodData
       end
     end
 
-    def self.verify_existing_users(filters, options = { project: GoodData.project, client: GoodData.connection })
+    def self.verify_existing_users(filters, options = {})
       project = options[:project]
 
       users_must_exist = options[:users_must_exist] == false ? false : true
@@ -118,7 +119,7 @@ module GoodData
       end
     end
 
-    def self.create_label_cache(result, options = { project: GoodData.project, client: GoodData.connection })
+    def self.create_label_cache(result, options = {})
       project = options[:project]
 
       result.reduce({}) do |a, e|
@@ -166,7 +167,7 @@ module GoodData
             label.find_value_uri(v)
           end
         rescue
-          errors << [label, v]
+          errors << [label.title, v]
           nil
         end
       end
@@ -204,7 +205,7 @@ module GoodData
     #
     # @param filters [Array<Hash>] Filters definition
     # @return [Array] first is list of MAQL statements
-    def self.maqlify_filters(filters, options = { project: GoodData.project, client: GoodData.connection })
+    def self.maqlify_filters(filters, options = {})
       project = options[:project]
       users_cache = options[:users_cache] || create_cache(project.users, :login)
       labels_cache = create_label_cache(filters, options)
@@ -262,7 +263,7 @@ module GoodData
     # @param options [Hash]
     # @option options [Boolean] :dry_run If dry run is true. No changes to he proejct are made but list of changes is provided
     # @return [Array] list of filters that needs to be created and deleted
-    def self.execute_variables(filters, var, options = { client: GoodData.connection, project: GoodData.project })
+    def self.execute_variables(filters, var, options = {})
       client = options[:client]
       project = options[:project]
       dry_run = options[:dry_run]
@@ -281,7 +282,7 @@ module GoodData
       [to_create, to_delete]
     end
 
-    def self.execute_mufs(filters, options = { client: GoodData.connection, project: GoodData.project })
+    def self.execute_mufs(filters, options = {})
       client = options[:client]
       project = options[:project]
 
@@ -289,7 +290,7 @@ module GoodData
       to_create, to_delete = execute(filters, project.data_permissions, MandatoryUserFilter, options.merge(type: :muf))
       return [to_create, to_delete] if dry_run
 
-      to_create.each_pair do |related_uri, group|
+      to_create.peach do |related_uri, group|
         group.each(&:save)
 
         res = client.get("/gdc/md/#{project.pid}/userfilters?users=#{related_uri}")
@@ -306,7 +307,7 @@ module GoodData
         client.post("/gdc/md/#{project.pid}/userfilters", payload)
       end
       unless options[:do_not_touch_filters_that_are_not_mentioned]
-        to_delete.each do |related_uri, group|
+        to_delete.peach do |related_uri, group|
           if related_uri
             res = client.get("/gdc/md/#{project.pid}/userfilters?users=#{related_uri}")
             items = res['userFilters']['items'].empty? ? [] : res['userFilters']['items'].first['userFilters']
@@ -365,7 +366,7 @@ module GoodData
     # @param klass [Class] Class can be aither UserFilter or VariableFilter
     # @param options [Hash] Filter definitions
     # @return [Array<Hash>]
-    def self.execute(user_filters, project_filters, klass, options = { client: GoodData.connection, project: GoodData.project })
+    def self.execute(user_filters, project_filters, klass, options = {})
       client = options[:client]
       project = options[:project]