gooddata 1.0.0-java

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

@@ -0,0 +1,268 @@
+# 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.
+
+require_relative '../metadata'
+require_relative 'metadata'
+
+module GoodData
+  class Report < GoodData::MdObject
+    include Mixin::Lockable
+
+    class << self
+      # Method intended to get all objects of that type in a specified project
+      #
+      # @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 = { :client => GoodData.connection, :project => GoodData.project })
+        query('report', Report, options)
+      end
+
+      def create(options = { :client => GoodData.connection, :project => GoodData.project })
+        client, project = GoodData.get_client_and_project(options)
+
+        title = options[:title]
+        fail 'Report needs a title specified' unless title
+        summary = options[:summary] || ''
+
+        options_rd = options.dup
+        options_rd.delete(:identifier)
+
+        rd = options[:rd] || ReportDefinition.create(options_rd)
+        rd.save
+
+        report = {
+          'report' => {
+            'content' => {
+              'domains' => [],
+              'definitions' => [rd.uri]
+            },
+            'meta' => {
+              'tags' => '',
+              'deprecated' => '0',
+              'summary' => summary,
+              'title' => title
+            }
+          }
+        }
+        # TODO: write test for report definitions with explicit identifiers
+        report['report']['meta']['identifier'] = options[:identifier] if options[:identifier]
+        client.create(Report, report, :project => project)
+      end
+
+      def data_result(result, options = {})
+        client = options[:client]
+        data_result_uri = result['execResult']['dataResult']
+        begin
+          result = client.poll_on_response(data_result_uri, options) do |body|
+            body && body['taskState'] && body['taskState']['status'] == 'WAIT'
+          end
+        rescue RestClient::BadRequest => e
+          resp = JSON.parse(e.response)
+          if GoodData::Helpers.get_path(resp, %w(error component)) == 'MD::DataResult'
+            raise GoodData::UncomputableReport
+          else
+            raise e
+          end
+        end
+
+        if result.to_s.empty?
+          ReportDataResult.new(data: [], top: 0, left: 0)
+        else
+          ReportDataResult.from_xtab(result)
+        end
+      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
+
+    # 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)
+      res = add_definition(report_definition)
+      res.save
+    end
+
+    # Returns the newest (current version) report definition as an object
+    #
+    # @return [GoodData::ReportDefinition] Returns the newest report defintion
+    def definition
+      project.report_definitions(latest_report_definition_uri)
+    end
+
+    alias_method :latest_report_definition, :definition
+
+    # Returns the newest (current version) report definition uri
+    #
+    # @return [String] Returns uri of the newest report defintion
+    def definition_uri
+      definition_uris.last
+    end
+
+    alias_method :latest_report_definition_uri, :definition_uri
+
+    # Gets a report definitions (versions) of this report as objects.
+    #
+    # @return [Array<GoodData::ReportDefinition>] Returns list of report definitions. Oldest comes first
+    def definitions
+      content['definitions'].pmap { |uri| project.report_definitions(uri) }
+    end
+    alias_method :report_definitions, :definitions
+
+    # Gets list of uris of report definitions (versions) of this report.
+    #
+    # @return [Array<String>] Returns list of report definitions' uris. Oldest comes first
+    def definition_uris
+      content['definitions']
+    end
+
+    # Deletes report along with its report definitions.
+    #
+    # @return [GoodData::Report] Returns self
+    def delete
+      defs = definitions
+      super
+      defs.peach(&:delete)
+      self
+    end
+
+    # Computes the report and returns the result. If it is not computable returns nil.
+    #
+    # @option options [Time] :time Force the platform to simutale the result at this time
+    # @return [GoodData::DataResult] Returns the result
+    def execute(options = {})
+      time = options[:time]
+
+      report_req = { 'report' => uri }
+      report_req['timestamp'] = time.to_i if time
+
+      fail 'You have to save the report before executing. If you do not want to do that please use GoodData::ReportDefinition' unless saved?
+      result = client.post "/gdc/projects/#{project.pid}/execute", 'report_req' => report_req
+      GoodData::Report.data_result(result, options.merge(client: client))
+    end
+
+    # Returns true if you can export and object
+    #
+    # @return [Boolean] Returns whether the report is exportable
+    def exportable?
+      true
+    end
+
+    # Returns binary data of the exported report in a given format. The format can be
+    # either 'csv', 'xls', 'xlsx' or 'pdf'.
+    #
+    # @return [String] Returns data
+    def export(format, options = {})
+      result = client.post("/gdc/projects/#{project.pid}/execute", 'report_req' => { 'report' => uri })
+      result1 = client.post('/gdc/exporter/executor', :result_req => { :format => format, :result => result })
+      client.poll_on_code(result1['uri'], options.merge(process: false))
+    end
+
+    # Exports a report too large to be computed on the UI. It executes in raw form.
+    # Saves the result into file.
+    #
+    # @param filename [String] Filename to save into
+    # @return [Net::HTTPResponse] Returns HTTP status
+    def export_raw(filename)
+      result = client.post("/gdc/app/projects/#{project.pid}/execute/raw", 'report_req' => { 'report' => uri })
+      client.download(result['uri'], filename, url_encode: false)
+    end
+
+    # Returns the newest (current version) report definition uri
+    #
+    # @return [String] Returns uri of the newest report defintion
+    def purge_report_of_unused_definitions!
+      full_list = definition_uris
+      remove_definition_but_latest
+      purged_list = definition_uris
+      to_remove = full_list - purged_list
+      save
+      to_remove.each { |uri| client.delete(uri) }
+      self
+    end
+
+    # Removes definition from the report. The definition to remove can be passed in any form that is accepted by
+    # GoodData::ReportDefintion[]
+    #
+    # @param definition [String | GoodData::ReportDefinition] Report defintion to remove
+    # @return [GoodData::Report] Returns report with removed definition
+    def remove_definition(definition)
+      a_def = GoodData::ReportDefinition[definition, project: project, client: client]
+      def_uri = a_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
+    # Removes all definitions but the latest from the report. This is useful for cleaning up before you create
+    # a template out of a project.
+    #
+    # @return [GoodData::Report] Returns report with removed definitions
+    def remove_definition_but_latest
+      to_remove = definition_uris - [latest_report_definition_uri]
+      to_remove.each do |uri|
+        remove_definition(uri)
+      end
+      self
+    end
+
+    # Method used for replacing values in their state according to mapping.
+    # Can be used to replace any values but it is typically used to replace
+    # the URIs. Returns a new object of the same type.
+    #
+    # @param [Array<Array>]Mapping specifying what should be exchanged for what. As mapping should be used output of GoodData::Helpers.prepare_mapping.
+    # @return [GoodData::Report]
+    def replace(mapping)
+      new_defs = definitions.map do |rep_def|
+        rep_def.replace(mapping)
+      end
+      new_defs.pmap(&:save)
+      self
+    end
+
+    ## Update report definition and reflect the change in report
+    #
+    # @param [Hash] opts Options
+    # @option opts [Boolean] :new_definition (true) If true then new definition will be created
+    # @return [GoodData::ReportDefinition] Updated and saved report definition
+    def update_definition(opts = { :new_definition => true }, &block)
+      # TODO: Cache the latest report definition somehow
+      repdef = definition.dup
+
+      block.call(repdef, self) if block_given?
+
+      if opts[:new_definition]
+        new_def = GoodData::ReportDefinition.create(:client => client, :project => project)
+
+        rd = repdef.json['reportDefinition']
+        rd.delete('links')
+        %w(author uri created identifier updated contributor).each { |k| rd['meta'].delete(k) }
+        new_def.json['reportDefinition'] = rd
+        new_def.save
+
+        add_definition!(new_def)
+        return new_def
+      else
+        repdef.save
+      end
+
+      repdef
+    end
+  end
+end

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

@@ -0,0 +1,272 @@
+# 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.
+
+require_relative '../metadata'
+require_relative 'metadata'
+
+# GoodData Module
+module GoodData
+  # Report Definition
+  # TODO: Add more doc ...
+  class ReportDefinition < GoodData::MdObject
+    class << self
+      # Method intended to get all objects of that type in a specified project
+      #
+      # @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 = { :client => GoodData.connection, :project => GoodData.project })
+        query('reportDefinition', ReportDefinition, options)
+      end
+
+      def create_metrics_part(left, top)
+        stuff = Array(left) + Array(top)
+        stuff.select { |item| item.respond_to?(:metric?) && item.metric? }.map do |metric|
+          create_metric_part(metric)
+        end
+      end
+
+      alias_method :create_measures_part, :create_metrics_part
+
+      def create_metric_part(metric)
+        {
+          'alias' => metric.title,
+          'uri' => metric.uri
+        }
+      end
+
+      alias_method :create_measure_part, :create_metric_part
+
+      def create_attribute_part(attrib)
+        {
+          'attribute' => {
+            'alias' => '',
+            'totals' => [],
+            'uri' => attrib.uri
+          }
+        }
+      end
+
+      # Method creates the list of filter representaion suitable for posting on
+      # the api. It can currently recognize 2 types of filters. Variable filters
+      # and attribute filters. Method for internal usage.
+      #
+      # @param filters [GoodData::Variable|Array<Array>]
+      # @param options [Hash] the options hash
+      # @return [Array<Hash>] Returns the structure that is stored internally in the report definition and later psted on the API
+      def create_filters_part(filters, options = {})
+        project = options[:project]
+        vars = filters.select { |f| f.is_a?(GoodData::Variable) }.map { |v| { expression: "[#{v.uri}]" } }
+        category = filters.select { |f| f.is_a?(Array) }.map { |v| GoodData::SmallGoodZilla.create_category_filter(v, project) }
+        vars + category
+      end
+
+      def create_part(stuff)
+        stuff = Array(stuff)
+        parts = stuff.reduce([]) do |memo, item|
+          if item.respond_to?(:metric?) && item.metric?
+            memo
+          else
+            memo << create_attribute_part(item)
+          end
+          memo
+        end
+        if stuff.any? { |item| item.respond_to?(:metric?) && item.metric? }
+          parts << 'metricGroup'
+        end
+        parts
+      end
+
+      def find(stuff, opts = { :client => GoodData.connection, :project => GoodData.project })
+        _client, project = GoodData.get_client_and_project(opts)
+
+        stuff.map do |item|
+          obj = if item.is_a?(String)
+                  begin
+                    project.objects(item)
+                  rescue RestClient::ResourceNotFound
+                    raise "Object given by id \"#{item}\" could not be found"
+                  end
+                elsif item.is_a?(Hash) && item.keys.include?(:title)
+                  case item[:type].to_s
+                  when 'metric'
+                    GoodData::Metric.find_first_by_title(item[:title], opts)
+                  when 'attribute'
+                    GoodData::Attribute.find_first_by_title(item[:title], opts)
+                  end
+                elsif item.is_a?(Hash) && (item.keys.include?(:id) || item.keys.include?(:identifier))
+                  id = item[:id] || item[:identifier]
+                  case item[:type].to_s
+                  when 'metric'
+                    project.metrics(id)
+                  when 'attribute'
+                    project.attributes(id)
+                  when 'label'
+                    projects.labels(id)
+                  end
+                else
+                  item
+                end
+          if obj.respond_to?(:attribute?) && obj.attribute?
+            obj.display_forms.first
+          else
+            obj
+          end
+        end
+      end
+
+      def execute(options = {})
+        left = Array(options[:left])
+        top = Array(options[:top])
+
+        metrics = (left + top).select { |item| item.respond_to?(:metric?) && item.metric? }
+
+        unsaved_metrics = metrics.reject(&:saved?)
+        unsaved_metrics.each { |m| m.title = 'Untitled metric' unless m.title }
+
+        begin
+          unsaved_metrics.each(&:save)
+          GoodData::ReportDefinition.create(options).execute
+        ensure
+          unsaved_metrics.each { |m| m.delete if m && m.saved? }
+        end
+      end
+
+      def create(options = { :client => GoodData.connection, :project => GoodData.project })
+        client, project = GoodData.get_client_and_project(options)
+
+        left = Array(options[:left])
+        top = Array(options[:top])
+        filters = options[:filters] || []
+
+        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'
+        fail fail_msg unless (left + top).all?(&:saved?)
+
+        pars = {
+          'reportDefinition' => {
+            'content' => {
+              'grid' => {
+                'sort' => {
+                  'columns' => [],
+                  'rows' => []
+                },
+                'columnWidths' => [],
+                'columns' => ReportDefinition.create_part(top),
+                'metrics' => ReportDefinition.create_metrics_part(left, top),
+                'rows' => ReportDefinition.create_part(left)
+              },
+              'format' => 'grid',
+              'filters' => ReportDefinition.create_filters_part(filters, :project => project)
+            },
+            'meta' => {
+              'tags' => '',
+              'summary' => '',
+              'title' => 'Untitled report definition'
+            }
+          }
+        }
+        # TODO: write test for report definitions with explicit identifiers
+        pars['reportDefinition']['meta']['identifier'] = options[:identifier] if options[:identifier]
+
+        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(&:attribute)
+    end
+
+    # Removes the color mapping from report definition
+    #
+    # @return [GoodData::ReportDefinition] Returns self
+    def reset_color_mapping!
+      global_chart_options = GoodData::Helpers.get_path(content, %w(chart styles global))
+      global_chart_options['colorMapping'] = [] if global_chart_options
+      self
+    end
+
+    # Return true if the report definition is a chart
+    #
+    # @return [Boolean] Return true if report definition is a chart
+    def chart?
+      !table?
+    end
+
+    def labels
+      attribute_parts.map { |part| project.labels(part['attribute']['uri']) }
+    end
+
+    def metric_parts
+      content['grid']['metrics']
+    end
+
+    alias_method :measure_parts, :metric_parts
+
+    def metrics
+      metric_parts.map { |i| project.metrics(i['uri']) }
+    end
+
+    def execute(opts = {})
+      result = if saved?
+                 pars = {
+                   'report_req' => { 'reportDefinition' => uri }
+                 }
+                 client.post "/gdc/projects/#{project.pid}/execute", pars
+               else
+                 data = {
+                   report_req: {
+                     definitionContent: {
+                       content: to_hash,
+                       projectMetadata: project.links['metadata']
+                     }
+                   }
+                 }
+                 uri = "/gdc/projects/#{project.pid}/execute"
+                 client.post(uri, data)
+               end
+      GoodData::Report.data_result(result, opts.merge(client: client))
+    end
+
+    def filters
+      content['filters'].map { |f| f['expression'] }
+    end
+
+    # Method used for replacing values in their state according to mapping.
+    # Can be used to replace any values but it is typically used to replace
+    # the URIs. Returns a new object of the same type.
+    #
+    # @param [Array<Array>]Mapping specifying what should be exchanged for what. As mapping should be used output of GoodData::Helpers.prepare_mapping.
+    # @return [GoodData::ReportDefinition]
+    def replace(mapping)
+      x = GoodData::MdObject.replace_quoted(self, mapping)
+      x = GoodData::MdObject.replace_bracketed(x, mapping)
+      vals = GoodData::MdObject.find_replaceable_values(self, mapping)
+      x = GoodData::MdObject.replace_quoted(x, vals)
+      GoodData::MdObject.replace_bracketed(x, vals)
+    end
+
+    # Return true if the report definition is a table
+    #
+    # @return [Boolean] Return true if report definition is a table
+    def table?
+      content['format'] == 'grid'
+    end
+  end
+end