gooddata 1.0.0-java

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

@@ -0,0 +1,67 @@
+# 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'
+
+module GoodData
+  class Dataset < 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('dataSet', Dataset, options)
+      end
+    end
+
+    # Gives you list of attributes on a dataset
+    #
+    # @return [Array<GoodData::Attribute>]
+    def attributes
+      attribute_uris.pmap { |a_uri| project.attributes(a_uri) }
+    end
+
+    # Gives you list of attribute uris on a dataset
+    #
+    # @return [Array<String>]
+    def attribute_uris
+      content['attributes']
+    end
+
+    # Gives you list of facts on a dataset
+    #
+    # @return [Array<GoodData::Fact>]
+    def facts
+      fact_uris.pmap { |a_uri| project.facts(a_uri) }
+    end
+
+    # Gives you list of fact uris on a dataset
+    #
+    # @return [Array<String>]
+    def fact_uris
+      content['facts']
+    end
+
+    # Tells you if a dataset is a date dimension. This is done by looking at
+    # the attributes and inspecting their identifiers.
+    #
+    # @return [Boolean]
+    def date_dimension?
+      content['urn'] && !content['urn'].empty? && fact_uris.empty?
+    end
+
+    # Delete the data in a dataset
+    def synchronize
+      project.execute_maql("SYNCHRONIZE {#{identifier}}")
+    end
+    alias_method :delete_data, :synchronize
+  end
+end

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

@@ -0,0 +1,57 @@
+# 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 '../../mixins/is_dimension'
+require_relative 'metadata'
+
+module GoodData
+  class Dimension < GoodData::MdObject
+    include Mixin::IsDimension
+
+    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('dimension', Dimension, options)
+      end
+
+      # Returns a Project object identified by given string
+      # The following identifiers are accepted
+      #  - /gdc/md/<id>
+      #  - /gdc/projects/<id>
+      #  - <id>
+      #
+      def [](id, opts = { client: GoodData.connection })
+        return id if id.instance_of?(GoodData::Dimension) || id.respond_to?(:dimension?) && id.dimension?
+
+        if id == :all
+          Dimension.all({ client: GoodData.connection }.merge(opts))
+        else
+          uri = id
+
+          c = client(opts)
+          fail ArgumentError, 'No :client specified' if c.nil?
+
+          response = c.get(uri)
+          c.factory.create(Dimension, response)
+        end
+      end
+    end
+
+    def attributes
+      content['attributes'].map do |attribute|
+        client.create(Attribute, { 'attribute' => attribute }, project: project)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# 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 '../../core/rest'
+require_relative '../../mixins/is_fact'
+
+require_relative 'metadata'
+
+module GoodData
+  class Fact < GoodData::MdObject
+    include Mixin::IsFact
+
+    # TODO: verify that we have all (which we do not right now)
+    FACT_BASE_AGGREGATIONS = [:sum, :min, :max, :avg, :median, :runsum, :runmin, :runmax, :runavg, :runstdev, :runstdevp, :runvar, :runvarp, :stdev, :stdevp, :var, :varp]
+
+    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('fact', Fact, options)
+      end
+    end
+
+    # Creates the basic count metric with the fact used. The metric created is not saved.
+    # @param [Hash] options the options to pass to the value list
+    # @option options [Symbol] :type type of aggregation function. Default is :sum
+    # @return [GoodData::Metric]
+    def create_metric(options = { :type => :sum })
+      a_type = options[:type] || :sum
+      unless FACT_BASE_AGGREGATIONS.include?(a_type)
+        fail "Suggested aggreagtion function (#{a_type}) does not exist for " /
+             'base metric created out of fact. You can use only one of ' /
+             "#{FACT_BASE_AGGREGATIONS.map { |x| ':' + x.to_s }.join(',')}"
+      end
+      a_title = options[:title] || "#{a_type} of #{title}"
+      project.create_metric("SELECT #{a_type.to_s.upcase}([#{uri}])", title: a_title, extended_notation: false)
+    end
+
+    alias_method :create_measure, :create_metric
+  end
+end

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

@@ -0,0 +1,49 @@
+# 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 '../../core/rest'
+require_relative '../../mixins/is_folder'
+
+require_relative 'metadata'
+
+module GoodData
+  class Folder < GoodData::MdObject
+    include Mixin::IsFolder
+
+    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('folder', Folder, options)
+      end
+    end
+
+    def entries
+      (json['folder']['content']['entries'] || []).pmap do |entry|
+        res = case json['folder']['content']['type'].first
+              when 'fact'
+                GoodData::Fact[entry['link'], :client => client, :project => project]
+              when 'metric'
+                GoodData::Metric[entry['link'], :client => client, :project => project]
+              else
+                GoodData::MdObject[entry['link'], :client => client, :project => project]
+              end
+        res
+      end
+    end
+
+    def type
+      json['folder']['content']['type'][0]
+    end
+  end
+end

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

@@ -0,0 +1,128 @@
+# 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 '../../mixins/is_label'
+require_relative 'metadata'
+
+module GoodData
+  class Label < GoodData::MdObject
+    include Mixin::IsLabel
+
+    # Finds an attribute element URI for given value. This URI can be used by find_element_value to find the original value again
+    # @param [String] value value of an label you are looking for
+    # @return [String]
+    def find_value_uri(value)
+      results = get_valid_elements(filter: value)
+      items = results['validElements']['items']
+      if items.empty?
+        fail(AttributeElementNotFound, value)
+      else
+        items.first['element']['uri']
+      end
+    end
+
+    # For an element id find values (titles) for this label. Element id can be given as both number id or URI as a string beginning with /
+    # @param [Object] element_id Element identifier either Number or a uri as a String
+    # @return [String] value of the element if found
+    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 = client.get(uri + "/?id=#{element_id}")
+      items = result['attributeElements']['elements']
+      if items.empty?
+        fail(AttributeElementNotFound, element_id)
+      else
+        items.first['title']
+      end
+    end
+
+    # Gets valid elements using /validElements? API
+    # @return [Array] Results
+    def get_valid_elements(url_or_params = {}, request_payload = {})
+      final_url = url_or_params
+
+      if url_or_params.is_a?(Hash)
+        default_params = {
+          limit: 1,
+          offset: 0,
+          order: 'asc'
+        }
+        params = default_params.merge(url_or_params).map { |x, v| "#{x}=#{CGI.escape(v.to_s)}" }.reduce { |acc, elem| "#{acc}&#{elem}" }
+        final_url = "#{uri}/validElements?#{params}"
+      end
+
+      results = client.post(final_url, 'validElementsRequest' => request_payload)
+
+      # Implementation of polling is based on
+      # https://opengrok.intgdc.com/source/xref/gdc-backend/src/test/java/com/gooddata/service/dao/ValidElementsDaoTest.java
+      status_url = results['uri']
+      if status_url
+        results = client.poll_on_response(status_url) do |body|
+          status = body['taskState'] && body['taskState']['status']
+          status == 'RUNNING' || status == 'PREPARED'
+        end
+      end
+
+      results
+    end
+
+    # Finds if a label has an attribute element for given value.
+    # @param [String] value value of an label you are looking for
+    # @return [Boolean]
+    def value?(value)
+      find_value_uri(value)
+      true
+    rescue AttributeElementNotFound
+      false
+    end
+
+    # Returns all values for this label. This is for inspection purposes only since obviously there can be huge number of elements.
+    # @param [Hash] options the options to pass to the value list
+    # @option options [Number] :limit limits the number of values to certain number. Default is 100
+    # @return [Array]
+    def values(options = {})
+      Enumerator.new do |y|
+        offset = options[:offset] || 0
+        page_limit = options[:limit] || 100
+        loop do
+          results = get_valid_elements(limit: page_limit, offset: offset)
+
+          elements = results['validElements']
+          elements['items'].map do |el|
+            v = el['element']
+            y << {
+              :value => v['title'],
+              :uri => v['uri']
+            }
+          end
+          break if elements['items'].count < page_limit
+          offset += page_limit
+        end
+      end
+    end
+
+    def values_count
+      results = get_valid_elements
+      count = GoodData::Helpers.get_path(results, %w(validElements paging total))
+      count && count.to_i
+    end
+
+    # Gives an attribute of current label
+    # @return [GoodData::Attibute]
+    def attribute
+      project.attributes(content['formOf'])
+    end
+
+    # Gives an attribute url of current label. Useful for mass actions when it does not introduce HTTP call.
+    # @return [GoodData::Attibute]
+    def attribute_uri
+      content['formOf']
+    end
+  end
+end
+
+GoodData::DisplayForm = GoodData::Label

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

@@ -0,0 +1,12 @@
+# 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 'pathname'
+
+base = Pathname(__FILE__).dirname.expand_path
+Dir.glob(base + '*.rb').each do |file|
+  require file
+end

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

@@ -0,0 +1,206 @@
+# 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 '../../goodzilla/goodzilla'
+require_relative '../../mixins/mixins'
+require_relative '../metadata'
+require_relative 'metadata'
+
+module GoodData
+  # Metric representation
+  class Metric < 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('metric', Metric, options)
+      end
+
+      def xcreate(metric, options = { :client => GoodData.connection, :project => GoodData.project })
+        create(metric, { extended_notation: true }.merge(options))
+      end
+
+      def create(metric, options = { :client => GoodData.connection, :project => GoodData.project })
+        client, project = GoodData.get_client_and_project(options)
+
+        if metric.is_a?(String)
+          expression = metric || options[:expression]
+          extended_notation = options[:extended_notation] || false
+          title = options[:title]
+          summary = options[:summary]
+        else
+          metric ||= options
+          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 => project.facts.reduce({}) do |memo, item|
+                           memo[item.title] = item.uri
+                           memo
+                         end,
+                         :attributes => project.attributes.reduce({}) do |memo, item|
+                           memo[item.title] = item.uri
+                           memo
+                         end,
+                         :metrics => project.metrics.reduce({}) do |memo, item|
+                           memo[item.title] = item.uri
+                           memo
+                         end
+                       }
+                       interpolated_metric = GoodData::SmallGoodZilla.interpolate_metric(expression, dict, options)
+                       interpolated_metric
+                     else
+                       expression
+                     end
+
+        metric = {
+          'metric' => {
+            'content' => {
+              'format' => '#,##0',
+              'expression' => expression
+            },
+            'meta' => {
+              'tags' => '',
+              'summary' => summary,
+              'title' => title
+            }
+          }
+        }
+        # TODO: add test for explicitly provided identifier
+        metric['metric']['meta']['identifier'] = options[:identifier] if options[:identifier]
+
+        client.create(Metric, metric, :project => project)
+      end
+
+      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, options)
+            else
+              tmp = {
+                :title => 'Temporary metric to be deleted'
+              }.merge(expression)
+              GoodData::Metric.create(tmp, options)
+            end
+        m.execute
+      end
+
+      def xexecute(expression, opts = { :client => GoodData.connection, :project => GoodData.project })
+        GoodData.get_client_and_project(opts)
+
+        execute(expression, opts.merge(:extended_notation => true))
+      end
+    end
+
+    def execute
+      opts = {
+        :client => client,
+        :project => project
+      }
+      res = GoodData::ReportDefinition.execute(opts.merge(:left => self))
+      res.data[0][0] if res && !res.empty?
+    end
+
+    def expression
+      content['expression']
+    end
+
+    def expression=(value)
+      content['expression'] = value
+    end
+
+    def validate
+      fail 'Metric needs to have title' if title.nil?
+      true
+    end
+
+    def metric?
+      true
+    end
+
+    # Checks that the expression contains certain metadata object.
+    # The difference between this and used_by using is in the fact that this
+    # is not a transitive closure. it searches only inside the expression
+    #
+    # @param [GoodData::MdObject] item Object that is going to be looked up
+    # @return [Boolean]
+    def contain?(item)
+      uri = item.respond_to?(:uri) ? item.uri : item
+      expression[uri] != nil
+    end
+
+    # Checks that the expression contains certain element of an attribute. The value is looked up through given label.
+    # @param [GoodData::Label] label Label though which the value is looked up
+    # @param [String] value Value that will be looked up through the label.
+    # @return [Boolean]
+    def contain_value?(label, value)
+      uri = label.find_value_uri(value)
+      contain?(uri)
+    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::Metric]
+    def replace(mapping)
+      x = GoodData::MdObject.replace_quoted(self, mapping)
+      x = GoodData::MdObject.replace_bracketed(x, mapping)
+      vals = GoodData::MdObject.find_replaceable_values(x, mapping)
+      GoodData::MdObject.replace_bracketed(x, vals)
+    end
+
+    # Method used for replacing attribute element values. Looks up certain value of a label in the MAQL expression and exchanges it for a different value of the same label.
+    # @param [GoodData::Label] label Label through which the value and for_value are resolved
+    # @param [String] value value that is going to be replaced
+    # @param [String] for_value value that is going to be the new one
+    # @return [GoodData::Metric]
+    def replace_value(label, value, for_label, for_value = nil)
+      label = label.respond_to?(:primary_label) ? label.primary_label : label
+      if for_value
+        for_label = for_label.respond_to?(:primary_label) ? for_label.primary_label : for_label
+        value_uri = label.find_value_uri(value)
+        for_value_uri = for_label.find_value_uri(for_value)
+        self.expression = expression.gsub(value_uri, for_value_uri)
+        self.expression = expression.gsub(label.attribute.uri, for_label.attribute.uri)
+      else
+        for_value = for_label
+        value_uri = label.find_value_uri(value)
+        for_value_uri = label.find_value_uri(for_value)
+        self.expression = expression.gsub(value_uri, for_value_uri)
+      end
+      self
+    end
+
+    # 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
+      SmallGoodZilla.pretty_print(expression, client: client, project: project)
+    end
+  end
+end