gooddata 1.0.0-java

data/lib/gooddata/models/automated_data_distribution.rb

@@ -0,0 +1,36 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2017 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 AutomatedDataDistribution < Rest::Resource
+    attr_writer :output_stage
+
+    def output_stage
+      return @output_stage if @output_stage
+
+      @output_stage = GoodData::AdsOutputStage[project: project, client: project.client]
+    end
+
+    def initialize(project)
+      self.project = project
+    end
+
+    def process
+      GoodData::Process[:all, project: project, client: project.client].find do |p|
+        p.type == :dataload
+      end
+    end
+
+    def create_output_stage(ads, opts = {})
+      data = {
+        ads: ads,
+        project: project,
+        client: project.client
+      }
+      @output_stage = GoodData::AdsOutputStage.create(data.merge(opts))
+    end
+  end
+end

data/lib/gooddata/models/blueprint/anchor_field.rb

@@ -0,0 +1,65 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2017 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 'attribute_field'
+
+module GoodData
+  module Model
+    class AnchorBlueprintField < AttributeBlueprintField
+      # Returns true if it is an anchor
+      #
+      # @return [Boolean] returns true
+      def anchor?
+        true
+      end
+
+      # Returns true if grain is defined
+      #
+      # @return [Boolean] Returns true if grain is defined on the anchor
+      def grain?
+        !data[:grain].nil?
+      end
+
+      # Returns grain definition if the anchor has it. Nil otherwise
+      #
+      # @return [Array<Hash>] Returns grain definitions
+      def grain
+        data[:grain]
+      end
+
+      # Removes all the labels from the anchor. This is a typical operation that people want to perform
+      #
+      # @return [GoodData::Model::ProjectBlueprint] Returns changed blueprint
+      def strip!
+        dataset_blueprint.strip_anchor!
+      end
+
+      # Alias for strip!. Removes all the labels from the anchor. This is a typical operation that people want to perform
+      #
+      # @return [GoodData::Model::ProjectBlueprint] Returns changed blueprint
+      def remove!
+        strip!
+      end
+
+      # Returns labels for anchor or empty array if there are none
+      #
+      # @return [Array<GoodData::Model::LabelBlueprintField>] Returns list of labels
+      def labels
+        dataset_blueprint.labels_for_attribute(self)
+      end
+
+      # Validates the field for presence of mandatory fields
+      #
+      # @return [Array<Hash>] Returns list of errors as hashes
+      def validate
+        errors = super
+        errors.concat(validate_presence_of(:id).map do |e|
+          { type: :error, message: "Field \"#{e}\" is not defined or empty for anchor \"#{id}\"" }
+        end)
+      end
+    end
+  end
+end

data/lib/gooddata/models/blueprint/attribute_field.rb

@@ -0,0 +1,45 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2017 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 'blueprint_field'
+
+module GoodData
+  module Model
+    class AttributeBlueprintField < BlueprintField
+      # Returns label that is considered referencing. It is either first one or the one marked
+      # with reference_label: true in blueprint
+      #
+      # @return [Array<GoodData::Model::LabelBlueprintField>] Returns list of labels
+      def reference_label
+        reference_label = labels.find { |label| label.respond_to?(:reference_label) && label.reference_label == true }
+        reference_label || labels.first
+      end
+
+      # Returns list of labels on the attribute. There has to be always at least one attribute
+      #
+      # @return [Array] returns list of the errors represented by hash structures
+      def labels
+        @dataset_blueprint.labels_for_attribute(self)
+      end
+
+      # Validates the fields in the attribute
+      #
+      # @return [Array] returns list of the errors represented by hash structures
+      def validate
+        errors = validate_presence_of(:id).map do |e|
+          { type: :error, message: "Field \"#{e}\" is not defined or empty for attribute \"#{id}\"" }
+        end
+        if labels.select(&:reference_label?).count > 1
+          errors << {
+            type: :error,
+            message: "Anchor \"#{id}\" can have only one label with reference_label field set to true"
+          }
+        end
+        errors
+      end
+    end
+  end
+end

data/lib/gooddata/models/blueprint/blueprint.rb

@@ -0,0 +1,11 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2017 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 'pathname'
+base = Pathname(__FILE__).dirname.expand_path
+Dir.glob(base + '*.rb').each do |file|
+  require file
+end

data/lib/gooddata/models/blueprint/blueprint_field.rb

@@ -0,0 +1,70 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2017 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
+  module Model
+    class BlueprintField
+      attr_reader :dataset_blueprint, :data
+
+      def id
+        @data[:id]
+      end
+
+      def initialize(data, dataset)
+        @data = GoodData::Helpers.symbolize_keys(data)
+        @data[:type] = @data[:type].to_sym
+        @dataset_blueprint = dataset
+      end
+
+      # Returns the md object in associated project or throws error if not present
+      #
+      # @return [GoodData::MdObject] md object that is represented in the blueprint
+      def in_project(project)
+        GoodData::MdObject[id, project: project, client: project.client]
+      end
+
+      def method_missing(method_sym, *arguments, &block)
+        if @data.key?(method_sym)
+          @data[method_sym]
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        if @data.key?(method_name)
+          true
+        else
+          super
+        end
+      end
+
+      def title
+        @data[:title] || GoodData::Helpers.titleize(@data[:id])
+      end
+
+      # Validates the fields in the field
+      #
+      # @return [Array] returns list of the errors represented by hash structures
+      def validate
+        []
+      end
+
+      def ==(other)
+        return false unless other.respond_to?(:data)
+        @data == other.data
+      end
+
+      private
+
+      def validate_presence_of(*fields)
+        fields.reduce([]) do |a, e|
+          data.key?(e) && !data[e].blank? ? a : a + [e]
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/models/blueprint/dashboard_builder.rb

@@ -0,0 +1,30 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2017 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
+  module Model
+    class DashboardBuilder
+      def initialize(title)
+        @title = title
+        @tabs = []
+      end
+
+      def add_tab(tab, &block)
+        tb = TabBuilder.new(tab)
+        block.call(tb)
+        @tabs << tb
+        tb
+      end
+
+      def to_hash
+        {
+          :name => @name,
+          :tabs => @tabs.map(&:to_hash)
+        }
+      end
+    end
+  end
+end

data/lib/gooddata/models/blueprint/dataset_blueprint.rb

@@ -0,0 +1,455 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2017 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 'schema_builder'
+require_relative 'schema_blueprint'
+
+module GoodData
+  module Model
+    class DatasetBlueprint < SchemaBlueprint
+      # Checks if a dataset has an anchor.
+      #
+      # @param dataset [Hash] Dataset blueprint
+      # @return [Boolean] returns true if dataset has an anchor
+      def self.anchor?(dataset)
+        columns(dataset).any? { |c| c[:type].to_s == 'anchor' }
+      end
+
+      # Returns anchor of a dataset
+      #
+      # @param dataset [Hash] Dataset blueprint
+      # @return [Hash] returns the anchor or nil
+      def self.anchor(dataset)
+        find_column_by_type(dataset, :anchor)
+      end
+
+      # Returns attributes of a dataset
+      #
+      # @param dataset [Hash] Dataset blueprint
+      # @return [Array<Hash>] returns the attribute or an empty array
+      def self.attributes(dataset)
+        find_columns_by_type(dataset, :attribute, :all)
+      end
+
+      # Returns attributes and anchor defined on a dataset
+      #
+      # @param dataset [Hash] Dataset blueprint
+      # @return [Array<Hash>] returns the attributes
+      def self.attributes_and_anchors(dataset)
+        [anchor(dataset)] + attributes(dataset)
+      end
+
+      # Returns all labels that is referenced by a label
+      #
+      # @param dataset [Hash] Dataset blueprint
+      # @return [Array<Hash>] returns the labels or an empty array
+      def self.attribute_for_label(dataset, label)
+        find_columns_by_type(dataset, :attribute, :anchor).find { |a| label[:reference] == a[:id] }
+      end
+
+      # Returns all the fields of a dataset. This means facts, attributes, references
+      #
+      # @param ds [Hash] Dataset blueprint
+      # @return [Boolean]
+      def self.columns(ds)
+        (ds.to_hash[:columns] || [])
+      end
+      singleton_class.send(:alias_method, :fields, :columns)
+
+      # Tells you if the object is a dataset. It consumes both Hash represenation
+      # or the GoodData::Model::DatasetBlueprint
+      #
+      # @param ds [Object] Value to be tested
+      # @return [Boolean]
+      def self.dataset_blueprint?(ds)
+        if ds.is_a?(DatasetBlueprint)
+          true
+        elsif ds.respond_to?(:[]) && ds.is_a?(Hash) && ds[:type].to_sym == :dataset
+          true
+        else
+          false
+        end
+      end
+
+      # Returns date facts of a dataset
+      #
+      # @param dataset [Hash] Dataset blueprint
+      # @return [Array<Hash>] returns the attribute or an empty array
+      def self.date_facts(dataset)
+        find_column_by_type(dataset, :date_fact)
+      end
+
+      # Returns label that is marked as default for a particular attribtue.
+      # This does not necessarily need to be the first one. This is a default label
+      # in terms of what is displayed on the UI
+      #
+      # @param dataset [Hash] Dataset blueprint
+      # @return [Array<Hash>] returns the labels or an empty array
+      def self.default_label_for_attribute(dataset, attribute)
+        default_label = labels_for_attribute(dataset, attribute).find { |l| l[:default_label] == true }
+        default_label
+      end
+
+      # Returns facts of a dataset
+      #
+      # @param dataset [Hash] Dataset blueprint
+      # @return [Array<Hash>] returns the attribute or an empty array
+      def self.facts(dataset)
+        find_columns_by_type(dataset, :fact, :date_fact)
+      end
+
+      # Finds a specific column given a name
+      #
+      # @param dataset [Hash] Dataset blueprint
+      # @param name [String] Name of a field
+      # @param all [Symbol] if :all is passed all mathching objects are returned
+      # Otherwise only the first one is
+      # @return [Array<Hash>] matching fields
+      def self.find_column_by_id(dataset, name, all = nil)
+        if all == :all
+          columns(dataset).select { |c| c[:id].to_s == name }
+        else
+          columns(dataset).find { |c| c[:id].to_s == name }
+        end
+      end
+
+      # Returns first field of a specified type.
+      #
+      # @param dataset [Hash | GoodData::Model::ProjectBlueprint] Dataset blueprint
+      # @param types [String | Symbol | Array[Symbol] | Array[String]] Type or types you would like to get
+      # as third parameter it return all object otherwise it returns the first one
+      # @return [Array<Hash>] matching fields
+      def self.find_column_by_type(dataset, *types)
+        columns(dataset).find { |c| types.any? { |t| t.to_s == c[:type].to_s } }
+      end
+
+      # Returns all the fields of a specified type. You can specify more types
+      # if you need more than one type.
+      #
+      # @param dataset [Hash | GoodData::Model::ProjectBlueprint] Dataset blueprint
+      # @param types [String | Symbol | Array[Symmbol] | Array[String]] Type or types you would like to get
+      # @return [Array<Hash>] matching fields
+      def self.find_columns_by_type(dataset, *types)
+        columns(dataset).select { |c| types.any? { |t| t.to_s == c[:type].to_s } }
+      end
+
+      # Returns labels facts of a dataset
+      #
+      # @param dataset [Hash] Dataset blueprint
+      # @return [Array<Hash>] returns the label or an empty array
+      def self.labels(dataset)
+        find_columns_by_type(dataset, :label)
+      end
+
+      def self.reference_label_for_attribtue(dataset, attribute)
+        labels = labels_for_attribute(dataset, attribute)
+        labels.find { |label| label[:reference_label] == true } || labels.first
+      end
+
+      # Returns labels for a particular attribute
+      #
+      # @param dataset [Hash] Dataset blueprint
+      # @param attribute [Hash] Attribute
+      # @return [Array<Hash>] returns the labels or an empty array
+      def self.labels_for_attribute(dataset, attribute)
+        labels(dataset).select { |l| l[:reference] == attribute[:id] }
+      end
+
+      # Returns references of a dataset
+      #
+      # @param dataset [Hash] Dataset blueprint
+      # @return [Array<Hash>] returns the references or an empty array
+      def self.references(dataset)
+        find_columns_by_type(dataset, :reference, :date)
+      end
+
+      # Returns anchor of a dataset
+      #
+      # @return [Hash] returns the anchor or nil
+      def anchor
+        find_column_by_type(:anchor)
+      end
+
+      # Checks if a dataset has an anchor.
+      #
+      # @return [Boolean] returns true if dataset has an anchor
+      def anchor?
+        columns.any? { |c| c.type == :anchor }
+      end
+
+      # Returns attributes of a dataset
+      #
+      # @return [Array<Hash>] returns the attribute or an empty array
+      def attributes(id = :all)
+        return id if id.is_a?(AttributeBlueprintField)
+        ats = find_columns_by_type(:attribute)
+        id == :all ? ats : ats.find { |a| a.id == id }
+      end
+
+      # Returns attributes and anchor defined on a dataset
+      #
+      # @return [Array<GoodData::Model::DatasetBlueprint>] returns the attributes
+      def attributes_and_anchors
+        attributes + [anchor]
+      end
+
+      # Changes the dataset through a builder. You provide a block and an istance of
+      # GoodData::Model::SchemaBuilder is passed in as the only parameter
+      #
+      # @return [GoodData::Model::SchemaBlueprint] returns changed dataset blueprint
+      def change(&block)
+        builder = SchemaBuilder.create_from_data(self)
+        block.call(builder)
+        @data = builder.to_hash
+        self
+      end
+
+      # Returns all the fields of a dataset. This means anchor, facts, attributes, references
+      # This method will cast them to correct types
+      #
+      # @return [Boolean]
+      def columns
+        DatasetBlueprint.columns(to_hash).map do |c|
+          case c[:type].to_sym
+          when :anchor
+            GoodData::Model::AnchorBlueprintField.new(c, self)
+          when :attribute
+            GoodData::Model::AttributeBlueprintField.new(c, self)
+          when :fact
+            GoodData::Model::FactBlueprintField.new(c, self)
+          when :label
+            GoodData::Model::LabelBlueprintField.new(c, self)
+          when :reference
+            GoodData::Model::ReferenceBlueprintField.new(c, self)
+          when :date
+            GoodData::Model::ReferenceBlueprintField.new(c, self)
+          else
+            GoodData::Model::BlueprintField.new(c, self)
+          end
+        end
+      end
+      alias_method :fields, :columns
+
+      # Creates a metric which counts numnber of lines in dataset. Works for both
+      # datasets with or without anchor
+      #
+      # @return [Boolean]
+      def count(project)
+        anchor.in_project(project).create_metric.execute
+      end
+
+      # Returns date facts of a dataset
+      #
+      # @return [Array<Hash>] returns the attribute or an empty array
+      def date_facts
+        find_columns_by_type(:date_fact)
+      end
+
+      # Duplicates the DatasetBlueprint. It is done as a deep duplicate
+      #
+      # @return [GoodData::Model::DatasetBlueprint] matching fields
+      def dup
+        DatasetBlueprint.new(GoodData::Helpers.deep_dup(data), project_blueprint)
+      end
+
+      # Returns facts of a dataset
+      #
+      # @return [Array<Hash>] returns the attribute or an empty array
+      def facts(id = :all)
+        return id if id.is_a?(FactBlueprintField)
+        fs = find_columns_by_type(:fact)
+        id == :all ? fs : fs.find { |a| a.id == id }
+      end
+
+      # Finds a specific column given a col
+      #
+      # @param col [GoodData::Model::BlueprintField | Hash] Field
+      # @return [GoodData::Model::BlueprintField] matching fields
+      def find_column(col)
+        columns.find { |c| c == col }
+      end
+
+      # Finds a specific column given an id
+      #
+      # @param id [String] Id of a field
+      # @param all [Symbol] if :all is passed all mathching objects are returned
+      # Otherwise only the first one is
+      # @return [Array<Hash>] matching fields
+      def find_column_by_id(id)
+        id = id.respond_to?(:id) ? id.id : id
+        columns.find { |c| c.id == id }
+      end
+
+      # Returns first field of a specified type.
+      #
+      # @param type [String | Symbol | Array[Symmbol] | Array[String]] Type or types you would like to get
+      # @return [GoodData::Model::BlueprintField] returns matching field
+      def find_column_by_type(*types)
+        columns.find { |c| types.any? { |t| t.downcase.to_sym == c.type } }
+      end
+
+      # Returns all the fields of a specified type. You can specify more types
+      # as an array if you need more than one type.
+      #
+      # @param type [String | Symbol | Array[Symmbol] | Array[String]] Type or types you would like to get
+      # as third parameter it return all object otherwise it returns the first one
+      # @return [Array<GoodData::Model::BlueprintField>] matching fields
+      def find_columns_by_type(*types)
+        columns.select { |c| types.any? { |t| t.downcase.to_sym == c.type } }
+      end
+
+      # Creates a DatasetBlueprint
+      #
+      # @param dataset [Hash] Dataset blueprint
+      # @return [DatasetBlueprint] returns the labels or an empty array
+      def initialize(init_data, blueprint)
+        super
+        @data[:type] = @data.key?('type') ? @data['type'].to_sym : @data[:type]
+        @data[:columns].each do |c|
+          c[:type] = c[:type].to_sym
+        end
+      end
+
+      # Returns labels facts of a dataset
+      #
+      # @param dataset [Hash] Dataset blueprint
+      # @return [Array<Hash>] returns the label or an empty array
+      def labels(id = :all)
+        return id if id.is_a?(LabelBlueprintField)
+        labs = find_columns_by_type(:label)
+        id == :all ? labs : labs.find { |l| l.id == id }
+      end
+
+      def attribute_for_label(label)
+        l = labels(label)
+        attributes_and_anchors.find { |a| a.id == l.reference }
+      end
+
+      def labels_for_attribute(attribute)
+        a = attributes(attribute)
+        labels.select { |l| l.reference == a.id }
+      end
+
+      # Merges two schemas together. This method changes the blueprint
+      # in place. If you would prefer the method that generates a new blueprint
+      # use merge method
+      #
+      # @param a_blueprint [GoodData::Model::DatasetBlueprint] Dataset blueprint to be merged
+      # @return [GoodData::Model::DatasetBlueprint] returns itself changed
+      def merge!(a_blueprint)
+        new_blueprint = GoodData::Model.merge_dataset_columns(self, a_blueprint)
+        @data = new_blueprint
+        self
+      end
+
+      # Returns references of a dataset
+      #
+      # @return [Array<Hash>] returns the references or an empty array
+      def references
+        find_columns_by_type(:reference, :date)
+      end
+
+      # Removes column from from the blueprint
+      #
+      # @param id [String] Id of the column to be removed
+      # @return [GoodData::Model::ProjectBlueprint] Returns changed blueprint
+      def remove_column!(id)
+        @project_blueprint.remove_column!(self, id)
+      end
+
+      # Removes all the labels from the anchor. This is a typical operation that people want to perform
+      #
+      # @return [GoodData::Model::ProjectBlueprint] Returns changed blueprint
+      def strip_anchor!
+        @project_blueprint.strip_anchor!(self)
+      end
+
+      # Method for suggest a couple of metrics that might get you started
+      # Idea is that we will provide couple of strategies. Currently the metrics
+      # are created in the random way but they should work.
+      #
+      # @return [Array<GoodData::Metric>] matching fields
+      def suggest_metrics
+        identifiers = facts.map { |f| identifier_for(f) }
+        identifiers.zip(facts).map do |id, fact|
+          Metric.xcreate(
+            :title => GoodData::Helpers.titleize(fact[:name]),
+            :expression => "SELECT SUM(![#{id}])"
+          )
+        end
+      end
+
+      alias_method :suggest_measures, :suggest_metrics
+
+      def to_blueprint
+        GoodData::Model::ProjectBlueprint.new(datasets: [to_hash])
+      end
+
+      # Validate the blueprint return array of errors that are found.
+      #
+      # @return [Array] array of errors
+      def validate
+        errors = []
+        errors.concat(validate_more_anchors)
+        errors.concat(validate_some_anchors)
+        errors.concat(validate_label_references)
+        errors.concat(validate_gd_data_type_errors)
+        errors.concat(fields.flat_map(&:validate))
+        errors.concat(validate_attribute_has_one_label)
+        errors
+      end
+
+      # Validate if the dataset has more than zero anchors defined.
+      #
+      # @return [Array] array of errors
+      def validate_some_anchors
+        find_columns_by_type(:anchor).count.zero? ? [{ type: :no_anchor, dataset: id }] : []
+      end
+
+      # Validate if the dataset does not have more than one anchor defined.
+      #
+      # @return [Array] array of errors
+      def validate_more_anchors
+        find_columns_by_type(:anchor).count > 1 ? [{ type: :more_than_on_anchor, dataset: id }] : []
+      end
+
+      # Validate if the attribute does have at least one label
+      #
+      # @return [Array] array of errors
+      def validate_attribute_has_one_label
+        find_columns_by_type(:attribute)
+          .select { |a| a.labels.empty? }
+          .map { |e| { type: :attribute_without_label, attribute: e.id } }
+      end
+
+      # Validate the that any labels are pointing to the existing attribute. If not returns the list of errors. Currently just violating labels.
+      #
+      # @return [Array] array of errors
+      def validate_label_references
+        labels.select { |r| r.attribute.nil? }
+          .map { |er_ref| { type: :wrong_label_reference, label: er_ref.id, wrong_reference: er_ref.data[:reference] } }
+      end
+
+      # Validate the the used gd_data_types are one of the allowed types. The data types are checked on lables and facts.
+      #
+      # @return [Array] array of errors
+      def validate_gd_data_type_errors
+        (labels + facts)
+          .select { |x| x.gd_data_type && !GoodData::Model.check_gd_data_type(x.gd_data_type) }
+          .map { |e| { :error => :invalid_gd_data_type_specified, :column => e.id } }
+      end
+
+      # Helper methods to decide wheather the dataset is considered wide.
+      # Currently the wider datasets have both performance and usability
+      # penalty
+      #
+      # @return [Boolean] matching fields
+      def wide?
+        fields.count > 32
+      end
+    end
+  end
+end