gooddata 1.0.2-java → 1.1.0-java

data/lib/gooddata/lcm/lcm2.rb

@@ -13,28 +13,35 @@ require_relative 'helpers/helpers'
 module GoodData
   module LCM2
     class SmartHash < Hash
+      @specification = nil
       def method_missing(name, *_args)
-        key = name.to_s.downcase.to_sym
+        data(name)
+      end
 
-        value = nil
-        keys.each do |k|
-          if k.to_s.downcase.to_sym == key
-            value = self[k]
-            break
-          end
-        end
+      def [](variable)
+        data(variable)
+      end
 
-        if value
-          value
-        else
-          begin
-            super
-          rescue
-            nil
-          end
+      def clear_filters
+        @specification = nil
+      end
+
+      def setup_filters(filter)
+        @specification = filter.to_hash
+      end
+
+      def check_specification(variable)
+        if @specification && !@specification[variable.to_sym] && !@specification[variable.to_s] \
+                          && !@specification[variable.to_s.downcase.to_sym] && !@specification[variable.to_s.downcase]
+          fail "Param #{variable} is not defined in the specification"
         end
       end
 
+      def data(variable)
+        check_specification(variable)
+        fetch(keys.find { |k| k.to_s.downcase.to_sym == variable.to_s.downcase.to_sym }, nil)
+      end
+
       def key?(key)
         return true if super
 
@@ -308,12 +315,7 @@ module GoodData
 
           # Invoke action
           begin
-            GoodData.logger.info("Running #{action.name} action ...")
-
-            # Check if all required parameters were passed
-            BaseAction.check_params(action.const_get('PARAMS'), params)
-
-            out = action.send(:call, params)
+            out = run_action action, params
           rescue => e
             errors << {
               action: action,
@@ -357,6 +359,17 @@ module GoodData
         }
       end
 
+      def run_action(action, params)
+        GoodData.logger.info("Running #{action.name} action ...")
+        params.clear_filters
+        # Check if all required parameters were passed
+        BaseAction.check_params(action.const_get('PARAMS'), params)
+        params.setup_filters(action.const_get('PARAMS'))
+        out = action.send(:call, params)
+        params.clear_filters
+        out
+      end
+
       def check_unused_params(actions, params)
         default_params = [
           :client_gdc_hostname,

data/lib/gooddata/lcm/types/class/gd_logger.rb

@@ -0,0 +1,23 @@
+# 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 '../base_type'
+
+require_relative 'class'
+
+module GoodData
+  module LCM2
+    module Type
+      class GdLogger < ClassType
+        CATEGORY = :class
+
+        def check(value)
+          value.class == Logger
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/lcm/types/class/gd_product.rb

@@ -0,0 +1,23 @@
+# 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 '../base_type'
+
+require_relative 'class'
+
+module GoodData
+  module LCM2
+    module Type
+      class GDDataProductType < ClassType
+        CATEGORY = :class
+
+        def check(value)
+          value.class == GoodData::DataProduct
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/lcm/types/class/gd_project.rb

@@ -0,0 +1,23 @@
+# 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 '../base_type'
+
+require_relative 'class'
+
+module GoodData
+  module LCM2
+    module Type
+      class GdProjectType < ClassType
+        CATEGORY = :class
+
+        def check(value)
+          value.class == GoodData::Project
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/lcm/types/class/smart_hash.rb

@@ -0,0 +1,23 @@
+# 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 '../base_type'
+
+require_relative 'class'
+
+module GoodData
+  module LCM2
+    module Type
+      class GdSmartHashType < ClassType
+        CATEGORY = :class
+
+        def check(value)
+          value.class == GoodData::LCM2::SmartHash
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/lcm/types/complex/segment.rb

@@ -22,7 +22,7 @@ module GoodData
           param :development_pid, instance_of(Type::StringType), required: true
 
           description 'Storage Driver'
-          param :driver, instance_of(Type::StringType), required: true # required: false, , default: 'pg'
+          param :driver, instance_of(Type::StringType), required: false, default: 'pg'
 
           description 'Master Project Name'
           param :master_name, instance_of(Type::StringType), required: true

data/lib/gooddata/lcm/types/scalar/integer.rb

@@ -13,8 +13,8 @@ module GoodData
         CATEGORY = :scalar
         INTERNAL_TYPE = Integer
 
-        def check(_value)
-          true
+        def check(value)
+          value.is_number?
         end
       end
     end

data/lib/gooddata/lcm/types/special/any.rb

@@ -0,0 +1,18 @@
+# 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 LCM2
+    module Type
+      class AnyType
+        CATEGORY = :special
+        def check(_)
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -98,7 +98,7 @@ module GoodData
       # @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)
+        find_columns_by_type(dataset, :fact, :date_fact, :hll)
       end
 
       # Finds a specific column given a name

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

@@ -36,9 +36,7 @@ module GoodData
         case c[:type].to_sym
         when :label
           label_to_manifest(project, dataset, c, mode)
-        when :fact
-          fact_to_manifest(project, dataset, c, mode)
-        when :date_fact
+        when :fact, :date_fact, :hll
           fact_to_manifest(project, dataset, c, mode)
         when :reference
           reference_to_manifest(project, dataset, c, mode)

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

@@ -129,7 +129,8 @@ module GoodData
             identifier: fact[:id],
             title: GoodData::Model.title(fact),
             folder: fact[:folder] || dataset[:folder] || GoodData::Model.title(dataset),
-            dataType: GoodData::Model.normalize_gd_data_type(fact[:gd_data_type]) || DEFAULT_FACT_DATATYPE
+            dataType: GoodData::Model.normalize_gd_data_type(fact[:gd_data_type]) || DEFAULT_FACT_DATATYPE,
+            type: fact[:type]
           }
         }
         payload.tap do |p|

data/lib/gooddata/models/from_wire.rb

@@ -120,7 +120,7 @@ module GoodData
         facts = stuff['dataset']['facts'] || []
         facts.map do |fact|
           {}.tap do |f|
-            f[:type] = fact['fact']['identifier'] =~ /^dt\./ ? :date_fact : :fact
+            f[:type] = resolve_fact_type(fact)
             f[:id] = fact['fact']['identifier']
             f[:title] = fact['fact']['title']
             f[:description] = fact['fact']['description'] if fact['fact']['description']
@@ -168,6 +168,18 @@ module GoodData
           end
         end
       end
+
+      private
+
+      def self.resolve_fact_type(fact)
+        if fact['fact']['type'].to_s.downcase == 'hll'
+          :hll
+        elsif fact['fact']['identifier'] =~ /^dt\./
+          :date_fact
+        else
+          :fact
+        end
+      end
     end
   end
 end

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

@@ -26,6 +26,28 @@ module GoodData
       def all(options = { :client => GoodData.connection, :project => GoodData.project })
         query('folder', Folder, options)
       end
+
+      def create(opts)
+        title = opts[:title]
+        summary = opts[:summary] || ''
+        type = opts[:type] || 'fact'
+
+        folder = {
+          'folder' => {
+            'content' => {
+              'type' => Array(type)
+            },
+            'meta' => {
+              'tags' => '',
+              'summary' => summary,
+              'title' => title
+            }
+          }
+        }
+
+        client, project = GoodData.get_client_and_project(opts)
+        client.create(Folder, folder, project: project)
+      end
     end
 
     def entries

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

@@ -13,6 +13,11 @@ module GoodData
   # Metric representation
   class Metric < MdObject
     include Mixin::Lockable
+    extend GoodData::Mixin::ContentPropertyReader
+    extend GoodData::Mixin::ContentPropertyWriter
+
+    content_property_reader :folders, :expression
+    content_property_writer :folders, :expression
 
     class << self
       # Method intended to get all objects of that type in a specified project
@@ -125,14 +130,6 @@ module GoodData
       res.data[0][0] if res && !res.empty?
     end
 
-    def expression
-      content['expression']
-    end
-
-    def expression=(value)
-      content['expression'] = value
-    end
-
     def validate
       fail 'Metric needs to have title' if title.nil?
       true

data/lib/gooddata/models/model.rb

@@ -86,7 +86,7 @@ module GoodData
       'GDC.time.day_us_noleading', # M/d/yy
     ]
 
-    GD_DATA_TYPES = ['BIGINT', 'DOUBLE', 'INTEGER', 'INT', /^VARCHAR\(([1-9]\d{0,3}|10000)\)$/i, /^DECIMAL\(\d{1,3},\s*\d{1,3}\)$/i]
+    GD_DATA_TYPES = ['BIGINT', 'DOUBLE', 'INTEGER', 'INT', 'HLL', /^VARCHAR\(([1-9]\d{0,3}|10000)\)$/i, /^DECIMAL\(\d{1,3},\s*\d{1,3}\)$/i]
 
     DEFAULT_FACT_DATATYPE = 'DECIMAL(12,2)'
     DEFAULT_ATTRIBUTE_DATATYPE = 'VARCHAR(128)'

data/lib/gooddata/models/process.rb

@@ -90,16 +90,23 @@ module GoodData
       # @option options [String] :name Readable name of the process
       # @option options [String] :process_id ID of a process to be redeployed (do not set if you want to create a new process)
       # @option options [Boolean] :verbose (false) Switch on verbose mode for detailed logging
-      def deploy(path, options = { :client => GoodData.client, :project => GoodData.project })
-        return deploy_brick(path, options) if path.to_s.start_with?(APP_STORE_URL)
-
-        return deploy_from_appstore(path.to_s, options) if (path.to_s =~ %r{\${.*}:(.*)\/(.*):\/}) == 0 # rubocop:disable Style/NumericPredicate
+      def deploy(path, options = { client: GoodData.client, project: GoodData.project })
+        if path.is_a?(Hash) && path[:component]
+          deploy_component path, options
+        elsif path.to_s.start_with?(APP_STORE_URL)
+          deploy_brick path, options
+        elsif path.to_s =~ %r{\${.*}:(.*)\/(.*):\/}
+          deploy_from_appstore path.to_s, options
+        else
+          deploy_simple_process path, options
+        end
+      end
 
+      def deploy_simple_process(path, options = { client: GoodData.client, project: GoodData.project })
         client, project = GoodData.get_client_and_project(options)
 
         path = Pathname(path) || fail('Path is not specified')
         files_to_exclude = options[:files_to_exclude].nil? ? [] : options[:files_to_exclude].map { |pname| Pathname(pname) }
-        process_id = options[:process_id]
 
         type = options[:type] || 'GRAPH'
         deploy_name = options[:name]
@@ -117,21 +124,7 @@ module GoodData
           }
         }
 
-        res = if process_id.nil?
-                client.post("/gdc/projects/#{project.pid}/dataload/processes", data)
-              else
-                client.put("/gdc/projects/#{project.pid}/dataload/processes/#{process_id}", data)
-              end
-
-        File.delete(deployed_path) if File.exist?(deployed_path)
-
-        if res['asyncTask']
-          res = client.poll_on_response(res['asyncTask']['links']['poll']) { |body| body['asyncTask'] }
-        end
-
-        process = client.create(Process, res, project: project)
-        puts HighLine.color("Deploy DONE #{path}", HighLine::GREEN) if verbose
-        process
+        save(data, options)
       end
 
       def deploy_brick(path, options = { :client => GoodData.client, :project => GoodData.project })
@@ -173,16 +166,12 @@ module GoodData
       end
 
       def deploy_from_appstore(path, options = { :client => GoodData.client, :project => GoodData.project })
-        client, project = GoodData.get_client_and_project(options)
-
         deploy_name = options[:name]
         fail ArgumentError, 'options[:name] can not be nil or empty!' if deploy_name.nil? || deploy_name.empty?
 
         verbose = options[:verbose] || false
         puts HighLine.color("Deploying #{path}", HighLine::BOLD) if verbose
 
-        process_id = options[:process_id]
-
         data = {
           process: {
             name: deploy_name,
@@ -191,26 +180,43 @@ module GoodData
           }
         }
 
+        save(data, options)
+      end
+
+      def deploy_component(data, options = { client: GoodData.client, project: GoodData.project })
+        client, project = GoodData.get_client_and_project(options)
+        data = { process: data } unless data[:process]
+        data[:process] = GoodData::Helpers.symbolize_keys(data[:process]).select { |k| [:type, :name, :component].include? k }
+        data[:process][:component] = GoodData::Helpers.symbolize_keys(data[:process][:component]).select { |k| [:name, :version].include? k }
+
+        # a feature flag is required to create component type processes
+        client.post "/gdc/projects/#{project.pid}/projectFeatureFlags",
+                    featureFlag: {
+                      key: 'enableEtlComponent',
+                      value: true
+                    }
+
+        save(data, options)
+      end
+
+      private
+
+      def save(data, options = { client: GoodData.client, project: GoodData.project })
+        client, project = GoodData.get_client_and_project(options)
+        process_id = data[:process_id]
         res =
           if process_id.nil?
             client.post("/gdc/projects/#{project.pid}/dataload/processes", data)
-
           else
             client.put("/gdc/projects/#{project.pid}/dataload/processes/#{process_id}", data)
-
           end
-
         if res.keys.first == 'asyncTask'
           res = JSON.parse(client.poll_on_code(res['asyncTask']['links']['poll'], options.merge(process: false)))
         end
 
-        process = client.create(Process, res, project: project)
-        puts HighLine.color("Deploy DONE #{path}", HighLine::GREEN) if verbose
-        process
+        client.create(Process, res, project: project)
       end
 
-      private
-
       def with_zip(opts = {})
         client = opts[:client]
         temp = Tempfile.new(['deploy-graph-archive', '.zip'])
@@ -326,6 +332,10 @@ module GoodData
       process['path']
     end
 
+    def component
+      process['component']
+    end
+
     def schedules
       project.schedules.select { |schedule| schedule.process_id == obj_id }
     end