gooddata 1.0.0-java

data/lib/gooddata/models/process.rb

@@ -0,0 +1,371 @@
+# 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 'zip'
+require 'uri'
+
+require_relative '../helpers/global_helpers'
+require_relative '../rest/resource'
+
+require_relative 'execution_detail'
+require_relative 'schedule'
+
+APP_STORE_URL ||= 'https://github.com/gooddata/app_store'
+
+module GoodData
+  class Process < Rest::Resource
+    attr_reader :data
+
+    alias_method :raw_data, :data
+    alias_method :json, :data
+    alias_method :to_hash, :data
+
+    class << self
+      def [](id, options = {})
+        project = options[:project]
+        c = options[:client] || (project && project.client)
+
+        if id == :all && project
+          uri = "/gdc/projects/#{project.pid}/dataload/processes"
+          data = c.get(uri)
+          data['processes']['items'].map do |process_data|
+            c.create(Process, process_data, project: project)
+          end
+        elsif id == :all
+          uri = "/gdc/account/profile/#{c.user.obj_id}/dataload/processes"
+          data = c.get(uri)
+          pids = data['processes']['items'].map { |process_data| process_data['process']['links']['self'].match(%r{/gdc/projects/(\w*)/})[1] }.uniq
+          projects_lookup = pids.pmap { |pid| c.projects(pid) }.reduce({}) do |a, e|
+            a[e.pid] = e
+            a
+          end
+
+          data['processes']['items'].map do |process_data|
+            pid = process_data['process']['links']['self'].match(%r{/gdc/projects/(\w*)/})[1]
+            c.create(Process, process_data, project: projects_lookup[pid])
+          end
+        else
+          uri = "/gdc/projects/#{project.pid}/dataload/processes/#{id}"
+          c.create(Process, c.get(uri), project: project)
+        end
+      end
+
+      def all
+        Process[:all]
+      end
+
+      def with_deploy(dir, options = {}, &block)
+        _client, project = GoodData.get_client_and_project(options)
+
+        GoodData.with_project(project) do
+          params = options[:params].nil? ? [] : [options[:params]]
+          if block
+            begin
+              res = GoodData::Process.deploy(dir, options.merge(:files_to_exclude => params))
+              block.call(res)
+            rescue => e
+              puts e.inspect
+            ensure
+              res.delete if res
+            end
+          else
+            GoodData::Process.deploy(dir, options.merge(:files_to_exclude => params))
+          end
+        end
+      end
+
+      def upload_package(path, files_to_exclude, opts = { :client => GoodData.connection })
+        GoodData.get_client_and_project(opts)
+        zip_and_upload(path, files_to_exclude, opts)
+      end
+
+      # Deploy a new process or redeploy existing one.
+      #
+      # @param path [String] Path to ZIP archive or to a directory containing files that should be ZIPed
+      # @option options [String] :files_to_exclude
+      # @option options [String] :type ('GRAPH') Type of process - GRAPH or RUBY
+      # @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
+
+        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]
+        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
+
+        deployed_path = Process.upload_package(path, files_to_exclude, client: client, project: project)
+        data = {
+          :process => {
+            :name => deploy_name,
+            :path => "/uploads/#{File.basename(deployed_path)}",
+            :type => type
+          }
+        }
+
+        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
+      end
+
+      def deploy_brick(path, options = { :client => GoodData.client, :project => GoodData.project })
+        client, project = GoodData.get_client_and_project(options)
+
+        brick_uri_parts = URI(path).path.split('/')
+        ref = brick_uri_parts[4]
+        brick_name = brick_uri_parts.last
+        brick_path = brick_uri_parts[5..-1].join('/')
+
+        Dir.mktmpdir do |dir|
+          Dir.chdir(dir) do
+            `git clone #{APP_STORE_URL}`
+          end
+
+          Dir.chdir(File.join(dir, 'app_store')) do
+            if ref
+              `git checkout #{ref}`
+
+              fail 'Wrong branch or tag specified!' if $CHILD_STATUS.to_i.nonzero?
+            end
+
+            opts = {
+              :client => client,
+              :project => project,
+              :name => brick_name,
+              :type => 'RUBY'
+            }
+
+            full_brick_path = File.join(dir, 'app_store', brick_path)
+
+            unless File.exist?(full_brick_path)
+              fail "Invalid brick name specified - '#{brick_name}'"
+            end
+
+            return deploy(full_brick_path, opts)
+          end
+        end
+      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,
+            path: path,
+            type: 'RUBY'
+          }
+        }
+
+        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
+      end
+
+      private
+
+      def with_zip(opts = {})
+        client = opts[:client]
+        temp = Tempfile.new(['deploy-graph-archive', '.zip'])
+        zip_filename = temp.path
+
+        temp.close!
+        Zip::File.open(zip_filename, Zip::File::CREATE) do |zipfile|
+          yield zipfile
+        end
+        client.upload_to_user_webdav(zip_filename, opts)
+        zip_filename
+      end
+
+      def zip_and_upload(path, files_to_exclude, opts = {})
+        client = opts[:client]
+        puts 'Creating package for upload'
+        if !path.directory? && (path.extname == '.grf' || path.extname == '.rb')
+          with_zip(opts) do |zipfile|
+            zipfile.add(File.basename(path), path)
+          end
+        elsif !path.directory?
+          # this branch expects a zipped file. Since the filename on webdav is by default
+          # equal to the filename of a local file. I happened often that the name clashed
+          # if ran in parallel. Create a randomized name to mitigate that
+          randomized_filename = (0...16).map { (65 + rand(26)).chr }.join
+          client.upload_to_user_webdav(path, { filename: randomized_filename }.merge(opts))
+          randomized_filename
+        else
+          with_zip(opts) do |zipfile|
+            files_to_upload = Dir[File.join(path, '**', '**')].reject { |f| files_to_exclude.include?(Pathname(path) + f) }
+            puts "Uploading #{files_to_upload.count} files."
+            files_to_upload.each do |file|
+              file_pathname = Pathname.new(file)
+              file_relative_pathname = file_pathname.relative_path_from(Pathname.new(path))
+              zipfile.add(file_relative_pathname, file)
+            end
+          end
+        end
+      end
+      # -----------------------------
+    end
+
+    def initialize(data)
+      @data = data
+    end
+
+    def delete
+      client.delete(uri)
+    end
+
+    # Redeploy existing process.
+    #
+    # @param path [String] Path to ZIP archive or to a directory containing files that should be ZIPed
+    # @option options [String] :files_to_exclude
+    # @option options [String] :process_id ('nobody') From address
+    # @option options [String] :type ('GRAPH') Type of process - GRAPH or RUBY
+    # @option options [String] :name Readable name of the process
+    # @option options [Boolean] :verbose (false) Switch on verbose mode for detailed logging
+    def deploy(path, options = {})
+      Process.deploy(path, { client: client, process_id: process_id, :project => project, :name => name, :type => type }.merge(options))
+    end
+
+    # Downloads the process from S3 in a zipped form.
+    #
+    # @return [IO] The stream of data that represents a zipped deployed process.
+    def download
+      link = links['source']
+      client.connection.refresh_token
+      client.get(link, process: false) { |_, _, result| RestClient.get(result.to_hash['location'].first) }
+    end
+
+    def process
+      data['process']
+    end
+
+    def name
+      process['name']
+    end
+
+    def type
+      process['type'].downcase.to_sym
+    end
+
+    def links
+      process['links']
+    end
+
+    def link
+      links['self']
+    end
+
+    alias_method :uri, :link
+
+    def obj_id
+      uri.split('/').last
+    end
+
+    alias_method :process_id, :obj_id
+
+    def executions_link
+      links['executions']
+    end
+
+    def graphs
+      process['graphs']
+    end
+
+    def executables
+      process['executables']
+    end
+
+    def path
+      process['path']
+    end
+
+    def schedules
+      project.schedules.select { |schedule| schedule.process_id == obj_id }
+    end
+
+    def create_schedule(cron, executable, options = {})
+      project.create_schedule(process_id, cron, executable, options.merge(client: client, project: project))
+    end
+
+    def execute(executable, options = {})
+      result = start_execution(executable, options)
+      begin
+        client.poll_on_code(result['executionTask']['links']['poll'], options)
+      rescue RestClient::RequestFailed => e
+        raise(e)
+      ensure
+        result = client.get(result['executionTask']['links']['detail'])
+        if result['executionDetail']['status'] == 'ERROR'
+          fail "Runing process failed. You can look at a log here #{result['executionDetail']['logFileName']}"
+        end
+      end
+      client.create(GoodData::ExecutionDetail, result, client: client, project: project)
+    end
+
+    def start_execution(executable, options = {})
+      params = options[:params] || {}
+      hidden_params = options[:hidden_params] || {}
+      client.post(executions_link,
+                  :execution => {
+                    :graph => executable.to_s,
+                    :params => GoodData::Helpers.encode_public_params(params),
+                    :hiddenParams => GoodData::Helpers.encode_hidden_params(hidden_params)
+                  })
+    end
+
+    def notification_rules
+      NotificationRule.all(project: project, process: self, client: client)
+    end
+
+    def create_notification_rule(opts = {})
+      NotificationRule.create(opts.merge(project: project, process: self, client: client))
+    end
+  end
+end

data/lib/gooddata/models/profile.rb

@@ -0,0 +1,451 @@
+# 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 'pmap'
+
+require_relative '../rest/object'
+
+require_relative 'project'
+
+module GoodData
+  class Profile < Rest::Resource
+    attr_reader :user, :json
+
+    EMPTY_OBJECT = {
+      'accountSetting' => {
+        'companyName' => nil,
+        'country' => nil,
+        'created' => nil,
+        'firstName' => nil,
+        'lastName' => nil,
+        'login' => nil,
+        'phoneNumber' => nil,
+        'position' => nil,
+        'timezone' => nil,
+        'updated' => nil,
+        'language' => nil,
+        'links' => {
+          'projects' => nil,
+          'self' => nil
+        },
+        'email' => nil,
+        'authenticationModes' => []
+      }
+    }
+
+    ASSIGNABLE_MEMBERS = [
+      :company,
+      :country,
+      :email,
+      :login,
+      :first_name,
+      :last_name,
+      :phone,
+      :position,
+      :timezone,
+      :language
+    ]
+
+    PROFILE_PATH = '/gdc/account/profile/%s'
+
+    class << self
+      # Get profile by ID or URI
+      #
+      # @param id ID or URI of user to be found
+      # @param [Hash] opts Additional optional options
+      # @option opts [GoodData::Rest::Client] :client Client used for communication with server
+      # @return GoodData::Profile User Profile
+      def [](id, opts = { client: GoodData.connection })
+        return id if id.instance_of?(GoodData::Profile) || id.respond_to?(:profile?) && id.profile?
+
+        if id.to_s !~ %r{^(\/gdc\/account\/profile\/)?[a-zA-Z\d]+$}
+          fail(ArgumentError, 'wrong type of argument. Should be either profile ID or path')
+        end
+
+        id = id.match(/[a-zA-Z\d]+$/)[0] if id =~ %r{/}
+
+        c = client(opts)
+        fail ArgumentError, 'No :client specified' if c.nil?
+
+        response = c.get(PROFILE_PATH % id)
+        c.factory.create(Profile, response)
+      end
+
+      # Creates new instance from hash with attributes
+      #
+      # @param attributes [Hash] Hash with initial attributes
+      # @return [GoodData::Profile] New profile instance
+      def create(attributes)
+        res = create_object(attributes)
+        res.save!
+        res
+      end
+
+      def create_object(attributes)
+        json = GoodData::Helpers.deep_dup(EMPTY_OBJECT)
+        json['accountSetting']['links']['self'] = attributes[:uri] if attributes[:uri]
+        res = client.create(GoodData::Profile, json)
+
+        attributes.each do |k, v|
+          res.send("#{k}=", v) if ASSIGNABLE_MEMBERS.include? k
+        end
+        res
+      end
+
+      def diff(item1, item2)
+        x = diff_list([item1], [item2])
+        return {} if x[:changed].empty?
+        x[:changed].first[:diff]
+      end
+
+      def diff_list(list1, list2)
+        GoodData::Helpers.diff(list1, list2, key: :login)
+      end
+
+      # Gets user currently logged in
+      # @return [GoodData::Profile] User currently logged-in
+      def current
+        client.user
+      end
+    end
+
+    # Creates new instance
+    #
+    # @return [Profile] New Profile instance
+    def initialize(json)
+      @json = json
+      @dirty = false
+    end
+
+    # Checks objects for equality
+    #
+    # @param right [GoodData::Profile] Project to compare with
+    # @return [Boolean] True if same else false
+    def ==(other)
+      return false unless other.respond_to?(:to_hash)
+      to_hash == other.to_hash
+    end
+
+    # Checks objects for non-equality
+    #
+    # @param right [GoodData::Profile] Project to compare with
+    # @return [Boolean] True if different else false
+    def !=(other)
+      !(self == other)
+    end
+
+    # Apply changes to object.
+    #
+    # @param changes [Hash] Hash with modifications
+    # @return [GoodData::Profile] Modified object
+    # def apply(changes)
+    #   GoodData::Profile.apply(self, changes)
+    # end
+
+    # Gets the company name
+    #
+    # @return [String] Company name
+    def company
+      @json['accountSetting']['companyName'] || ''
+    end
+
+    # Set the company name
+    #
+    # @param val [String] Company name to be set
+    def company=(val)
+      @dirty ||= company != val
+      @json['accountSetting']['companyName'] = val
+    end
+
+    # Gets the language
+    #
+    # @return [String] Language
+    def language
+      @json['accountSetting']['language'] || 'en-US'
+    end
+
+    # Set the language
+    #
+    # @param val [String] Language to be set
+    def language=(val)
+      @dirty ||= language != val
+      @json['accountSetting']['language'] = val
+    end
+
+    # Gets the country
+    #
+    # @return [String] Country
+    def country
+      @json['accountSetting']['country'] || ''
+    end
+
+    # Set the country
+    #
+    # @param val [String] Country to be set
+    def country=(val)
+      @dirty ||= country != val
+      @json['accountSetting']['country'] = val
+    end
+
+    # Gets date when created
+    #
+    # @return [DateTime] Created date
+    def created
+      DateTime.parse(@json['accountSetting']['created'])
+    end
+
+    # Deletes this account settings
+    def delete
+      client.delete uri
+    end
+
+    # Gets hash representing diff of profiles
+    #
+    # @param user [GoodData::Profile] Another profile to compare with
+    # @return [Hash] Hash representing diff
+    def diff(user)
+      GoodData::Profile.diff(self, user)
+    end
+
+    # Gets the email
+    #
+    # @return [String] Email address
+    def email
+      @json['accountSetting']['email'] || ''
+    end
+
+    # Set the email
+    #
+    # @param val [String] Email to be set
+    def email=(val)
+      @dirty ||= email != val
+      @json['accountSetting']['email'] = val
+    end
+
+    # Gets the first name
+    #
+    # @return [String] First name
+    def first_name
+      @json['accountSetting']['firstName'] || ''
+    end
+
+    # Set the first name
+    #
+    # @param val [String] First name to be set
+    def first_name=(val)
+      @dirty ||= first_name != val
+      @json['accountSetting']['firstName'] = val
+    end
+
+    # Get full name
+    #
+    # @return String Full Name
+    # NOTE: This can be tricky to implement correctly for i18n
+    def full_name
+      "#{first_name} #{last_name}"
+    end
+
+    alias_method :title, :full_name
+
+    # Gets the last name
+    #
+    # @return [String] Last name
+    def last_name
+      @json['accountSetting']['lastName'] || ''
+    end
+
+    # Set the last name
+    #
+    # @param val [String] Last name to be set
+    def last_name=(val)
+      @dirty ||= last_name != val
+      @json['accountSetting']['lastName'] = val
+    end
+
+    # Gets the login
+    #
+    # @return [String] Login
+    def login
+      @json['accountSetting']['login'] || ''
+    end
+
+    # Set the login
+    #
+    # @param val [String] Login to be set
+    def login=(val)
+      @dirty ||= login != val
+      @json['accountSetting']['login'] = val
+    end
+
+    # Gets the resource identifier
+    #
+    # @return [String] Resource identifier
+    def obj_id
+      uri.split('/').last
+    end
+
+    alias_method :account_setting_id, :obj_id
+
+    # Gets the phone
+    #
+    # @return [String] Phone
+    def phone
+      @json['accountSetting']['phoneNumber'] || ''
+    end
+
+    alias_method :phone_number, :phone
+
+    # Set the phone
+    #
+    # @param val [String] Phone to be set
+    def phone=(val)
+      @dirty ||= phone != val
+      @json['accountSetting']['phoneNumber'] = val
+    end
+
+    alias_method :phone_number=, :phone=
+
+    # Gets the position in company
+    #
+    # @return [String] Position in company
+    def position
+      @json['accountSetting']['position'] || ''
+    end
+
+    # Set the position
+    #
+    # @param val [String] Position to be set
+    def position=(val)
+      @dirty ||= position != val
+      @json['accountSetting']['position'] = val
+    end
+
+    # Gets the array of projects
+    #
+    # @return [Array<GoodData::Project>] Array of project where account settings belongs to
+    def projects
+      projects = client.get @json['accountSetting']['links']['projects']
+      projects['projects'].map do |project|
+        client.create(GoodData::Project, project)
+      end
+    end
+
+    # Saves object if dirty, clears dirty flag
+    def save!
+      if @dirty
+        raw = @json.dup
+        raw['accountSetting'].delete('login')
+
+        if uri && !uri.empty?
+          url = "/gdc/account/profile/#{obj_id}"
+          @json = client.put url, raw
+          @dirty = false
+        end
+      end
+      self
+    end
+
+    # Gets the preferred timezone
+    #
+    # @return [String] Preferred timezone
+    def timezone
+      @json['accountSetting']['timezone'] || ''
+    end
+
+    # Set the timezone
+    #
+    # @param val [String] Timezone to be set
+    def timezone=(val)
+      @dirty ||= timezone != val
+      @json['accountSetting']['timezone'] = val
+    end
+
+    # Gets the date when updated
+    #
+    # @return [DateTime] Updated date
+    def updated
+      DateTime.parse(@json['accountSetting']['updated'])
+    end
+
+    # Gets the resource REST URI
+    #
+    # @return [String] Resource URI
+    def uri
+      GoodData::Helpers.get_path(@json, %w(accountSetting links self))
+    end
+
+    def data
+      data = @json || {}
+      data['accountSetting'] || {}
+    end
+
+    def links
+      data['links'] || {}
+    end
+
+    def content
+      keys = (data.keys - ['links'])
+      data.slice(*keys)
+    end
+
+    def name
+      (first_name || '') + (last_name || '')
+    end
+
+    def password
+      @json['accountSetting']['password']
+    end
+
+    def password=(a_password)
+      @dirty = true
+      @json['accountSetting']['password'] = a_password
+    end
+
+    def sso_provider
+      @json['accountSetting']['ssoProvider']
+    end
+
+    def sso_provider=(an_sso_provider)
+      @dirty = true
+      @json['accountSetting']['ssoProvider'] = an_sso_provider
+    end
+
+    def authentication_modes
+      @json['accountSetting']['authenticationModes'].map { |x| x.downcase.to_sym }
+    end
+
+    def authentication_modes=(modes)
+      modes = Array(modes)
+      @dirty = true
+      @json['accountSetting']['authenticationModes'] = modes.map { |x| x.to_s.upcase }
+    end
+
+    def to_hash
+      tmp = GoodData::Helpers.symbolize_keys(content.merge(uri: uri))
+      [
+        [:companyName, :company],
+        [:phoneNumber, :phone],
+        [:firstName, :first_name],
+        [:lastName, :last_name],
+        [:authenticationModes, :authentication_modes],
+        [:ssoProvider, :sso_provider]
+      ].each do |vals|
+        wire, rb = vals
+        tmp[rb] = tmp[wire]
+        tmp.delete(wire)
+      end
+      tmp
+    end
+
+    def create_channel
+      GoodData::ChannelConfiguration.create(to: email, title: email, client: client)
+    end
+
+    def channels
+      GoodData::ChannelConfiguration.all(client: client)
+    end
+  end
+end