gooddata-edge 0.6.27.edge

data/lib/gooddata/commands/user.rb

@@ -0,0 +1,39 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2015 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 'highline/import'
+require 'multi_json'
+
+require_relative '../core/core'
+
+module GoodData
+  module Command
+    class User
+      class << self
+        def roles(pid)
+          roles_response = GoodData.get("/gdc/projects/#{pid}/roles")
+
+          roles = {}
+          roles_response['projectRoles']['roles'].each do |role_uri|
+            r = GoodData.get(role_uri)
+            identifier = r['projectRole']['meta']['identifier']
+            roles[identifier] = {
+              :user_uri => r['projectRole']['links']['roleUsers'],
+              :uri => role_uri
+            }
+          end
+          roles
+        end
+
+        def show(opts = { client: GoodData.connection })
+          client = opts[:client]
+          fail ArgumentError, 'No :client specified' if client.nil?
+          pp client.user.json
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/connection.rb

@@ -0,0 +1,127 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2015 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 'uri'
+
+require_relative 'core/logging'
+
+require_relative 'rest/rest'
+
+module GoodData
+  class << self
+    DEFAULT_SSO_OPTIONS = {
+      :url => '/gdc/app/account/bootstrap',
+      :valid => 24 * 60 * 60
+    }
+
+    # Returns the active GoodData connection earlier initialized via GoodData.connect call
+    #
+    # @see GoodData.connect
+    def connection
+      # TODO: Remove this after successful rest-factory transition
+      Rest::Client.connection # || fail('Please authenticate with GoodData.connect first')
+    end
+
+    alias_method :client, :connection
+
+    # Connect to the GoodData API
+    #
+    # @param options
+    # @param second_options
+    # @param third_options
+    #
+    def connect(options = nil, second_options = nil, third_options = {})
+      Rest::Client.connect(options, second_options, third_options)
+    end
+
+    # Disconnect (logout) if logged in
+    def disconnect
+      Rest::Client.disconnect
+    end
+
+    def with_connection(options = nil, second_options = nil, third_options = {}, &bl)
+      connection = connect(options, second_options, third_options)
+      bl.call(connection)
+    rescue Exception => e # rubocop:disable RescueException
+      puts e.message
+      raise e
+    ensure
+      disconnect
+    end
+
+    # Generates SSO URL
+    #
+    # This SSO implementation is custom implementation provided by GoodData
+    # that allows your application to sign in an existing GoodData user.
+    # The authentication is done not by username and password but by generating a session
+    # specific token using pair of PGP keys.
+    #
+    # @see https://developer.gooddata.com/article/single-sign-on
+    #
+    # @param [String] login Email address used for logging into gooddata
+    # @param [String] provider Name of SSO provider
+    # @param [Hash] opts Additional options
+    # @option opts [Fixnum] :validity Validity in seconds from 'now'
+    # @return [String] URL which can be used for SSO logging in
+    def sso_url(login, provider, opts = DEFAULT_SSO_OPTIONS)
+      opts = DEFAULT_SSO_OPTIONS.merge(opts)
+
+      ts = DateTime.now.strftime('%s').to_i + opts[:valid]
+      obj = {
+        'email' => login,
+        'validity' => ts
+      }
+
+      json_data = JSON.pretty_generate(obj) + "\n"
+
+      file_json = Tempfile.new('gooddata-sso-json')
+      file_json.write(json_data)
+
+      file_json.rewind
+      file_signed = Tempfile.new('gooddata-sso-signed')
+
+      cmd = "gpg --no-tty --armor --yes -u #{login} --output #{file_signed.path} --sign #{file_json.path}"
+      res = system(cmd)
+      fail 'Unable to sign json' unless res
+
+      file_signed.rewind
+      file_final = Tempfile.new('gooddata-sso-final')
+
+      cmd = "gpg --yes --no-tty --trust-model always --armor --output #{file_final.path} --encrypt --recipient security@gooddata.com #{file_signed.path}"
+      res = system(cmd)
+      fail 'Unable to encrypt json' unless res
+
+      file_final.rewind
+      final = file_final.read
+
+      "#{GoodData::Helpers::AuthHelper.read_server}/gdc/account/customerlogin?sessionId=#{CGI.escape(final)}&serverURL=#{CGI.escape(provider)}&targetURL=#{CGI.escape(opts[:url])}"
+    end
+
+    # Connect to GoodData using SSO
+    #
+    # This SSO implementation is custom implementation provided by GoodData
+    # that allows your application to sign in an existing GoodData user.
+    # The authentication is done not by username and password but by generating a session
+    # specific token using pair of PGP keys.
+    #
+    # @see https://developer.gooddata.com/article/single-sign-on
+    #
+    # @param [String] login Email address used for logging into gooddata
+    # @param [String] provider Name of SSO provider
+    # @return [GoodData::Rest::Client] Instance of REST client
+    def connect_sso(login, provider)
+      url = sso_url(login, provider)
+
+      params = {
+        :x_gdc_request => "#{GoodData::Rest::Connection.generate_string}:#{GoodData::Rest::Connection.generate_string}"
+      }
+
+      RestClient.get url, params do |response, _request, _result|
+        Rest::Client.connect_sso(:sst_token => URI.decode(response.cookies['GDCAuthSST']))
+      end
+    end
+  end
+end

data/lib/gooddata/core/core.rb

@@ -0,0 +1,12 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2015 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/core/logging.rb

@@ -0,0 +1,105 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2015 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 'rest-client'
+
+require_relative 'nil_logger'
+
+module GoodData
+  DEFAULT_LOG_LEVEL = Logger::INFO
+  DEFAULT_LOG_OUTPUT = STDOUT
+  DEFAULT_LOGGER_CLASS = Logger
+
+  DEFAULT_RESTLOG_LEVEL = Logger::INFO
+  DEFAULT_RESTLOG_OUTPUT = STDOUT
+  DEFAULT_RESTLOGGER_CLASS = Logger
+
+  class << self
+    attr_accessor :logger, :rest_logger
+    attr_writer :stats
+
+    # Turn logging on
+    #
+    # ### Example
+    #
+    #     # Turn of default logging
+    #     GoodData.logging_on
+    #
+    #     # Log only WARN and higher
+    #     GoodData.logging_on(Logger::WARN)
+    #
+    #     # Log DEBUG and above to file
+    #     GoodData.logging_on(Logger::DEBUG, 'log.txt')
+    #
+    def logging_on(level = DEFAULT_LOG_LEVEL, output = DEFAULT_LOG_OUTPUT, klass = DEFAULT_LOGGER_CLASS)
+      @logger = klass.new(output)
+      @logger.level = level
+      @logger
+    end
+
+    # Turn logging on
+    #
+    # ### Example
+    #
+    #     GoodData.logging_off
+    #
+    def logging_off
+      @logger = NilLogger.new
+    end
+
+    def logging_on?
+      !@logger.instance_of?(NilLogger)
+    end
+
+    # Turn logging on with HTTP included
+    #
+    # ### Example
+    #
+    #     GoodData.logging_http_on
+    #
+    def logging_http_on(level = DEFAULT_RESTLOG_LEVEL, output = DEFAULT_RESTLOG_OUTPUT, klass = DEFAULT_RESTLOGGER_CLASS)
+      @logger = klass.new(output)
+      @logger.level = level
+      @logger
+    end
+
+    # Turn logging on
+    #
+    # ### Example
+    #
+    #     GoodData.logging_http_off
+    #
+    def logging_http_off
+      @rest_client = NilLogger.new
+    end
+
+    def logging_http_on?
+      !@rest_client.instance_of?(NilLogger)
+    end
+
+    def stats_on
+      @stats = true
+    end
+
+    def stats_on?
+      @stats
+    end
+
+    def stats_off
+      @stats = false
+    end
+
+    # Initial setup of logger
+    GoodData.logger = GoodData.logging_on
+
+    # Initial setup of rest logger
+    GoodData.rest_logger = GoodData.logging_http_on(
+      nil,
+      DEFAULT_RESTLOG_OUTPUT,
+      NilLogger
+    )
+  end
+end

data/lib/gooddata/core/nil_logger.rb

@@ -0,0 +1,23 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2015 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
+  # Dummy implementation of logger
+  class NilLogger
+    attr_accessor :level
+
+    def initialize(*_args)
+      @level = nil
+    end
+
+    def debug(*_args)
+    end
+
+    alias_method :info, :debug
+    alias_method :warn, :debug
+    alias_method :error, :debug
+  end
+end

data/lib/gooddata/core/project.rb

@@ -0,0 +1,74 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2015 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
+  @project = nil
+
+  class << self
+    # Sets the active project
+    #
+    # @param project A project identifier
+    #
+    # ### Examples
+    #
+    # The following calls are equivalent
+    #
+    #     # Assign project ID
+    #     GoodData.project = 'afawtv356b6usdfsdf34vt'
+    #
+    #     # Use project ID
+    #     GoodData.use 'afawtv356b6usdfsdf34vt'
+    #
+    #     # Use project URL
+    #     GoodData.use '/gdc/projects/afawtv356b6usdfsdf34vt'
+    #
+    #     # Select project using indexer on GoodData::Project class
+    #     GoodData.project = Project['afawtv356b6usdfsdf34vt']
+    # Assigns global/default GoodData project
+    def project=(project, opts = { :client => GoodData.connection })
+      if project.is_a? Project
+        @project = project
+      elsif project.nil?
+        @project = nil
+      else
+        @project = Project[project, opts]
+      end
+      @project
+    end
+
+    alias_method :use, :project=
+
+    attr_reader :project
+
+    # Returns the active project
+    #
+    # def project
+    #   threaded[:project]
+    # end
+
+    # Perform block in context of another project than currently set
+    #
+    # @param project Project to use
+    # @param bl Block to be performed
+    def with_project(project, opts = { :client => GoodData.connection }, &bl)
+      fail 'You have to specify a project when using with_project' if project.nil? || (project.is_a?(String) && project.empty?)
+      fail 'You have to specify block' unless bl
+      old_project = GoodData.project
+
+      begin
+        GoodData.use(project, opts)
+        res = bl.call(GoodData.project)
+      rescue RestClient::ResourceNotFound
+        GoodData.project = old_project
+        raise(GoodData::ProjectNotFound, 'Project was not found')
+      end
+
+      GoodData.project = old_project
+
+      res
+    end
+  end
+end

data/lib/gooddata/core/rest.rb

@@ -0,0 +1,149 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2015 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 << self
+    # Performs a HTTP GET request.
+    #
+    # Retuns the JSON response formatted as a Hash object.
+    #
+    # @param path The HTTP path on the GoodData server (must be prefixed with a forward slash)
+    #
+    # ### Examples
+    #
+    #     GoodData.get '/gdc/projects'
+    #
+    def get(path, options = {})
+      connection.get(path, options)
+    end
+
+    # Performs a HTTP POST request.
+    #
+    # Retuns the JSON response formatted as a Hash object.
+    #
+    # @param path The HTTP path on the GoodData server (must be prefixed with a forward slash)
+    # @param data The payload data in the format of a Hash object
+    #
+    # ### Examples
+    #
+    #     client.post '/gdc/projects', { ... }
+    #
+    def post(path, data = {}, options = {})
+      connection.post path, data, options
+    end
+
+    # Performs a HTTP PUT request.
+    #
+    # Retuns the JSON response formatted as a Hash object.
+    #
+    # ### Parameters
+    #
+    # @param path The HTTP path on the GoodData server (must be prefixed with a forward slash)
+    # @param data The payload data in the format of a Hash object
+    #
+    # ### Examples
+    #
+    #     client.put '/gdc/projects', { ... }
+    #
+    def put(path, data, options = {})
+      connection.put path, data, options
+    end
+
+    # Performs a HTTP DELETE request.
+    #
+    # Retuns the JSON response formatted as a Hash object.
+    #
+    # @param path The HTTP path on the GoodData server (must be prefixed with a forward slash)
+    #
+    # ### Examples
+    #
+    #     GoodData.delete '/gdc/project/1'
+    #
+    def delete(path, options = {})
+      connection.delete path, options
+    end
+
+    # Upload to user directory
+    # @return [String]
+    def upload_to_user_webdav(file, options = {})
+      url = user_webdav_path({ :client => GoodData.client }.merge(options))
+      connection.upload(file, options.merge(staging_url: url))
+    end
+
+    # Get WebDav directory for project data
+    # @return [String]
+    def project_webdav_path(options = {})
+      options = merge_options(options)
+      project = options[:project]
+      project.project_webdav_path
+    end
+
+    # Upload to project directory
+    def upload_to_project_webdav(file, options = {})
+      options = merge_options(options)
+      url = project_webdav_path(options)
+      connection.upload(file, options.merge(:staging_url => url))
+    end
+
+    # Download from project directory
+    def download_from_project_webdav(file, where, options = {})
+      options = merge_options(options)
+      url = project_webdav_path(options)
+      connection.download(file, where, options.merge(:staging_url => url))
+    end
+
+    # Get WebDav directory for user data
+    # @return [String]
+    def user_webdav_path(options = {})
+      client = GoodData::Rest::Object.client({ :client => GoodData.client }.merge(options))
+      client.user_webdav_path
+    end
+
+    # Download from user directory
+    def download_from_user_webdav(file, where, options = {})
+      url = user_webdav_path({ :client => GoodData.client }.merge(options))
+      connection.download(file, where, options.merge(:staging_url => url))
+    end
+
+    # Generalizaton of poller. Since we have quite a variation of how async proceses are handled
+    # this is a helper that should help you with resources where the information about "Are we done"
+    # is the http code of response. By default we repeat as long as the code == 202. You can
+    # change the code if necessary. It expects the URI as an input where it can poll. It returns the
+    # value of last poll. In majority of cases these are the data that you need.
+    #
+    # @param link [String] Link for polling
+    # @param options [Hash] Options
+    # @return [Hash] Result of polling
+    def poll_on_code(link, options = {})
+      client = options[:client]
+      fail ArgumentError, 'No :client specified' if client.nil?
+      client.poll_on_code(link, options)
+    end
+
+    # Generalizaton of poller. Since we have quite a variation of how async proceses are handled
+    # this is a helper that should help you with resources where the information about "Are we done"
+    # is inside the response. It expects the URI as an input where it can poll and a block that should
+    # return either false -> 'meaning we are done' or true -> meaning sleep and repeat. It returns the
+    # value of last poll. In majority of cases these are the data that you need
+    #
+    # @param link [String] Link for polling
+    # @param options [Hash] Options
+    # @return [Hash] Result of polling
+    def poll_on_response(link, options = {}, &bl)
+      client = options[:client]
+      fail ArgumentError, 'No :client specified' if client.nil?
+      client.poll_on_response(link, options, &bl)
+    end
+
+    private
+
+    def merge_options(opts)
+      {
+        :project => GoodData.project
+      }.merge(opts)
+    end
+  end
+end