gooddata 0.6.7 → 0.6.8

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

@@ -15,7 +15,7 @@ module GoodData
     # @return [String]
     def find_value_uri(value)
       escaped_value = CGI.escape(value)
-      results = GoodData.post("#{uri}/validElements?limit=30&offset=0&order=asc&filter=#{escaped_value}", {})
+      results = client.post("#{uri}/validElements?limit=30&offset=0&order=asc&filter=#{escaped_value}", {})
       items = results['validElements']['items']
       if items.empty?
         fail(AttributeElementNotFound, value)
@@ -30,7 +30,7 @@ module GoodData
     def find_element_value(element_id)
       element_id = element_id.is_a?(String) ? element_id.match(/\?id=(\d+)/)[1] : element_id
       uri = links['elements']
-      result = GoodData.get(uri + "/?id=#{element_id}")
+      result = client.get(uri + "/?id=#{element_id}")
       items = result['attributeElements']['elements']
       if items.empty?
         fail "Element id #{element_id} was not found"
@@ -55,7 +55,7 @@ module GoodData
     # @return [Array]
     def values(options = {})
       limit = options[:limit] || 100
-      results = GoodData.post("#{uri}/validElements?limit=#{limit}&offset=0&order=asc", {})
+      results = client.post("#{uri}/validElements?limit=#{limit}&offset=0&order=asc", {})
       results['validElements']['items'].map do |el|
         v = el['element']
         {
@@ -68,7 +68,7 @@ module GoodData
     # Gives an attribute of current label
     # @return [GoodData::Attibute]
     def attribute
-      GoodData::Attribute[content['formOf']]
+      project.attributes(content['formOf'])
     end
 
     # Gives an attribute url of current label. Useful for mass actions when it does not introduce HTTP call.

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

@@ -1,12 +1,18 @@
 # encoding: UTF-8
 
 require_relative '../../goodzilla/goodzilla'
+require_relative '../../mixins/mixins'
 require_relative '../metadata'
 require_relative 'metadata'
 
 module GoodData
   # Metric representation
   class Metric < MdObject
+    attr_reader :json
+
+    alias_method :to_hash, :json
+
+    include GoodData::Mixin::RestResource
     root_key :metric
 
     PARSE_MAQL_OBJECT_REGEXP = /\[([^\]]+)\]/
@@ -17,46 +23,52 @@ module GoodData
       # @param options [Hash] the options hash
       # @option options [Boolean] :full if passed true the subclass can decide to pull in full objects. This is desirable from the usability POV but unfortunately has negative impact on performance so it is not the default
       # @return [Array<GoodData::MdObject> | Array<Hash>] Return the appropriate metadata objects or their representation
-      def all(options = {})
+      def all(options = { :client => GoodData.connection, :project => GoodData.project })
         query('metrics', Metric, options)
       end
 
-      def xcreate(options)
-        if options.is_a?(String)
-          create(:expression => options, :extended_notation => true)
-        else
-          create(options.merge(:extended_notation => true))
-        end
+      def xcreate(metric, options = { :client => GoodData.connection, :project => GoodData.project })
+        create(metric, options.merge(:extended_notation => true))
       end
 
-      def create(options = {})
-        if options.is_a?(String)
-          expression = options
-          extended_notation = false
-          title = nil
-        else
+      def create(metric, 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?
+
+        if metric.is_a?(String)
+          expression = metric || options[:expression]
+          extended_notation = options[:extended_notation] || false
           title = options[:title]
           summary = options[:summary]
-          expression = options[:expression] || fail('Metric has to have its expression defined')
-          extended_notation = options[:extended_notation] || false
+        else
+          title = metric[:title] || options[:title]
+          summary = metric[:summary] || options[:summary]
+          expression = metric[:expression] || options[:expression] || fail('Metric has to have its expression defined')
+          extended_notation = metric[:extended_notation] || options[:extended_notation] || false
         end
 
         expression = if extended_notation
                        dict = {
-                         :facts => GoodData::Fact[:all].reduce({}) do |memo, item|
-                           memo[item['title']] = item['link']
+                         :facts => project.facts.reduce({}) do |memo, item|
+                           memo[item.title] = item.uri
                            memo
                          end,
-                         :attributes => GoodData::Attribute[:all].reduce({}) do |memo, item|
-                           memo[item['title']] = item['link']
+                         :attributes => project.attributes.reduce({}) do |memo, item|
+                           memo[item.title] = item.uri
                            memo
                          end,
-                         :metrics => GoodData::Metric[:all].reduce({}) do |memo, item|
-                           memo[item['title']] = item['link']
+                         :metrics => project.metrics.reduce({}) do |memo, item|
+                           memo[item.title] = item.uri
                            memo
                          end
                        }
-                       interpolated_metric = GoodData::SmallGoodZilla.interpolate_metric(expression, dict)
+                       interpolated_metric = GoodData::SmallGoodZilla.interpolate_metric(expression, dict, options)
                        interpolated_metric
                      else
                        expression
@@ -77,37 +89,53 @@ module GoodData
         }
         # TODO: add test for explicitly provided identifier
         metric['metric']['meta']['identifier'] = options[:identifier] if options[:identifier]
-        Metric.new(metric)
+
+        client.create(Metric, metric, :project => project)
       end
 
-      def execute(expression, options = {})
+      def execute(expression, options = { :client => GoodData.connection })
+        # client = options[:client]
+        # fail ArgumentError, 'No :client specified' if client.nil?
+
+        options = expression if expression.is_a?(Hash)
+
         m = if expression.is_a?(String)
               tmp = {
                 :title => 'Temporary metric to be deleted',
                 :expression => expression
               }.merge(options)
 
-              GoodData::Metric.create(tmp)
+              GoodData::Metric.create(tmp, options)
             else
               tmp = {
                 :title => 'Temporary metric to be deleted'
               }.merge(expression)
-              GoodData::Metric.create(tmp)
+              GoodData::Metric.create(tmp, options)
             end
         m.execute
       end
 
-      def xexecute(expression)
-        if expression.is_a?(String)
-          execute(:expression => expression, :extended_notation => true)
-        else
-          execute(expression.merge(:extended_notation => true))
-        end
+      def xexecute(expression, opts = { :client => GoodData.connection, :project => GoodData.project })
+        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?
+
+        execute(expression, opts.merge(:extended_notation => true))
       end
     end
 
     def execute
-      res = GoodData::ReportDefinition.execute(:left => self)
+      opts = {
+        :client => client,
+        :project => project
+      }
+
+      res = GoodData::ReportDefinition.execute(opts.merge(:left => self))
       res && res[0][0]
     end
 
@@ -120,7 +148,7 @@ module GoodData
     end
 
     def validate
-      fail 'Meric needs to have title' if title.nil?
+      fail 'Metric needs to have title' if title.nil?
       true
     end
 
@@ -181,16 +209,26 @@ module GoodData
     # Looks up the readable values of the objects used inside of MAQL epxpressions. Labels and elements titles are based on the primary label.
     # @return [String] Ther resulting MAQL like expression
     def pretty_expression
+      opts = {
+        :client => client,
+        :project => project
+      }
+
       temp = expression.dup
-      expression.scan(PARSE_MAQL_OBJECT_REGEXP).each do |uri|
+      pairs = expression.scan(PARSE_MAQL_OBJECT_REGEXP).pmap do |uri|
         uri = uri.first
         if uri =~ /elements/
-          temp.sub!(uri, Attribute.find_element_value(uri))
+          [uri, Attribute.find_element_value(uri, opts)]
         else
-          obj = GoodData::MdObject[uri]
-          temp.sub!(uri, obj.title)
+          [uri, GoodData::MdObject[uri, opts].title]
         end
       end
+
+      pairs.each do |el|
+        uri = el[0]
+        obj = el[1]
+        temp.sub!(uri, obj)
+      end
       temp
     end
   end

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

@@ -13,14 +13,24 @@ module GoodData
       # @param options [Hash] the options hash
       # @option options [Boolean] :full if passed true the subclass can decide to pull in full objects. This is desirable from the usability POV but unfortunately has negative impact on performance so it is not the default
       # @return [Array<GoodData::MdObject> | Array<Hash>] Return the appropriate metadata objects or their representation
-      def all(options = {})
+      def all(options = { :client => GoodData.connection, :project => GoodData.project })
         query('reports', Report, options)
       end
 
-      def create(options = {})
+      def create(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?
+
         title = options[:title]
+        fail 'Report needs a title specified' unless title
         summary = options[:summary] || ''
-        rd = options[:rd] || ReportDefinition.create(:top => options[:top], :left => options[:left])
+        rd = options[:rd] || ReportDefinition.create(options)
         rd.save
 
         report = {
@@ -39,35 +49,49 @@ module GoodData
         }
         # TODO: write test for report definitions with explicit identifiers
         report['report']['meta']['identifier'] = options[:identifier] if options[:identifier]
-        Report.new report
+        client.create(Report, report, :project => project)
       end
     end
 
+    # Add a report definition to a report. This will show on a UI as a new version.
+    #
+    # @param report_definition [GoodData::ReportDefinition | String] Report definition to add. Either it can be a URI of a report definition or an actual report definition object.
+    # @return [GoodData::Report] Return self
+    def add_definition(report_definition)
+      rep_def = project.report_definitions(report_definition)
+      content['definitions'] = definition_uris << rep_def.uri
+      self
+    end
+
     def results
       content['results']
     end
 
     def definitions
+      content['definitions'].pmap { |uri| project.report_definitions(uri) }
+    end
+
+    def definition_uris
       content['definitions']
     end
 
     def latest_report_definition_uri
-      definitions.last
+      definition_uris.last
     end
 
     def latest_report_definition
-      GoodData::MdObject[latest_report_definition_uri]
+      project.report_definitions(latest_report_definition_uri)
     end
 
     def remove_definition(definition)
       def_uri = is_a?(GoodData::ReportDefinition) ? definition.uri : definition
-      content['definitions'] = definitions.reject { |x| x == def_uri }
+      content['definitions'] = definition_uris.reject { |x| x == def_uri }
       self
     end
 
     # TODO: Cover with test. You would probably need something that will be able to create a report easily from a definition
     def remove_definition_but_latest
-      to_remove = definitions - [latest_report_definition_uri]
+      to_remove = definition_uris - [latest_report_definition_uri]
       to_remove.each do |uri|
         remove_definition(uri)
       end
@@ -75,25 +99,29 @@ module GoodData
     end
 
     def purge_report_of_unused_definitions!
-      full_list = definitions
+      full_list = definition_uris
       remove_definition_but_latest
-      purged_list = definitions
+      purged_list = definition_uris
       to_remove = full_list - purged_list
       save
-      to_remove.each { |uri| GoodData.delete(uri) }
+      to_remove.each { |uri| client.delete(uri) }
       self
     end
 
     def execute
       fail 'You have to save the report before executing. If you do not want to do that please use GoodData::ReportDefinition' unless saved?
-      result = GoodData.post '/gdc/xtab2/executor3', 'report_req' => { 'report' => uri }
+      result = client.post '/gdc/xtab2/executor3', 'report_req' => { 'report' => uri }
       data_result_uri = result['execResult']['dataResult']
-      result = GoodData.get data_result_uri
-      while result['taskState'] && result['taskState']['status'] == 'WAIT'
-        sleep 10
-        result = GoodData.get data_result_uri
+
+      result = client.poll_on_response(data_result_uri) do |body|
+        body && body['taskState'] && body['taskState']['status'] == 'WAIT'
+      end
+
+      if result.empty?
+        client.create(EmptyResult, result)
+      else
+        client.create(ReportDataResult, result)
       end
-      ReportDataResult.new(GoodData.get data_result_uri)
     end
 
     def exportable?
@@ -105,5 +133,12 @@ module GoodData
       result1 = GoodData.post('/gdc/exporter/executor', :result_req => { :format => format, :result => result })
       GoodData.poll_on_code(result1['uri'], process: false)
     end
+
+    def replace(what, for_what)
+      new_defs = definitions.map do |rep_def|
+        rep_def.replace(what, for_what)
+      end
+      new_defs.pmap(&:save)
+    end
   end
 end

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

@@ -16,7 +16,7 @@ module GoodData
       # @param options [Hash] the options hash
       # @option options [Boolean] :full if passed true the subclass can decide to pull in full objects. This is desirable from the usability POV but unfortunately has negative impact on performance so it is not the default
       # @return [Array<GoodData::MdObject> | Array<Hash>] Return the appropriate metadata objects or their representation
-      def all(options = {})
+      def all(options = { :client => GoodData.connection, :project => GoodData.project })
         query('reportdefinition', ReportDefinition, options)
       end
 
@@ -60,20 +60,23 @@ module GoodData
         parts
       end
 
-      def find(stuff)
+      def find(stuff, opts = { :client => GoodData.connection, :project => GoodData.project })
+        client = opts[:client]
+        fail ArgumentError, 'No :client specified' if client.nil?
+
         stuff.map do |item|
           if item.respond_to?(:attribute?) && item.attribute?
             item.display_forms.first
           elsif item.is_a?(String)
-            x = GoodData::MdObject.get_by_id(item)
+            x = GoodData::MdObject.get_by_id(item, opts)
             fail "Object given by id \"#{item}\" could not be found" if x.nil?
             case x.raw_data.keys.first.to_s
             when 'attribute'
-              GoodData::Attribute.new(x.raw_data).display_forms.first
+              GoodData::Attribute.new(x.json).display_forms.first
             when 'attributeDisplayForm'
-              GoodData::Label.new(x.raw_data)
+              GoodData::Label.new(x.json)
             when 'metric'
-              GoodData::Metric.new(x.raw_data)
+              GoodData::Metric.new(x.json)
             end
           elsif item.is_a?(Hash) && item.keys.include?(:title)
             case item[:type].to_s
@@ -120,48 +123,71 @@ module GoodData
         begin
           unsaved_metrics.each { |m| m.save }
           rd = GoodData::ReportDefinition.create(options)
-          data_result(execute_inline(rd))
+          data_result(execute_inline(rd, options), options)
         ensure
           unsaved_metrics.each { |m| m.delete if m && m.saved? }
         end
       end
 
-      def execute_inline(rd)
-        rd = rd.respond_to?(:raw_data) ? rd.raw_data : rd
+      def execute_inline(rd, opts = { :client => GoodData.connection, :project => GoodData.project })
+        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?
+
+        rd = rd.respond_to?(:json) ? rd.json : rd
         data = {
           report_req: {
             definitionContent: {
               content: rd,
-              projectMetadata: GoodData.project.links['metadata']
+              projectMetadata: project.links['metadata']
             }
           }
         }
-        uri = "/gdc/app/projects/#{GoodData.project.pid}/execute"
-        GoodData.post(uri, data)
+        uri = "/gdc/app/projects/#{project.pid}/execute"
+
+        client.post(uri, data)
       end
 
       # TODO: refactor the method. It should be instance method
       # Method used for getting a data_result from a wire representation of
       # @param result [Hash, Object] Wire data from JSON
       # @return [GoodData::ReportDataResult]
-      def data_result(result)
+      def data_result(result, options = { :client => GoodData.connection })
+        client = options[:client]
+        fail ArgumentError, 'No :client specified' if client.nil?
+
         data_result_uri = result['execResult']['dataResult']
-        result = GoodData.get data_result_uri
+        result = client.poll_on_response(data_result_uri) do |body|
+          body && body['taskState'] && body['taskState']['status'] == 'WAIT'
+        end
 
-        while result && result['taskState'] && result['taskState']['status'] == 'WAIT'
-          sleep 10
-          result = GoodData.get data_result_uri
+        if result.empty?
+          client.create(EmptyResult, result)
+        else
+          client.create(ReportDataResult, result)
         end
-        return nil unless result
-        ReportDataResult.new(GoodData.get data_result_uri)
       end
 
-      def create(options = {})
+      def create(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?
+
         left = Array(options[:left])
         top = Array(options[:top])
 
-        left = ReportDefinition.find(left)
-        top = ReportDefinition.find(top)
+        left = ReportDefinition.find(left, options)
+        top = ReportDefinition.find(top, options)
 
         # TODO: Put somewhere for i18n
         fail_msg = 'All metrics in report definition must be saved'
@@ -193,24 +219,148 @@ module GoodData
         # TODO: write test for report definitions with explicit identifiers
         pars['reportDefinition']['meta']['identifier'] = options[:identifier] if options[:identifier]
 
-        ReportDefinition.new(pars)
+        client.create(ReportDefinition, pars, :project => project)
       end
     end
 
+    def attribute_parts
+      cols = content['grid']['columns'] || []
+      rows = content['grid']['rows'] || []
+      items = cols + rows
+      items.select { |item| item.is_a?(Hash) && item.keys.first == 'attribute' }
+    end
+
+    def attributes
+      labels.map { |label| label.attribute }
+    end
+
+    def labels
+      attribute_parts.map { |part| project.labels(part['attribute']['uri']) }
+    end
+
+    def metric_parts
+      content['grid']['metrics']
+    end
+
     def metrics
-      content['grid']['metrics'].map { |i| GoodData::Metric[i['uri']] }
+      metric_parts.map { |i| project.metrics(i['uri']) }
     end
 
-    def execute
+    def execute(opts = { :client => GoodData.connection, :project => GoodData.project })
+      opts = {
+        :client => client,
+        :project => project
+      }
+
       result = if saved?
                  pars = {
                    'report_req' => { 'reportDefinition' => uri }
                  }
-                 GoodData.post '/gdc/xtab2/executor', pars
+                 client.post '/gdc/xtab2/executor', pars
                else
-                 ReportDefinition.execute_inline(self)
+                 ReportDefinition.execute_inline(self, opts)
                end
-      ReportDefinition.data_result(result)
+      ReportDefinition.data_result(result, opts)
+    end
+
+    def filters
+      content['filters'].map { |f| f['expression'] }
+    end
+
+    # Replace certain object in report definition. Returns new definition which is not saved.
+    #
+    # @param what [GoodData::MdObject | String] Object which responds to uri or a string that should be replaced
+    # @option for_what [GoodData::MdObject | String] Object which responds to uri or a string that should used as replacement
+    # @return [Array<GoodData::MdObject> | Array<Hash>] Return the appropriate metadata objects or their representation
+    def replace(what, for_what = nil)
+      pairs = if what.is_a?(Hash)
+                whats = what.keys
+                to_whats = what.values
+                whats.zip(to_whats)
+              else
+                [[what, for_what]]
+              end
+
+      pairs.each do |pair|
+        what = pair[0]
+        for_what = pair[1]
+
+        uri_what = what.respond_to?(:uri) ? what.uri : what
+        uri_for_what = for_what.respond_to?(:uri) ? for_what.uri : for_what
+
+        content['grid']['metrics'] = metric_parts.map do |item|
+          item.deep_dup.tap do |i|
+            i['uri'].gsub!(uri_what, uri_for_what)
+          end
+        end
+
+        cols = content['grid']['columns'] || []
+        content['grid']['columns'] = cols.map do |item|
+          if item.is_a?(Hash)
+            item.deep_dup.tap do |i|
+              i['attribute']['uri'].gsub!(uri_what, uri_for_what)
+            end
+          else
+            item
+          end
+        end
+
+        rows = content['grid']['rows'] || []
+        content['grid']['rows'] = rows.map do |item|
+          if item.is_a?(Hash)
+            item.deep_dup.tap do |i|
+              i['attribute']['uri'].gsub!(uri_what, uri_for_what)
+            end
+          else
+            item
+          end
+        end
+
+        widths = content['grid']['columnWidths'] || []
+        content['grid']['columnWidths'] = widths.map do |item|
+          if item.is_a?(Hash)
+            item.deep_dup.tap do |i|
+              if i['locator'][0].key?('attributeHeaderLocator')
+                i['locator'][0]['attributeHeaderLocator']['uri'].gsub!(uri_what, uri_for_what)
+              end
+            end
+          else
+            item
+          end
+        end
+
+        sort = content['grid']['sort']['columns'] || []
+        content['grid']['sort']['columns'] = sort.map do |item|
+          if item.is_a?(Hash)
+            item.deep_dup.tap do |i|
+              next unless i.key?('metricSort')
+              next unless i['metricSort'].key?('locators')
+              next unless i['metricSort']['locators'][0].key?('attributeLocator2')
+              i['metricSort']['locators'][0]['attributeLocator2']['uri'].gsub!(uri_what, uri_for_what)
+              i['metricSort']['locators'][0]['attributeLocator2']['element'].gsub!(uri_what, uri_for_what)
+            end
+          else
+            item
+          end
+        end
+
+        if content.key?('chart')
+          content['chart']['buckets'] = content['chart']['buckets'].reduce({}) do |a, e|
+            key = e[0]
+            val = e[1]
+            # binding.pry
+            a[key] = val.map do |item|
+              item.deep_dup.tap do |i|
+                i['uri'].gsub!(uri_what, uri_for_what)
+              end
+            end
+            a
+          end
+        end
+
+        content['filters'] = filters.map { |filter_expression| { 'expression' => filter_expression.gsub(uri_what, uri_for_what) } }
+      end
+      self
     end
   end
 end