gooddata 0.6.7 → 0.6.8

data/lib/gooddata/models/project_creator.rb

@@ -9,21 +9,24 @@ module GoodData
   module Model
     class ProjectCreator
       class << self
-        def migrate(options = {})
-          spec = options[:spec] || fail('You need to provide spec for migration')
+        def migrate(opts = { :client => GoodData.connection, :project => GoodData.project })
+          client = opts[:client]
+          fail ArgumentError, 'No :client specified' if client.nil?
+
+          spec = opts[:spec] || fail('You need to provide spec for migration')
           bp = ProjectBlueprint.new(spec)
           spec = bp.to_hash
 
           fail GoodData::ValidationError, "Blueprint is invalid #{bp.validate.inspect}" unless bp.valid?
 
-          token = options[:token]
-          project = options[:project] || GoodData::Project.create(:title => spec[:title], :auth_token => token)
+          token = opts[:token]
+          project = opts[:project] || GoodData::Project.create(:title => spec[:title], :auth_token => token, :client => client)
           fail('You need to specify token for project creation') if token.nil? && project.nil?
 
           begin
-            GoodData.with_project(project) do |p|
+            GoodData.with_project(project, opts) do |p|
               # migrate_date_dimensions(p, spec[:date_dimensions] || [])
-              migrate_datasets(p, spec)
+              migrate_datasets(spec, :project => p, :client => client)
               load(p, spec)
               migrate_metrics(p, spec[:metrics] || [])
               migrate_reports(p, spec[:reports] || [])
@@ -41,40 +44,47 @@ module GoodData
           end
         end
 
-        def migrate_datasets(project, spec)
+        def migrate_datasets(spec, 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 = Project[p, { :client => client }]
+          fail ArgumentError, 'Wrong :project specified' if project.nil?
+
           bp = ProjectBlueprint.new(spec)
           # schema = Schema.load(schema) unless schema.respond_to?(:to_maql_create)
           # project = GoodData.project unless project
-          uri = "/gdc/projects/#{GoodData.project.pid}/model/diff"
-          result = GoodData.post(uri, bp.to_wire)
+          uri = "/gdc/projects/#{project.pid}/model/diff"
+          result = client.post(uri, bp.to_wire)
+
           link = result['asyncTask']['link']['poll']
-          response = GoodData.get(link, :process => false)
+          response = client.get(link, :process => false)
+
           # pp response
           while response.code != 200
             sleep 1
-            GoodData.connection.retryable(:tries => 3, :on => RestClient::InternalServerError) do
+            client.retryable(:tries => 3, :on => RestClient::InternalServerError) do
               sleep 1
-              response = GoodData.get(link, :process => false)
+              response = client.get(link, :process => false)
               # pp response
             end
           end
-          response = GoodData.get(link)
-          ldm_links = GoodData.get project.md[LDM_CTG]
-          ldm_uri = Links.new(ldm_links)[LDM_MANAGE_CTG]
+
+          response = client.get(link)
+
           chunks = pick_correct_chunks(response['projectModelDiff']['updateScripts'])
           chunks['updateScript']['maqlDdlChunks'].each do |chunk|
-            response = GoodData.post ldm_uri, 'manage' => { 'maql' => chunk }
-            polling_url = response['entries'].first['link']
-            polling_result = GoodData.poll_on_response(polling_url) do |body|
-              body['wTaskStatus']['status'] == 'RUNNING'
-            end
-            fail 'Creating dataset failed' if polling_result['wTaskStatus']['status'] == 'ERROR'
+            result = project.execute_maql(chunk)
+            fail 'Creating dataset failed' if result['wTaskStatus']['status'] == 'ERROR'
           end
 
           bp.datasets.zip(GoodData::Model::ToManifest.to_manifest(bp.to_hash)).each do |ds|
             dataset = ds[0]
             manifest = ds[1]
-            GoodData::ProjectMetadata["manifest_#{dataset.name}"] = manifest.to_json
+            GoodData::ProjectMetadata["manifest_#{dataset.name}", :client => client, :project => project] = manifest.to_json
           end
         end
 

data/lib/gooddata/models/project_metadata.rb

@@ -3,21 +3,27 @@
 module GoodData
   class ProjectMetadata
     class << self
-      def keys
-        ProjectMetadata[:all].keys
+      def keys(opts = { :client => GoodData.connection })
+        ProjectMetadata[:all, opts].keys
       end
 
-      def [](key, options = {})
+      def [](key, opts = { :client => GoodData.connection })
+        client = opts[:client]
+        fail ArgumentError, 'No :client specified' if client.nil?
+
+        project = opts[:project]
+        fail ArgumentError, 'No :project specified' if project.nil?
+
         if key == :all
-          uri = "/gdc/projects/#{GoodData.project.pid}/dataload/metadata"
-          res = GoodData.get(uri)
+          uri = "/gdc/projects/#{project.pid}/dataload/metadata"
+          res = client.get(uri)
           res['metadataItems']['items'].reduce({}) do |memo, i|
             memo[i['metadataItem']['key']] = i['metadataItem']['value']
             memo
           end
         else
-          uri = "/gdc/projects/#{GoodData.project.pid}/dataload/metadata/#{key}"
-          res = GoodData.get(uri)
+          uri = "/gdc/projects/#{project.pid}/dataload/metadata/#{key}"
+          res = client.get(uri)
           res['metadataItem']['value']
         end
       end
@@ -25,27 +31,33 @@ module GoodData
       alias_method :get, :[]
       alias_method :get_key, :[]
 
-      def key?(key)
-        ProjectMetadata[key]
+      def key?(key, opts = { :client => GoodData.connection })
+        ProjectMetadata[key, opts]
         true
       rescue RestClient::ResourceNotFound
         false
       end
 
-      def []=(key, val)
+      def []=(key, opts = { :client => GoodData.connection }, val = nil)
+        client = opts[:client]
+        fail ArgumentError, 'No :client specified' if client.nil?
+
+        project = opts[:project]
+        fail ArgumentError, 'No :project specified' if project.nil?
+
         data = {
           :metadataItem => {
             :key => key,
             :value => val
           }
         }
-        uri = "/gdc/projects/#{GoodData.project.pid}/dataload/metadata/"
+        uri = "/gdc/projects/#{project.pid}/dataload/metadata/"
         update_uri = uri + key
 
-        if key?(key)
-          GoodData.put(update_uri, data)
+        if key?(key, opts)
+          client.put(update_uri, data)
         else
-          GoodData.post(uri, data)
+          client.post(uri, data)
         end
       end
     end

data/lib/gooddata/models/project_role.rb

@@ -1,22 +1,21 @@
 # encoding: UTF-8
 
+require 'pmap'
+
 require_relative 'profile'
 
-require_relative '../mixins/mixins'
+require_relative '../rest/rest'
+
+require_relative '../mixins/rest_resource'
 
 module GoodData
-  class ProjectRole
+  class ProjectRole < GoodData::Rest::Object
     attr_accessor :json
 
-    include GoodData::Mixin::RestGetters
-
-    class << self
-      include GoodData::Mixin::RestResource
-    end
+    include GoodData::Mixin::RestResource
 
-    ProjectRole.root_key :projectRole
+    root_key :projectRole
 
-    include GoodData::Mixin::RootKeyGetter
     include GoodData::Mixin::Author
     include GoodData::Mixin::Contributor
     include GoodData::Mixin::Timestamps
@@ -25,22 +24,21 @@ module GoodData
       @json = json
     end
 
-    ProjectRole.data_property_reader :permissions
+    data_property_reader :permissions
 
-    ProjectRole.metadata_property_reader :identifier, :title, :summary
+    metadata_property_reader :identifier, :title, :summary
 
     # Gets Users with this Role
     #
     # @return [Array<GoodData::Profile>] List of users
     def users
-      res = []
       url = data['links']['roleUsers']
-      tmp = GoodData.get url
-      tmp['associatedUsers']['users'].each do |user_url|
-        user = GoodData.get user_url
-        res << GoodData::Profile.new(user)
+      tmp = client.get url
+      tmp['associatedUsers']['users'].pmap do |user_url|
+        url = user_url
+        user = client.get url
+        client.create(GoodData::Profile, user)
       end
-      res
     end
 
     # Gets Raw object URI

data/lib/gooddata/models/report_data_result.rb

@@ -85,6 +85,10 @@ module GoodData
       differences
     end
 
+    def empty?
+      false
+    end
+
     private
 
     def each_level(table, level, children, lookup)

data/lib/gooddata/models/schedule.rb

@@ -1,7 +1,10 @@
 # encoding: UTF-8
 
+require_relative '../rest/resource'
+require_relative '../extensions/hash'
+
 module GoodData
-  class Schedule
+  class Schedule < Rest::Resource
     attr_reader :dirty, :data
 
     alias_method :json, :data
@@ -12,26 +15,44 @@ module GoodData
       # Looks for schedule
       # @param id [String] URL, ID of schedule or :all
       # @return [GoodData::Schedule|Array<GoodData::Schedule>] List of schedules
-      def [](id, options = {})
+      def [](id, opts = { :client => GoodData.connection, :project => GoodData.project })
+        c = client(opts)
+        fail ArgumentError, 'No :client specified' if c.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 id == :all
-          GoodData::Schedule.all
+          GoodData::Schedule.all(opts)
         else
           if id =~ %r{\/gdc\/projects\/[a-zA-Z\d]+\/schedules\/?[a-zA-Z\d]*}
             url = id
-            tmp = GoodData.get url
-            return GoodData::Schedule.new(tmp)
+            tmp = c.get url
+            return c.create(GoodData::Schedule, tmp)
           end
 
-          tmp = GoodData.get "/gdc/projects/#{GoodData.project.pid}/schedules/#{id}"
-          GoodData::Schedule.new(tmp)
+          tmp = c.get "/gdc/projects/#{project.pid}/schedules/#{id}"
+          c.create(GoodData::Schedule, tmp, project: project)
         end
       end
 
       # Returns list of all schedules for active project
       # @return [Array<GoodData::Schedule>] List of schedules
-      def all
-        tmp = GoodData.get "/gdc/projects/#{GoodData.project.pid}/schedules"
-        tmp['schedules']['items'].map { |schedule| GoodData::Schedule.new(schedule) }
+      def all(opts = { :client => GoodData.connection, :project => GoodData.project })
+        c = client(opts)
+        fail ArgumentError, 'No :client specified' if c.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?
+
+        tmp = c.get "/gdc/projects/#{project.pid}/schedules"
+        tmp['schedules']['items'].map { |schedule| c.create(GoodData::Schedule, schedule) }
       end
 
       # Creates new schedules from parameters passed
@@ -42,6 +63,15 @@ module GoodData
       # @param options [Hash] Optional options
       # @return [GoodData::Schedule] New GoodData::Schedule instance
       def create(process_id, cron, executable, options = {})
+        c = client(options)
+        fail ArgumentError, 'No :client specified' if c.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?
+
         default_opts = {
           :type => 'MSETL',
           :timezone => 'UTC',
@@ -78,7 +108,7 @@ module GoodData
         default[:params] = default_params
 
         json = {
-          'schedule' => default.merge(options)
+          'schedule' => default.merge(options.except(:project, :client))
         }
 
         tmp = json['schedule'][:params]['PROCESS_ID']
@@ -96,13 +126,13 @@ module GoodData
         tmp = json['schedule'][:type]
         fail 'Schedule type has to be provided' if tmp.nil? || tmp.empty?
 
-        url = "/gdc/projects/#{GoodData.project.pid}/schedules"
-        res = GoodData.post url, json
+        url = "/gdc/projects/#{project.pid}/schedules"
+        res = c.post url, json
 
         fail 'Unable to create new schedule' if res.nil?
 
-        new_obj_json = GoodData.get res['schedule']['links']['self']
-        GoodData::Schedule.new(new_obj_json)
+        new_obj_json = c.get res['schedule']['links']['self']
+        c.create(GoodData::Schedule, new_obj_json, client: c, project: p)
       end
     end
 
@@ -111,12 +141,13 @@ module GoodData
     # @param json [Object] Raw JSON
     # @return [GoodData::Schedule] New GoodData::Schedule instance
     def initialize(json)
+      super
       @json = json
     end
 
     # Deletes schedule
     def delete
-      GoodData.delete uri
+      client.delete uri
     end
 
     # Executes schedule
@@ -126,9 +157,9 @@ module GoodData
       data = {
         :execution => {}
       }
-      execution = GoodData.post(execution_url, data)
-      GoodData.poll_on_response(execution['execution']['links']['self']) do |body|
-        body['execution'] && body['execution']['status'] == 'RUNNING'
+      execution = client.post(execution_url, data)
+      client.poll_on_response(execution['execution']['links']['self']) do |body|
+        body['execution'] && (body['execution']['status'] == 'RUNNING' || body['execution']['status'] == 'SCHEDULED')
       end
     end
 
@@ -239,7 +270,7 @@ module GoodData
     def executions
       if @json
         url = @json['schedule']['links']['executions']
-        res = GoodData.get url
+        res = client.get url
         res['executions']['items']
       end
     end

data/lib/gooddata/models/schema_blueprint.rb

@@ -199,14 +199,13 @@ module GoodData
       # datasets with or without anchor
       #
       # @return [Boolean]
-      def count
+      def count(project)
         id = if anchor?
                GoodData::Model.identifier_for(to_hash, anchor)
              else
                GoodData::Model.identifier_for(to_hash, type: :anchor_no_label)
              end
-        # binding.pry
-        attribute = GoodData::Attribute[id]
+        attribute = project.attributes(id)
         attribute.create_metric.execute
       end
 
@@ -261,6 +260,13 @@ module GoodData
         DatasetBlueprint.find_column_by_type(to_hash, type, all)
       end
 
+      # Returns identifier for dataset
+      #
+      # @return [String] identifier
+      def identifier
+        GoodData::Model.identifier_for(to_hash)
+      end
+
       # Creates a DatasetBlueprint
       #
       # @param dataset [Hash] Dataset blueprint

data/lib/gooddata/rest/README.md

@@ -0,0 +1,37 @@
+# Rest
+
+Proof of Concept of GoodWay of dealing with non-perfect REST Endpoints
+
+## Terminology
+
+Terms like 'MUST', 'MUST NOT', 'SHALL', 'SHALL NOT' are used as defined in [RFC 2119](https://www.ietf.org/rfc/rfc2119.txt)
+
+## Architecture
+
+There are few basic classes.
+
+- Connection
+- Client
+- Factory
+- Object
+- Resource
+
+## Connection
+
+Low-level network connection
+
+## Client
+
+User's interface to GoodData Platform.
+
+## Factory
+
+Authority responsible for creating Object bounded to some Connection.
+
+## Object
+
+Remote REST-like accessible content.
+
+## Resource
+
+Objects which are (at least mimicking to be) first class citizen REST Resource with full CRUD