gooddata-edge 0.6.27.edge

data/lib/gooddata/models/project_creator.rb

@@ -0,0 +1,126 @@
+# 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 'project'
+require_relative 'blueprint/project_blueprint'
+
+require 'open-uri'
+
+module GoodData
+  module Model
+    class ProjectCreator
+      class << self
+        def migrate(opts = {})
+          opts = { client: GoodData.connection }.merge(opts)
+          client = opts[:client]
+          fail ArgumentError, 'No :client specified' if client.nil?
+
+          spec = opts[:spec] || fail('You need to provide spec for migration')
+          bp = ProjectBlueprint.new(spec)
+          fail GoodData::ValidationError, "Blueprint is invalid #{bp.validate.inspect}" unless bp.valid?
+          spec = bp.to_hash
+
+          project = opts[:project] || client.create_project(opts.merge(:title => spec[:title], :client => client, :environment => opts[:environment]))
+
+          begin
+            migrate_datasets(spec, opts.merge(project: project, client: client))
+            load(p, spec)
+            migrate_metrics(p, spec[:metrics] || [])
+            migrate_reports(p, spec[:reports] || [])
+            migrate_dashboards(p, spec[:dashboards] || [])
+            execute_tests(p, spec[:assert_tests] || [])
+            project
+          end
+        end
+
+        def migrate_datasets(spec, opts = {})
+          opts = { client: GoodData.connection }.merge(opts)
+          dry_run = opts[:dry_run]
+
+          client, project = GoodData.get_client_and_project(opts)
+
+          bp = ProjectBlueprint.new(spec)
+          uri = "/gdc/projects/#{project.pid}/model/diff?includeGrain=true"
+          result = client.post(uri, bp.to_wire)
+
+          link = result['asyncTask']['link']['poll']
+          response = client.get(link, :process => false)
+
+          while response.code != 200
+            sleep 1
+            GoodData::Rest::Client.retryable(:tries => 3) do
+              sleep 1
+              response = client.get(link, :process => false)
+            end
+          end
+
+          response = client.get(link)
+
+          chunks = pick_correct_chunks(response['projectModelDiff']['updateScripts'], opts)
+          if !chunks.nil? && !dry_run
+            chunks['updateScript']['maqlDdlChunks'].each do |chunk|
+              result = project.execute_maql(chunk)
+              fail 'Creating dataset failed' if result['wTaskStatus']['status'] == 'ERROR'
+            end
+          end
+          chunks
+        end
+
+        def migrate_reports(project, spec)
+          spec.each do |report|
+            project.add_report(report)
+          end
+        end
+
+        def migrate_dashboards(project, spec)
+          spec.each do |dash|
+            project.add_dashboard(dash)
+          end
+        end
+
+        def migrate_metrics(project, spec)
+          spec.each do |metric|
+            project.add_metric(metric)
+          end
+        end
+
+        alias_method :migrate_measures, :migrate_metrics
+
+        def load(project, spec)
+          if spec.key?(:uploads) # rubocop:disable Style/GuardClause
+            spec[:uploads].each do |load|
+              schema = GoodData::Model::Schema.new(spec[:datasets].find { |d| d[:name] == load[:dataset] })
+              project.upload(load[:source], schema, load[:mode])
+            end
+          end
+        end
+
+        def execute_tests(_project, spec)
+          spec.each do |assert|
+            result = GoodData::ReportDefinition.execute(assert[:report])
+            fail "Test did not pass. Got #{result.table.inspect}, expected #{assert[:result].inspect}" if result.table != assert[:result]
+          end
+        end
+
+        def pick_correct_chunks(chunks, opts = {})
+          preference = opts[:preference] || {}
+          # first is cascadeDrops, second is preserveData
+          rules = [
+            { priority: 1, cascade_drops: false, preserve_data: true },
+            { priority: 2, cascade_drops: false, preserve_data: false },
+            { priority: 3, cascade_drops: true, preserve_data: true },
+            { priority: 4, cascade_drops: true, preserve_data: false }
+          ]
+          stuff = chunks.select { |chunk| chunk['updateScript']['maqlDdlChunks'] }.map { |chunk| { cascade_drops: chunk['updateScript']['cascadeDrops'], preserve_data: chunk['updateScript']['preserveData'], maql: chunk['updateScript']['maqlDdlChunks'], orig: chunk } }
+          results = GoodData::Helpers.join(rules, stuff, [:cascade_drops, :preserve_data], [:cascade_drops, :preserve_data], inner: true).sort_by { |l| l[:priority] }
+
+          pick = results.find { |r| r.values_at(:cascade_drops, :preserve_data) == preference.values_at(:cascade_drops, :preserve_data) } || results.first
+          pick[:orig] if pick
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/models/project_metadata.rb

@@ -0,0 +1,67 @@
+# 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.
+
+module GoodData
+  class ProjectMetadata
+    class << self
+      def keys(opts = { :client => GoodData.connection, :project => GoodData.project })
+        ProjectMetadata[:all, opts].keys
+      end
+
+      def [](key, opts = { :client => GoodData.connection, :project => GoodData.project })
+        client, project = GoodData.get_client_and_project(opts)
+
+        get_opts = {
+          do_not_log: [
+            RestClient::ResourceNotFound
+          ]
+        }
+
+        if key == :all
+          uri = "/gdc/projects/#{project.pid}/dataload/metadata"
+          res = client.get(uri, get_opts)
+          res['metadataItems']['items'].reduce({}) do |memo, i|
+            memo[i['metadataItem']['key']] = i['metadataItem']['value']
+            memo
+          end
+        else
+          uri = "/gdc/projects/#{project.pid}/dataload/metadata/#{key}"
+          res = client.get(uri, get_opts)
+          res['metadataItem']['value']
+        end
+      end
+
+      alias_method :get, :[]
+      alias_method :get_key, :[]
+
+      def key?(key, opts = { :client => GoodData.connection, :project => GoodData.project })
+        ProjectMetadata[key, opts]
+        true
+      rescue RestClient::ResourceNotFound
+        false
+      end
+
+      def []=(key, opts = { :client => GoodData.connection, :project => GoodData.project }, val = nil)
+        client, project = GoodData.get_client_and_project(opts)
+
+        data = {
+          :metadataItem => {
+            :key => key,
+            :value => val
+          }
+        }
+        uri = "/gdc/projects/#{project.pid}/dataload/metadata/"
+        update_uri = uri + key
+
+        if key?(key, opts)
+          client.put(update_uri, data)
+        else
+          client.post(uri, data)
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/models/project_role.rb

@@ -0,0 +1,79 @@
+# 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 'pmap'
+
+require_relative 'profile'
+
+require_relative '../rest/rest'
+
+require_relative '../mixins/rest_resource'
+
+module GoodData
+  class ProjectRole < Rest::Resource
+    include Mixin::Author
+    include Mixin::Contributor
+    include Mixin::Timestamps
+
+    EMPTY_OBJECT = {
+      'projectRole' => {
+        'permissions' => {},
+        'links' => {},
+        'meta' => {}
+      }
+    }
+
+    def self.create_object(data)
+      meta_data = {}.tap do |d|
+        d[:created] = data[:created] || Time.now
+        d[:identifier] = data[:identifier]
+        d[:updated] = data[:updated] || d[:created] || Time.now
+        d[:title] = data[:title]
+        d[:summary] = data[:summary]
+      end
+      new_data = GoodData::Helpers.deep_dup(EMPTY_OBJECT).tap do |d|
+        d['projectRole']['links']['self'] = data[:uri] if data[:uri]
+        d['projectRole']['meta'] = d['projectRole']['meta'].merge(GoodData::Helpers.stringify_keys(meta_data))
+        d['projectRole']['permissions'] = d['projectRole']['permissions'].merge(GoodData::Helpers.stringify_keys(data[:permissions] || {}))
+      end
+      new(new_data)
+    end
+
+    def initialize(json)
+      @json = json
+    end
+
+    data_property_reader :permissions
+
+    metadata_property_reader :identifier, :title, :summary
+
+    # Gets Users with this Role
+    #
+    # @return [Array<GoodData::Profile>] List of users
+    def users
+      url = data['links']['roleUsers']
+      tmp = client.get url
+      tmp['associatedUsers']['users'].pmap do |user_url|
+        url = user_url
+        user = client.get url
+        client.create(GoodData::Profile, user)
+      end
+    end
+
+    # Gets Raw object URI
+    #
+    # @return [string] URI of this project role
+    def uri
+      return @json['projectRole']['links']['self'] if @json['projectRole']['links']['self']
+      return nil unless @json['projectRole']['links']['roleUsers']
+      @json['projectRole']['links']['roleUsers'].split('/')[0...-1].join('/')
+    end
+
+    def ==(other)
+      uri == other.uri
+    end
+  end
+end

data/lib/gooddata/models/report_data_result.rb

@@ -0,0 +1,266 @@
+# 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.
+
+module GoodData
+  class ReportDataResult < Rest::Resource
+    class << self
+      # Does all the needed parsing on the apyload coming from the API and returns an instance of ReportDataResult
+      #
+      # @param [Hash] data Data coming from the API
+      # @return [GoodData::ReportDataResult] Returns new report data result
+      def from_xtab(data)
+        top = top_headers(data)
+        left = left_headers(data)
+        jank = GoodData::Helpers.zeroes(rows(top), cols(left), nil)
+        d = data(data)
+        stuff = d.empty? ? GoodData::Helpers.zeroes(rows(left), cols(top), nil) : d
+
+        a = jank.zip(top).map { |x, y| x + y }
+        b = left.zip(stuff).map { |x, y| x + y }
+        result = a + b
+        ReportDataResult.new(data: result, top: rows(top), left: cols(left))
+      end
+
+      private
+
+      def line(child)
+        children = child['children'] || []
+        return (child['first']..child['last']).to_a.map { [child['id']] } if children.empty?
+        children.flat_map { |c| line(c) }.map do |x|
+          child['id'].nil? ? x : [child['id']] + x
+        end
+      end
+
+      def root_line(root)
+        lookups = root['lookups']
+        header = line(root['tree'])
+        header.map { |l| l.each_with_index.map { |item, index| lookups[index][item] } }
+      end
+
+      def top_headers(data)
+        root = data['xtab_data']['columns']
+        root_line(root).transpose
+      end
+
+      def left_headers(data)
+        root = data['xtab_data']['rows']
+        root_line(root)
+      end
+
+      def cols(stuff)
+        stuff.first.count
+      end
+
+      def rows(stuff)
+        stuff.count
+      end
+
+      def data(data)
+        data['xtab_data']['data'].map { |row| row.map { |i| i ? BigDecimal(i) : i } }
+      end
+    end
+
+    # Returns
+    #
+    # @param [Hash] opts Data for the report
+    # @option opts [Array<Array>] :data The data as a matrix. First rows then cols
+    # @option opts [Number] :top Number of rows that are representing the top header
+    # @option opts [Number] :left Number of cols that are representing the left header
+    # @return [GoodData::ReportDataResult] Returns new report data result
+    def initialize(opts)
+      @data = opts[:data]
+      @top_headers_rows_nums = opts[:top]
+      @left_headers_cols_nums = opts[:left]
+    end
+
+    # Gives you new report result with top headers removed
+    #
+    # @return [GoodData::ReportDataResult] Returns new report data result
+    def without_top_headers
+      slice(@top_headers_rows_nums, 0)
+    end
+
+    # Gives you new report result with left headers removed
+    #
+    # @return [GoodData::ReportDataResult] Returns new report data result
+    def without_left_headers
+      slice(0, @left_headers_cols_nums)
+    end
+
+    # Gives you left headers as an Array
+    #
+    # @return [Array] Return left headers as Array of Arrays. The notation is of a matrix. First rows then cols.
+    def left_headers
+      return nil if @left_headers_cols_nums == 0
+      top = @left_headers_cols_nums - 1
+      without_top_headers.slice(0, [0, top]).to_a
+    end
+
+    # Gives you right headers as an Array
+    #
+    # @return [Array] Return top headers as Array of Arrays. The notation is of a matrix. First rows then cols.
+    def top_headers
+      return nil if @top_headers_rows_nums == 0
+      top = @top_headers_rows_nums - 1
+      without_left_headers.slice([0, top], 0).to_a
+    end
+
+    # Gives you data as a new ReportDataResult
+    #
+    # @return [Array] Return left headers as Array of Arrays. The notation is of a matrix. First rows then cols.
+    def data
+      slice(@top_headers_rows_nums, @left_headers_cols_nums)
+    end
+
+    def each
+      to_a.each
+    end
+    alias_method :each_line, :each
+    alias_method :each_row, :each
+
+    def each_column
+      size.last.times.map do |i|
+        col = map { |row| row[i] }
+        yield(col)
+      end
+    end
+
+    # Gives you data as a new ReportDataResult
+    #
+    # @return [Array] Return left headers as Array of Arrays. The notation is of a matrix. First rows then cols.
+    def to_a
+      @data
+    end
+    alias_method :to_table, :to_a
+
+    # Gives report as a table suitable for printing out
+    #
+    # @return [String]
+    def to_s(options = {})
+      with_indices = options[:index]
+
+      a = to_table.to_a
+      data = a.transpose
+      data.unshift((1..a.length).to_a) if with_indices
+      processed_data = data.each_with_index.map do |col, i|
+        col.unshift(i.zero? ? nil : i) if with_indices # inserts row labels #
+        w = col.map { |cell| cell.to_s.length }.max # w = "column width" #
+        col.each_with_index.map do |cell, j|
+          j.zero? ? cell.to_s.center(w) : cell.to_s.ljust(w)
+        end # alligns the column #
+      end
+      processed_data.transpose.map { |row| "[#{row.join(' | ')}]" }.unshift('').join("\n")
+    end
+
+    # Allows to pick particular row inside the report result
+    #
+    # @return [Array] Returns a row of data
+    def [](index)
+      @data[index]
+    end
+    alias_method :row, :[]
+
+    # Allows to pick particular column inside the report result
+    #
+    # @return [Array] Returns a column of data. The column is returned transposed
+    def column(index)
+      transpose[index]
+    end
+
+    # Is the report without any data? This can be caused by the fact that the filters are too restrictive or data are not loaded in
+    #
+    # @return [Array] Returns true if data result is empty
+    def empty?
+      row, cols = size
+      row == 0 && cols == 0
+    end
+
+    # Allows you to test if a report contains a row.
+    #
+    # @param [Array<String | Number>] row Row that you want to test. It is looking for the whole row. If the headers are getting in the way use #without_left_headers or #without_top_headers
+    # @return [Array] Returns true if data are inside a report
+    def include_row?(row)
+      @data.include?(row)
+    end
+
+    # Allows you to test if a report contains a column.
+    #
+    # @param [Array<String | Number>] row Row that you want to test. It is looking for the whole row. If the headers are getting in the way use #without_left_headers or #without_top_headers
+    # @return [Array] Returns true if data are inside a report
+    def include_column?(col)
+      transpose.include_row?(col)
+    end
+
+    # Returns the size of the report
+    #
+    # @return [Array<Number>] The size of the report result as an array. First element is rows second is columns
+    def size
+      [@data.size, @data.empty? ? 0 : @data.first.size]
+    end
+
+    # Transposes data and returns as new data result
+    #
+    # @return [GoodData::ReportDataResult] Returns new report data result with flipped columns and rows
+    def transpose
+      ReportDataResult.new(data: to_a.transpose, top: @left_headers_cols_nums, left: @top_headers_rows_nums)
+    end
+
+    # Gives you report result with a subset of data starting at position rows, cols
+    #
+    # @param [Number] rows Position where you want to slice your row. Currently accepts only number
+    # @param [Number] cols Position where you want to slice your row. Currently accepts only number
+    # @return [GoodData::ReportDataResult] Returns new report data result sliced data
+    def slice(rows, cols)
+      rows = rows.is_a?(Enumerable) ? rows : [rows, size.first]
+      cols = cols.is_a?(Enumerable) ? cols : [cols, size.last]
+      new_data = @data[rows.first..rows.last].map { |col| col[cols.first..cols.last] }
+      if client
+        client.create(ReportDataResult, data: new_data, top: @top_headers_rows_nums - rows.first, left: @left_headers_cols_nums - cols.first, project: project)
+      else
+        ReportDataResult.new(data: new_data, top: @top_headers_rows_nums - rows.first, left: @left_headers_cols_nums - cols.first, project: project)
+      end
+    end
+
+    # Returns the size of the the data portion of report
+    #
+    # @return [Array<Number>] The size of the report result as an array. First element is rows second is columns
+    def data_size
+      data.size
+    end
+
+    def ==(other)
+      return false if size != other.size
+      @data == other.to_a
+    end
+
+    def eq?(other)
+      self == other
+    end
+
+    # Implements subtraction. Works only on reports that have same number of columns. Gives you columns that are not in other.
+    #
+    # @param [GoodData::ReportDataResult] other The other report result
+    # @return [Array<Array>] Returns rows that are not contained in other
+    def -(other)
+      fail 'Seems you are not using a data result as a parameter' unless other.respond_to?(:size)
+      message = 'Results do not have compatible sizes. Subtracting the dataresults works row wise so you have to have the same number of columns'
+      fail message if size.last != other.size.last
+      to_a - other.to_a
+    end
+
+    # Implements diff. Works only on reports that have same number of columns (because it uses #- behind the scene).
+    #
+    # @param [GoodData::ReportDataResult] other The other report result
+    # @return [Hash] Returns a hash that gives you the differences in the report results
+    def diff(other)
+      {
+        added: other - self,
+        removed: self - other,
+        same: @data & other.to_a
+      }
+    end
+  end
+end