gooddata 0.6.24 → 0.6.25

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

@@ -8,8 +8,6 @@ require_relative '../metadata'
 
 module GoodData
   class Dataset < MdObject
-    root_key :dataSet
-
     class << self
       # Method intended to get all objects of that type in a specified project
       #

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

@@ -10,9 +10,7 @@ require_relative 'metadata'
 
 module GoodData
   class Dimension < GoodData::MdObject
-    root_key :dimension
-
-    include GoodData::Mixin::IsDimension
+    include Mixin::IsDimension
 
     class << self
       # Method intended to get all objects of that type in a specified project

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

@@ -12,9 +12,7 @@ require_relative 'metadata'
 
 module GoodData
   class Fact < GoodData::MdObject
-    root_key :fact
-
-    include GoodData::Mixin::IsFact
+    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]

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

@@ -10,9 +10,7 @@ require_relative 'metadata'
 
 module GoodData
   class Label < GoodData::MdObject
-    root_key :attributeDisplayForm
-
-    include GoodData::Mixin::IsLabel
+    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

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

@@ -12,12 +12,7 @@ require_relative 'metadata'
 module GoodData
   # Metric representation
   class Metric < MdObject
-    include GoodData::Mixin::Lockable
-
-    alias_method :to_hash, :json
-
-    include GoodData::Mixin::RestResource
-    root_key :metric
+    include Mixin::Lockable
 
     class << self
       # Method intended to get all objects of that type in a specified project
@@ -34,14 +29,7 @@ module GoodData
       end
 
       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?
+        client, project = GoodData.get_client_and_project(options)
 
         if metric.is_a?(String)
           expression = metric || options[:expression]
@@ -119,14 +107,7 @@ module GoodData
       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?
+        GoodData.get_client_and_project(opts)
 
         execute(expression, opts.merge(:extended_notation => true))
       end
@@ -175,27 +156,15 @@ module GoodData
       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
+    # 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(what, for_what = nil)
-      pairs = if what.is_a?(Hash)
-                whats = what.keys
-                to_whats = what.values
-                whats.zip(to_whats)
-              elsif what.is_a?(Array) && for_what.is_a?(Array)
-                whats.zip(to_whats)
-              else
-                [[what, for_what]]
-              end
-
-      pairs.each do |a, b|
-        uri_what = a.respond_to?(:uri) ? a.uri : a
-        uri_for_what = b.respond_to?(:uri) ? b.uri : b
-        self.expression = expression.gsub("[#{uri_what}]", "[#{uri_for_what}]")
-      end
-      self
+    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.

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

@@ -9,9 +9,7 @@ require_relative 'metadata'
 
 module GoodData
   class Report < GoodData::MdObject
-    root_key :report
-
-    include GoodData::Mixin::Lockable
+    include Mixin::Lockable
 
     class << self
       # Method intended to get all objects of that type in a specified project
@@ -24,14 +22,7 @@ module GoodData
       end
 
       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 = client.projects(p)
-        fail ArgumentError, 'Wrong :project specified' if project.nil?
+        client, project = GoodData.get_client_and_project(options)
 
         title = options[:title]
         fail 'Report needs a title specified' unless title
@@ -208,15 +199,13 @@ module GoodData
       self
     end
 
-    # Replaces all occurences of something with something else. This is just a convenience method. The
-    # real work is done under the hood in report definition. This is just deferring to those
+    # 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 what [Object] What you would like to have changed
-    # @param for_what [Object] What you would like to have changed this for
-    # @return [GoodData::Report] Returns report with removed definition
-    def replace(what, for_what)
+    # @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(what, for_what)
+        rep_def.replace(mapping)
       end
       new_defs.pmap(&:save)
       self

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

@@ -12,8 +12,6 @@ module GoodData
   # Report Definition
   # TODO: Add more doc ...
   class ReportDefinition < GoodData::MdObject
-    root_key :reportDefinition
-
     class << self
       # Method intended to get all objects of that type in a specified project
       #
@@ -52,10 +50,16 @@ module GoodData
         }
       end
 
-      def create_filters_part(filters)
-        filters.select { |f| f.class == GoodData::Variable }.map do |v|
-          { expression: "[#{v.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)
@@ -75,10 +79,7 @@ module GoodData
       end
 
       def find(stuff, opts = { :client => GoodData.connection, :project => GoodData.project })
-        client = opts[:client]
-        project = opts[:project]
-        fail ArgumentError, 'No :client specified' if client.nil?
-        fail ArgumentError, 'No :project specified' if project.nil?
+        _client, project = GoodData.get_client_and_project(opts)
 
         stuff.map do |item|
           obj = if item.is_a?(String)
@@ -133,14 +134,7 @@ module GoodData
       end
 
       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?
+        client, project = GoodData.get_client_and_project(options)
 
         left = Array(options[:left])
         top = Array(options[:top])
@@ -167,7 +161,7 @@ module GoodData
                 'rows' => ReportDefinition.create_part(left)
               },
               'format' => 'grid',
-              'filters' => ReportDefinition.create_filters_part(filters)
+              'filters' => ReportDefinition.create_filters_part(filters, :project => project)
             },
             'meta' => {
               'tags' => '',
@@ -249,101 +243,15 @@ module GoodData
       content['filters'].map { |f| f['expression'] }
     end
 
-    # Replace certain object in report definition. Returns new definition which is not saved.
+    # 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 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)
-              elsif what.is_a?(Array) && for_what.is_a?(Array)
-                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|
-          GoodData::Helpers.deep_dup(item).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)
-            GoodData::Helpers.deep_dup(item).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)
-            GoodData::Helpers.deep_dup(item).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)
-            GoodData::Helpers.deep_dup(item).tap do |i|
-              if i['locator'].length > 0 && 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)
-            GoodData::Helpers.deep_dup(item).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]
-            a[key] = val.map do |item|
-              GoodData::Helpers.deep_dup(item).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
+    # @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)
+      GoodData::MdObject.replace_bracketed(x, vals)
     end
 
     # Return true if the report definition is a table

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

@@ -0,0 +1,274 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2015 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 'scheduled_mail/dashboard_attachment'
+require_relative 'scheduled_mail/report_attachment'
+
+require_relative '../../helpers/global_helpers'
+
+require_relative '../../core/core'
+require_relative '../metadata'
+require_relative 'metadata'
+require_relative 'report'
+
+require 'multi_json'
+
+module GoodData
+  class ScheduledMail < GoodData::MdObject
+    root_key :scheduledMail
+
+    include GoodData::Mixin::Lockable
+
+    DEFAULT_OPTS = {
+      # Meta options
+      :title => 'Scheduled report example',
+      :summary => 'Daily at 12:00pm PT',
+      :tags => '',
+      :deprecated => 0,
+
+      # Content When options
+      :recurrency => '0:0:0:12:0:0',
+      :startDate => '2012-06-05',
+      :timeZone => 'America/Los_Angeles',
+
+      # Content Email options
+      :to => [],
+      :bcc => [],
+      :subject => 'Scheduled Report',
+      :body => "Hey, I'm sending you new Reports and Dashboards!",
+
+      # Attachments
+      :attachments => []
+    }
+
+    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('scheduledMail', ScheduledMail, options)
+      end
+
+      def convert_attachment(item, opts)
+        if item.is_a?(GoodData::Dashboard)
+          {
+            dashboardAttachment: GoodData::DashboardAttachment::DEFAULT_OPTS.merge(opts.merge(:uri => item.uri))
+          }
+        elsif item.is_a?(GoodData::Report)
+          {
+            reportAttachment: GoodData::ReportAttachment::DEFAULT_OPTS.merge(opts.merge(:uri => item.uri))
+          }
+        elsif item.is_a?(GoodData::DashboardAttachment)
+          item.json
+        elsif item.is_a?(GoodData::ReportAttachment)
+          item.json
+        elsif item.is_a?(Hash)
+          item
+        elsif item == 'dashboardAttachment'
+          {
+            dashboardAttachment: GoodData::DashboardAttachment::DEFAULT_OPTS.merge(opts)
+          }
+        elsif item == 'reportAttachment'
+          {
+            reportAttachment: GoodData::ReportAttachment::DEFAULT_OPTS.merge(opts)
+          }
+        end
+      end
+
+      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 = client.projects(p)
+        fail ArgumentError, 'Wrong :project specified' if project.nil?
+
+        opts = GoodData::ScheduledMail::DEFAULT_OPTS.merge(GoodData::Helpers.symbolize_keys(options))
+
+        scheduled_mail = {
+          :scheduledMail => {
+            :meta => {
+              :title => opts[:title],
+              :summary => opts[:summary],
+              :tags => opts[:tags],
+              :deprecated => opts[:deprecated]
+            },
+            :content => {
+              :when => {
+                :recurrency => opts[:recurrency],
+                :startDate => opts[:startDate] || opts[:start_date],
+                :timeZone => opts[:timeZone] || opts[:time_zone] || opts[:timezone]
+              },
+              :to => opts[:to].is_a?(Array) ? opts[:to] : [opts[:to]],
+              :bcc => opts[:bcc].is_a?(Array) ? opts[:bcc] : [opts[:bcc]],
+              :subject => opts[:subject],
+              :body => opts[:body]
+            }
+          }
+        }
+
+        attachments = opts[:attachments].map do |attachment|
+          key = attachment.keys.first
+          body = attachment[key]
+
+          ScheduledMail.convert_attachment(key, body)
+        end
+
+        scheduled_mail[:scheduledMail][:content][:attachments] = attachments
+
+        client.create(ScheduledMail, GoodData::Helpers.deep_stringify_keys(scheduled_mail), :project => project)
+      end
+    end
+
+    # Add attachment
+    #
+    # @param [String | Object] item Schedule to add
+    # @param [Hash] opts Optional schedule options
+    # @return [Array] New list of attachments
+    def add_attachment(item, opts)
+      attachment = ScheduledMail.convert_attachment(item, opts)
+      fail ArgumentError unless attachment
+
+      content['attachments'] << attachment
+    end
+
+    # Add attachment and save
+    #
+    # @param [String | Object] item Schedule to add
+    # @param [Hash] opts Optional schedule options
+    # @return [Array] New list of attachments
+    def add_attachment!(item, opts)
+      add_attachment(item, opts)
+      save!
+    end
+
+    # Get attachments as objects
+    #
+    # @return [Array<GoodData::DashboardAttachment | GoodData::ReportAttachment>] Array of attachments
+    def attachments
+      content['attachments'].map do |attachment|
+        key = attachment.keys.first
+
+        if key == 'dashboardAttachment'
+          GoodData::DashboardAttachment.new(self, attachment)
+        elsif key == 'reportAttachment'
+          GoodData::ReportAttachment.new(self, attachment)
+        else
+          RuntimeError "Unsupported attachment type: #{key}"
+        end
+      end
+    end
+
+    # Get body
+    #
+    # @return [String] Scheduled email body
+    def body
+      content['body']
+    end
+
+    # Set body
+    #
+    # @param [String] new_body New body to be set
+    # @return [String] New body
+    def body=(new_body)
+      content['body'] = new_body
+    end
+
+    # Get recurrency string
+    #
+    # @return [String] Recurrency (cron) string
+    def recurrency
+      content['when']['recurrency']
+    end
+
+    # Set recurrency
+    #
+    # @param [String] new_recurrency New recurrency to be set
+    # @return [Hash] New recurrency
+    def recurrency=(new_recurrency)
+      content['when']['recurrency'] = new_recurrency
+    end
+
+    # Get start date
+    #
+    # @return [String] Start date
+    def start_date
+      content['when']['startDate']
+    end
+
+    # Set start date
+    #
+    # @param [String] new_start_date New start date to be set
+    # @return [String] New start date
+    def start_date=(new_start_date)
+      content['when']['startDate'] = new_start_date
+    end
+
+    # Get subject
+    #
+    # @return [String] Subject of scheduled email
+    def subject
+      content['subject']
+    end
+
+    # Set subject
+    #
+    # @param [String] new_subject New subject to be set
+    # @return [String] New subject
+    def subject=(new_subject)
+      content['subject'] = new_subject
+    end
+
+    # Get timezone
+    #
+    # @return [String] Timezone
+    def timezone
+      content['when']['timeZone']
+    end
+
+    # Set timezone
+    #
+    # @param [String] new_timezone New timezone string to be set
+    # @return [String] New timezone
+    def timezone=(new_timezone)
+      content['when']['timeZone'] = new_timezone
+    end
+
+    # Get recipients
+    #
+    # @return [String] Recipients of email
+    def to
+      content['to']
+    end
+
+    # Set recipients
+    #
+    # @param [String|Array<String>] new_to New recipients to be set
+    # @return [Array<String>] New recipient list
+    def to=(new_to)
+      content['to'] = new_to.is_a?(Array) ? new_to : [new_to]
+    end
+
+    # Get 'when' section
+    #
+    # @return [Hash] 'when' section from json
+    def when
+      content['when']
+    end
+
+    # Set 'when' section
+    #
+    # @param [Hash] new_when New 'when' section to be set
+    # @return [Hash] New 'when' section
+    def when=(new_when)
+      content['when'] = new_when
+    end
+  end
+end