gooddata 0.6.7 → 0.6.8

data/lib/gooddata/models/model.rb

@@ -1,6 +1,5 @@
 # encoding: UTF-8
 
-require_relative '../core/connection'
 require_relative '../core/rest'
 
 require_relative 'metadata/metadata'
@@ -61,7 +60,15 @@ module GoodData
       end
 
       # Load given file into a data set described by the given schema
-      def upload_data(path, project_blueprint, dataset, options = {})
+      def upload_data(path, project_blueprint, dataset, options = { :client => GoodData.connection, :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, 'Wrong :project specified' if project.nil?
         # path = if path =~ URI.regexp
         #   Tempfile.open('remote_file') do |temp|
         #     temp << open(path).read
@@ -99,7 +106,7 @@ module GoodData
           end
 
           # upload it
-          GoodData.upload_to_user_webdav("#{dir}/upload.zip", :directory => File.basename(dir))
+          client.upload_to_user_webdav("#{dir}/upload.zip", :directory => File.basename(dir), :client => options[:client], :project => options[:project])
         ensure
           FileUtils.rm_rf dir
         end
@@ -107,15 +114,15 @@ module GoodData
         # kick the load
         pull = { 'pullIntegration' => File.basename(dir) }
         link = project.md.links('etl')['pull']
-        task = GoodData.post link, pull
+        task = client.post link, pull
 
-        res = GoodData.poll_on_response(task['pullTask']['uri']) do |body|
+        res = client.poll_on_response(task['pullTask']['uri']) do |body|
           body['taskStatus'] == 'RUNNING' || body['taskStatus'] == 'PREPARED'
         end
 
         if res['taskStatus'] == 'ERROR'
           s = StringIO.new
-          GoodData.download_from_user_webdav(File.basename(dir) + '/upload_status.json', s)
+          client.download_from_user_webdav(File.basename(dir) + '/upload_status.json', s)
           js = MultiJson.load(s.string)
           fail "Load Failed with error #{JSON.pretty_generate(js)}"
         end

data/lib/gooddata/models/process.rb

@@ -2,8 +2,10 @@
 
 require 'pry'
 
+require_relative '../rest/resource'
+
 module GoodData
-  class Process
+  class Process < GoodData::Rest::Object
     attr_reader :data
 
     alias_method :raw_data, :data
@@ -12,15 +14,24 @@ module GoodData
 
     class << self
       def [](id, options = {})
-        if id == :all
-          uri = "/gdc/projects/#{GoodData.project.pid}/dataload/processes"
-          data = GoodData.get(uri)
+        project = options[:project]
+        c = client(options)
+
+        if id == :all && project
+          uri = "/gdc/projects/#{project.pid}/dataload/processes"
+          data = c.get(uri)
           data['processes']['items'].map do |process_data|
             Process.new(process_data)
           end
+        elsif id == :all
+          uri = "/gdc/account/profile/#{c.user.obj_id}/dataload/processes"
+          data = c.get(uri)
+          data['processes']['items'].map do |process_data|
+            c.create(Process, process_data)
+          end
         else
-          uri = "/gdc/projects/#{GoodData.project.pid}/dataload/processes/#{id}"
-          new(GoodData.get(uri))
+          uri = "/gdc/projects/#{project.pid}/dataload/processes/#{id}"
+          c.create(Process, c.get(uri), project: project)
         end
       end
 
@@ -30,8 +41,16 @@ module GoodData
 
       # TODO: Check the params.
       def with_deploy(dir, options = {}, &block)
-        # verbose = options[:verbose] || false
-        GoodData.with_project(options[:project_id] || options[:project]) do |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, 'Wrong :project specified' if project.nil?
+
+        GoodData.with_project(project) do
           params = options[:params].nil? ? [] : [options[:params]]
           if block
             begin
@@ -46,9 +65,37 @@ module GoodData
         end
       end
 
-      def upload_package(path, files_to_exclude)
-        if !path.directory?
-          GoodData.upload_to_user_webdav(path)
+      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?
+
+        if !path.directory? && (path.extname == '.grf' || path.extname == '.rb')
+          puts 'Creating package for upload'
+          Tempfile.open('deploy-graph-archive') do |temp|
+            Zip::OutputStream.open(temp.path) do |zio|
+              FileUtils.cd(path.parent) do
+                files_to_pack = [path.basename]
+                files_to_pack.each do |item|
+                  puts "including #{item}"
+                  unless File.directory?(item)
+                    zio.put_next_entry(item)
+                    zio.print IO.read(item)
+                  end
+                end
+              end
+            end
+
+            client.upload_to_user_webdav(temp.path, opts)
+            temp.path
+          end
+        elsif !path.directory?
+          client.upload_to_user_webdav(path, opts)
           path
         else
           Tempfile.open('deploy-graph-archive') do |temp|
@@ -57,7 +104,7 @@ module GoodData
 
                 files_to_pack = Dir.glob('./**/*').reject { |f| files_to_exclude.include?(Pathname(path) + f) }
                 files_to_pack.each do |item|
-                  # puts "including #{item}" if verbose
+                  puts "including #{item}"
                   unless File.directory?(item)
                     zio.put_next_entry(item)
                     zio.print IO.read(item)
@@ -65,7 +112,8 @@ module GoodData
                 end
               end
             end
-            GoodData.upload_to_user_webdav(temp.path)
+
+            client.upload_to_user_webdav(temp.path, opts)
             temp.path
           end
         end
@@ -80,15 +128,27 @@ 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 = 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?
+
         path = Pathname(path) || fail('Path is not specified')
-        files_to_exclude = options[:files_to_exclude].nil? ? [] : options[:files_to_exclude].map { |p| Pathname(p) }
+        files_to_exclude = options[:files_to_exclude].nil? ? [] : options[:files_to_exclude].map { |pname| Pathname(pname) }
         process_id = options[:process_id]
 
         type = options[:type] || 'GRAPH'
         deploy_name = options[:name]
+        fail ArgumentError, 'options[:name] can not be nil or empty!' if deploy_name.nil? || deploy_name.empty?
+
         verbose = options[:verbose] || false
         puts HighLine.color("Deploying #{path}", HighLine::BOLD) if verbose
-        deployed_path = Process.upload_package(path, files_to_exclude)
+
+        deployed_path = Process.upload_package(path, files_to_exclude, :client => client, :project => project)
         data = {
           :process => {
             :name => deploy_name,
@@ -96,12 +156,14 @@ module GoodData
             :type => type
           }
         }
+
         res = if process_id.nil?
-                GoodData.post("/gdc/projects/#{GoodData.project.pid}/dataload/processes", data)
+                client.post("/gdc/projects/#{project.pid}/dataload/processes", data)
               else
-                GoodData.put("/gdc/projects/#{GoodData.project.pid}/dataload/processes/#{process_id}", data)
+                client.put("/gdc/projects/#{project.pid}/dataload/processes/#{process_id}", data)
               end
-        process = Process.new(res)
+
+        process = client.create(Process, res, project: p)
         puts HighLine.color("Deploy DONE #{path}", HighLine::GREEN) if verbose
         process
       end
@@ -112,7 +174,7 @@ module GoodData
     end
 
     def delete
-      GoodData.delete(uri)
+      client.delete(uri)
     end
 
     # Redeploy existing process.
@@ -128,7 +190,7 @@ module GoodData
     end
 
     def process
-      json['process']
+      data['process']
     end
 
     def name
@@ -146,6 +208,7 @@ module GoodData
     def link
       links['self']
     end
+
     alias_method :uri, :link
 
     def obj_id
@@ -167,28 +230,28 @@ module GoodData
     end
 
     def schedules
-      GoodData::Schedule[:all].select { |schedule| schedule.process_id == obj_id }
+      project.schedules.select { |schedule| schedule.process_id == obj_id }
     end
 
     def create_schedule(cron, executable, options = {})
-      GoodData::Schedule.create(process_id, cron, executable, options)
+      project.create_schedule(process_id, cron, executable, options.merge(client: client, project: project))
     end
 
     def execute(executable, options = {})
       params = options[:params] || {}
       hidden_params = options[:hidden_params] || {}
-      result = GoodData.post(executions_link,
-                             :execution => {
-                               :graph => executable.to_s,
-                               :params => params,
-                               :hiddenParams => hidden_params
-                             })
+      result = client.post(executions_link,
+                           :execution => {
+                             :graph => executable.to_s,
+                             :params => params,
+                             :hiddenParams => hidden_params
+                           })
       begin
-        GoodData.poll_on_code(result['executionTask']['links']['poll'])
+        client.poll_on_code(result['executionTask']['links']['poll'])
       rescue RestClient::RequestFailed => e
         raise(e)
       ensure
-        result = GoodData.get(result['executionTask']['links']['detail'])
+        result = client.get(result['executionTask']['links']['detail'])
         if result['executionDetail']['status'] == 'ERROR'
           fail "Runing process failed. You can look at a log here #{result["executionDetail"]["logFileName"]}"
         end

data/lib/gooddata/models/profile.rb

@@ -1,11 +1,14 @@
 # encoding: UTF-8
 
+require 'pmap'
+
+require_relative '../rest/object'
+
 require_relative 'project'
 
 module GoodData
-  # Account settings representation with some added sugar
-  class Profile
-    attr_reader :json
+  class Profile < GoodData::Rest::Object
+    attr_reader :user, :json
 
     EMPTY_OBJECT = {
       'accountSetting' => {
@@ -73,8 +76,7 @@ module GoodData
       # Gets user currently logged in
       # @return [GoodData::Profile] User currently logged-in
       def current
-        json = GoodData.get GoodData.connection.user['profile']
-        GoodData::Profile.new(json)
+        GoodData.connection.user
       end
 
       # Gets hash representing diff of profiles
@@ -207,7 +209,7 @@ module GoodData
 
     # Deletes this account settings
     def delete
-      GoodData.delete uri
+      client.delete uri
     end
 
     # Gets hash representing diff of profiles
@@ -278,13 +280,6 @@ module GoodData
       @json['accountSetting']['login'] = val
     end
 
-    # Get full name
-    #
-    # @return [String] Full name
-    def name
-      "#{first_name} #{last_name}"
-    end
-
     # Gets the resource identifier
     #
     # @return [String] Resource identifier
@@ -328,14 +323,10 @@ module GoodData
     #
     # @return [Array<GoodData::Project>] Array of project where account settings belongs to
     def projects
-      res = []
-
-      projects = GoodData.get @json['accountSetting']['links']['projects']
-      projects['projects'].each do |project|
-        res << GoodData::Project.new(project)
+      projects = client.get @json['accountSetting']['links']['projects']
+      projects['projects'].map do |project|
+        client.create(GoodData::Project, project)
       end
-
-      res
     end
 
     # Saves object if dirty, clears dirty flag
@@ -380,5 +371,12 @@ module GoodData
     def uri
       @json['accountSetting']['links']['self']
     end
+
+    private
+
+    def initialize(json)
+      @json = json
+      @user = @json['accountSetting']['firstName'] + ' ' + @json['accountSetting']['lastName']
+    end
   end
 end

data/lib/gooddata/models/project.rb

@@ -3,16 +3,22 @@
 require 'csv'
 require 'zip'
 require 'fileutils'
+require 'multi_json'
+require 'pmap'
+require 'zip'
 
-require_relative 'process'
 require_relative '../exceptions/no_project_error'
 
-require_relative '../mixins/mixins'
+require_relative '../rest/resource'
+require_relative '../mixins/author'
+require_relative '../mixins/contributor'
+require_relative '../mixins/rest_resource'
 
+require_relative 'process'
 require_relative 'project_role'
 
 module GoodData
-  class Project
+  class Project < GoodData::Rest::Resource
     USERSPROJECTS_PATH = '/gdc/account/profile/%s/projects'
     PROJECTS_PATH = '/gdc/projects'
     PROJECT_PATH = '/gdc/projects/%s'
@@ -24,20 +30,19 @@ module GoodData
     alias_method :to_json, :json
     alias_method :raw_data, :json
 
-    include GoodData::Mixin::MetaGetter
-    include GoodData::Mixin::DataGetter
-
-    class << self
-      include GoodData::Mixin::RootKeySetter
+    include GoodData::Mixin::RestResource
 
-      include GoodData::Mixin::MetaPropertyReader
+    Project.root_key :project
 
-      include GoodData::Mixin::MetaPropertyWriter
+    include GoodData::Mixin::Author
+    include GoodData::Mixin::Contributor
 
+    class << self
       # Returns an array of all projects accessible by
       # current user
-      def all
-        GoodData.profile.projects
+      def all(opts = {})
+        c = client(opts)
+        c.user.projects
       end
 
       # Returns a Project object identified by given string
@@ -46,10 +51,11 @@ module GoodData
       #  - /gdc/projects/<id>
       #  - <id>
       #
-      def [](id, options = {})
-        return id if id.respond_to?(:project?) && id.project?
+      def [](id, opts = {})
+        return id if id.instance_of?(GoodData::Project) || id.respond_to?(:project?) && id.project?
+
         if id == :all
-          Project.all
+          Project.all(opts)
         else
           if id.to_s !~ %r{^(\/gdc\/(projects|md)\/)?[a-zA-Z\d]+$}
             fail(ArgumentError, 'wrong type of argument. Should be either project ID or path')
@@ -57,48 +63,46 @@ module GoodData
 
           id = id.match(/[a-zA-Z\d]+$/)[0] if id =~ /\//
 
-          response = GoodData.get PROJECT_PATH % id
-          Project.new response
+          c = client(opts)
+          fail ArgumentError, 'No :client specified' if c.nil?
+
+          response = c.get(PROJECT_PATH % id)
+          c.factory.create(Project, response)
         end
       end
 
-      Project.root_key :project
-
-      include GoodData::Mixin::RootKeyGetter
-      include GoodData::Mixin::DataGetter
-      include GoodData::Mixin::Author
-      include GoodData::Mixin::Contributor
-      include GoodData::Mixin::Timestamps
-
       # Create a project from a given attributes
       # Expected keys:
       # - :title (mandatory)
       # - :summary
       # - :template (default /projects/blank)
       #
-      def create(attributes, &block)
-        GoodData.logger.info "Creating project #{attributes[:title]}"
+      def create(opts = { :client => GoodData.connection }, &block)
+        GoodData.logger.info "Creating project #{opts[:title]}"
 
-        auth_token = attributes[:auth_token] || GoodData.connection.auth_token
+        c = client(opts)
+        fail ArgumentError, 'No :client specified' if c.nil?
+
+        auth_token = opts[:auth_token] || GoodData.connection.auth_token
         fail 'You have to provide your token for creating projects as :auth_token parameter' if auth_token.nil? || auth_token.empty?
 
         json = {
           'project' =>
             {
               'meta' => {
-                'title' => attributes[:title],
-                'summary' => attributes[:summary] || 'No summary'
+                'title' => opts[:title],
+                'summary' => opts[:summary] || 'No summary'
               },
               'content' => {
-                'guidedNavigation' => attributes[:guided_navigation] || 1,
+                'guidedNavigation' => opts[:guided_navigation] || 1,
                 'authorizationToken' => auth_token,
-                'driver' => attributes[:driver] || 'Pg'
+                'driver' => opts[:driver] || 'Pg'
               }
             }
         }
 
-        json['project']['meta']['projectTemplate'] = attributes[:template] if attributes[:template] && !attributes[:template].empty?
-        project = Project.new json
+        json['project']['meta']['projectTemplate'] = opts[:template] if opts[:template] && !opts[:template].empty?
+        project = c.create(Project, json)
         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'
@@ -119,6 +123,13 @@ module GoodData
         project
       end
 
+      def find(opts = {}, client = GoodData::Rest::Client.client)
+        user = client.user
+        user.projects['projects'].map do |project|
+          client.create(GoodData::Project, project)
+        end
+      end
+
       def create_from_blueprint(blueprint, options = {})
         GoodData::Model::ProjectCreator.migrate(:spec => blueprint, :token => options[:auth_token])
       end
@@ -141,15 +152,18 @@ module GoodData
       end
     end
 
-    def add_metric(options = {})
-      options[:expression] || fail('Metric has to have its expression defined')
-      m1 = GoodData::Metric.xcreate(options)
-      m1.save
+    def add_metric(metric, options = {})
+      default = { client: client, project: self }
+      if metric.is_a?(String)
+        GoodData::Metric.xcreate(metric, options.merge(default))
+      else
+        GoodData::Metric.xcreate(metric.merge(default))
+      end
     end
     alias_method :create_metric, :add_metric
 
     def add_report(options = {})
-      rep = GoodData::Report.create(options)
+      rep = GoodData::Report.create(options.merge(client: client, project: self))
       rep.save
     end
     alias_method :create_report, :add_report
@@ -161,13 +175,29 @@ module GoodData
       user_has_role?(GoodData.user, 'admin')
     end
 
+    # Helper for getting attributes of a project
+    #
+    # @param [String | Number | Object] Anything that you can pass to GoodData::Attribute[id]
+    # @return [GoodData::Attribute | Array<GoodData::Attribute>] fact instance or list
+    def attributes(id = :all)
+      GoodData::Attribute[id, project: self, client: client]
+    end
+
+    def attribute_by_title(title)
+      GoodData::Attribute.find_first_by_title(title, project: self, client: client)
+    end
+
+    def attributes_by_title(title)
+      GoodData::Attribute.find_by_title(title, project: self, client: client)
+    end
+
     # Gets project blueprint from the server
     #
     # @return [GoodData::ProjectRole] Project role if found
     def blueprint
-      result = GoodData.get("/gdc/projects/#{pid}/model/view")
+      result = client.get("/gdc/projects/#{pid}/model/view")
       polling_url = result['asyncTask']['link']['poll']
-      model = GoodData.poll_on_code(polling_url)
+      model = client.poll_on_code(polling_url)
       GoodData::Model::FromWire.from_wire(model)
     end
 
@@ -177,9 +207,9 @@ module GoodData
     def browser_uri(options = {})
       grey = options[:grey]
       if grey
-        GoodData.connection.url + uri
+        client.connection.url + uri
       else
-        GoodData.connection.url + '#s=' + uri
+        client.connection.url + '#s=' + uri
       end
     end
 
@@ -188,12 +218,12 @@ module GoodData
     # @return [GoodData::Project] Newly created project
     def clone(options = {})
       # TODO: Refactor so if export or import fails the new_project will be cleaned
-      with_data = options[:data] || true
-      with_users = options[:users] || false
+      with_data = options[:data].nil? ? true : options[:data]
+      with_users = options[:users].nil? ? false : options[:users]
       a_title = options[:title] || "Clone of #{title}"
 
       # Create the project first so we know that it is passing. What most likely is wrong is the tokena and the export actaully takes majoiryt of the time
-      new_project = GoodData::Project.create(options.merge(:title => a_title))
+      new_project = GoodData::Project.create(options.merge(:title => a_title, :client => client))
 
       export = {
         :exportProject => {
@@ -202,11 +232,11 @@ module GoodData
         }
       }
 
-      result = GoodData.post("/gdc/md/#{obj_id}/maintenance/export", export)
+      result = client.post("/gdc/md/#{obj_id}/maintenance/export", export)
       export_token = result['exportArtifact']['token']
 
       status_url = result['exportArtifact']['status']['uri']
-      GoodData.poll_on_response(status_url) do |body|
+      client.poll_on_response(status_url) do |body|
         body['taskState']['status'] == 'RUNNING'
       end
 
@@ -216,35 +246,46 @@ module GoodData
         }
       }
 
-      result = GoodData.post("/gdc/md/#{new_project.obj_id}/maintenance/import", import)
+      result = client.post("/gdc/md/#{new_project.obj_id}/maintenance/import", import)
       status_url = result['uri']
-      GoodData.poll_on_response(status_url) do |body|
+      client.poll_on_response(status_url) do |body|
         body['taskState']['status'] == 'RUNNING'
       end
 
       new_project
     end
 
-    def datasets
-      blueprint.datasets
-      datasets_uri = "#{md['data']}/sets"
-      response = GoodData.get datasets_uri
-      response['dataSetsInfo']['sets'].map do |ds|
-        DataSet[ds['meta']['uri']]
-      end
+    def create_schedule(process, date, executable, options = {})
+      GoodData::Schedule.create(process, date, executable, options.merge(:client => client, :project => self))
     end
 
-    # Gets processes for the project
+    # Helper for getting dashboards of a project
     #
-    # @return [Array<GoodData::Process>] Processes for the current project
-    def processes
-      GoodData::Process.all
+    # @param [String | Number | Object] Anything that you can pass to GoodData::Dashboard[id]
+    # @return [GoodData::Dashboard | Array<GoodData::Dashboard>] dashboard instance or list
+    def dashboards(id = :all)
+      GoodData::Dashboard[id, project: self, client: client]
+    end
+
+    def datasets
+      blueprint.datasets
     end
 
     # Deletes project
     def delete
       fail "Project '#{title}' with id #{uri} is already deleted" if state == :deleted
-      GoodData.delete(uri)
+      client.delete(uri)
+    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
+    # @return [Array] Result of executing MAQLs
+    def delete_all_data(options = {})
+      return false unless options[:force]
+      datasets.pmap do |dataset|
+        execute_maql("SYNCHRONIZE {#{dataset.identifier}}")
+      end
     end
 
     # Deletes dashboards for project
@@ -252,30 +293,58 @@ module GoodData
       Dashboard.all.map { |data| Dashboard[data['link']] }.each { |d| d.delete }
     end
 
+    def deploy_process(path, options = {})
+      GoodData::Process.deploy(path, options.merge(client: client, project: self))
+    end
+
     # Executes DML expression. See (https://developer.gooddata.com/article/deleting-records-from-datasets)
     # for some examples and explanations
     #
     # @param dml [String] DML expression
+    # @return [Hash] Result of executing DML
     def execute_dml(dml)
       uri = "/gdc/md/#{pid}/dml/manage"
-      result = GoodData.post(uri,
-                             manage: {
-                               maql: dml
-                             })
+      result = client.post(uri, manage: { maql: dml })
       polling_uri = result['uri']
-      result = GoodData.get(polling_uri)
-      while result['taskState'] && result['taskState']['status'] == 'WAIT'
-        sleep 10
-        result = GoodData.get polling_uri
+
+      client.poll_on_response(polling_uri) do |body|
+        body && body['taskState'] && body['taskState']['status'] == 'WAIT'
+      end
+    end
+
+    # Executes MAQL expression and waits for it to be finished.
+    #
+    # @param maql [String] MAQL expression
+    # @return [Hash] Result of executing MAQL
+    def execute_maql(maql)
+      ldm_links = client.get(md[GoodData::Model::LDM_CTG])
+      ldm_uri = Links.new(ldm_links)[GoodData::Model::LDM_MANAGE_CTG]
+      response = client.post(ldm_uri, manage: { maql: maql })
+      polling_uri = response['entries'].first['link']
+
+      client.poll_on_response(polling_uri) do |body|
+        body && body['wTaskStatus'] && body['wTaskStatus']['status'] == 'RUNNING'
       end
     end
 
     # Helper for getting facts of a project
     #
     # @param [String | Number | Object] Anything that you can pass to GoodData::Fact[id]
-    # @return [GoodData::Fact] fact instance or list
-    def fact(id)
-      GoodData::Fact[id, project: self]
+    # @return [GoodData::Fact | Array<GoodData::Fact>] fact instance or list
+    def facts(id = :all)
+      GoodData::Fact[id, project: self, client: client]
+    end
+
+    def fact_by_title(title)
+      GoodData::Fact.find_first_by_title(title, project: self, client: client)
+    end
+
+    def facts_by_title(title)
+      GoodData::Fact.find_by_title(title, project: self, client: client)
+    end
+
+    def find_attribute_element_value(uri)
+      GoodData::Attribute.find_element_value(uri, client: client, project: self)
     end
 
     # Gets project role by its identifier
@@ -348,6 +417,107 @@ module GoodData
       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
+
+        # Lookup for role
+        role_name = user.json['user']['content']['role'] || 'readOnlyUser'
+        role = get_role_by_identifier(role_name, role_list)
+        next if role.nil?
+
+        # Assign user project role
+        add_user(domain_user, [role.uri])
+      end
+
+      ##########################
+      # Remove old users
+      ##########################
+      # diff[:removed].map do |user|
+      #   user.disable(self)
+      # end
+    end
+
     # Checks whether user has particular role in given proejct
     #
     # @param user [GoodData::Profile | GoodData::Membership | String] User in question. Can be passed by login (String), profile or membershi objects
@@ -365,6 +535,7 @@ module GoodData
     #
     # @param json Json used for initialization
     def initialize(json)
+      super
       @json = json
     end
 
@@ -403,21 +574,17 @@ module GoodData
       }
 
       url = "/gdc/projects/#{pid}/invitations"
-      GoodData.post(url, data)
+      client.post(url, data)
     end
 
     # Returns invitations to project
     #
     # @return [Array<GoodData::Invitation>] List of invitations
     def invitations
-      res = []
-
-      tmp = GoodData.get @json['project']['links']['invitations']
-      tmp['invitations'].each do |invitation|
-        res << GoodData::Invitation.new(invitation)
+      invitations = client.get @json['project']['links']['invitations']
+      invitations['invitations'].pmap do |invitation|
+        client.create GoodData::Invitation, invitation
       end
-
-      res
     end
 
     # Returns project related links
@@ -427,12 +594,21 @@ module GoodData
       data['links']
     end
 
-    def lint
-      blueprint.lint
+    # Helper for getting labels of a project
+    #
+    # @param [String | Number | Object] Anything that you can pass to
+    # GoodData::Label[id] + it supports :all as welll
+    # @return [GoodData::Fact | Array<GoodData::Fact>] fact instance or list
+    def labels(id = :all, opts = {})
+      if id == :all
+        attributes.pmapcat { |a| a.labels }.uniq
+      else
+        GoodData::Label[id, opts.merge(project: self, client: client)]
+      end
     end
 
     def md
-      @md ||= Links.new GoodData.get(data['links']['metadata'])
+      @md ||= client.create(Links, client.get(data['links']['metadata']))
     end
 
     # Gets membership for profile specified
@@ -449,6 +625,21 @@ module GoodData
       list.find { |m| m.login == profile.login }
     end
 
+    # Helper for getting metrics of a project
+    #
+    # @return [Array<GoodData::Metric>] matric instance or list
+    def metrics(id = :all, opts = { :full => true })
+      GoodData::Metric[id, opts.merge(project: self, client: client)]
+    end
+
+    def metric_by_title(title)
+      GoodData::Metric.find_first_by_title(title, project: self, client: client)
+    end
+
+    def metrics_by_title(title)
+      GoodData::Metric.find_by_title(title, project: self, client: client)
+    end
+
     # Checks if the profile is member of project
     #
     # @param [GoodData::Profile] profile - Profile to be checked
@@ -467,26 +658,32 @@ module GoodData
 
     alias_method :pid, :obj_id
 
-    def partial_md_export(objects, options = {})
-      # TODO: refactor polling to md_polling in client
+    # Helper for getting objects of a project
+    #
+    # @return [Array<GoodData::MdObject>] object instance or list
+    def objects(id, opts = {})
+      GoodData::MdObject[id, opts.merge(project: self, client: client)]
+    end
 
-      fail 'Nothing to migrate. You have to pass list of objects, ids or uris that you would like to migrate' if objects.nil? || objects.empty?
-      fail 'The objects to migrate has to be provided as an array' unless objects.is_a?(Array)
+    def partial_md_export(objs, options = {})
+      fail 'Nothing to migrate. You have to pass list of objects, ids or uris that you would like to migrate' if objs.nil?
+      objs = [objs] unless objs.is_a?(Array)
+      fail 'Nothing to migrate. The list you provided is empty' if objs.empty?
 
       target_project = options[:project]
       fail 'You have to provide a project instance or project pid to migrate to' if target_project.nil?
-      target_project = GoodData::Project[target_project]
-      objects = objects.map { |obj| GoodData::MdObject[obj] }
+      target_project = client.projects(target_project)
+      objs = objs.pmap { |obj| objects(obj) }
       export_payload = {
         :partialMDExport => {
-          :uris => objects.map { |obj| obj.uri }
+          :uris => objs.map { |obj| obj.uri }
         }
       }
-      result = GoodData.post("#{GoodData.project.md['maintenance']}/partialmdexport", export_payload)
+      result = client.post("#{md['maintenance']}/partialmdexport", export_payload)
       polling_url = result['partialMDArtifact']['status']['uri']
       token = result['partialMDArtifact']['token']
 
-      polling_result = GoodData.poll_on_response(polling_url) do |body|
+      polling_result = client.poll_on_response(polling_url) do |body|
         body['wTaskStatus'] && body['wTaskStatus']['status'] == 'RUNNING'
       end
 
@@ -500,10 +697,10 @@ module GoodData
         }
       }
 
-      result = GoodData.post("#{target_project.md['maintenance']}/partialmdimport", import_payload)
+      result = client.post("#{target_project.md['maintenance']}/partialmdimport", import_payload)
       polling_url = result['uri']
 
-      GoodData.poll_on_response(polling_url) do |body|
+      client.poll_on_response(polling_url) do |body|
         body['wTaskStatus'] && body['wTaskStatus']['status'] == 'RUNNING'
       end
 
@@ -512,6 +709,14 @@ module GoodData
 
     alias_method :transfer_objects, :partial_md_export
 
+    # Helper for getting processes of a project
+    #
+    # @param [String | Number | Object] Anything that you can pass to GoodData::Report[id]
+    # @return [GoodData::Report | Array<GoodData::Report>] report instance or list
+    def processes(id = :all)
+      GoodData::Process[id, project: self, client: client]
+    end
+
     # Checks if this object instance is project
     #
     # @return [Boolean] Return true for all instances
@@ -520,8 +725,8 @@ module GoodData
     end
 
     def info
-      results = blueprint.datasets.map do |ds|
-        [ds, ds.count]
+      results = blueprint.datasets.pmap do |ds|
+        [ds, ds.count(self)]
       end
       puts title
       puts GoodData::Helpers.underline(title)
@@ -544,21 +749,38 @@ module GoodData
     # Forces project to reload
     def reload!
       if saved?
-        response = GoodData.get(uri)
+        response = client.get(uri)
         @json = response
       end
       self
     end
 
+    # Helper for getting reports of a project
+    #
+    # @param [String | Number | Object] Anything that you can pass to GoodData::Report[id]
+    # @return [GoodData::Report | Array<GoodData::Report>] report instance or list
+    def reports(id = :all)
+      GoodData::Report[id, project: self, client: client]
+    end
+
+    # Helper for getting report definitions of a project
+    #
+    # @param [String | Number | Object] Anything that you can pass to GoodData::ReportDefinition[id]
+    # @return [GoodData::ReportDefinition | Array<GoodData::ReportDefinition>] report definition instance or list
+    def report_definitions(id = :all, options = {})
+      GoodData::ReportDefinition[id, options.merge(project: self, client: client)]
+    end
+
     # Gets the list or project roles
     #
     # @return [Array<GoodData::ProjectRole>] List of roles
     def roles
       url = "/gdc/projects/#{pid}/roles"
-      tmp = GoodData.get(url)
-      tmp['projectRoles']['roles'].map do |role_url|
-        json = GoodData.get role_url
-        GoodData::ProjectRole.new(json)
+
+      tmp = client.get(url)
+      tmp['projectRoles']['roles'].pmap do |role_url|
+        json = client.get role_url
+        client.create(GoodData::ProjectRole, json)
       end
     end
 
@@ -569,11 +791,11 @@ module GoodData
       data_to_send['project']['content'].delete('isPublic')
       data_to_send['project']['content'].delete('state')
       response = if uri
-                   GoodData.post(PROJECT_PATH % pid, data_to_send)
-                   GoodData.get uri
+                   client.post(PROJECT_PATH % pid, data_to_send)
+                   client.get uri
                  else
-                   result = GoodData.post(PROJECTS_PATH, data_to_send)
-                   GoodData.get result['uri']
+                   result = client.post(PROJECTS_PATH, data_to_send)
+                   client.get result['uri']
                  end
       @json = response
       self
@@ -587,12 +809,10 @@ module GoodData
       !res
     end
 
-    # Gets project schedules
-    #
-    # @return [Array<GoodData::Schedule>] List of schedules
-    def schedules
-      tmp = GoodData.get @json['project']['links']['schedules']
-      tmp['schedules']['items'].map { |schedule| GoodData::Schedule.new(schedule) }
+    # @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)
+      GoodData::Schedule[id, project: self, client: client]
     end
 
     # Gets SLIs data
@@ -602,7 +822,7 @@ module GoodData
       link = "#{data['links']['metadata']}#{SLIS_PATH}"
 
       # FIXME: Review what to do with passed extra argument
-      Metadata.new GoodData.get(link)
+      Metadata.new client.get(link)
     end
 
     # Gets project state
@@ -637,14 +857,10 @@ module GoodData
     #
     # @return [Array<GoodData::User>] List of users
     def users
-      res = []
-
-      tmp = GoodData.get @json['project']['links']['users']
+      tmp = client.get @json['project']['links']['users']
       tmp['users'].map do |user|
-        res << GoodData::Membership.new(user)
+        client.factory.create(GoodData::Membership, user)
       end
-
-      res
     end
 
     alias_method :members, :users
@@ -660,9 +876,10 @@ module GoodData
 
         # Get domain info from REST, add to cache
         if domain.nil?
+          d = GoodData::Domain[domain_name, { :client => client }]
           domain = {
-            :domain => GoodData::Domain[domain_name],
-            :users => GoodData::Domain[domain_name].users
+            :domain => d,
+            :users => d.users(:client => client)
           }
 
           domain[:users_map] = Hash[domain[:users].map { |u| [u.email, u] }]
@@ -735,7 +952,7 @@ module GoodData
     #
     # @param list List of users to be disabled
     def users_remove(list)
-      list.map do |user|
+      list.pmap do |user|
         user.disable
       end
     end
@@ -772,7 +989,7 @@ module GoodData
         }
       }
 
-      GoodData.post url, payload
+      client.post url, payload
     end
 
     alias_method :add_user, :set_user_roles
@@ -782,12 +999,12 @@ 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)
-      list.map do |user_hash|
+      list.pmap do |user_hash|
         user = user_hash[:user]
         roles = user_hash[:role] || user_hash[:roles]
         {
           :user => user,
-          :result => set_user_roles(user, roles, role_list)
+          :result => set_user_roles(user, roles)
         }
       end
     end
@@ -800,9 +1017,9 @@ module GoodData
     # invalid_objects - Checks metadata for invalid/corrupted objects.
     # asyncTask response
     def validate(filters = %w(ldm pdm metric_filter invalid_objects))
-      response = GoodData.post "#{GoodData.project.md['validate-project']}", 'validateProject' => filters
+      response = client.post "#{md['validate-project']}", 'validateProject' => filters
       polling_link = response['asyncTask']['link']['poll']
-      GoodData.poll_on_response(polling_link) do |body|
+      client.poll_on_response(polling_link) do |body|
         body['wTaskStatus'] && body['wTaskStatus']['status'] == 'RUNNING'
       end
     end