gooddata 0.5.16 → 0.6.0.pre2

data/lib/gooddata/models/profile.rb

@@ -29,4 +29,4 @@ module GoodData
       @user = @json['accountSetting']['firstName'] + " " + @json['accountSetting']['lastName']
     end
   end
-end
+end

data/lib/gooddata/models/project.rb

@@ -1,4 +1,4 @@
-require 'zip/zip'
+require 'zip'
 require 'fileutils'
 
 module GoodData
@@ -18,7 +18,7 @@ module GoodData
       def all
         json = GoodData.get GoodData.profile.projects
         json['projects'].map do |project|
-          Project.new project['project']
+          Project.new project
         end
       end
 
@@ -29,6 +29,7 @@ module GoodData
       #  - <id>
       #
       def [](id)
+        return id if id.respond_to?(:is_project?) && id.is_project?
         if id.to_s !~ /^(\/gdc\/(projects|md)\/)?[a-zA-Z\d]+$/
           raise ArgumentError.new("wrong type of argument. Should be either project ID or path")
         end
@@ -36,7 +37,7 @@ module GoodData
         id = id.match(/[a-zA-Z\d]+$/)[0] if id =~ /\//
 
         response = GoodData.get PROJECT_PATH % id
-        Project.new response['project']
+        Project.new response
       end
 
       # Create a project from a given attributes
@@ -45,26 +46,32 @@ module GoodData
       # - :summary
       # - :template (default /projects/blank)
       #
-      def create(attributes)
+      def create(attributes, &block)
         GoodData.logger.info "Creating project #{attributes[:title]}"
 
         auth_token = attributes.delete(:auth_token) || GoodData.connection.auth_token
 
-        json = {
-          'meta' => {
-            'title' => attributes[:title],
-            'summary' => attributes[:summary]
-          },
-          'content' => {
-            # 'state' => 'ENABLED',
-            'guidedNavigation' => 1,
-            'authorizationToken' => auth_token
+        json = {:project =>
+          {
+            'meta' => {
+              'title' => attributes[:title],
+              'summary' => attributes[:summary] || "No summary"
+            },
+            'content' => {
+              'guidedNavigation' => 1,
+              'authorizationToken' => auth_token,
+              "driver" => "Pg"
+            }
           }
         }
-
         json['meta']['projectTemplate'] = attributes[:template] if attributes[:template] && !attributes[:template].empty?
         project = Project.new json
         project.save
+        if block
+          GoodData::with_project(project) do |p|
+            block.call(p)
+          end
+        end
         project
       end
     end
@@ -74,20 +81,29 @@ module GoodData
     end
 
     def save
-      response = GoodData.post PROJECTS_PATH, { 'project' => @json }
+      response = GoodData.post PROJECTS_PATH, raw_data
       if uri == nil
         response = GoodData.get response['uri']
-        @json = response['project']
+        @json = response
       end
     end
 
     def delete
       raise "Project '#{title}' with id #{uri} is already deleted" if state == :deleted
-      GoodData.delete @json['links']['self']
+      GoodData.delete data['links']['self']
     end
 
     def uri
-      @json['links']['self'] if @json['links'] && @json['links']['self']
+      data['links']['self'] if data && data['links'] && data['links']['self']
+    end
+
+    def browser_uri(options={})
+      ui = options[:ui]
+      if ui
+        GoodData.connection.url + "#s=" + uri
+      else
+        GoodData.connection.url + uri
+      end
     end
 
     def obj_id
@@ -95,15 +111,15 @@ module GoodData
     end
 
     def title
-      @json['meta']['title'] if @json['meta']
+      data['meta']['title'] if data['meta']
     end
 
     def state
-      @json['content']['state'].downcase.to_sym if @json['content'] && @json['content']['state']
+      data['content']['state'].downcase.to_sym if data['content'] && data['content']['state']
     end
 
     def md
-      @md ||= Links.new GoodData.get(@json['links']['metadata'])
+      @md ||= Links.new GoodData.get(data['links']['metadata'])
     end
 
     # Creates a data set within the project
@@ -112,11 +128,38 @@ module GoodData
     # p.add_dataset 'Test', [ { 'name' => 'a1', 'type' => 'ATTRIBUTE' ... } ... ]
     # p.add_dataset 'title' => 'Test', 'columns' => [ { 'name' => 'a1', 'type' => 'ATTRIBUTE' ... } ... ]
     #
-    def add_dataset(schema, columns = nil)
-      schema = { 'title' => schema, 'columns' => columns } if columns
-      schema = Model::Schema.new schema if schema.is_a? Hash
-      raise ArgumentError.new("Required either schema object or title plus columns array") unless schema.is_a? Model::Schema
-      Model.add_schema schema, self
+    def add_dataset(schema_def, columns = nil, &block)
+      schema = if block
+        builder = block.call(Model::SchemaBuilder.new(schema_def))
+        builder.to_schema
+      else
+        sch = { :title => schema_def, :columns => columns } if columns
+        sch = Model::Schema.new schema_def if schema_def.is_a? Hash
+        sch = schema_def if schema_def.is_a?(Model::Schema)
+        raise ArgumentError.new("Required either schema object or title plus columns array") unless schema_def.is_a? Model::Schema
+        sch
+      end
+      Model.add_schema(schema, self)
+    end
+
+    def add_metric(options={})
+      expression = options[:expression] || fail("Metric has to have its expression defined")
+      m1 = GoodData::Metric.create(options)
+      m1.save
+    end
+
+    def add_report(options={})
+      rep = GoodData::Report.create(options)
+      rep.save
+    end
+
+    def add_dashboard(options={})
+      dash = GoodData::Dashboard.create(options)
+      dash.save
+    end
+
+    def add_user(email_address, domain)
+      
     end
 
     def upload(file, schema, mode = "FULL")
@@ -124,7 +167,7 @@ module GoodData
     end
 
     def slis
-      link = "#{@json['links']['metadata']}#{SLIS_PATH}"
+      link = "#{data['links']['metadata']}#{SLIS_PATH}"
       Metadata.new GoodData.get(link)
     end
 
@@ -132,12 +175,25 @@ module GoodData
       datasets_uri  = "#{md['data']}/sets"
       response      = GoodData.get datasets_uri
       response['dataSetsInfo']['sets'].map do |ds|
-        DataSet.new ds
+        DataSet[ds["meta"]["uri"]]
       end
     end
 
-    def to_json
+    def raw_data
       @json
     end
+
+    def data
+      raw_data["project"]
+    end
+
+    def to_json
+      raw_data.to_json
+    end
+
+    def is_project?
+      true
+    end
+
   end
 end

data/lib/gooddata/models/report.rb

@@ -1,6 +1,8 @@
 module GoodData
   class Report < GoodData::MdObject 
 
+    root_key :report
+
     class << self
       def [](id)
         if id == :all
@@ -9,8 +11,51 @@ module GoodData
           super
         end
       end
+            
+      def create(options={})
+        title = options[:title]
+        summary = options[:summary] || ""
+        rd = options[:rd] || ReportDefinition.create(:top => options[:top], :left => options[:left])
+        rd.save
+
+        report = Report.new({
+           "report" => {
+              "content" => {
+                 "domains" => [],
+                 "definitions" => [rd.uri]
+              },
+              "meta" => {
+                 "tags" => "",
+                 "deprecated" => "0",
+                 "summary" => summary,
+                 "title" => title
+              }
+           }
+        })        
+      end
     end
 
+# ----
+
+    def title=(a_title)
+      @json["report"]["meta"]["title"] = a_title
+    end
+
+    def summary=(a_summary)
+      @json[:report][:meta][:summary] = a_summary
+    end
+
+    def add_definition(a_definition)
+      @json[:report][:content][:definitions] << a_definition
+    end
+    
+    def to_json(options={})
+      JSON.pretty_generate(@json, options)
+    end
+# ----
+
+
+
     def results
       content["results"]
     end

data/lib/gooddata/models/report_definition.rb

@@ -0,0 +1,139 @@
+module GoodData
+  class ReportDefinition < GoodData::MdObject 
+
+    root_key :reportDefinition
+
+    class << self
+      def [](id)
+        if id == :all
+          GoodData.get(GoodData.project.md['query'] + '/reportdefinition/')['query']['entries']
+        else 
+          super
+        end
+      end
+
+      def create_metrics_part(left, top)
+        stuff = Array(left) + Array(top)
+        stuff.find_all {|item| item.respond_to?(:is_metric?)}.map do |metric|
+          create_metric_part(metric)
+        end
+      end
+
+      def create_metric_part(metric)
+        {
+          "alias" => metric.title,
+          "uri" => metric.uri
+        }
+      end
+
+      def create_attribute_part(attrib)
+        {
+           "attribute" => {
+              "alias" => "",
+              "totals" => [],
+              "uri" => attrib.uri
+           }
+        }
+      end
+
+      def create_part(stuff)
+        stuff = Array(stuff)
+        parts = stuff.reduce([]) do |memo, item|
+          if item.respond_to?(:is_metric?)
+            memo
+          else
+            memo << create_attribute_part(item)
+          end
+          memo
+        end
+        if stuff.any? {|item| item.respond_to?(:is_metric?)}
+          parts << "metricGroup"
+        end
+        parts
+      end
+
+      def find(stuff)
+        stuff.map do |item|
+          if item.respond_to?(:is_attribute?)
+            item.display_forms.first
+          elsif item.is_a?(String)
+            GoodData::Attribute.find_first_by_title(item).display_forms.first
+          elsif item.is_a?(Hash) && item[:type].to_s == "metric"
+            GoodData::Metric.find_first_by_title(item[:title])
+          elsif item.is_a?(Hash) && item[:type].to_s == "attribute"
+            GoodData::Attribute.find_first_by_title(item[:title]).display_forms.first
+          else
+            item
+          end
+        end
+      end
+
+      def execute(options={})
+        left = Array(options[:left])
+        top = Array(options[:top])
+
+        metrics = (left + top).find_all {|item| item.respond_to?(:is_metric?)}
+
+        unsaved_metrics = metrics.reject {|i| i.saved?}
+        unsaved_metrics.each {|m| m.title = "Untitled metric" unless m.title}
+
+        begin
+          unsaved_metrics.each {|m| m.save}
+          rd = GoodData::ReportDefinition.create(options)
+          rd.save
+          rd.execute
+        ensure
+          rd.delete if rd.saved? rescue nil
+          unsaved_metrics.each {|m| m.delete if m.saved?}
+        end
+      end
+
+      def create(options={})
+        left = Array(options[:left])
+        top = Array(options[:top])
+
+        left = ReportDefinition.find(left)
+        top = ReportDefinition.find(top)
+
+        ReportDefinition.new({
+           "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" => []
+              },
+              "meta" => {
+                 "tags" => "",
+                 "summary" => "",
+                 "title" => "Untitled report definition"
+              }
+           }
+        })
+      end
+    end
+
+    def metrics 
+      content["grid"]["metrics"].map {|i| GoodData::Metric[i["uri"]]}
+    end
+
+    def execute
+      result = GoodData.post '/gdc/xtab2/executor3', {"report_req" => {"reportDefinition" => uri}}
+      data_result_uri = result["execResult"]["dataResult"]
+      result = GoodData.get data_result_uri
+      while result["taskState"] && result["taskState"]["status"] == "WAIT" do
+         sleep 10
+         result = GoodData.get data_result_uri
+       end
+      ReportDataResult.new(GoodData.get data_result_uri)
+    end
+  end    
+end

data/lib/gooddata/version.rb

@@ -1,3 +1,3 @@
 module GoodData
-  VERSION = "0.5.16"
+  VERSION = "0.6.0.pre2"
 end

data/lib/templates/bricks/brick.rb.erb

@@ -0,0 +1,7 @@
+class MyBrick < Gooddata::Bricks::Brick
+
+  def call(params)
+    # do something here
+  end
+
+end

data/lib/templates/bricks/main.rb.erb

@@ -0,0 +1,4 @@
+require 'gooddata/bricks'
+require './mybrick'
+
+Gooddata::Bricks::Pipeline.prepare([LoggerMiddleware, BenchMiddleware, GoodDataMiddleware, MyBrick])

data/spec/goodzilla_spec.rb

@@ -0,0 +1,57 @@
+require 'gooddata/goodzilla/goodzilla'
+
+describe GoodData::SmallGoodZilla do
+  
+  MAQL_EXAMPLE = 'SELECT SUM(#"Amount") WHERE @"Date"=#"X" AND ?"Snapshot EOP"=1'
+  FACTS = {
+    "Amount" => "a",
+    "X" => "x"
+  }
+  ATTRIBUTES = {
+    "Date" => "d"
+  }
+  METRICS = {
+    "Snapshot EOP" => "snap"
+  }
+  DICT = {
+    :facts => FACTS,
+    :attributes => ATTRIBUTES,
+    :metrics => METRICS,
+  }
+  
+  it "should parse metrics out of the string" do
+    x = GoodData::SmallGoodZilla.get_facts(MAQL_EXAMPLE)
+    x.should == ["Amount", "X"]
+  end
+
+  it "should parse attributes out of the string" do
+    x = GoodData::SmallGoodZilla.get_attributes(MAQL_EXAMPLE)
+    x.should == ["Date"]
+  end
+
+  it "should parse metrics out of the string" do
+    x = GoodData::SmallGoodZilla.get_metrics(MAQL_EXAMPLE)
+    x.should == ["Snapshot EOP"]
+  end
+
+  it "should interpolate the values" do
+    
+    interpolated = GoodData::SmallGoodZilla.interpolate({
+      :facts => ["Amount", "X"],
+      :attributes => ["Date"],
+      :metrics => ["Snapshot EOP"]
+    }, DICT)
+    
+    interpolated.should == {
+      :facts => [["Amount", "a"], ["X", "x"]],
+      :attributes => [["Date", "d"]],
+      :metrics => [["Snapshot EOP", "snap"]]
+    }
+  end
+
+  it "should return interpolated metric" do
+    interpolated = GoodData::SmallGoodZilla.interpolate_metric(MAQL_EXAMPLE, DICT)
+    interpolated.should == "SELECT SUM([a]) WHERE [d]=[x] AND [snap]=1"
+  end
+
+end