gooddata 0.6.49 → 0.6.50

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

@@ -1,6 +1,6 @@
 # encoding: UTF-8
 #
-# Copyright (c) 2010-2015 GoodData Corporation. All rights reserved.
+# Copyright (c) 2010-2017 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.
 

data/lib/gooddata/models/model.rb

@@ -1,6 +1,6 @@
 # encoding: UTF-8
 #
-# Copyright (c) 2010-2015 GoodData Corporation. All rights reserved.
+# Copyright (c) 2010-2017 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.
 

data/lib/gooddata/models/models.rb

@@ -1,6 +1,6 @@
 # encoding: UTF-8
 #
-# Copyright (c) 2010-2015 GoodData Corporation. All rights reserved.
+# Copyright (c) 2010-2017 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.
 

data/lib/gooddata/models/module_constants.rb

@@ -1,6 +1,6 @@
 # encoding: UTF-8
 #
-# Copyright (c) 2010-2015 GoodData Corporation. All rights reserved.
+# Copyright (c) 2010-2017 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.
 

data/lib/gooddata/models/notification_rule.rb

@@ -0,0 +1,113 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2017 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 NotificationRule < Rest::Resource
+    NOTIFICATION_RULES_PATH = '/gdc/projects/%s/dataload/processes/%s/notificationRules'
+
+    EMPTY_OBJECT = {
+      'notificationRule' => {
+        'email' => '',
+        'subject' => '',
+        'body' => '',
+        'events' => []
+      }
+    }
+
+    attr_accessor :email, :subject, :body, :events, :process
+    attr_reader :subscription, :channels
+
+    class << self
+      def [](id = :all, opts = { client: GoodData.connection })
+        c = GoodData.get_client(opts)
+        pid = (opts[:project].respond_to?(:pid) && opts[:project].pid) || opts[:project]
+        process_id = (opts[:process].respond_to?(:process_id) && opts[:process].process_id) || opts[:process]
+        uri = NOTIFICATION_RULES_PATH % [pid, process_id]
+        if id == :all
+          data = c.get uri
+          data['notificationRules']['items'].map { |notification_data| c.create(NotificationRule, notification_data) }
+        else
+          c.create(NotificationRule, c.get("#{uri}/#{id}"))
+        end
+      end
+
+      def all(opts = { client: GoodData.connection })
+        NotificationRule[:all, opts]
+      end
+
+      def create(opts = { client: GoodData.connection })
+        [:email, :events, :project, :process].each { |key| fail "No #{key.inspect} specified" unless opts[key] }
+
+        pid = (opts[:project].respond_to?(:pid) && opts[:project].pid) || opts[:project]
+        process_id = (opts[:process].respond_to?(:process_id) && opts[:process].process_id) || opts[:process]
+        events = (opts[:events].respond_to?(:each) && opts[:events]) || [opts[:events]]
+
+        notification_rule = create_object({ subject: 'Email subject', body: 'Email body' }.merge(opts).merge(project: pid, process: process_id, events: events))
+        notification_rule.save
+        notification_rule
+      end
+
+      def create_object(data = {})
+        c = GoodData.get_client(data)
+
+        new_data = GoodData::Helpers.deep_dup(EMPTY_OBJECT).tap do |d|
+          d['notificationRule']['email'] = data[:email]
+          d['notificationRule']['subject'] = data[:subject]
+          d['notificationRule']['body'] = data[:body]
+          d['notificationRule']['events'] = data[:events]
+        end
+
+        c.create(NotificationRule, new_data, data)
+      end
+    end
+
+    def initialize(json)
+      super
+      @json = json
+
+      @email = data['email']
+      @subject = data['subject']
+      @body = data['body']
+      @events = data['events']
+    end
+
+    def uri
+      data['links']['self'] if data && data['links'] && data['links']['self']
+    end
+
+    def obj_id
+      uri.split('/').last
+    end
+
+    alias_method :notification_rule_id, :obj_id
+
+    def save
+      response = if uri
+                   data_to_send = GoodData::Helpers.deep_dup(EMPTY_OBJECT).tap do |d|
+                     d['notificationRule']['email'] = email
+                     d['notificationRule']['subject'] = subject
+                     d['notificationRule']['body'] = body
+                     d['notificationRule']['events'] = (events.respond_to?(:each) && events) || events
+                   end
+                   client.put(uri, data_to_send)
+                 else
+                   client.post(NOTIFICATION_RULES_PATH % [project, process], raw_data)
+                 end
+      @json = client.get response['notificationRule']['links']['self']
+      @subscription = data['links']['subscription']
+      @channels = data['links']['channels']
+    end
+
+    def ==(other)
+      return false unless [:email, :subject, :body, :events].all? { |m| other.respond_to?(m) }
+      @email == other.email && @subject == other.subject && @body == other.body && @events == other.events
+    end
+
+    def delete
+      client.delete uri
+    end
+  end
+end

data/lib/gooddata/models/process.rb

@@ -1,10 +1,9 @@
 # encoding: UTF-8
 #
-# Copyright (c) 2010-2015 GoodData Corporation. All rights reserved.
+# Copyright (c) 2010-2017 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 'pry'
 require 'zip'
 require 'uri'
 
@@ -27,7 +26,7 @@ module GoodData
     class << self
       def [](id, options = {})
         project = options[:project]
-        c = client(options)
+        c = options[:client] || (project && project.client)
 
         if id == :all && project
           uri = "/gdc/projects/#{project.pid}/dataload/processes"
@@ -355,5 +354,13 @@ module GoodData
                     :hiddenParams => GoodData::Helpers.encode_hidden_params(hidden_params)
                   })
     end
+
+    def notification_rules
+      NotificationRule.all(project: project, process: self, client: client)
+    end
+
+    def create_notification_rule(opts = {})
+      NotificationRule.create(opts.merge(project: project, process: self, client: client))
+    end
   end
 end

data/lib/gooddata/models/profile.rb

@@ -1,6 +1,6 @@
 # encoding: UTF-8
 #
-# Copyright (c) 2010-2015 GoodData Corporation. All rights reserved.
+# Copyright (c) 2010-2017 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.
 
@@ -422,5 +422,13 @@ module GoodData
       end
       tmp
     end
+
+    def create_channel
+      GoodData::ChannelConfiguration.create(to: email, title: email, client: client)
+    end
+
+    def channels
+      GoodData::ChannelConfiguration.all(client: client)
+    end
   end
 end

data/lib/gooddata/models/project.rb

@@ -1,6 +1,6 @@
 # encoding: UTF-8
 #
-# Copyright (c) 2010-2015 GoodData Corporation. All rights reserved.
+# Copyright (c) 2010-2017 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.
 
@@ -62,7 +62,7 @@ module GoodData
       # Returns an array of all projects accessible by
       # current user
       def all(opts = { client: GoodData.connection })
-        c = client(opts)
+        c = GoodData.get_client(opts)
         c.user.projects
       end
 
@@ -84,9 +84,7 @@ module GoodData
 
           id = id.match(/[a-zA-Z\d]+$/)[0] if id =~ %r{/}
 
-          c = client(opts)
-          fail ArgumentError, 'No :client specified' if c.nil?
-
+          c = GoodData.get_client(opts)
           response = c.get(PROJECT_PATH % id)
           c.factory.create(Project, response)
         end
@@ -104,7 +102,7 @@ module GoodData
       end
 
       def create_object(data = {})
-        c = client(data)
+        c = GoodData.get_client(data)
         new_data = GoodData::Helpers.deep_dup(EMPTY_OBJECT).tap do |d|
           d['project']['meta']['title'] = data[:title]
           d['project']['meta']['summary'] = data[:summary] if data[:summary]
@@ -126,15 +124,15 @@ module GoodData
       # - :summary
       # - :template (default /projects/blank)
       #
-      def create(opts = { :client => GoodData.connection }, &block)
+      def create(opts = { client: GoodData.connection }, &block)
         GoodData.logger.info "Creating project #{opts[:title]}"
 
-        c = client(opts)
-        fail ArgumentError, 'No :client specified' if c.nil?
-
-        opts = { :auth_token => Helpers::AuthHelper.read_token }.merge(opts)
         auth_token = opts[:auth_token] || opts[:token]
-        fail ArgumentError, 'You have to provide your token for creating projects as :auth_token parameter' if auth_token.nil? || auth_token.empty?
+        if auth_token.nil? || auth_token.empty?
+          opts = { auth_token: Helpers::AuthHelper.read_token }.merge(opts)
+          auth_token = opts[:auth_token]
+        end
+        fail ArgumentError, 'You have to provide your token for creating projects as :auth_token or :token parameter' if auth_token.nil? || auth_token.empty?
 
         project = create_object(opts)
         project.save
@@ -157,15 +155,16 @@ module GoodData
         project
       end
 
-      def find(_opts = {}, client = GoodData::Rest::Client.client)
-        user = client.user
+      def find(opts = { client: GoodData.connection })
+        c = GoodData.get_client(opts)
+        user = c.user
         user.projects['projects'].map do |project|
-          client.create(GoodData::Project, project)
+          c.create(GoodData::Project, project)
         end
       end
 
       def create_from_blueprint(blueprint, options = {})
-        GoodData::Model::ProjectCreator.migrate(options.merge(spec: blueprint, client: GoodData.connection))
+        GoodData::Model::ProjectCreator.migrate(options.merge(spec: blueprint, client: client))
       end
 
       # Takes one CSV line and creates hash from data extracted
@@ -212,13 +211,15 @@ module GoodData
       end
 
       def transfer_processes(from_project, to_project)
-        from_project.processes.each do |process|
-          to_process = to_project.processes.find { |p| p.name == process.name }
+        to_project_processes = to_project.processes
+        from_project.processes.uniq(&:name).each do |process|
+          fail "The process name #{process.name} must be unique in transfered project #{to_project}" if to_project_processes.count { |p| p.name == process.name } > 1
+          to_process = to_project_processes.find { |p| p.name == process.name }
 
           if process.path
             to_process.delete if to_process
             GoodData::Process.deploy_from_appstore(process.path, name: process.name, client: to_project.client, project: to_project)
-          else
+          elsif process.type != :dataload
             Dir.mktmpdir('etl_transfer') do |dir|
               dir = Pathname(dir)
               filename = dir + 'process.zip'
@@ -230,9 +231,20 @@ module GoodData
             end
           end
         end
+
+        if from_project.processes.any? { |p| p.type == :dataload }
+          if to_project_processes.any? { |p| p.type == :dataload }
+            to_project.add.output_stage.schema = from_project.add.output_stage.schema
+            to_project.add.output_stage.output_stage_prefix = from_project.add.output_stage.output_stage_prefix
+            to_project.add.output_stage.save
+          else
+            from_prj_output_stage = from_project.add.output_stage
+            to_project.add.output_stage = GoodData::AdsOutputStage.create(client: to_project.client, ads: from_prj_output_stage.schema, client_id: from_prj_output_stage.client_id, output_stage_prefix: from_prj_output_stage.output_stage_prefix, project: to_project)
+          end
+        end
         res = (from_project.processes + to_project.processes).map { |p| [p, p.name, p.type] }
         res.group_by { |x| [x[1], x[2]] }
-          .select { |_, procs| procs.length == 1 }
+          .select { |_, procs| procs.length == 1 && procs[2] != :dataload }
           .flat_map { |_, procs| procs.select { |p| p[0].project.pid == to_project.pid }.map { |p| p[0] } }
           .peach(&:delete)
       end
@@ -242,7 +254,14 @@ module GoodData
       # @param client [GoodData::Rest::Client] GoodData client to be used for connection
       # @param from_project [GoodData::Project | GoodData::Segment | GoodData:Client | String] Object to be cloned from. Can be either segment in which case we take the master, client in which case we take its project, string in which case we treat is as an project object or directly project
       def transfer_schedules(from_project, to_project)
-        cache = to_project.processes.sort_by(&:name).zip(from_project.processes.sort_by(&:name)).flat_map { |remote, local| local.schedules.map { |schedule| [remote, local, schedule] } }
+        cache = to_project
+                  .processes.sort_by(&:name)
+                  .zip(from_project.processes.sort_by(&:name))
+                  .flat_map do |remote, local|
+                    local.schedules.map do |schedule|
+                      [remote, local, schedule]
+                    end
+                  end
 
         remote_schedules = to_project.schedules
         remote_stuff = remote_schedules.map do |s|
@@ -265,13 +284,21 @@ module GoodData
         end
 
         diff = GoodData::Helpers.diff(remote_stuff, local_stuff, key: :name, fields: [:name, :cron, :after, :params, :hidden_params, :reschedule])
-        stack = diff[:added].map { |x| [:added, x] } + diff[:changed].map { |x| [:changed, x] }
+        stack = diff[:added].map do |x|
+          [:added, x]
+        end
+
+        stack += diff[:changed].map do |x|
+          [:changed, x]
+        end
+
         schedule_cache = remote_schedules.reduce({}) do |a, e|
           a[e.name] = e
           a
         end
-        messages = []
-        loop do
+
+        results = []
+        loop do # rubocop:disable Metrics/BlockLength
           break if stack.empty?
           state, changed_schedule = stack.shift
           if state == :added
@@ -280,44 +307,74 @@ module GoodData
               stack << [state, schedule_spec]
               next
             end
-            remote_process, process_spec = cache.find { |_remote, _local, schedule| schedule.name == schedule_spec[:name] }
-            messages << { message: "Creating schedule #{schedule_spec[:name]} for process #{remote_process.name}" }
-            executable = schedule_spec[:executable] || (process_spec["process_type"] == 'ruby' ? 'main.rb' : 'main.grf')
-            params = {
-              params: schedule_spec[:params].merge('PROJECT_ID' => to_project.pid),
-              hidden_params: schedule_spec[:hidden_params],
-              name: schedule_spec[:name],
-              reschedule: schedule_spec[:reschedule]
-            }
+            remote_process, process_spec = cache.find do |_remote, local, schedule|
+              (schedule_spec[:process_id] == local.process_id) && (schedule.name == schedule_spec[:name])
+            end
+
+            GoodData.logger.info("Creating schedule #{schedule_spec[:name]} for process #{remote_process.name}")
+
+            executable = nil
+            if process_spec.type != :dataload
+              executable = schedule_spec[:executable] || (process_spec.type == :ruby ? 'main.rb' : 'main.grf')
+            end
+            params = schedule_parameters(to_project.pid, schedule_spec)
             created_schedule = remote_process.create_schedule(schedule_spec[:cron] || schedule_cache[schedule_spec[:after]], executable, params)
             schedule_cache[created_schedule.name] = created_schedule
+
+            results << {
+              state: :added,
+              process: remote_process,
+              schedule: created_schedule
+            }
           else
             schedule_spec = changed_schedule[:new_obj]
             if schedule_spec[:after] && !schedule_cache[schedule_spec[:after]]
               stack << [state, schedule_spec]
               next
             end
-            remote_process, process_spec = cache.find { |i| i[2].name == schedule_spec[:name] }
+
+            remote_process, process_spec = cache.find do |i|
+              i[2].name == schedule_spec[:name]
+            end
+
             schedule = changed_schedule[:old_obj][:remote_schedule]
-            messages << { message: "Updating schedule #{schedule_spec[:name]} for process #{remote_process.name}" }
+
+            GoodData.logger.info("Updating schedule #{schedule_spec[:name]} for process #{remote_process.name}")
+
             schedule.params = (schedule_spec[:params] || {})
             schedule.cron = schedule_spec[:cron] if schedule_spec[:cron]
             schedule.after = schedule_cache[schedule_spec[:after]] if schedule_spec[:after]
             schedule.hidden_params = schedule_spec[:hidden_params] || {}
-            schedule.executable = schedule_spec[:executable] || (process_spec["process_type"] == 'ruby' ? 'main.rb' : 'main.grf')
+            if process_spec.type != :dataload
+              schedule.executable = schedule_spec[:executable] || (process_spec.type == :ruby ? 'main.rb' : 'main.grf')
+            end
+
             schedule.reschedule = schedule_spec[:reschedule]
             schedule.name = schedule_spec[:name]
             schedule.save
             schedule_cache[schedule.name] = schedule
+
+            results << {
+              state: :changed,
+              process: remote_process,
+              schedule: schedule
+            }
           end
         end
 
         diff[:removed].each do |removed_schedule|
-          messages << { message: "Removing schedule #{removed_schedule[:name]}" }
+          GoodData.logger.info("Removing schedule #{removed_schedule[:name]}")
+
           removed_schedule[:remote_schedule].delete
+
+          results << {
+            state: :removed,
+            process: removed_schedule.process,
+            schedule: removed_schedule
+          }
         end
-        messages
-        # messages.map {|m| m.merge({custom_project_id: custom_project_id})}
+
+        results
       end
 
       def transfer_tagged_stuff(from_project, to_project, tag)
@@ -325,9 +382,28 @@ module GoodData
 
         objects = from_project.find_by_tag(tag)
 
-        puts JSON.pretty_generate(objects)
+        if objects.any?
+          puts JSON.pretty_generate(objects)
+          from_project.partial_md_export(objects, project: to_project)
+        else
+          GoodData.logger.info('No tagged objects to transfer')
+        end
+      end
+
+      def transfer_color_palette(from_project, to_project)
+        colors = from_project.current_color_palette
+        to_project.create_custom_color_palette(colors) unless colors.empty?
+      end
+
+      private
 
-        from_project.partial_md_export(objects, project: to_project)
+      def schedule_parameters(id, schedule_spec)
+        {
+          params: schedule_spec[:params].merge('PROJECT_ID' => id),
+          hidden_params: schedule_spec[:hidden_params],
+          name: schedule_spec[:name],
+          reschedule: schedule_spec[:reschedule]
+        }
       end
     end
 
@@ -453,7 +529,7 @@ module GoodData
     # @param options [Hash] Export options
     # @option options [Boolean] :data Clone project with data
     # @option options [Boolean] :users Clone project with users
-    # @option options [String] :authorized_users Comma separated logins of authorized users. Users that can use the export
+    # @option options [Boolean] :exclude_schedules Specifies whether to include scheduled emails
     # @return [GoodData::Project] Newly created project
     def clone(options = {})
       a_title = options[:title] || "Clone of #{title}"
@@ -491,6 +567,8 @@ module GoodData
     # @option options [Boolean] :data Clone project with data
     # @option options [Boolean] :users Clone project with users
     # @option options [String] :authorized_users Comma separated logins of authorized users. Users that can use the export
+    # @option options [Boolean] :exclude_schedules Specifies whether to include scheduled notifications in the export
+    # @option options [Boolean] :cross_data_center_export Specifies whether export can be used in any data center
     # @return [String] token of the export
     def export_clone(options = {})
       with_data = options[:data].nil? ? true : options[:data]
@@ -503,12 +581,22 @@ module GoodData
         }
       }
       export[:exportProject][:authorizedUsers] = options[:authorized_users] if options[:authorized_users]
+      if options[:exclude_schedules]
+        exclude_notifications = options[:exclude_schedules] ? 1 : 0
+        export[:exportProject][:excludeSchedules] = exclude_notifications
+      end
+      if options[:cross_data_center_export]
+        cross_data_center = options[:cross_data_center_export] ? 1 : 0
+        export[:exportProject][:crossDataCenterExport] = cross_data_center
+      end
 
       result = client.post("/gdc/md/#{obj_id}/maintenance/export", export)
       status_url = result['exportArtifact']['status']['uri']
-      client.poll_on_response(status_url) do |body|
+      polling_result = client.poll_on_response(status_url) do |body|
         body['taskState']['status'] == 'RUNNING'
       end
+
+      ensure_clone_task_ok(polling_result, GoodData::ExportCloneError)
       result['exportArtifact']['token']
     end
 
@@ -534,9 +622,10 @@ module GoodData
 
       result = client.post("/gdc/md/#{obj_id}/maintenance/import", import)
       status_url = result['uri']
-      client.poll_on_response(status_url, options) do |body|
+      polling_result = client.poll_on_response(status_url, options) do |body|
         body['taskState']['status'] == 'RUNNING'
       end
+      ensure_clone_task_ok(polling_result, GoodData::ImportCloneError)
       self
     end
 
@@ -751,8 +840,20 @@ module GoodData
       GoodData.download_from_project_webdav(file, where, project: self)
     end
 
+    def driver
+      content['driver']
+    end
+
     def environment
-      json['project']['content']['environment']
+      content['environment']
+    end
+
+    def public?
+      content['isPublic']
+    end
+
+    def token
+      content['authorizationToken']
     end
 
     # Gets user by its email, full_name, login or uri
@@ -828,7 +929,7 @@ module GoodData
       puts "Inviting #{email}, role: #{role}"
 
       role_url = nil
-      if role.index('/gdc/').nonzero?
+      if role.index('/gdc/').nil?
         tmp = get_role(role)
         role_url = tmp.uri if tmp
       else
@@ -1307,7 +1408,14 @@ module GoodData
           tmp = client.get("/gdc/projects/#{pid}/users", params: { offset: offset, limit: limit })
           tmp['users'].each do |user_data|
             user = client.create(GoodData::Membership, user_data, project: self)
-            y << user if opts[:all] || user && user.enabled?
+
+            if opts[:all]
+              y << user
+            elsif opts[:disabled]
+              y << user if user && user.disabled?
+            else
+              y << user if user && user.enabled?
+            end
           end
           break if tmp['users'].count < limit
           offset += limit
@@ -1321,11 +1429,23 @@ module GoodData
       return [new_users, users_list] unless whitelist
 
       new_whitelist_proc = proc do |user|
-        whitelist.any? { |wl| wl.is_a?(Regexp) ? user[:login] =~ wl : (user[:login] && user[:login].include?(wl)) }
+        whitelist.any? do |wl|
+          if wl.is_a?(Regexp)
+            user[:login] =~ wl
+          else
+            user[:login] && user[:login] == wl
+          end
+        end
       end
 
       whitelist_proc = proc do |user|
-        whitelist.any? { |wl| wl.is_a?(Regexp) ? user.login =~ wl : (user.login && user.login.include?(wl)) }
+        whitelist.any? do |wl|
+          if wl.is_a?(Regexp)
+            user.login =~ wl
+          else
+            user.login && user.login == wl
+          end
+        end
       end
 
       if mode == :include
@@ -1408,9 +1528,18 @@ module GoodData
 
       # Remove old users
       to_remove = diff[:removed].reject { |user| user[:status] == 'DISABLED' || user[:status] == :disabled }
-      GoodData.logger.warn("Removing #{to_remove.count} users from project (#{pid})")
+      GoodData.logger.warn("Disabling #{to_remove.count} users from project (#{pid})")
       results.concat(disable_users(to_remove, roles: role_list, project_users: whitelisted_users))
 
+      # Remove old users completely
+      if options[:remove_users_from_project]
+        to_remove = (to_remove + users(disabled: true).to_a).map(&:to_hash).uniq do |user|
+          user[:uri]
+        end
+        GoodData.logger.warn("Removing #{to_remove.count} users from project (#{pid})")
+        results.concat(remove_users(to_remove))
+      end
+
       # reassign to groups
       mappings = new_users.map(&:to_hash).flat_map do |user|
         groups = user[:user_group] || []
@@ -1450,6 +1579,21 @@ module GoodData
       end
     end
 
+    def remove_users(list)
+      list = list.map(&:to_hash)
+
+      list.pmapcat do |u|
+        u_id = GoodData::Helpers.last_uri_part(u[:uri])
+        url = "#{uri}/users/#{u_id}"
+        begin
+          client.delete(url)
+          [{ type: :successful, operation: :user_deleted_from_project, user: u }]
+        rescue => e
+          [{ type: :failed, message: e.message }]
+        end
+      end
+    end
+
     def check_groups(specified_groups)
       groups = user_groups.map(&:name)
       missing_groups = specified_groups - groups
@@ -1567,6 +1711,47 @@ module GoodData
       [user, roles]
     end
 
+    def add
+      @add ||= GoodData::AutomatedDataDistribution.new(self)
+      @add
+    end
+
+    def transfer_etl(target)
+      GoodData::Project.transfer_etl(client, self, target)
+    end
+
+    def transfer_processes(target)
+      GoodData::Project.transfer_processes(self, target)
+    end
+
+    def transfer_schedules(target)
+      GoodData::Project.transfer_schedules(self, target)
+    end
+
+    def transfer_tagged_stuff(target, tag)
+      GoodData::Project.transfer_tagged_stuff(self, target, tag)
+    end
+
+    def create_output_stage(ads, opts = {})
+      add.create_output_stage(ads, opts)
+    end
+
+    def transfer_color_palette(target)
+      GoodData::Project.transfer_color_palette(self, target)
+    end
+
+    def current_color_palette
+      GoodData::StyleSetting.current(client: client, project: self)
+    end
+
+    def create_custom_color_palette(colors)
+      GoodData::StyleSetting.create(colors, client: client, project: self)
+    end
+
+    def reset_color_palette
+      GoodData::StyleSetting.reset(client: client, project: self)
+    end
+
     private
 
     def generate_user_payload(user_uri, status = 'ENABLED', roles_uri = nil)
@@ -1583,5 +1768,18 @@ module GoodData
       payload['user']['content']['userRoles'] = roles_uri if roles_uri
       payload
     end
+
+    # Checks state of an export/import task.
+    # @param response [Hash] Response from API
+    # @param clone_task_error [Error] Error to raise when state is not OK
+    def ensure_clone_task_ok(response, clone_task_error)
+      if response['taskState'].nil?
+        fail clone_task_error, "Clone task failed with unknown response: #{response}"
+      elsif response['taskState']['status'] != 'OK'
+        messages = response['taskState']['messages'] || []
+        interpolated_messages = GoodData::Helpers.interpolate_error_messages(messages).join(' ')
+        fail clone_task_error, "Clone task failed. #{interpolated_messages}"
+      end
+    end
   end
 end