gooddata 0.6.11 → 0.6.12

data/lib/gooddata/models/metadata/metric.rb

@@ -17,8 +17,6 @@ module GoodData
     include GoodData::Mixin::RestResource
     root_key :metric
 
-    PARSE_MAQL_OBJECT_REGEXP = /\[([^\]]+)\]/
-
     class << self
       # Method intended to get all objects of that type in a specified project
       #
@@ -212,27 +210,7 @@ module GoodData
     # Looks up the readable values of the objects used inside of MAQL epxpressions. Labels and elements titles are based on the primary label.
     # @return [String] Ther resulting MAQL like expression
     def pretty_expression
-      opts = {
-        :client => client,
-        :project => project
-      }
-
-      temp = expression.dup
-      pairs = expression.scan(PARSE_MAQL_OBJECT_REGEXP).pmap do |uri|
-        uri = uri.first
-        if uri =~ /elements/
-          [uri, Attribute.find_element_value(uri, opts)]
-        else
-          [uri, GoodData::MdObject[uri, opts].title]
-        end
-      end
-
-      pairs.each do |el|
-        uri = el[0]
-        obj = el[1]
-        temp.sub!(uri, obj)
-      end
-      temp
+      SmallGoodZilla.pretty_print(expression, client: client, project: project)
     end
   end
 end

data/lib/gooddata/models/metadata/report.rb

@@ -120,8 +120,8 @@ module GoodData
     #
     # @return [String] Returns data
     def export(format)
-      result = GoodData.post('/gdc/xtab2/executor3', 'report_req' => { 'report' => uri })
-      result1 = GoodData.post('/gdc/exporter/executor', :result_req => { :format => format, :result => result })
+      result = client.post('/gdc/xtab2/executor3', 'report_req' => { 'report' => uri })
+      result1 = client.post('/gdc/exporter/executor', :result_req => { :format => format, :result => result })
       GoodData.poll_on_code(result1['uri'], process: false)
     end
 

data/lib/gooddata/models/metadata/report_definition.rb

@@ -44,6 +44,12 @@ module GoodData
         }
       end
 
+      def create_filters_part(filters)
+        filters.select { |f| f.class == GoodData::Variable }.map do |v|
+          { expression: "[#{v.uri}]" }
+        end
+      end
+
       def create_part(stuff)
         stuff = Array(stuff)
         parts = stuff.reduce([]) do |memo, item|
@@ -146,7 +152,6 @@ module GoodData
           }
         }
         uri = "/gdc/app/projects/#{project.pid}/execute"
-
         client.post(uri, data)
       end
 
@@ -170,6 +175,13 @@ module GoodData
         end
       end
 
+      # Return true if the report definition is a chart
+      #
+      # @return [Boolean] Return true if report definition is a chart
+      def chart?
+        !table?
+      end
+
       def create(options = { :client => GoodData.connection, :project => GoodData.project })
         client = options[:client]
         fail ArgumentError, 'No :client specified' if client.nil?
@@ -182,6 +194,7 @@ module GoodData
 
         left = Array(options[:left])
         top = Array(options[:top])
+        filters = options[:filters] || []
 
         left = ReportDefinition.find(left, options)
         top = ReportDefinition.find(top, options)
@@ -204,7 +217,7 @@ module GoodData
                 'rows' => ReportDefinition.create_part(left)
               },
               'format' => 'grid',
-              'filters' => []
+              'filters' => ReportDefinition.create_filters_part(filters)
             },
             'meta' => {
               'tags' => '',
@@ -373,5 +386,12 @@ module GoodData
       end
       self
     end
+
+    # Return true if the report definition is a table
+    #
+    # @return [Boolean] Return true if report definition is a table
+    def table?
+      content['format'] == 'grid'
+    end
   end
 end

data/lib/gooddata/models/metadata/variable.rb

@@ -0,0 +1,81 @@
+# encoding: UTF-8
+
+require_relative '../metadata'
+
+require_relative 'metadata'
+
+module GoodData
+  class Variable < MdObject
+    root_key :prompt
+
+    class << self
+      # Method intended to get all objects of that type in a specified project
+      #
+      # @param options [Hash] the options hash
+      # @option options [Boolean] :full if passed true the subclass can decide to pull in full objects. This is desirable from the usability POV but unfortunately has negative impact on performance so it is not the default
+      # @return [Array<GoodData::MdObject> | Array<Hash>] Return the appropriate metadata objects or their representation
+      def all(options = { :client => GoodData.connection, :project => GoodData.project })
+        query('prompts', Variable, options)
+      end
+
+      def create(data, options = { :client => GoodData.connection, :project => GoodData.project })
+        title = data[:title]
+        project = options[:project]
+        c = client(options)
+        attribute = project.attributes(data[:attribute])
+
+        payload = {
+          'prompt' => {
+            'content' => {
+              'attribute' => attribute.uri,
+              'type' => 'filter'
+            },
+            'meta' => {
+              'tags' => '',
+              'deprecated' => '0',
+              'summary' => '',
+              'title' => title,
+              'category' => 'prompt'
+            }
+          }
+        }
+        c.create(self, payload, project: project)
+      end
+    end
+
+    # Retrieves variable values
+    #
+    # @return [Array<GoodData::VariableUserFilter>] Values of variable
+    def values
+      payload = {
+        variablesSearch: {
+          variables: [
+            uri
+          ],
+          context: []
+        }
+      }
+      client.post("/gdc/md/#{project.pid}/variables/search", payload)['variables'].map { |f| client.create(GoodData::VariableUserFilter, f, project: project) }
+    end
+
+    # Retrieves variable values and returns only those related to user
+    #
+    # @return [Array<GoodData::VariableUserFilter>] Values of variable related to user
+    def user_values
+      values.select { |x| x.level == :user }
+    end
+
+    # Retrieves variable values and returns only those related to project
+    #
+    # @return [Array<GoodData::VariableUserFilter>] Values of variable related to project
+    def project_values
+      values.select { |x| x.level == :project }
+    end
+
+    # Deletes all the values and eventually the variable itself
+    def delete
+      values.pmap(&:delete)
+      super
+    end
+  end
+end

data/lib/gooddata/models/model.rb

@@ -6,6 +6,7 @@ require_relative 'metadata/metadata'
 
 require_relative 'links'
 require_relative 'module_constants'
+require_relative 'user_filters/user_filters'
 
 require 'fileutils'
 require 'multi_json'
@@ -122,7 +123,7 @@ module GoodData
 
         if res['taskStatus'] == 'ERROR' # rubocop:disable Style/GuardClause
           s = StringIO.new
-          client.download_from_user_webdav(File.basename(dir) + '/upload_status.json', s)
+          client.download_from_user_webdav(File.basename(dir) + '/upload_status.json', s, :client => client, :project => project)
           js = MultiJson.load(s.string)
           fail "Load Failed with error #{JSON.pretty_generate(js)}"
         end

data/lib/gooddata/models/process.rb

@@ -51,7 +51,6 @@ module GoodData
         Process[:all]
       end
 
-      # TODO: Check the params.
       def with_deploy(dir, options = {}, &block)
         client = options[:client]
         fail ArgumentError, 'No :client specified' if client.nil?
@@ -87,7 +86,7 @@ module GoodData
         project = GoodData::Project[p, opts]
         fail ArgumentError, 'Wrong :project specified' if project.nil?
 
-        zip_and_upload path, files_to_exclude, opts
+        zip_and_upload(path, files_to_exclude, opts)
       end
 
       # Deploy a new process or redeploy existing one.
@@ -119,7 +118,7 @@ module GoodData
         verbose = options[:verbose] || false
         puts HighLine.color("Deploying #{path}", HighLine::BOLD) if verbose
 
-        deployed_path = Process.upload_package(path, files_to_exclude, :client => client, :project => project)
+        deployed_path = Process.upload_package(path, files_to_exclude, client: client, project: project)
         data = {
           :process => {
             :name => deploy_name,
@@ -197,7 +196,7 @@ module GoodData
     # @option options [String] :name Readable name of the process
     # @option options [Boolean] :verbose (false) Switch on verbose mode for detailed logging
     def deploy(path, options = {})
-      Process.deploy(path, options.merge(:process_id => process_id, :client => client, :project => project))
+      Process.deploy(path, client: client, process_id: process_id, :project => project).merge(options)
     end
 
     # Downloads the process from S3 in a zipped form.

data/lib/gooddata/models/profile.rb

@@ -68,26 +68,13 @@ module GoodData
         c.factory.create(Profile, response)
       end
 
-      # Apply changes to object.
-      #
-      # @param obj [GoodData::Profile] Object to be modified
-      # @param changes [Hash] Hash with modifications
-      # @return [GoodData::Profile] Modified object
-      def apply(obj, changes)
-        changes.each do |param, val|
-          next unless ASSIGNABLE_MEMBERS.include? param
-          obj.send("#{param}=", val)
-        end
-        obj
-      end
-
       # Creates new instance from hash with attributes
       #
       # @param attributes [Hash] Hash with initial attributes
       # @return [GoodData::Profile] New profile instance
       def create(attributes)
         json = EMPTY_OBJECT.dup
-        res = GoodData::Profile.new(json)
+        res = client.create(GoodData::Profile, json)
 
         attributes.each do |k, v|
           res.send("#{k}=", v) if ASSIGNABLE_MEMBERS.include? k
@@ -97,62 +84,20 @@ module GoodData
         res
       end
 
-      # Gets user currently logged in
-      # @return [GoodData::Profile] User currently logged-in
-      def current
-        GoodData.connection.user
+      def diff(item_1, item_2)
+        x = diff_list([item_1], [item_2])
+        return {} if x[:changed].empty?
+        x[:changed].first[:diff]
       end
 
-      # Gets hash representing diff of profiles
-      #
-      # @param user1 [GoodData::Profile] Original user
-      # @param user2 [GoodData::Profile] User to compare with
-      # @return [Hash] Hash representing diff
-      def diff(user1, user2)
-        res = {}
-        ASSIGNABLE_MEMBERS.each do |k|
-          l_value = user1.send("#{k}")
-          r_value = user2.send("#{k}")
-          res[k] = r_value if l_value != r_value
-        end
-        res
+      def diff_list(list_1, list_2)
+        GoodData::Helpers.diff(list_1, list_2, key: :login)
       end
 
-      def diff_list(list1, list2)
-        tmp = Hash[list1.map { |v| [v.email, v] }]
-
-        res = {
-          :added => [],
-          :removed => [],
-          :changed => []
-        }
-
-        list2.each do |user_new|
-          user_existing = tmp[user_new.email]
-          if user_existing.nil?
-            res[:added] << user_new
-            next
-          end
-
-          next if user_existing == user_new
-
-          diff = self.diff(user_existing, user_new)
-          res[:changed] << {
-            :user => user_existing,
-            :diff => diff
-          }
-        end
-
-        tmp = Hash[list2.map { |v| [v.email, v] }]
-        list1.each do |user_existing|
-          user_new = tmp[user_existing.email]
-          if user_new.nil?
-            res[:removed] << user_existing
-            next
-          end
-        end
-
-        res
+      # Gets user currently logged in
+      # @return [GoodData::Profile] User currently logged-in
+      def current
+        client.user
       end
     end
 
@@ -169,13 +114,8 @@ module GoodData
     # @param right [GoodData::Profile] Project to compare with
     # @return [Boolean] True if same else false
     def ==(other)
-      res = true
-      ASSIGNABLE_MEMBERS.each do |k|
-        l_val = send("#{k}")
-        r_val = other.send("#{k}")
-        res = false if l_val != r_val
-      end
-      res
+      return false unless other.respond_to?(:to_hash)
+      to_hash == other.to_hash
     end
 
     # Checks objects for non-equality
@@ -190,9 +130,9 @@ module GoodData
     #
     # @param changes [Hash] Hash with modifications
     # @return [GoodData::Profile] Modified object
-    def apply(changes)
-      GoodData::Profile.apply(self, changes)
-    end
+    # def apply(changes)
+    #   GoodData::Profile.apply(self, changes)
+    # end
 
     # Gets the company name
     #
@@ -374,7 +314,7 @@ module GoodData
 
         if uri && !uri.empty?
           url = "/gdc/account/profile/#{obj_id}"
-          @json = GoodData.put url, raw
+          @json = client.put url, raw
           @dirty = false
         end
       end
@@ -406,14 +346,42 @@ module GoodData
     #
     # @return [String] Resource URI
     def uri
-      @json['accountSetting']['links']['self']
+      GoodData::Helpers.get_path(@json, %w(accountSetting links self))
+      # @json['accountSetting']['links']['self']
     end
 
-    private
+    def data
+      data = @json || {}
+      data['accountSetting'] || {}
+    end
 
-    def initialize(json)
-      @json = json
-      @user = @json['accountSetting']['firstName'] + ' ' + @json['accountSetting']['lastName']
+    def links
+      data['links'] || {}
+    end
+
+    def content
+      keys = (data.keys - ['links'])
+      data.slice(*keys)
+    end
+
+    def name
+      (first_name || '') + (last_name || '')
+    end
+
+    def to_hash
+      tmp = content.merge(uri: uri).symbolize_keys
+      [
+        [:companyName, :company],
+        [:phoneNumber, :phone],
+        [:firstName, :first_name],
+        [:lastName, :last_name],
+        [:authenticationModes, :authentication_modes]
+      ].each do |vals|
+        wire, rb = vals
+        tmp[rb] = tmp[wire]
+        tmp.delete(wire)
+      end
+      tmp
     end
   end
 end

data/lib/gooddata/models/project.rb

@@ -152,6 +152,10 @@ module GoodData
       end
     end
 
+    # Creates a metric in a project
+    #
+    # @param [options] Optional report options
+    # @return [GoodData::Report] Instance of new report
     def add_metric(metric, options = {})
       default = { client: client, project: self }
       if metric.is_a?(String)
@@ -189,7 +193,7 @@ module GoodData
     #
     # @return [Boolean] True if user has admin role in the project, false otherwise.
     def am_i_admin?
-      user_has_role?(GoodData.user, 'admin')
+      user_has_role?(client.user, 'admin')
     end
 
     # Helper for getting attributes of a project
@@ -252,6 +256,10 @@ module GoodData
       end
     end
 
+    def dimensions(id = :all)
+      GoodData::Dimension[id, client: client, project: self]
+    end
+
     # Export a clone from a project to be later imported.
     # If you do not want to do anything special and you do not need fine grained
     # controle use clone method which does all the heavy lifting for you.
@@ -302,17 +310,20 @@ module GoodData
     end
 
     def compute_report(spec = {})
-      GoodData::ReportDefinition.execute(spec.merge(:client => client, :project => self))
+      GoodData::ReportDefinition.execute(spec.merge(client: client, project: self))
     end
 
     def compute_metric(expression)
-      GoodData::Metric.xexecute(expression, :client => client, :project => self)
+      GoodData::Metric.xexecute(expression, client: client, project: self)
     end
 
     def create_schedule(process, date, executable, options = {})
-      GoodData::Schedule.create(process, date, executable, options.merge(:client => client, :project => self))
+      GoodData::Schedule.create(process, date, executable, options.merge(client: client, project: self))
     end
 
+    def create_variable(data)
+      GoodData::Variable.create(data, client: client, project: self)
+    end
     # Helper for getting dashboards of a project
     #
     # @param [String | Number | Object] Anything that you can pass to GoodData::Dashboard[id]
@@ -325,6 +336,10 @@ module GoodData
       blueprint.datasets
     end
 
+    def data_permissions
+      GoodData::MandatoryUserFilter.all(client: client, project: self)
+    end
+
     # Deletes project
     def delete
       fail "Project '#{title}' with id #{uri} is already deleted" if state == :deleted
@@ -401,6 +416,13 @@ module GoodData
       GoodData::Attribute.find_element_value(uri, client: client, project: self)
     end
 
+    # Get WebDav directory for project data
+    # @return [String]
+    def get_project_webdav_path(_file)
+      u = URI(links['uploads'])
+      URI.join(u.to_s.chomp(u.path.to_s), '/project-uploads/', "#{pid}/")
+    end
+
     # Gets project role by its identifier
     #
     # @param [String] role_name Title of role to look for
@@ -454,122 +476,55 @@ module GoodData
       nil
     end
 
-    # Gets user by its email, full_name, login or uri
+    # 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.
     #
     # @param [String] name Name to look for
     # @param [Array<GoodData::User>]user_list Optional cached list of users used for look-ups
     # @return [GoodDta::Membership] User
-    def get_user(name, user_list = users)
-      return name if name.instance_of?(GoodData::Membership)
-      return member(name) if name.instance_of?(GoodData::Profile)
-      name.downcase!
-      user_list.each do |user|
-        return user if user.uri.downcase == name ||
-                       user.login.downcase == name ||
-                       user.email.downcase == name
+    def get_user(slug, user_list = users)
+      search_crit = if slug.respond_to?(:login)
+                      slug.login || slug.uri
+                    elsif slug.is_a?(Hash)
+                      slug[:login] || slug[:uri]
+                    else
+                      slug
+                    end
+      return nil unless search_crit
+      user_list.find do |user|
+        user.uri == search_crit.downcase ||
+          user.login.downcase == search_crit.downcase
       end
-      nil
     end
 
-    # Exports project users to file
-    def import_users(path, opts = { :header => true }, &_block)
-      opts[:path] = path
-
-      ##########################
-      # Caching/Cached objects
-      ##########################
-      domains = {}
-      current_users = users
-      role_list = roles
-
-      ##########################
-      # Load users from CSV
-      ##########################
-      new_users = GoodData::Helpers.csv_read(opts) do |row|
-        json = {}
-        if block_given?
-          json = yield row
-        else
-          json = {
-            'user' => {
-              'content' => {
-                'email' => row[0],
-                'login' => row[1],
-                'firstname' => row[2],
-                'lastname' => row[3]
-              },
-              'meta' => {}
-            }
-          }
-        end
-
-        GoodData::User.new(json)
-      end
-
-      ##########################
-      # Diff users
-      ##########################
-      diff = GoodData::User.diff_list(current_users, new_users)
-
-      ##########################
-      # Create new users
-      ##########################
-      diff[:added].map do |user|
-        # TODO: Add user here
-        domain_name = user.json['user']['content']['domain']
-
-        # Lookup for domain in cache'
-        domain = domains[domain_name]
-
-        # Get domain info from REST, add to cache
-        if domain.nil?
-          domain = {
-            :domain => GoodData::Domain[domain_name],
-            :users => GoodData::Domain[domain_name].users
-          }
-
-          domain[:users_map] = Hash[domain[:users].map { |u| [u.email, u] }]
-          domains[domain_name] = domain
-        end
-
-        # Check if user exists in domain
-        domain_user = domain[:users_map][user.email]
-
-        # Create domain user if needed
-        unless domain_user
-          password = user.json['user']['content']['password']
-
-          # Fill necessary user data
-          user_data = {
-            :login => user.login,
-            :firstName => user.first_name,
-            :lastName => user.last_name,
-            :password => password,
-            :verifyPassword => password,
-            :email => user.login
-          }
-
-          # Add created user to cache
-          domain_user = domain[:domain].add_user(user_data)
-          domain[:users] << domain_user
-          domain[:users_map][user.email] = domain_user
-        end
+    # Get WebDav directory for user data
+    # @return [String]
+    def get_user_webdav_path(_file)
+      u = URI(links['uploads'])
+      URI.join(u.to_s.chomp(u.path.to_s), '/uploads/')
+    end
 
-        # Lookup for role
-        role_name = user.json['user']['content']['role'] || 'readOnlyUser'
-        role = get_role_by_identifier(role_name, role_list)
-        next if role.nil?
+    # Gets user by its email, full_name, login or uri
+    alias_method :member, :get_user
 
-        # Assign user project role
-        add_user(domain_user, [role.uri])
+    # Gets user by its email, full_name, login or uri.
+    #
+    # @param [String] name Name to look for
+    # @param [Array<GoodData::User>]user_list Optional cached list of users used for look-ups
+    # @return [GoodDta::Membership] User
+    def fuzzy_get_user(name, user_list = users)
+      return name if name.instance_of?(GoodData::Membership)
+      return member(name) if name.instance_of?(GoodData::Profile)
+      name = name.is_a?(Hash) ? name[:login] || name[:uri] : name
+      return nil unless name
+      name.downcase!
+      user_list.select do |user|
+        user.uri.downcase == name ||
+          user.login.downcase == name ||
+          user.email.downcase == name
       end
-
-      ##########################
-      # Remove old users
-      ##########################
-      # diff[:removed].map do |user|
-      #   user.disable(self)
-      # end
+      nil
     end
 
     # Checks whether user has particular role in given proejct
@@ -665,20 +620,6 @@ module GoodData
       @md ||= client.create(Links, client.get(data['links']['metadata']))
     end
 
-    # Gets membership for profile specified
-    #
-    # @param [GoodData::Profile] profile - Profile to be checked
-    # @param [Array<GoodData::Membership>] list Optional list of members to check against
-    # @return [GoodData::Membership] Membership if found
-    def member(profile, list = members)
-      if profile.is_a? String
-        return list.find do |m|
-          m.uri == profile || m.login == profile
-        end
-      end
-      list.find { |m| m.login == profile.login }
-    end
-
     # Get data from project specific metadata storage
     #
     # @param [Symbol | String] :all or nothing for all keys or a string for value of specific key
@@ -719,6 +660,10 @@ module GoodData
       !member(profile, list).nil?
     end
 
+    def members?(profiles, list = members)
+      profiles.map { |p| member?(p, list) }
+    end
+
     # Gets raw resource ID
     #
     # @return [String] Raw resource ID
@@ -850,7 +795,7 @@ module GoodData
       tmp = client.get(url)
       tmp['projectRoles']['roles'].pmap do |role_url|
         json = client.get role_url
-        client.create(GoodData::ProjectRole, json)
+        client.create(GoodData::ProjectRole, json, project: self)
       end
     end
 
@@ -926,103 +871,81 @@ module GoodData
     # List of users in project
     #
     # @return [Array<GoodData::User>] List of users
-    def users
-      tmp = client.get @json['project']['links']['users']
-      tmp['users'].map do |user|
-        client.factory.create(GoodData::Membership, user)
+    def users(opts = { offset: 0, limit: 100 })
+      result = []
+
+      # TODO: @korczis, review this after WA-3953 get fixed
+      offset = 0 || opts[:offset]
+      uri = "/gdc/projects/#{pid}/users?offset=#{offset}&limit=#{opts[:limit]}"
+      loop do
+        break unless uri
+        tmp = client(opts).get(uri)
+        tmp['users'].each do |user|
+          result << client.factory.create(GoodData::Membership, user, project: self)
+        end
+        offset += opts[:limit]
+        if tmp['users'].length == opts[:limit]
+          uri = "/gdc/projects/#{pid}/users?offset=#{offset}&limit=#{opts[:limit]}"
+        else
+          uri = nil
+        end
       end
+
+      opts[:all] ? result : result.select(&:enabled?).reject(&:deleted?)
     end
 
     alias_method :members, :users
 
-    def users_create(list, role_list = roles)
-      domains = {}
-      list.map do |user|
-        # TODO: Add user here
-        domain_name = user.json['user']['content']['domain']
-
-        # Lookup for domain in cache'
-        domain = domains[domain_name]
-
-        # Get domain info from REST, add to cache
-        if domain.nil?
-          d = GoodData::Domain[domain_name, { :client => client }]
-          domain = {
-            :domain => d,
-            :users => d.users(:client => client)
-          }
+    def whitelist_users(new_users, users_list, whitelist)
+      # whitelist_users
+      return [new_users, users_list] unless whitelist
 
-          domain[:users_map] = Hash[domain[:users].map { |u| [u.email, u] }]
-          domains[domain_name] = domain
-        end
+      whitelist_proc = proc do |user|
+        whitelist.any? { |wl| wl.is_a?(Regexp) ? user[:login] =~ wl : user[:login].include?(wl) }
+      end
 
-        # Check if user exists in domain
-        domain_user = domain[:users_map][user.email]
-        fail ArgumentError, "Trying to add user '#{user.login}' which is not valid user in domain '#{domain_name}'" if domain_user.nil?
+      [new_users.reject(&whitelist_proc), users_list.reject(&whitelist_proc)]
+    end
 
-        # Lookup for role
-        role_name = user.json['user']['content']['role'] || 'readOnlyUser'
-        role = get_role(role_name, role_list)
-        fail ArgumentError, "Invalid role name specified '#{role_name}' for user '#{user.email}'" if role.nil?
+    # Imports users
+    def import_users(new_users, options = {})
+      domain = options[:domain]
+      users_list = users.map(&:to_hash)
+      new_users = new_users.map { |x| (x.is_a?(Hash) && x[:user] && x[:user].to_hash.merge(role: x[:role])) || x.to_hash }
 
-        # Assign user project role
-        set_user_roles(domain_user, [role.uri], role_list)
-      end
-    end
+      whitelisted_new_users, whitelisted_users = whitelist_users(new_users.map(&:to_hash), users_list, options[:whitelists])
 
-    # Imports users from CSV
-    #
-    # # Features
-    # - Create new users
-    # - Delete old users
-    # - Update existing users
-    #
-    # CSV Format
-    # TODO: Describe CSV Format here
-    #
-    # @param path CSV file to be loaded
-    # @param opts Optional additional options
-    def users_import(new_users, domain = nil)
       # Diff users
-      diff = GoodData::Membership.diff_list(users, new_users)
-
+      diff = GoodData::Helpers.diff(whitelisted_users, whitelisted_new_users, key: :login)
+      results = []
       # Create domain users
-      GoodData::Domain.users_create(diff[:added], domain)
+      results.concat domain.create_users(diff[:added])
+
+      # Update domain users
+      domain.create_users(diff[:changed].map { |u| u[:new_obj] })
 
       # Create new users
       role_list = roles
-      users_create(diff[:added], role_list)
-
-      # Get changed users objects from hash
-      list = diff[:changed].map do |user|
-        user[:user]
-      end
-
-      # Join list of changed users with 'same' users
-      list = list.zip(diff[:same]).flatten.compact
-
-      new_users_map = Hash[new_users.map { |u| [u.email, u] }]
-
-      # Create list with user, desired_roles hashes
-      list = list.map do |user|
+      u = diff[:added].map do |x|
         {
-          :user => user,
-          :roles => new_users_map[user.email].json['user']['content']['role'].split(' ').map(&:downcase).sort
+          user: x,
+          role: x[:role] || x[:roles]
         }
       end
+      results.concat create_users(u, roles: role_list, domain: domain)
 
-      # Update existing users
-      set_users_roles(list, role_list)
+      # # 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)
 
       # Remove old users
-      users_remove(diff[:removed])
+      results.concat(disable_users(diff[:removed]))
+      results
     end
 
-    # Disable users
-    #
-    # @param list List of users to be disabled
-    def users_remove(list)
-      list.pmap(&:disable)
+    def disable_users(list, options = {})
+      project_users = options[:project_users] || users
+      list.map { |u| get_user(u, project_users) }.pmap(&:disable)
     end
 
     # Update user
@@ -1030,14 +953,18 @@ module GoodData
     # @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(user, desired_roles, role_list = roles)
-      if user.is_a? String
-        user = get_user(user)
-        fail ArgumentError, "Invalid user '#{user}' specified" if user.nil?
-      end
+    def set_user_roles(login, desired_roles, options = {})
+      role_list = options[:roles] || roles
+      domain = client.domain(options[:domain]) if options[:domain]
+      project_users = options[:project_users] || users
+      domain_users = options[:domain_users] || (domain && domain.users)
 
-      desired_roles = [desired_roles] unless desired_roles.is_a? Array
+      project_user = get_user(login, project_users)
+      domain_user = domain.get_user(login, domain_users) if domain && !project_user
+      user = project_user || domain_user
+      fail ArgumentError, "Invalid user '#{login}' specified" unless user
 
+      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?
@@ -1057,7 +984,7 @@ module GoodData
         }
       }
 
-      client.post url, payload
+      client.post(url, payload)
     end
 
     alias_method :add_user, :set_user_roles
@@ -1066,17 +993,43 @@ 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, _role_list = roles)
+    def set_users_roles(list, options = {})
+      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|
-        user = user_hash[:user]
-        roles = user_hash[:role] || user_hash[:roles]
-        {
-          :user => user,
-          :result => set_user_roles(user, roles)
-        }
+        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 }
+        end
       end
     end
 
+    alias_method :add_users, :set_users_roles
+    alias_method :create_users, :set_users_roles
+
+    def add_data_permissions(filters, options = {})
+      GoodData::UserFilterBuilder.execute_mufs(filters, { client: client, project: self }.merge(options))
+    end
+
+    def add_variable_permissions(filters, var, options = {})
+      GoodData::UserFilterBuilder.execute_variables(filters, var, { client: client, project: self }.merge(options))
+    end
+
     # Run validation on project
     # Valid settins for validation are (default all):
     # ldm - Checks the consistency of LDM objects.
@@ -1091,5 +1044,9 @@ module GoodData
         body['wTaskStatus'] && body['wTaskStatus']['status'] == 'RUNNING'
       end
     end
+
+    def variables(id = :all, options = { client: client, project: self })
+      GoodData::Variable[id, options]
+    end
   end
 end