gooddata 0.5.16 → 0.6.0.pre2

data/lib/gooddata/models/attribute.rb

@@ -0,0 +1,24 @@
+module GoodData
+  class Attribute < GoodData::MdObject 
+
+    root_key :attribute
+
+    class << self
+      def [](id)
+        if id == :all
+          GoodData.get(GoodData.project.md['query'] + '/attributes/')['query']['entries']
+        else 
+          super
+        end
+      end
+    end
+
+    def display_forms
+      content["displayForms"].map {|df| GoodData::DisplayForm[df["meta"]["uri"]]}
+    end
+
+    def is_attribute?
+      true
+    end
+  end
+end

data/lib/gooddata/models/dashboard.rb

@@ -1,6 +1,8 @@
 module GoodData
   class Dashboard < GoodData::MdObject 
 
+    root_key :projectDashboard
+
     class << self
       def [](id)
         if id == :all
@@ -8,7 +10,65 @@ module GoodData
         else 
           super
         end
+
+      end
+
+      def create_report_tab(tab)
+        title = tab[:title]
+        {
+          :title => title,
+          :items => tab[:items].map {|i| GoodData::Dashboard.create_report_tab_item(i)}
+        }
+      end
+
+      def create_report_tab_item(options={})
+        title = options[:title]
+
+        report = GoodData::Report.find_first_by_title(title)
+        {
+           :reportItem => {
+              :obj => report.uri,
+              :sizeY => options[:size_y] || 200,
+              :sizeX => options[:size_x] || 300,
+              :style => {
+                 :displayTitle => 1,
+                 :background => {
+                    :opacity => 0
+                 }
+              },
+              :visualization => {
+                 :grid => {
+                    :columnWidths => []
+                 },
+                 :oneNumber => {
+                    :labels => {}
+                 }
+              },
+              :positionY => options[:position_y] || 0,
+              :filters => [],
+              :positionX => options[:position_x] || 0
+           }
+        }
       end
+
+      def create(options={})
+        binding.pry
+        stuff = {
+           "projectDashboard" => {
+              "content" => {
+                 "tabs" => options[:tabs].map {|t| GoodData::Dashboard.create_report_tab(t)},
+                 "filters" => []
+              },
+              "meta" => {
+                 "tags" => options[:tags],
+                 "summary" => options[:summary],
+                 "title" => options[:title]
+              }
+           }
+        }
+        Dashboard.new(stuff)
+      end
+
     end
 
     def export(format, options={})

data/lib/gooddata/models/data_result.rb

@@ -1,6 +1,6 @@
 module GoodData
 
-  class Row < FasterCSV::Row
+  class Row < CSV::Row
     def ==(other)
        len = length()
        return false if len != other.length
@@ -72,7 +72,7 @@ module GoodData
     end
 
     def assemble_table
-      @table = FasterCSV::Table.new([GoodData::Row.new([],[],false)])
+      @table = CSV::Table.new([GoodData::Row.new([],[],false)])
     end
 
     def to_table
@@ -117,7 +117,7 @@ module GoodData
       else
         @headers = sf_data.first.keys - [:type, :Id]
       end
-      @table = FasterCSV::Table.new(sf_data.collect do |line|
+      @table = CSV::Table.new(sf_data.collect do |line|
         GoodData::Row.new([], @headers.map {|h| line[h] || ' '}, false)
       end)
     rescue
@@ -179,7 +179,7 @@ module GoodData
     end
 
     def to_table
-      FasterCSV::Table.new(table.transpose.map {|line| GoodData::Row.new([], line.map {|item| item || ' '}, false)})
+      CSV::Table.new(table.transpose.map {|line| GoodData::Row.new([], line.map {|item| item || ' '}, false)})
     end
 
     def == (otherDataResult)
@@ -187,8 +187,6 @@ module GoodData
       csv_table = to_table
       len =  csv_table.length
       return false if len != otherDataResult.to_table.length
-
-
       result
     end
 

data/lib/gooddata/models/data_set.rb

@@ -0,0 +1,20 @@
+module GoodData
+  class DataSet < MdObject
+    
+    root_key :dataSet
+    
+    SLI_CTG = 'singleloadinterface'
+    DS_SLI_CTG = 'dataset-singleloadinterface'
+
+    def sli_enabled?
+      content['mode'] == 'SLI'
+    end
+
+    def sli
+      raise NoProjectError.new "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]
+    end
+  end
+end

data/lib/gooddata/models/display_form.rb

@@ -0,0 +1,7 @@
+module GoodData
+  class DisplayForm < GoodData::MdObject 
+
+    root_key :attributeDisplayForm
+
+  end
+end

data/lib/gooddata/models/fact.rb

@@ -0,0 +1,17 @@
+module GoodData
+  class Fact < GoodData::MdObject 
+
+    root_key :fact
+
+    class << self
+      def [](id)
+        if id == :all
+          GoodData.get(GoodData.project.md['query'] + '/facts/')['query']['entries']
+        else 
+          super
+        end
+      end
+    end
+
+  end
+end

data/lib/gooddata/models/metadata.rb

@@ -6,6 +6,10 @@ module GoodData
     IDENTIFIERS_CFG = 'instance-identifiers'
 
     class << self
+      def root_key(a_key)
+        define_method :root_key, Proc.new { a_key.to_s}
+      end
+      
       def [](id)
         raise "Cannot search for nil #{self.class}" unless id
         uri = if id.is_a? Integer or id =~ /^\d+$/
@@ -17,7 +21,16 @@ module GoodData
         else
           raise "Unexpected object id format: expected numeric ID, identifier with no slashes or an URI starting with a slash"
         end
-        self.new((GoodData.get uri).values[0]) unless uri.nil?
+        self.new(GoodData.get uri) unless uri.nil?
+      end
+
+      def find_by_tag(tag)
+        self[:all].find_all {|r| r["tags"].split(",").include?(tag)}
+      end
+
+      def find_first_by_title(title)
+        item = self[:all].find {|r| r["title"] == title}
+        self[item["link"]]
       end
 
       private
@@ -39,8 +52,7 @@ module GoodData
     end
 
     def delete
-      raise "Project '#{title}' with id #{uri} is already deleted" if state == :deleted
-      GoodData.delete @json['links']['self']
+      GoodData.delete(uri)
     end
 
     def obj_id
@@ -48,13 +60,17 @@ module GoodData
     end
 
     def links
-      @json['links']
+      data['links']
     end
 
     def uri
       meta['uri']
     end
 
+    def browser_uri
+      GoodData.connection.url + meta['uri']
+    end
+
     def identifier
       meta['identifier']
     end
@@ -67,12 +83,28 @@ module GoodData
       meta['summary']
     end
 
+    def title=(a_title)
+      data["meta"]["title"] = a_title
+    end
+
+    def summary=(a_summary)
+      data["meta"]["summary"] = a_summary
+    end
+
+    def tags
+      data["meta"]["tags"]
+    end
+
+    def tags=(list_of_tags)
+      data["meta"]["tags"] = tags
+    end
+
     def meta
-      @json['meta']
+      data['meta']
     end
 
     def content
-      @json['content']
+      data['content']
     end
 
     def project
@@ -89,21 +121,41 @@ module GoodData
       result["entries"]
     end
 
-  end
+    def to_json
+      @json.to_json
+    end
 
-  class DataSet < MdObject
-    SLI_CTG = 'singleloadinterface'
-    DS_SLI_CTG = 'dataset-singleloadinterface'
+    def raw_data
+      @json
+    end
+
+    def data
+      raw_data[root_key]
+    end
+
+    def saved?
+      !!uri
+    end
+
+    def save
+      fail("Validation failed") unless validate
+
+      if saved?
+        GoodData.put(uri, to_json)
+      else
+        result = GoodData.post(GoodData.project.md['obj'], to_json)
+        saved_object = self.class[result["uri"]]
+        @json = saved_object.raw_data
+      end
+      self
+    end
 
-    def sli_enabled?
-      content['mode'] == 'SLI'
+    def ==(other)
+      other.uri == uri
     end
 
-    def sli
-      raise NoProjectError.new "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]
+    def validate
+      true
     end
   end
 end

data/lib/gooddata/models/metric.rb

@@ -0,0 +1,90 @@
+require 'gooddata/goodzilla/goodzilla'
+
+module GoodData
+  class Metric < GoodData::MdObject 
+
+    root_key :metric
+
+    class << self
+      def [](id)
+        if id == :all
+          GoodData.get(GoodData.project.md['query'] + '/metrics/')['query']['entries']
+        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 = true
+          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]
+        end
+
+        expression = if extended_notation
+          dict = {
+            :facts => GoodData::Fact[:all].reduce({}) {|memo, item| memo[item["title"]] = item["link"]; memo},
+            :attributes => GoodData::Attribute[:all].reduce({}) {|memo, item| memo[item["title"]] = item["link"]; memo},
+            :metrics => GoodData::Metric[:all].reduce({}) {|memo, item| memo[item["title"]] = item["link"]; memo},
+          }
+          interpolated_metric = GoodData::SmallGoodZilla.interpolate_metric(expression, dict)
+          interpolated_metric
+        else
+          expression
+        end
+
+        Metric.new({
+           "metric" => {
+              "content" => {
+                 "format" => "#,##0",
+                 "expression" => expression
+              },
+              "meta" => {
+                 "tags" => "",
+                 "summary" => summary,
+                 "title" => title,
+              }
+           }
+        })
+      end
+
+      def execute(expression, options={})
+        m = GoodData::Metric.create({:title => "Temporary metric to be deleted", :expression => expression}.merge(options))
+        m.execute
+      end
+
+      def xexecute(expression)
+        execute(expression, {:extended_notation => true})
+      end
+
+    end
+
+    def execute
+      res = GoodData::ReportDefinition.execute(:left => self)
+      res.to_table[0][0]
+    end
+
+    def validate
+      fail "Meric needs to have title" if title.nil?
+      true
+    end
+
+    def is_metric?
+      true
+    end
+      
+  end
+end

data/lib/gooddata/models/process.rb

@@ -0,0 +1,112 @@
+require 'pry'
+require 'highline'
+
+module GoodData
+  class Process
+
+    class << self
+      def [](id)
+        if id == :all
+          GoodData.get("/gdc/projects/hi95siviyangv53c3vptkz1eas546pnn/dataload/processes")
+        else 
+          self.new(GoodData.get("/gdc/projects/hi95siviyangv53c3vptkz1eas546pnn/dataload/processes/#{id}"))
+        end
+      end
+
+      def deploy(dir, options={}, &block) 
+        if block
+          begin
+            res = deploy_graph(dir, options)
+            block.call(res)
+          ensure
+            self_link = res["process"]["links"]["self"]
+            GoodData.delete(self_link)
+          end
+        else
+          deploy_graph(dir, options)
+        end
+      end
+
+      def deploy_graph(dir, options={}) 
+        dir = Pathname(dir)
+        fail "Provided path (#{dir}) is not directory." unless dir.directory?
+        type = options[:type] || "ETL"
+        
+        deploy_name = options[:name] || options[:project_name]
+        verbose = options[:verbose] || false
+        project_pid = 'hi95siviyangv53c3vptkz1eas546pnn'
+        
+        puts HighLine::color("Deploying #{dir}", HighLine::BOLD) if verbose
+        res = nil
+
+        Tempfile.open("deploy-graph-archive") do |temp|
+          Zip::OutputStream.open(temp.path) do |zio|
+            Dir.glob(dir + "**/*") do |item|
+              puts "including #{item}" if verbose
+              unless File.directory?(item)
+                zio.put_next_entry(item)
+                zio.print IO.read(item)
+              end
+            end
+          end
+
+          GoodData.connection.upload(temp.path)
+          process_id = options[:process]
+
+          data = {
+              :process => {
+                :name => deploy_name,
+                :path => "/uploads/#{File.basename(temp.path)}",
+                :type => type
+              }
+            }
+          res = if process_id.nil?
+            GoodData.post("/gdc/projects/#{project_pid}/dataload/processes", data)
+          else
+            GoodData.put("/gdc/projects/#{project_pid}/dataload/processes/#{process_id}", data)
+          end
+        end
+        puts HighLine::color("Deploy DONE #{dir}", HighLine::BOLD) if verbose
+        binding.pry
+        res
+      end
+    end
+
+    def initialize(data)
+      @data = data
+    end
+
+    def links
+      @data["process"]["links"]
+    end
+    
+    def link
+      links["self"]
+    end
+
+    def executions_link
+      links["executions"]
+    end
+
+    def execute_process(graph, options={})
+      result = GoodData.post(executions_link, {
+        :execution => {
+         :graph => graph,
+         :params => {}  
+        }
+      })
+      begin
+        GoodData.poll(result, "executionTask")
+      rescue RestClient::RequestFailed => e
+
+      ensure
+        result = GoodData.get(result["executionTask"]["links"]["detail"])
+        if result["executionDetail"]["status"] == "ERROR"
+          fail "Runing process failed. You can look at a log here #{result["executionDetail"]["logFileName"]}"
+        end
+      end
+      result
+    end
+
+  end
+end