gooddata 0.6.0 → 0.6.2

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

@@ -0,0 +1,61 @@
+# encoding: UTF-8
+
+require_relative '../md_object'
+require_relative '../../helpers'
+
+module GoodData
+  module Model
+    ##
+    # This is a base class for server-side LDM elements such as attributes, labels and
+    # facts
+    #
+    class Column < MdObject
+      attr_accessor :folder, :name, :title, :schema
+
+      def initialize(hash, schema)
+        super()
+        fail(ArgumentError, "Schema must be provided, got #{schema.class}") unless schema.is_a? Schema
+        fail('Data set fields must have their names defined') if hash[:name].nil?
+
+        @name = hash[:name]
+        @title = hash[:title] || hash[:name].humanize
+        @folder = hash[:folder]
+        @schema = schema
+      end
+
+      ##
+      # Generates an identifier from the object name by transliterating
+      # non-Latin character and then dropping non-alphanumerical characters.
+      #
+      def identifier
+        @identifier ||= "#{type_prefix}.#{@schema.name}.#{name}"
+      end
+
+      def to_maql_drop
+        "DROP {#{identifier}};\n"
+      end
+
+      def visual
+        visual = super
+        visual += ", FOLDER {#{folder_prefix}.#{(folder)}}" if folder
+        visual
+      end
+
+      def to_csv_header(row)
+        name
+      end
+
+      def to_csv_data(headers, row)
+        row[name]
+      end
+
+      # Overriden to prevent long strings caused by the @schema attribute
+      #
+      def inspect
+        to_s.sub(/>$/, " @title=#{@title.inspect}, @name=#{@name.inspect}, @folder=#{@folder.inspect}," \
+                       " @schema=#{@schema.to_s.sub(/>$/, ' @title=' + @schema.name.inspect + '>')}" \
+                       ">")
+      end
+    end
+  end
+end

data/lib/gooddata/models/{dashboard.rb → metadata/dashboard.rb}

@@ -1,13 +1,18 @@
 # encoding: UTF-8
 
+require_relative '../../core/core'
+require_relative '../metadata'
 require_relative 'metadata'
+require_relative 'report'
+
+require 'multi_json'
 
 module GoodData
   class Dashboard < GoodData::MdObject
     root_key :projectDashboard
 
     class << self
-      def [](id)
+      def [](id, options = {})
         if id == :all
           GoodData.get(GoodData.project.md['query'] + '/projectdashboards/')['query']['entries']
         else
@@ -23,7 +28,7 @@ module GoodData
         }
       end
 
-      def create_report_tab_item(options={})
+      def create_report_tab_item(options = {})
         title = options[:title]
 
         report = GoodData::Report.find_first_by_title(title)
@@ -53,7 +58,7 @@ module GoodData
         }
       end
 
-      def create(options={})
+      def create(options = {})
         stuff = {
           'projectDashboard' => {
             'content' => {
@@ -75,16 +80,16 @@ module GoodData
       true
     end
 
-    def export(format, options={})
+    def export(format, options = {})
       supported_formats = [:pdf]
       fail "Wrong format provied \"#{format}\". Only supports formats #{supported_formats.join(', ')}" unless supported_formats.include?(format)
       tab = options[:tab] || ''
 
       req_uri = "/gdc/projects/#{GoodData.project.uri}/clientexport"
-      x = GoodData.post(req_uri, {'clientExport' => {'url' => "https://secure.gooddata.com/dashboard.html#project=#{GoodData.project.uri}&dashboard=#{uri}&tab=#{tab}&export=1", 'name' => title}}, :process => false)
-      while (x.code == 202) do
+      x = GoodData.post(req_uri, { 'clientExport' => { 'url' => "https://secure.gooddata.com/dashboard.html#project=#{GoodData.project.uri}&dashboard=#{uri}&tab=#{tab}&export=1", 'name' => title } }, :process => false)
+      while x.code == 202
         sleep(1)
-        uri = MultiJson.load(x.body)["asyncTask"]["link"]["poll"]
+        uri = MultiJson.load(x.body)['asyncTask']['link']['poll']
         x = GoodData.get(uri, :process => false)
       end
       x

data/lib/gooddata/models/{data_set.rb → metadata/data_set.rb}

@@ -1,9 +1,10 @@
 # encoding: UTF-8
 
-require_relative 'metadata.rb'
+require_relative '../metadata.rb'
+require_relative 'metadata'
 
 module GoodData
-  class DataSet < MdObject
+  class DataSet < GoodData::MdObject
     root_key :dataSet
 
     SLI_CTG = 'singleloadinterface'
@@ -14,7 +15,7 @@ module GoodData
     end
 
     def sli
-      raise NoProjectError.new 'Connect to a project before searching for an object' unless GoodData.project
+      fail(NoProjectError, 'Connect to a project before searching for an object') unless GoodData.project
       slis = GoodData.project.md.links(Model::LDM_CTG).links(SLI_CTG)[DS_SLI_CTG]
       uri = slis[identifier]['link']
       MdObject[uri]
@@ -28,4 +29,4 @@ module GoodData
       content['facts'].map { |a| GoodData::Attribute[a] }
     end
   end
-end
+end

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

@@ -0,0 +1,26 @@
+# encoding: UTF-8
+
+require_relative '../md_object'
+
+module GoodData
+  module Model
+    class DateDimension < MdObject
+      def initialize(spec = {})
+        super()
+        @name = spec[:name]
+        @title = spec[:title] || @name
+        @urn = spec[:urn] || 'URN:GOODDATA:DATE'
+      end
+
+      def to_maql_create
+        # urn = "urn:chefs_warehouse_fiscal:date"
+        # title = "title"
+        # name = "name"
+
+        maql = ''
+        maql += "INCLUDE TEMPLATE \"#{@urn}\" MODIFY (IDENTIFIER \"#{@name}\", TITLE \"#{@title}\");"
+        maql
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# encoding: UTF-8
+
+require_relative '../metadata'
+require_relative 'metadata'
+
+module GoodData
+  class DisplayForm < GoodData::MdObject
+    root_key :attributeDisplayForm
+
+    # 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)
+      value = CGI.escapeHTML(value)
+      results = GoodData.post("#{uri}/validElements?limit=30&offset=0&order=asc&filter=#{value}", {})
+      items = results['validElements']['items']
+      if items.empty?
+        fail "#{value} not found"
+      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 = GoodData.get(uri + "/?id=#{element_id}")
+      items = result['attributeElements']['elements']
+      if items.empty?
+        fail "Element id #{element_id} was not found"
+      else
+        items.first['title']
+      end
+    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 = {})
+      limit = options[:limit] || 100
+      results = GoodData.post("#{uri}/validElements?limit=#{limit}&offset=0&order=asc", {})
+      results['validElements']['items'].map do |el|
+        v = el['element']
+        {
+          :value => v['title'],
+          :uri => v['uri']
+        }
+      end
+    end
+
+    # Gives an attribute of current label
+    # @return [GoodData::Attibute]
+    def attribute
+      GoodData::Attribute[content['formOf']]
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# encoding: UTF-8
+
+require_relative '../metadata'
+require_relative '../../core/rest'
+require_relative 'metadata'
+
+module GoodData
+  class Fact < GoodData::MdObject
+    root_key :fact
+
+    # TODO: verify that we have all (which we do not right now)
+    FACT_BASE_AGGREGATIONS = [:sum, :min, :max, :avg, :median]
+
+    class << self
+      def [](id, options = {})
+        if id == :all
+          facts = GoodData.get(GoodData.project.md['query'] + '/facts/')['query']['entries']
+          options[:full] ? facts.map { |f| Fact[f['link']] } : facts
+        else
+          super
+        end
+      end
+    end
+
+    def fact?
+      true
+    end
+
+    def create_metric(options = {})
+      a_type = options[:type] || :sum
+      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(',')}" unless FACT_BASE_AGGREGATIONS.include?(a_type)
+      a_title = options[:title] || "#{a_type} of #{title}"
+      Metric.xcreate(:expression => "SELECT #{a_type.to_s.upcase}(![#{identifier}])", :title => a_title)
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# encoding: UTF-8
+
+require_relative '../md_object'
+
+module GoodData
+  module Model
+    ##
+    # Base class for GoodData attribute and fact folder abstractions
+    #
+    class Folder < MdObject
+      def initialize(title)
+        # TODO: should a super be here?
+        # how to deal with name vs title?
+        @title = title
+        @name = GoodData::Helpers.sanitize_string(title)
+      end
+
+      def to_maql_create
+        "CREATE FOLDER {#{type_prefix}.#{name}}" \
+            + " VISUAL (#{visual}) TYPE #{type};\n"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+# encoding: UTF-8
+
+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,197 @@
+# encoding: UTF-8
+
+require_relative '../../goodzilla/goodzilla'
+require_relative '../metadata'
+require_relative 'metadata'
+
+module GoodData
+  # Metric representation
+  class Metric < MdObject
+    root_key :metric
+
+    PARSE_MAQL_OBJECT_REGEXP = /\[([^\]]+)\]/
+
+    class << self
+      def [](id, options = {})
+        if id == :all
+          metrics = GoodData.get(GoodData.project.md['query'] + '/metrics/')['query']['entries']
+          options[:full] ? metrics.map { |m| Metric[m['link']] } : metrics
+        else
+          super
+        end
+      end
+
+      def xcreate(options)
+        if options.is_a?(String)
+          create(:expression => options, :extended_notation => true)
+        else
+          create(options.merge(:extended_notation => true))
+        end
+      end
+
+      def create(options = {})
+        if options.is_a?(String)
+          expression = options
+          extended_notation = false
+          title = nil
+        else
+          title = options[:title]
+          summary = options[:summary]
+          expression = options[:expression] || fail('Metric has to have its expression defined')
+          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']
+                           memo
+                         end,
+                         :attributes => GoodData::Attribute[:all].reduce({}) do |memo, item|
+                           memo[item['title']] = item['link']
+                           memo
+                         end,
+                         :metrics => GoodData::Metric[:all].reduce({}) do |memo, item|
+                           memo[item['title']] = item['link']
+                           memo
+                         end
+                       }
+                       interpolated_metric = GoodData::SmallGoodZilla.interpolate_metric(expression, dict)
+                       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]
+        Metric.new(metric)
+      end
+
+      def execute(expression, options = {})
+        m = if expression.is_a?(String)
+              tmp = {
+                :title => 'Temporary metric to be deleted',
+                :expression => expression
+              }.merge(options)
+
+              GoodData::Metric.create(tmp)
+            else
+              tmp = {
+                :title => 'Temporary metric to be deleted'
+              }.merge(expression)
+              GoodData::Metric.create(tmp)
+            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
+      end
+    end
+
+    def execute
+      res = GoodData::ReportDefinition.execute(:left => self)
+      res[0][0]
+    end
+
+    def expression
+      content['expression']
+    end
+
+    def expression=(value)
+      content['expression'] = value
+    end
+
+    def validate
+      fail 'Meric 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::DisplayForm] 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 objects like Attribute, Fact or Metric.
+    # @param [GoodData::MdObject] what Object that should be replaced
+    # @param [GoodData::MdObject] for_what Object it is replaced with
+    # @return [GoodData::Metric]
+    def replace(what, for_what)
+      uri_what = what.respond_to?(:uri) ? what.uri : what
+      uri_for_what = for_what.respond_to?(:uri) ? for_what.uri : for_what
+      self.expression = expression.gsub(uri_what, uri_for_what)
+      self
+    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::DisplayForm] 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
+      temp = expression.dup
+      expression.scan(PARSE_MAQL_OBJECT_REGEXP).each do |uri|
+        uri = uri.first
+        if uri =~ /elements/
+          temp.sub!(uri, Attribute.find_element_value(uri))
+        else
+          obj = GoodData::MdObject[uri]
+          temp.sub!(uri, obj.title)
+        end
+      end
+      temp
+    end
+  end
+end