gooddata 1.0.0-java

data/lib/gooddata/helpers/helpers.rb

@@ -0,0 +1,10 @@
+# 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.
+
+base = Pathname(__FILE__).dirname.expand_path
+Dir.glob(base + '*.rb').each do |file|
+  require_relative file
+end

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

@@ -0,0 +1,12 @@
+# 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/lcm/actions/apply_custom_maql.rb

@@ -0,0 +1,80 @@
+# 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
+    # Applies custom MAQL DDL to all client projects so customized
+    # labels and fiscal calendars are not deleted.
+    # To ease up further automation, the MAQL DDL may be
+    # stored in separate field in lcm_release
+    # table as we will need custom Release brick action which will populate it.
+    class ApplyCustomMaql < BaseAction
+      DESCRIPTION = 'Apply Custom MAQL DDL'
+
+      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
+
+        description 'Segments to manage'
+        param :segments, array_of(instance_of(Type::SegmentType)), required: true
+
+        description 'Should be custom MAQL DDL Applied'
+        param :apply_maql_ddl, instance_of(Type::BooleanType), required: false, default: false
+      end
+
+      RESULT_HEADER = [
+        :segment,
+        :maql,
+        :status
+      ]
+
+      class << self
+        def call(params)
+          return [] unless params.apply_maql_ddl.to_b
+
+          client = params.gdc_gd_client
+
+          domain_name = params.organization || params.domain
+          domain = client.domain(domain_name) || fail("Invalid domain name specified - #{domain_name}")
+          data_product = params.data_product
+
+          segment_ids = params.segments.map(&:segment_id)
+          domain_segments = domain.segments(:all, data_product).select do |ds|
+            segment_ids.include?(ds.segment_id)
+          end
+
+          res = []
+          domain_segments.peach do |ds|
+            maql = 'CREATE DATASET {dataset.quotes} VISUAL (TITLE "Stock Quotes Data");'
+
+            unless maql.empty?
+              ds.clients.peach do |dc|
+                project = dc.project
+
+                r = project.execute_maql(maql)
+
+                item = {
+                  segment: ds.segment_id,
+                  maql: maql,
+                  status: r
+                }
+
+                res.push(item)
+              end
+            end
+          end
+
+          res
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# 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 AssociateClients < BaseAction
+      DESCRIPTION = 'Associate LCM Clients'
+
+      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
+
+        description 'Delete Extra Clients'
+        param :delete_extra, instance_of(Type::BooleanType), required: false, default: false
+
+        description 'Physically Delete Client Projects'
+        param :delete_projects, instance_of(Type::BooleanType), required: false, default: false
+
+        description 'Clients'
+        param :clients, array_of(instance_of(Type::HashType)), required: true, generated: true
+
+        description 'Segments to provision'
+        param :segments_filter, array_of(instance_of(Type::StringType)), required: false
+      end
+
+      RESULT_HEADER = [
+        :id,
+        :status,
+        :originalProject,
+        :client,
+        :type
+      ]
+
+      class << self
+        def call(params)
+          client = params.gdc_gd_client
+
+          domain_name = params.organization || params.domain
+          domain = client.domain(domain_name) || fail("Invalid domain name specified - #{domain_name}")
+          data_product = params.data_product
+
+          segments = {}
+
+          params.clients.group_by { |data| data[:segment] }.each do |segment_name, clients|
+            segment = domain.segments(segment_name, data_product)
+            segments[segment_name] = segment
+            (clients.map(&:id) - segment.clients.map(&:id)).each do |c|
+              segment.create_client(id: c)
+            end
+          end
+
+          params.clients.map! do |data|
+            data[:data_product_id] = segments[data[:segment]].data_product.data_product_id
+            data
+          end
+
+          domain.update_clients_settings(params.clients)
+
+          delete_projects = GoodData::Helpers.to_boolean(params.delete_projects)
+          delete_extra = GoodData::Helpers.to_boolean(params.delete_extra)
+          options = { delete_projects: delete_projects }
+          options.merge!(delete_extra_option(params)) if delete_extra
+
+          domain.update_clients(params.clients, options)
+        end
+
+        private
+
+        def delete_extra_option(params)
+          if params.segments_filter && params.segments_filter.any?
+            { delete_extra_in_segments: params.segments_filter }
+          else
+            { delete_extra: GoodData::Helpers.to_boolean(params.delete_extra) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/lcm/actions/base_action.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 '../dsl/dsl'
+require_relative '../helpers/helpers'
+require_relative '../types/types'
+
+module GoodData
+  module LCM2
+    class BaseAction
+      class << self
+        include Dsl::Dsl
+
+        def check_params(specification, params)
+          Helpers.check_params(specification, params)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# 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 CollectComputedAttributeMetrics < BaseAction
+      DESCRIPTION = 'Collect all metrics which is used in computed attributes in development projects'
+
+      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)
+          results = []
+          development_client = params.development_client
+
+          synchronize = params.synchronize.pmap do |info|
+            from = info.from
+            from_project = development_client.projects(from) || fail("Invalid 'from' project specified - '#{from}'")
+
+            metric_uris = from_project.computed_attributes.flat_map { |a| a.using('metric').map { |m| m['link'] } }
+
+            info[:transfer_uris] ||= []
+            info[:transfer_uris] += metric_uris
+
+            results += metric_uris.map do |uri|
+              {
+                project: from,
+                transfer_uri: uri
+              }
+            end
+
+            info
+          end
+
+          {
+            results: results,
+            params: {
+              synchronize: synchronize
+            }
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# 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'
+require 'thread_safe'
+
+module GoodData
+  module LCM2
+    class CollectClientProjects < BaseAction
+      DESCRIPTION = 'Collect All Client Projects 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
+
+        description 'Segments to manage'
+        param :segments, array_of(instance_of(Type::SegmentType)), required: true
+      end
+
+      RESULT_HEADER = [
+        :client_id,
+        :project
+      ]
+
+      class << self
+        def call(params)
+          client = params.gdc_gd_client
+
+          domain = client.domain(params.organization) || fail("Invalid domain name specified - #{params.organization}")
+
+          data_product = params.data_product
+          all_segments = domain.segments(:all, data_product)
+
+          segment_names = params.segments.map do |segment|
+            segment.segment_id.downcase
+          end
+
+          segments = all_segments.select do |segment|
+            segment_names.include?(segment.segment_id.downcase)
+          end
+
+          client_projects = ThreadSafe::Hash.new
+
+          results = segments.pmap do |segment|
+            segment.clients.map do |segment_client|
+              project = segment_client.project
+
+              res = {
+                client_id: segment_client.client_id,
+                project: project && project.pid
+              }
+
+              client_projects[segment_client.client_id] = {
+                segment_client: segment_client,
+                project: project
+              }
+
+              res
+            end
+          end
+
+          {
+            results: results.flatten,
+            params: {
+              client_projects: client_projects
+            }
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,128 @@
+# 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 CollectClients < BaseAction
+      DESCRIPTION = 'Collect Clients'
+
+      PARAMS = define_params(self) do
+        description 'Client Used for Connecting to GD'
+        param :gdc_gd_client, instance_of(Type::GdClientType), required: true
+
+        description 'Segments to manage'
+        param :segments, array_of(instance_of(Type::SegmentType)), required: true
+
+        description 'Client Id Column'
+        param :client_id_column, instance_of(Type::StringType), required: false
+
+        description 'Segment Id Column'
+        param :segment_id_column, instance_of(Type::StringType), required: false
+
+        description 'Project Id Column'
+        param :project_id_column, instance_of(Type::StringType), required: false
+
+        description 'Client Project Title Column'
+        param :project_title_column, instance_of(Type::StringType), required: false
+
+        description 'Client Project Token Column'
+        param :project_token_column, instance_of(Type::StringType), required: false
+
+        description 'Input Source'
+        param :input_source, instance_of(Type::HashType), required: true
+      end
+
+      RESULT_HEADER = [
+        :client,
+        :segment_id,
+        :title
+      ]
+
+      class << self
+        def call(params)
+          segment_names = params.segments.map(&:segment_id)
+
+          clients, errors = collect_clients(params, segment_names)
+          fail "These are errors while collecting clients from input data:\n#{errors.join("\n")}" unless errors.empty?
+
+          results = clients.map do |client|
+            {
+              client: client[:id],
+              segment_id: client[:segment],
+              title: client[:project_title]
+            }
+          end
+
+          {
+            results: results,
+            params: {
+              clients: clients
+            }
+          }
+        end
+
+        def collect_clients(params, segment_names = nil)
+          client_id_column = params.client_id_column || 'client_id'
+          segment_id_column = params.segment_id_column || 'segment_id'
+          project_id_column = params.project_id_column || 'project_id'
+          project_title_column = params.project_title_column || 'project_title'
+          project_token_column = params.project_token_column || 'project_token'
+          client = params.gdc_gd_client
+
+          clients = []
+          errors = []
+          data_source = GoodData::Helpers::DataSource.new(params.input_source)
+          input_data = File.open(data_source.realize(params), 'r:UTF-8')
+          GoodData.logger.debug("Input data: #{input_data.read}")
+          GoodData.logger.debug("Segment names: #{segment_names}")
+          CSV.foreach(input_data, :headers => true, :return_headers => false, encoding: 'utf-8') do |row|
+            GoodData.logger.debug("Processing row: #{row}")
+            segment_name = row[segment_id_column]
+            GoodData.logger.debug("Segment name: #{segment_name}")
+            if segment_names.nil? || segment_names.include?(segment_name)
+              client_id = row[client_id_column]
+              pid = row[project_id_column]
+
+              if pid
+                begin
+                  errors << "Project #{pid} of client #{client_id} is deleted." if client.projects(pid).deleted?
+                rescue
+                  errors << "Seems like you (user executing the script - #{client.user.login}) \
+                  do not have access to project \"#{pid}\" of client \"#{client_id}\""
+                end
+              end
+
+              clients << {
+                id: client_id,
+                segment: segment_name,
+                project: pid,
+                settings: [
+                  {
+                    name: 'lcm.token',
+                    value: row[project_token_column]
+                  },
+                  {
+                    name: 'lcm.title',
+                    value: row[project_title_column]
+                  }
+                ]
+              }.compact
+            end
+          end
+
+          if clients.empty?
+            errors << "No segments or clients qualify for provisioning. \
+            Please check the input source data, platform segments, and the SEGMENTS_FILTER parameter. \
+            The intersection of these three elements is empty set."
+          end
+          [clients, errors]
+        end
+      end
+    end
+  end
+end