gooddata 0.6.49 → 0.6.50

data/lib/gooddata/lcm/actions/ensure_release_table.rb

@@ -0,0 +1,56 @@
+# 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_action'
+
+module GoodData
+  module LCM2
+    class EnsureReleaseTable < BaseAction
+      DESCRIPTION = 'Ensures presence of LCM_RELEASE table'
+
+      PARAMS = define_params(self) do
+        description 'ADS Client'
+        param :ads_client, instance_of(Type::AdsClientType), required: true
+
+        description 'Table Name'
+        param :release_table_name, instance_of(Type::StringType), required: false
+      end
+
+      RESULT_HEADER = [
+        :table_name,
+        :status
+      ]
+
+      DEFAULT_TABLE_NAME = 'LCM_RELEASE'
+
+      class << self
+        def call(params)
+          # Check if all required parameters were passed
+          BaseAction.check_params(PARAMS, params)
+
+          replacements = {
+            table_name: params.release_table_name || DEFAULT_TABLE_NAME
+          }
+
+          path = File.expand_path('../../data/create_lcm_release.sql.erb', __FILE__)
+          query = GoodData::Helpers::ErbHelper.template_file(path, replacements)
+
+          sql_result = params.ads_client.execute(query)
+
+          # TODO: Format
+          GoodData.logger.info(JSON.pretty_generate(sql_result))
+
+          [
+            {
+              table_name: replacements[:table_name],
+              status: 'ok'
+            }
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/lcm/actions/ensure_segments.rb

@@ -0,0 +1,35 @@
+# 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_action'
+
+module GoodData
+  module LCM2
+    class EnsureSegments < BaseAction
+      DESCRIPTION = 'Ensure Segments Exist (LCM API)'
+
+      PARAMS = define_params(self) do
+        description 'Client Used for Connecting to GD'
+        param :gd_client, instance_of(Type::GdClientType), required: true
+
+        description 'Segments to manage'
+        param :segments, array_of(instance_of(Type::SegmentType)), required: true
+      end
+
+      class << self
+        def call(params)
+          # Check if all required parameters were passed
+          BaseAction.check_params(PARAMS, params)
+
+          results = []
+
+          # Return results
+          results
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/lcm/actions/ensure_technical_users_domain.rb

@@ -0,0 +1,66 @@
+# 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_action'
+
+module GoodData
+  module LCM2
+    class EnsureTechnicalUsersDomain < BaseAction
+      DESCRIPTION = 'Ensure Technical Users in Domain'
+
+      PARAMS = define_params(self) do
+        description 'Client Used for Connecting to GD'
+        param :gdc_gd_client, instance_of(Type::GdClientType), required: true
+
+        description 'Organization Name'
+        param :organization, instance_of(Type::StringType), required: true
+      end
+
+      RESULT_HEADER = [
+        :login,
+        :email,
+        :domain,
+        :status
+      ]
+
+      class << self
+        def call(params)
+          # Check if all required parameters were passed
+          BaseAction.check_params(PARAMS, params)
+
+          client = params.gdc_gd_client
+
+          domain_name = params.organization || params.domain
+          domain = client.domain(domain_name) || fail("Invalid domain name specified - #{domain_name}")
+
+          technical_users = params.technical_user || []
+          technical_users.map do |technical_user|
+            domain_user = domain.users.find do |du|
+              du.login == technical_user
+            end
+
+            if domain_user
+              {
+                login: domain_user.login,
+                email: domain_user.email,
+                domain: domain_name,
+                status: 'exists'
+              }
+            else
+              user = domain.add_user(login: technical_user, email: technical_user)
+              {
+                login: user.login,
+                email: user.email,
+                domain: domain_name,
+                status: 'added'
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/lcm/actions/ensure_technical_users_project.rb

@@ -0,0 +1,68 @@
+# 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_action'
+
+module GoodData
+  module LCM2
+    class EnsureTechnicalUsersProject < BaseAction
+      DESCRIPTION = 'Ensure Technical Users in Project'
+
+      PARAMS = define_params(self) do
+        description 'Client Used for Connecting to GD'
+        param :gdc_gd_client, instance_of(Type::GdClientType), required: true
+      end
+
+      RESULT_HEADER = [
+        :project,
+        :pid,
+        :login,
+        :role,
+        :result,
+        :message,
+        :url
+      ]
+
+      class << self
+        def call(params)
+          # Check if all required parameters were passed
+          BaseAction.check_params(PARAMS, params)
+
+          client = params.gdc_gd_client
+
+          technical_users = params.technical_user || []
+          new_users = technical_users.map do |technical_user|
+            {
+              login: technical_user,
+              role: 'admin'
+            }
+          end
+
+          results = params.synchronize.map do |synchronize_info|
+            synchronize_info[:to].map do |entry|
+              project = client.projects(entry[:pid])
+              res = project.create_users(new_users)
+
+              new_users.zip(res).map do |f, s|
+                {
+                  project: project.title,
+                  pid: project.pid,
+                  login: f[:login],
+                  role: f[:role],
+                  result: s[:type],
+                  message: s[:message],
+                  url: s[:user]
+                }
+              end
+            end
+          end
+
+          results.flatten
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/lcm/actions/ensure_titles.rb

@@ -0,0 +1,54 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2016 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_action'
+
+module GoodData
+  module LCM2
+    class EnsureTitles < BaseAction
+      DESCRIPTION = 'Ensure Project Titles - Based On Input Source Data'
+
+      PARAMS = define_params(self) do
+        description 'Client Used for Connecting to GD'
+        param :gdc_gd_client, instance_of(Type::GdClientType), required: true
+      end
+
+      class << self
+        def call(params)
+          # Check if all required parameters were passed
+          BaseAction.check_params(PARAMS, params)
+
+          client = params.gdc_gd_client
+
+          domain_name = params.organization || params.domain
+          domain = client.domain(domain_name) || fail("Invalid domain name specified - #{domain_name}")
+
+          domain_segments = {}
+          domain.segments.each do |segment|
+            domain_segments[segment.segment_id] = {}
+            segment.clients.each do |segment_client|
+              domain_segments[segment.segment_id][segment_client.client_id] = segment_client.project
+            end
+          end
+
+          params.clients.map do |segment_client|
+            segment_id = segment_client.segment
+            client_id  = segment_client.id
+            project = domain_segments[segment_id][client_id]
+            project.title = segment_client[:project_title]
+            project.save
+
+            {
+              segment: segment_id,
+              client: client_id,
+              title: project.title
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/lcm/actions/hello_world.rb

@@ -0,0 +1,44 @@
+# 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_action'
+
+module GoodData
+  module LCM2
+    class HelloWorld < BaseAction
+      DESCRIPTION = 'Print Hello World Message'
+
+      PARAMS = define_params(self) do
+        description 'Message to be printed'
+        param :message, instance_of(Type::StringType), required: true
+
+        description 'Number of Iterations'
+        param :iterations, instance_of(Type::IntegerType), required: false, default: 1
+      end
+
+      class << self
+        def say(msg)
+          puts "#{name}#say - #{msg}"
+        end
+
+        def call(params)
+          # Check if all required parameters were passed
+          BaseAction.check_params(PARAMS, params)
+
+          say(params.message)
+
+          msg = {
+            message: params.message
+          }
+          results = [msg]
+
+          # Return results
+          results
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/lcm/actions/print_actions.rb

@@ -0,0 +1,61 @@
+# 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_action'
+
+module GoodData
+  module LCM2
+    class PrintActions < BaseAction
+      DESCRIPTION = 'Print Information About Actions'
+
+      PARAMS = {
+      }
+
+      class << self
+        def call(params)
+          # Check if all required parameters were passed
+          BaseAction.check_params(PARAMS, params)
+
+          results = []
+
+          actions = GoodData::LCM2::BaseAction.descendants
+
+          actions.each do |action|
+            action_params = action.const_get(:PARAMS)
+            action_params_keys = action_params.keys
+            params = action_params_keys.map do |param|
+              param
+            end
+
+            types = action_params.map do |_k, param|
+              param[:type].class.short_name
+            end
+
+            required = action_params.map do |_k, param|
+              param[:opts][:required]
+            end
+
+            defaults = action_params.map do |_k, param|
+              param[:opts][:default]
+            end
+
+            results << {
+              name: action.short_name,
+              description: action.const_get(:DESCRIPTION),
+              params: params.join("\n"),
+              types: types.join("\n"),
+              required: required.join("\n"),
+              default: defaults.join("\n")
+            }
+          end
+
+          # Return results
+          results
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/lcm/actions/print_modes.rb

@@ -0,0 +1,72 @@
+# 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_action'
+
+module GoodData
+  module LCM2
+    class PrintModes < BaseAction
+      DESCRIPTION = 'Print Modes'
+
+      PARAMS = {
+      }
+
+      class << self
+        def call(params)
+          # Check if all required parameters were passed
+          BaseAction.check_params(PARAMS, params)
+
+          results = []
+          GoodData::LCM2::MODES.keys.each_with_index do |mode, index|
+            actions = GoodData::LCM2::MODES[mode]
+            action_names = actions.map do |k, _action|
+              params_length = k.const_get(:PARAMS).keys.length
+              k.short_name + ("\n" * (params_length > 1 ? params_length - 1 : 0))
+            end
+
+            params = actions.map do |action|
+              action.const_get(:PARAMS).map do |_k, param|
+                param[:name]
+              end
+            end
+
+            types = actions.map do |action|
+              action.const_get(:PARAMS).map do |_k, param|
+                param[:type]
+                # param[:type].class.short_name
+              end
+            end
+
+            required = actions.map do |action|
+              action.const_get(:PARAMS).map do |_k, param|
+                param[:opts][:required]
+              end
+            end
+
+            defaults = actions.map do |action|
+              action.const_get(:PARAMS).map do |_k, param|
+                param[:opts][:default]
+              end
+            end
+
+            results << {
+              '#' => index,
+              mode: mode,
+              actions: action_names.join("\n"),
+              params: params.join("\n"),
+              types: types.join("\n"),
+              required: required.join("\n"),
+              default: defaults.join("\n")
+            }
+          end
+
+          # Return results
+          results
+        end
+      end
+    end
+  end
+end