gooddata 0.6.24 → 0.6.25

data/lib/gooddata/models/metadata/scheduled_mail/dashboard_attachment.rb

@@ -0,0 +1,62 @@
+# 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
+  class DashboardAttachment
+    include GoodData::Mixin::RootKeyGetter
+    include GoodData::Mixin::DataGetter
+
+    attr_reader :scheduled_email
+    attr_accessor :json
+
+    DEFAULT_OPTS = {
+      :allTabs => 1,
+      :tabs => []
+    }
+
+    def initialize(scheduled_email, json)
+      @scheduled_email = scheduled_email
+      @json = json
+    end
+
+    # Get all tabs flag
+    #
+    # @return [Fixnum] All dashboard tabs?
+    def all_tabs
+      data['allTabs']
+    end
+
+    # Set all tabs flag
+    #
+    # @param [String | Fixnum] new_all_tabs New value of all_tabs flag to be set
+    # @return [Fixnum] New value of all_tabs flag
+    def all_tabs=(new_all_tabs)
+      data['allTabs'] = new_all_tabs.to_i
+    end
+
+    # Get selected tabs
+    #
+    # @return [Array<String>] List of selected tabs
+    def tabs
+      data['tabs']
+    end
+
+    # Set selected tabs
+    #
+    # @param [Array<String>] new_tabs New list of selected tabs to be set
+    # @return [Array<String>] New list of selected tabs
+    def tabs=(new_tabs)
+      data['tabs'] = new_tabs
+    end
+
+    # Get attachment URI
+    #
+    # @return [String] Attachment URI
+    def uri
+      data['uri']
+    end
+  end
+end

data/lib/gooddata/models/metadata/scheduled_mail/report_attachment.rb

@@ -0,0 +1,64 @@
+# 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
+  class ReportAttachment
+    include GoodData::Mixin::RootKeyGetter
+    include GoodData::Mixin::DataGetter
+
+    attr_reader :scheduled_email
+    attr_accessor :json
+
+    DEFAULT_OPTS = {
+      :formats => %w(pdf xls),
+      :exportOptions => {
+        :pageOrientation => 'landscape'
+      }
+    }
+
+    def initialize(scheduled_email, json)
+      @scheduled_email = scheduled_email
+      @json = json
+    end
+
+    # Get export options settings
+    #
+    # @return [Hash] Export options settings
+    def export_options
+      data['exportOptions']
+    end
+
+    # Set export options settings
+    #
+    # @param [Hash] new_export_options New export options settings to be set
+    # @return [Hash] New export options settings
+    def export_options=(new_export_options)
+      data['exportOptions'] = new_export_options
+    end
+
+    # Get formats
+    #
+    # @return [Array<String>] List of selected formats
+    def formats
+      data['formats']
+    end
+
+    # Set formats
+    #
+    # @param [String | Array<String>] new_formats New list of selected formats to be set
+    # @return [Array<String>] New list of selected formats
+    def formats=(new_formats)
+      data['formats'] = new_formats.is_a?(Array) ? new_formats : [new_formats]
+    end
+
+    # Get attachment URI
+    #
+    # @return [String] Attachment URI
+    def uri
+      data['uri']
+    end
+  end
+end

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

@@ -10,8 +10,6 @@ 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
       #
@@ -69,6 +67,14 @@ module GoodData
       values.select { |x| x.level == :user }
     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::Variable]
+    def replace(mapping)
+      GoodData::MdObject.replace_quoted(self, mapping)
+    end
+
     # Retrieves variable values and returns only those related to project
     #
     # @return [Array<GoodData::VariableUserFilter>] Values of variable related to project

data/lib/gooddata/models/model.rb

@@ -151,16 +151,9 @@ module GoodData
       # @param options [Hash] Additional options
       # @return [Hash] Batch upload result
       def upload_multiple_data(data, project_blueprint, options = { :client => GoodData.connection, :project => GoodData.project })
-        client = options[:client]
-        fail ArgumentError, 'No :client specified' if client.nil?
+        client, project = GoodData.get_client_and_project(options)
 
-        p = options[:project]
-        fail ArgumentError, 'No :project specified' if p.nil?
-
-        project = GoodData::Project[p, options]
-        fail ArgumentError, 'Wrong :project specified' if project.nil?
-
-        project = options[:project] || GoodData.project
+        project ||= GoodData.project
 
         manifest = {
 

data/lib/gooddata/models/process.rb

@@ -14,7 +14,7 @@ require_relative 'execution_detail'
 require_relative 'schedule'
 
 module GoodData
-  class Process < GoodData::Rest::Object
+  class Process < Rest::Resource
     attr_reader :data
 
     alias_method :raw_data, :data
@@ -56,14 +56,7 @@ module GoodData
       end
 
       def with_deploy(dir, options = {}, &block)
-        client = options[:client]
-        fail ArgumentError, 'No :client specified' if client.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?
+        _client, project = GoodData.get_client_and_project(options)
 
         GoodData.with_project(project) do
           params = options[:params].nil? ? [] : [options[:params]]
@@ -83,15 +76,7 @@ module GoodData
       end
 
       def upload_package(path, files_to_exclude, opts = { :client => GoodData.connection })
-        client = opts[:client]
-        fail ArgumentError, 'No :client specified' if client.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?
-
+        GoodData.get_client_and_project(opts)
         zip_and_upload(path, files_to_exclude, opts)
       end
 
@@ -104,14 +89,7 @@ module GoodData
       # @option options [String] :process_id ID of a process to be redeployed (do not set if you want to create a new process)
       # @option options [Boolean] :verbose (false) Switch on verbose mode for detailed logging
       def deploy(path, options = { :client => GoodData.client, :project => GoodData.project })
-        client = options[:client]
-        fail ArgumentError, 'No :client specified' if client.nil?
-
-        p = options[:project]
-        fail ArgumentError, 'No :project specified' if p.nil?
-
-        project = GoodData::Project[p, options]
-        fail ArgumentError, 'No :project specified' if project.nil?
+        client, project = GoodData.get_client_and_project(options)
 
         path = Pathname(path) || fail('Path is not specified')
         files_to_exclude = options[:files_to_exclude].nil? ? [] : options[:files_to_exclude].map { |pname| Pathname(pname) }
@@ -139,7 +117,7 @@ module GoodData
                 client.put("/gdc/projects/#{project.pid}/dataload/processes/#{process_id}", data)
               end
 
-        process = client.create(Process, res, project: p)
+        process = client.create(Process, res, project: project)
         puts HighLine.color("Deploy DONE #{path}", HighLine::GREEN) if verbose
         process
       end
@@ -284,8 +262,8 @@ module GoodData
       client.post(executions_link,
                   :execution => {
                     :graph => executable.to_s,
-                    :params => GoodData::Helpers.encode_params(params, false),
-                    :hiddenParams => GoodData::Helpers.encode_params(hidden_params, true)
+                    :params => GoodData::Helpers.encode_public_params(params),
+                    :hiddenParams => GoodData::Helpers.encode_hidden_params(hidden_params)
                   })
     end
   end

data/lib/gooddata/models/profile.rb

@@ -11,7 +11,7 @@ require_relative '../rest/object'
 require_relative 'project'
 
 module GoodData
-  class Profile < GoodData::Rest::Object
+  class Profile < Rest::Resource
     attr_reader :user, :json
 
     EMPTY_OBJECT = {

data/lib/gooddata/models/project.rb

@@ -19,13 +19,18 @@ require_relative '../rest/resource'
 require_relative '../mixins/author'
 require_relative '../mixins/contributor'
 require_relative '../mixins/rest_resource'
+require_relative '../mixins/uri_getter'
 
 require_relative 'process'
 require_relative 'project_role'
 require_relative 'blueprint/blueprint'
 
+require_relative 'metadata/scheduled_mail'
+require_relative 'metadata/scheduled_mail/dashboard_attachment'
+require_relative 'metadata/scheduled_mail/report_attachment'
+
 module GoodData
-  class Project < GoodData::Rest::Resource
+  class Project < Rest::Resource
     USERSPROJECTS_PATH = '/gdc/account/profile/%s/projects'
     PROJECTS_PATH = '/gdc/projects'
     PROJECT_PATH = '/gdc/projects/%s'
@@ -48,15 +53,9 @@ module GoodData
 
     attr_accessor :connection, :json
 
-    alias_method :to_json, :json
-    alias_method :raw_data, :json
-
-    include GoodData::Mixin::RestResource
-
-    Project.root_key :project
-
-    include GoodData::Mixin::Author
-    include GoodData::Mixin::Contributor
+    include Mixin::Author
+    include Mixin::Contributor
+    include Mixin::UriGetter
 
     class << self
       # Returns an array of all projects accessible by
@@ -129,7 +128,7 @@ module GoodData
         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'
-          if project.state.to_s == 'deleted'
+          if project.deleted?
             # if project is switched to deleted state, fail. This is usually problem of creating a template which is invalid.
             fail 'Project was marked as deleted during creation. This usually means you were trying to create from template and it failed.'
           end
@@ -181,6 +180,18 @@ module GoodData
 
     alias_method :create_dashboard, :add_dashboard
 
+    def add_user_group(data)
+      g = GoodData::UserGroup.create(data.merge(project: self))
+
+      begin
+        g.save
+      rescue RestClient::Conflict
+        user_groups(data[:name])
+      end
+    end
+
+    alias_method :create_group, :add_user_group
+
     # Creates a metric in a project
     #
     # @param [options] Optional report options
@@ -259,7 +270,7 @@ module GoodData
     #
     # @return [GoodData::ProjectRole] Project role if found
     def blueprint(options = {})
-      result = client.get("/gdc/projects/#{pid}/model/view", params: { includeDeprecated: true })
+      result = client.get("/gdc/projects/#{pid}/model/view", params: { includeDeprecated: true, includeGrain: true })
       polling_url = result['asyncTask']['link']['poll']
       model = client.poll_on_code(polling_url, options)
       bp = GoodData::Model::FromWire.from_wire(model)
@@ -293,7 +304,7 @@ module GoodData
       begin
         # Create the project first so we know that it is passing.
         # What most likely is wrong is the token and the export actaully takes majority of the time
-        new_project = GoodData::Project.create(options.merge(:title => a_title, :client => client))
+        new_project = GoodData::Project.create(options.merge(:title => a_title, :client => client, :driver => content[:driver]))
         export_token = export_clone(options)
         new_project.import_clone(export_token)
       rescue
@@ -344,6 +355,10 @@ module GoodData
       result['exportArtifact']['token']
     end
 
+    def user_groups(id = :all, options = {})
+      GoodData::UserGroup[id, options.merge(project: self)]
+    end
+
     # Imports a clone into current project. The project has to be freshly
     # created.
     #
@@ -397,10 +412,17 @@ module GoodData
 
     # Deletes project
     def delete
-      fail "Project '#{title}' with id #{uri} is already deleted" if state == :deleted
+      fail "Project '#{title}' with id #{uri} is already deleted" if deleted?
       client.delete(uri)
     end
 
+    # Returns true if project is in deleted state
+    #
+    # @return [Boolean] Returns true if object deleted. False otherwise.
+    def deleted?
+      state == :deleted
+    end
+
     # Helper for getting rid of all data in the project
     #
     # @option options [Boolean] :force has to be added otherwise the operation is not performed
@@ -894,171 +916,68 @@ module GoodData
       self
     end
 
-    DEFAULT_REPLACE_DATE_DIMENSION_OPTIONS = {
-      :old => nil,
-      :new => nil,
-      :purge => false,
-      :dry_run => true,
-      :mapping => {}
-    }
-
-    def replace_date_dimension(opts)
-      fail ArgumentError, 'No :old dimension specified' if opts[:old].nil?
-      fail ArgumentError, 'No :new dimension specified' if opts[:new].nil?
-
-      # Merge with default options
-      opts = DEFAULT_REPLACE_DATE_DIMENSION_OPTIONS.merge(opts)
-
-      get_attribute = lambda do |attr|
-        return attr if attr.is_a?(GoodData::Attribute)
-
-        res = attribute_by_identifier(attr)
-        return res if res
-
-        attribute_by_title(attr)
-      end
-
-      if opts[:old] && opts[:new]
-        fail ArgumentError, 'You specified both :old => :new and :mapping' if opts[:mapping] && !opts[:mapping].empty?
-
-        attrs = attributes_by_title(/\(#{opts[:old]}\)$/)
-
-        attrs.each do |old_attr|
-          new_attr_title = old_attr.title.sub("(#{opts[:old]})", "(#{opts[:new]})")
-          new_attr = attribute_by_title(new_attr_title)
-
-          fail "Unable to find attribute '#{new_attr_title}' in date dimension '#{opts[:new]}'" if new_attr.nil?
-
-          opts[:mapping][old_attr] = new_attr
-        end
-      end
-
-      mufs = user_filters
-
-      # Replaces string anywhere in JSON with another string and returns back new JSON
-      json_replace = lambda do |object, old_uri, new_uri|
-        old_json = JSON.generate(object.json)
-        regexp_replace = Regexp.new(old_uri + '([^0-9])')
-
-        new_json = old_json.gsub(regexp_replace, "#{new_uri}\\1")
-        if old_json != new_json
-          object.json = JSON.parse(new_json)
-          object.save
-        end
-        object
-      end
+    # Method used for walking through objects in project and trying to replace all occurences of some object for another object. This is typically used as a means for exchanging Date dimensions.
+    #
+    # @param mapping [Array<Array>] Mapping specifying what should be exchanged for what. As mapping should be used output of GoodData::Helpers.prepare_mapping.
+    def replace_from_mapping(mapping, opts = {})
+      default = {
+        :purge => false,
+        :dry_run => false
+      }
+      opts = default.merge(opts)
+      dry_run = opts[:dry_run]
 
-      # delete old report definitions (only the last version of each report is kept)
       if opts[:purge]
         GoodData.logger.info 'Purging old project definitions'
         reports.peach(&:purge_report_of_unused_definitions!)
       end
 
-      fail ArgumentError, 'No :mapping specified' if opts[:mapping].nil? || opts[:mapping].empty?
-
-      # Preprocess mapping, do necessary lookup
-      mapping = {}
-      opts[:mapping].each do |k, v|
-        attr_src = get_attribute.call(k)
-        attr_dest = get_attribute.call(v)
-
-        fail ArgumentError, "Unable to find attribute with identifier '#{k}'" if attr_src.nil?
-        fail ArgumentError, "Unable to find attribute with identifier '#{v}'" if attr_dest.nil?
-
-        mapping[attr_src] = attr_dest
-      end
-
-      # Iterate over all date attributes
-      mapping.each do |old_date, new_date|
-        GoodData.logger.info "  replacing date attribute '#{old_date.title}' (#{old_date.uri}) with '#{new_date.title}' (#{new_date.uri})"
-
-        # For each attribute prepare list of labels to replace
-        labels_mapping = {}
-
-        old_date.labels.each do |old_label|
-          new_label_title = old_label.title.sub("(#{opts[:old]})", "(#{opts[:new]})")
-
-          # Go through all labels, label_by_title has some issues
-          new_date.json['attribute']['content']['displayForms'].each do |label_tmp|
-            if label_tmp['meta']['title'] == new_label_title
-              new_label = labels(label_tmp['meta']['uri'])
-              labels_mapping[old_label] = new_label
+      fail ArgumentError, 'No mapping specified' if mapping.blank?
+      rds = report_definitions
+
+      {
+        # data_permissions: data_permissions,
+        variables: variables,
+        dashboards: dashboards,
+        metrics: metrics,
+        report_definitions: rds
+      }.each do |key, collection|
+        puts "Replacing #{key}"
+        collection.peach do |item|
+          new_item = item.replace(mapping)
+          if new_item.json != item.json
+            if dry_run
+              GoodData.logger.info "Would save #{new_item.uri}. Running in dry run mode"
+            else
+              GoodData.logger.info "Saving #{new_item.uri}"
+              new_item.save
             end
           end
         end
+      end
 
-        # Now we should have all labels for this attribute and its replacement in new date dimension
-        # First fix all affected metrics that are using this attribute
-        dependent = old_date.usedby
-        GoodData.logger.info 'Fixing metrics...'
-        dependent.each do |dependent_object|
-          next if dependent_object['category'] != 'metric'
-
-          affected_metric = metrics(dependent_object['link'])
-
-          GoodData.logger.info "Metric '#{dependent_object['title']}' (#{affected_metric.uri}) contains old date attribute '#{old_date.title}' ...replacing"
-          affected_metric.replace(old_date.uri, new_date.uri)
-          affected_metric.save unless opts[:dry_run]
-        end
-
-        # Then search which reports are still using this attribute after replacement in metric...
-        dependent = old_date.usedby
-        GoodData.logger.info 'Fixing reports (standard)...'
-        dependent.each do |dependent_object|
-          # This does not seem to work every time... some references are kept...
-          next if dependent_object['category'] != 'reportDefinition'
-
-          affected_rd = report_definitions(dependent_object['link'])
-
-          GoodData.logger.info "reportDefinition (#{affected_rd.uri}) contains old date attribute '#{old_date.title}' ...replacing"
-          affected_rd.replace(old_date.uri, new_date.uri)
-
-          # Affected_rd.replace(labels_mapping) #not sure if this is working correctly, try to do it one by one
-          labels_mapping.each_pair do |old_label, new_label|
-            affected_rd.replace(old_label.uri, new_label.uri)
-          end
-
-          affected_rd.save unless opts[:dry_run]
-        end
-
-        # Then search which dashboards and reports are still using this attribute after standard replacement in reports...
-        dependent = old_date.usedby
-        GoodData.logger.info 'Fixing reports (force) & dashboards...'
-
-        # If standard replace did not work, use force...
-        dependent.each do |dependent_object|
-          case dependent_object['category']
-          when 'reportDefinition'
-            affected_rd = report_definitions(dependent_object['link'])
-
-            GoodData.logger.info "reportDefinition '#{affected_rd.title}' (#{affected_rd.uri}) still contains old date attribute '#{old_date.title}' ...replacing by force"
-            json_replace.call(affected_rd, old_date.uri, new_date.uri)
-
-            # Iterate over all labels
-            labels_mapping.each_pair do |old_label, new_label|
-              json_replace.call(affected_rd, old_label.uri, new_label.uri)
-            end
-
-            affected_rd.save unless opts[:dry_run]
-          when 'projectDashboard'
-            affected_dashboard = dashboards(dependent_object['link'])
-
-            GoodData.logger.info "Dashboard '#{affected_dashboard.title}' (#{affected_dashboard.uri}) contains old date attribute '#{old_date.title}' ...replacing by force"
-            json_replace.call(affected_dashboard, old_date.uri, new_date.uri)
-
-            # Iterate over all labels
-            labels_mapping.each_pair do |old_label, new_label|
-              json_replace.call(affected_dashboard, old_label.uri, new_label.uri)
-            end
-
-            affected_dashboard.save unless opts[:dry_run]
+      GoodData.logger.info 'Replacing hidden metrics'
+      local_metrics = rds.pmapcat { |rd| rd.using('metric') }.select { |m| m['deprecated'] == '1' }
+      puts "Found #{local_metrics.count} metrics"
+      local_metrics.pmap { |m| metrics(m['link']) }.peach do |item|
+        new_item = item.replace(mapping)
+        if new_item.json != item.json
+          if dry_run
+            GoodData.logger.info "Would save #{new_item.uri}. Running in dry run mode"
+          else
+            GoodData.logger.info "Saving #{new_item.uri}"
+            new_item.save
           end
         end
+      end
 
-        mufs.each do |muf|
-          json_replace.call(muf, old_date.uri, new_date.uri)
+      GoodData.logger.info 'Replacing variable values'
+      variables.each do |var|
+        var.values.peach do |val|
+          val.replace(mapping).save unless dry_run
         end
       end
+      nil
     end
 
     # Helper for getting reports of a project
@@ -1107,6 +1026,15 @@ module GoodData
       self
     end
 
+    # Schedules an email with dashboard or report content
+    def schedule_mail(options = GoodData::ScheduledMail::DEFAULT_OPTS)
+      GoodData::ScheduledMail.create(options.merge(client: client, project: self))
+    end
+
+    def scheduled_mails(options = { :full => false })
+      GoodData::ScheduledMail[:all, options.merge(project: self, client: client)]
+    end
+
     # @param [String | Number | Object] Anything that you can pass to GoodData::Schedule[id]
     # @return [GoodData::Schedule | Array<GoodData::Schedule>] schedule instance or list
     def schedules(id = :all)
@@ -1190,7 +1118,7 @@ module GoodData
 
     alias_method :members, :users
 
-    def whitelist_users(new_users, users_list, whitelist)
+    def whitelist_users(new_users, users_list, whitelist, mode = :exclude)
       return [new_users, users_list] unless whitelist
 
       new_whitelist_proc = proc do |user|
@@ -1201,7 +1129,11 @@ module GoodData
         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)]
+      if mode == :include
+        [new_users.select(&new_whitelist_proc), users_list.select(&whitelist_proc)]
+      elsif mode == :exclude
+        [new_users.reject(&new_whitelist_proc), users_list.reject(&whitelist_proc)]
+      end
     end
 
     # Imports users
@@ -1214,6 +1146,9 @@ module GoodData
 
       whitelisted_new_users, whitelisted_users = whitelist_users(new_users.map(&:to_hash), users_list, options[:whitelists])
 
+      # First check that if groups are provided we have them set up
+      check_groups(new_users.map(&:to_hash).flat_map { |u| u[:user_group] || [] }.uniq)
+
       # 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')
@@ -1259,6 +1194,30 @@ module GoodData
       to_remove = diff[:removed].reject { |user| user[:status] == 'DISABLED' || user[:status] == :disabled }
       GoodData.logger.warn("Removing #{to_remove.count} users from project (#{pid})")
       results.concat(disable_users(to_remove))
+
+      # reassign to groups
+      mappings = new_users.map(&:to_hash).flat_map do |user|
+        groups = user[:user_group] || []
+        groups.map { |g| [user[:login], g] }
+      end
+      unless mappings.empty?
+        users_lookup = users.reduce({}) do |a, e|
+          a[e.login] = e
+          a
+        end
+        mappings.group_by { |_, g| g }.each do |g, mapping|
+          # find group + set users
+          # CARE YOU DO NOT KNOW URI
+          user_groups(g).set_members(mapping.map { |user, _| user }.map { |login| users_lookup[login] && users_lookup[login].uri })
+        end
+        mentioned_groups = mappings.map(&:last).uniq
+        groups_to_cleanup = user_groups.reject { |g| mentioned_groups.include?(g.name) }
+        # clean all groups not mentioned with exception of whitelisted users
+        groups_to_cleanup.each do |g|
+          g.set_members(whitelist_users(g.members.map(&:to_hash), [], options[:whitelists], :include).first.map { |x| x[:uri] })
+        end
+      end
+      results
     end
 
     def disable_users(list)
@@ -1274,6 +1233,12 @@ module GoodData
       end
     end
 
+    def check_groups(specified_groups)
+      groups = user_groups.map(&:name)
+      missing_groups = specified_groups - groups
+      fail "All groups have to be specified before you try to import users. Groups that are currently in project are #{groups.join(',')} and you asked for #{missing_groups.join(',')}" unless missing_groups.empty?
+    end
+
     # Update user
     #
     # @param user User to be updated
@@ -1288,7 +1253,6 @@ module GoodData
       fail ArgumentError, "User #{user_uri} could not be aded. #{failure.first['message']}" unless failure.blank?
       res
     end
-
     alias_method :add_user, :set_user_roles
 
     # Update list of users