gooddata-edge 0.6.27.edge

data/lib/gooddata/models/user_filters/user_filters.rb

@@ -0,0 +1,13 @@
+# 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_relative file
+end

data/lib/gooddata/models/user_filters/variable_user_filter.rb

@@ -0,0 +1,31 @@
+# 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_relative 'user_filter'
+
+module GoodData
+  class VariableUserFilter < UserFilter
+    # Creates or updates the variable user filter on the server
+    #
+    # @return [String]
+    def save
+      res = client.post(uri, :variable => @json)
+      @json[:uri] = res['uri']
+      self
+    end
+
+    # Method used for replacing values in their state according to mapping. Can be used to replace any values but it is typically used to replace the URIs. Returns a new object of the same type.
+    #
+    # @param [Array<Array>]Mapping specifying what should be exchanged for what. As mapping should be used output of GoodData::Helpers.prepare_mapping.
+    # @return [GoodData::VariableUserFilter]
+    def replace(mapping)
+      x = GoodData::MdObject.replace_quoted(self, mapping)
+      x = GoodData::MdObject.replace_bracketed(x, mapping)
+      vals = GoodData::MdObject.find_replaceable_values(x, mapping)
+      GoodData::MdObject.replace_bracketed(x, vals)
+    end
+  end
+end

data/lib/gooddata/models/user_group.rb

@@ -0,0 +1,241 @@
+# 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_relative '../rest/rest'
+require_relative '../rest/resource'
+require_relative '../mixins/author'
+require_relative '../mixins/contributor'
+require_relative '../mixins/links'
+require_relative '../mixins/rest_resource'
+require_relative '../mixins/uri_getter'
+
+module GoodData
+  # Representation of User Group
+  #
+  # Use user groups to manage user access to dashboards on the GoodData Portal.
+  # Create groups to more quickly manage permissions for users with
+  # the the same role or who need similar access to dashboards.
+  # Groups can be part of groups.
+  class UserGroup < Rest::Resource
+    include Mixin::Author
+    include Mixin::Contributor
+    include Mixin::Links
+    include Mixin::UriGetter
+
+    EMPTY_OBJECT = {
+      'userGroup' => {
+        'content' => {
+          'name' => nil,
+          'description' => nil,
+          'project' => nil
+        }
+      }
+    }
+
+    class << self
+      # Returns list of all segments or a particular segment
+      #
+      # @param id [String|Symbol] Uri of the segment required or :all for all segments.
+      # @return [Array<GoodData::Segment>] List of segments for a particular domain
+      def [](id, opts = {})
+        # TODO: Replace with GoodData.get_client_and_project(opts)
+        project = opts[:project]
+        fail 'Project has to be passed in options' unless project
+        fail 'Project has to be of type GoodData::Project' unless project.is_a?(GoodData::Project)
+        client = project.client
+
+        results = client.get('/gdc/userGroups', params: { :project => project.pid, :user => opts[:user] }.compact)
+        groups = GoodData::Helpers.get_path(results, %w(userGroups items)).map { |i| client.create(GoodData::UserGroup, i, :project => project) }
+        id == :all ? groups : groups.find { |g| g.obj_id == id || g.name == id }
+      end
+
+      # Create new user group
+      #
+      # @param data [Hash] Initial data
+      # @return [UserGroup] Newly created user group
+      def create(data)
+        new_data = GoodData::Helpers.deep_dup(EMPTY_OBJECT).tap do |d|
+          d['userGroup']['content']['name'] = data[:name]
+          d['userGroup']['content']['description'] = data[:description]
+          d['userGroup']['content']['project'] = data[:project].respond_to?(:uri) ? data[:project].uri : data[:project]
+        end
+
+        client.create(GoodData::UserGroup, GoodData::Helpers.deep_stringify_keys(new_data))
+      end
+
+      # Constructs payload for user management/manipulation
+      #
+      # @return [Hash] Created payload
+      def construct_payload(users, operation)
+        users = users.is_a?(Array) ? users : [users]
+
+        {
+          modifyMembers: {
+            operation: operation,
+            items: users.map do |user|
+              uri = user.respond_to?(:uri) ? user.uri : user
+              fail 'You cannot add group as member of another group as of now.' if uri =~ %r{^\/gdc\/userGroups\/}
+              uri
+            end
+          }
+        }
+      end
+
+      # URI used for membership manipulation/managementv
+      #
+      # @param client [Client] Client used for communication with platform
+      # @param users [User | String | Array<User> | Array<String>] User(s) to be modified
+      # @param operation [String] Operation to be performed - ADD, SET, REMOVE
+      # @param uri [String] URI to be used for operation
+      # @return [String] URI used for membership manipulation/management
+      def modify_users(client, users, operation, uri)
+        payload = construct_payload(users, operation)
+        client.post(uri, payload)
+      end
+    end
+
+    # Initialize object with json
+    #
+    # @return [UserGroup] User Group object initialized with json
+    def initialize(json)
+      @json = json
+      self
+    end
+
+    # Add member(s) to user group
+    #
+    # @param [String | User | Array<User>] Users to add to user group
+    # @return [nil] Nothing is returned
+    def add_members(user)
+      UserGroup.modify_users(client, user, 'ADD', uri_modify_members)
+    end
+
+    alias_method :add_member, :add_members
+
+    # Gets user group name
+    #
+    # @return [String] User group name
+    def name
+      content['name']
+    end
+
+    # Sets user group name
+    #
+    # @param name [String] New user group name
+    # @return [String] New user group name
+    def name=(name)
+      content['name'] = name
+      name
+    end
+
+    # Gets user group description
+    #
+    # @return [String] User group description
+    def description
+      content['description']
+    end
+
+    # Sets user group description
+    #
+    # @param name [String] New user group description
+    # @return [String] New user group description
+    def description=(name)
+      content['description'] = name
+    end
+
+    # Gets Users with this Role
+    #
+    # @return [Array<GoodData::Profile>] List of users
+    def members
+      url = GoodData::Helpers.get_path(data, %w(links members))
+      return [] unless url
+      Enumerator.new do |y|
+        loop do
+          res = client.get url
+          res['userGroupMembers']['paging']['next']
+          res['userGroupMembers']['items'].each do |member|
+            case member.keys.first
+            when 'user'
+              y << client.create(GoodData::Profile, client.get(GoodData::Helpers.get_path(member, %w(user links self))), :project => project)
+            when 'userGroup'
+              y << client.create(UserGroup, client.get(GoodData::Helpers.get_path(member, %w(userGroup links self))), :project => project)
+            end
+          end
+          url = res['userGroupMembers']['paging']['next']
+          break unless url
+        end
+      end
+    end
+
+    # Verifies if user is in a group or any nested group and returns true if it does
+    #
+    # @return [Boolean] Retruns true if member is member of the group or any of its members
+    def member?(a_member)
+      # could be better on API directly?
+      uri = a_member.respond_to?(:uri) ? a_member.uri : a_member
+      members.map(&:uri).include?(uri)
+    end
+
+    # Save user group
+    # New group is created if needed else existing one is updated
+    #
+    # @return [UserGroup] Created or updated user group
+    def save
+      res = if uri
+              # get rid of unsupprted keys
+              data = json['userGroup']
+              client.put(uri, 'userGroup' => data.except('meta', 'links'))
+            else
+              client.post('/gdc/userGroups', @json)
+            end
+      @json = client.get(res['uri'])
+      self
+    end
+
+    # Remove member(s) from user group
+    #
+    # @param [String | User | Array<User>] Users to remove from user group
+    # @return [nil] Nothing is returned
+    def remove_members(user)
+      UserGroup.modify_users(client, user, 'REMOVE', uri_modify_members)
+    end
+
+    alias_method :remove_member, :remove_members
+
+    # Set member(s) to user group.
+    # Only users passed to this call will be new members of user group.
+    # Old members not passed to this method will be removed!
+    #
+    # @param [String | User | Array<User>] Users to set as members of user group
+    # @return [nil] Nothing is returned
+    def set_members(user) # rubocop:disable Style/AccessorMethodName
+      UserGroup.modify_users(client, user, 'SET', uri_modify_members)
+    end
+
+    alias_method :set_member, :set_members
+
+    # URI used for membership manipulation/management
+    #
+    # @return [String] URI used for membership manipulation/management
+    def uri_modify_members
+      links['modifyMembers']
+    end
+
+    # Is it a user group?
+    #
+    # @return [Boolean] Return true if it is a user group
+    def user_group?
+      true
+    end
+
+    # Checks if two user groups are same
+    #
+    # @return [Boolean] Return true if the two groups are same
+    def ==(other)
+      uri == other.uri
+    end
+  end
+end

data/lib/gooddata/rest/README.md

@@ -0,0 +1,37 @@
+# Rest
+
+Proof of Concept of GoodWay of dealing with non-perfect REST Endpoints
+
+## Terminology
+
+Terms like 'MUST', 'MUST NOT', 'SHALL', 'SHALL NOT' are used as defined in [RFC 2119](https://www.ietf.org/rfc/rfc2119.txt)
+
+## Architecture
+
+There are few basic classes.
+
+- Connection
+- Client
+- Factory
+- Object
+- Resource
+
+## Connection
+
+Low-level network connection
+
+## Client
+
+User's interface to GoodData Platform.
+
+## Factory
+
+Authority responsible for creating Object bounded to some Connection.
+
+## Object
+
+Remote REST-like accessible content.
+
+## Resource
+
+Objects which are (at least mimicking to be) first class citizen REST Resource with full CRUD

data/lib/gooddata/rest/client.rb

@@ -0,0 +1,389 @@
+# 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 '../helpers/auth_helpers'
+
+require_relative 'connection'
+require_relative 'object_factory'
+
+require_relative '../mixins/inspector'
+
+module GoodData
+  module Rest
+    # User's interface to GoodData Platform.
+    #
+    # MUST provide way to use - DELETE, GET, POST, PUT
+    # SHOULD provide way to use - HEAD, Bulk GET ...
+    class Client
+      #################################
+      # Constants
+      #################################
+      DEFAULT_CONNECTION_IMPLEMENTATION = GoodData::Rest::Connection
+      DEFAULT_SLEEP_INTERVAL = 10
+      DEFAULT_POLL_TIME_LIMIT = 5 * 60 * 60 # 5 hours
+
+      #################################
+      # Class variables
+      #################################
+      @@instance = nil # rubocop:disable ClassVars
+
+      #################################
+      # Getters/Setters
+      #################################
+
+      # Decide if we need provide direct access to connection
+      attr_reader :connection
+
+      # TODO: Decide if we need provide direct access to factory
+      attr_reader :factory
+      attr_reader :opts
+
+      include Mixin::Inspector
+      inspector :object_id
+
+      #################################
+      # Class methods
+      #################################
+      class << self
+        # Globally available way to connect (and create client and set global instance)
+        #
+        # ## HACK
+        # To make transition from old implementation to new one following HACK IS TEMPORARILY ENGAGED!
+        #
+        # 1. First call of #connect sets the GoodData::Rest::Client.instance (static, singleton instance)
+        # 2. There are METHOD functions with same signature as their CLASS counterparts using singleton instance
+        #
+        # ## Example
+        #
+        # client = GoodData.connect('jon.smith@goodddata.com', 's3cr3tp4sw0rd')
+        #
+        # @param username [String] Username to be used for authentication
+        # @param password [String] Password to be used for authentication
+        # @return [GoodData::Rest::Client] Client
+        def connect(username, password = 'aaaa', opts = {})
+          if username.nil? && password.nil?
+            username = ENV['GD_GEM_USER']
+            password = ENV['GD_GEM_PASSWORD']
+          end
+
+          username = GoodData::Helpers.symbolize_keys(username) if username.is_a?(Hash)
+
+          new_opts = opts.dup
+          if username.is_a?(Hash) && username.key?(:sst_token)
+            new_opts = new_opts.merge(username)
+          elsif username.is_a? Hash
+            new_opts = new_opts.merge(username)
+            new_opts[:username] = username[:login] || username[:user] || username[:username]
+            new_opts[:password] = username[:password]
+          elsif username.nil? && password.nil? && opts.blank?
+            new_opts = Helpers::AuthHelper.read_credentials
+          else
+            new_opts[:username] = username
+            new_opts[:password] = password
+          end
+
+          new_opts = { verify_ssl: true }.merge(new_opts)
+          if username.is_a?(Hash) && username[:cookies]
+            new_opts[:sst_token] = username[:cookies]['GDCAuthSST']
+            new_opts[:cookies] = username[:cookies]
+          end
+
+          unless new_opts[:sst_token]
+            fail ArgumentError, 'No username specified' if new_opts[:username].nil?
+            fail ArgumentError, 'No password specified' if new_opts[:password].nil?
+          end
+
+          if username.is_a?(Hash) && username.key?(:server)
+            new_opts[:server] = username[:server]
+          end
+
+          client = Client.new(new_opts)
+          GoodData.logger.info("Connected to server with webdav path #{client.user_webdav_path}")
+
+          if client
+            at_exit do
+              puts client.connection.stats_table if client && client.connection && (GoodData.stats_on? || client.stats_on?)
+            end
+          end
+
+          # HACK: This line assigns class instance # if not done yet
+          @@instance = client # rubocop:disable ClassVars
+        end
+
+        def connect_sso(sso)
+          client = Client.new(sso)
+          client
+        end
+
+        def disconnect
+          if @@instance # rubocop:disable Style/GuardClause
+            @@instance.disconnect
+            @@instance = nil # rubocop:disable ClassVars
+          end
+        end
+
+        def connection
+          @@instance
+        end
+
+        # Retry block if exception thrown
+        def retryable(options = {}, &block)
+          GoodData::Rest::Connection.retryable(options, &block)
+        end
+
+        alias_method :client, :connection
+      end
+
+      # Constructor of client
+      # @param opts [Hash] Client options
+      # @option opts [String] :username Username used for authentication
+      # @option opts [String] :password Password used for authentication
+      # @option opts :connection_factory Object able to create new instances of GoodData::Rest::Connection
+      # @option opts [GoodData::Rest::Connection] :connection Existing GoodData::Rest::Connection
+      def initialize(opts)
+        # TODO: Decide if we want to pass the options directly or not
+        @opts = opts
+
+        @connection_factory = @opts[:connection_factory] || DEFAULT_CONNECTION_IMPLEMENTATION
+
+        # TODO: See previous TODO
+        # Create connection
+        @connection = opts[:connection] || @connection_factory.new(opts)
+
+        # Connect
+        connect
+
+        # Create factory bound to previously created connection
+        @factory = ObjectFactory.new(self)
+      end
+
+      def create_project(options = { title: 'Project' })
+        GoodData::Project.create({ client: self }.merge(options))
+      end
+
+      def create_project_from_blueprint(blueprint, options = {})
+        GoodData::Model::ProjectCreator.migrate(options.merge(spec: blueprint, client: self))
+      end
+
+      def domain(domain_name)
+        GoodData::Domain[domain_name, :client => self]
+      end
+
+      def project_is_accessible?(id)
+        projects(id) && true
+      rescue
+        true
+      end
+
+      def projects(id = :all)
+        GoodData::Project[id, client: self]
+      end
+
+      def processes(id = :all)
+        GoodData::Process[id, client: self]
+      end
+
+      def connect
+        username = @opts[:username]
+        password = @opts[:password]
+
+        @connection.connect(username, password, @opts)
+      end
+
+      def disconnect
+        @connection.disconnect
+      end
+
+      #######################
+      # Factory stuff
+      ######################
+      def create(klass, data = {}, opts = {})
+        @factory.create(klass, data, opts)
+      end
+
+      def find(klass, opts = {})
+        @factory.find(klass, opts)
+      end
+
+      # Gets resource by name
+      def resource(res_name)
+        puts "Getting resource '#{res_name}'"
+        nil
+      end
+
+      def user(id = nil)
+        if id
+          create(GoodData::Profile, get(id))
+        else
+          create(GoodData::Profile, @connection.user)
+        end
+      end
+
+      def stats_off
+        @stats = false
+      end
+
+      def stats_on
+        @stats = true
+      end
+
+      def stats_on?
+        @stats
+      end
+
+      def generate_request_id
+        @connection.generate_request_id
+      end
+
+      #######################
+      # Rest
+      #######################
+      # HTTP DELETE
+      #
+      # @param uri [String] Target URI
+      def delete(uri, opts = {})
+        @connection.delete uri, opts
+      end
+
+      # HTTP GET
+      #
+      # @param uri [String] Target URI
+      def get(uri, opts = {}, & block)
+        @connection.get uri, opts, & block
+      end
+
+      def project_webdav_path(opts = { project: GoodData.project })
+        p = opts[:project]
+        fail ArgumentError, 'No :project specified' if p.nil?
+
+        project = GoodData::Project[p, opts]
+        fail ArgumentError, 'Wrong :project specified' if project.nil?
+
+        url = project.links['uploads']
+        fail 'Project WebDAV not supported in this Data Center' unless url
+
+        GoodData.logger.warn 'Beware! Project webdav is deprecated and should not be used.'
+        url
+      end
+
+      def user_webdav_path
+        uri = if opts[:webdav_server]
+                opts[:webdav_server]
+              else
+                links.find { |i| i['category'] == 'uploads' }['link']
+              end
+        res = uri.chomp('/') + '/'
+        res[0] == '/' ? "#{connection.server}#{res}" : res
+      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 = {})
+        code = options[:code] || 202
+        process = options[:process]
+
+        response = poll_on_response(link, options.merge(:process => false)) do |resp|
+          resp.code == code
+        end
+
+        if process == false
+          response
+        else
+          get(link)
+        end
+      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 true -> 'meaning we are done' or false -> 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)
+        sleep_interval = options[:sleep_interval] || DEFAULT_SLEEP_INTERVAL
+        time_limit = options[:time_limit] || DEFAULT_POLL_TIME_LIMIT
+        process = options[:process] == false ? false : true
+
+        # get the first status and start the timer
+        response = get(link, process: process)
+        poll_start = Time.now
+
+        while bl.call(response)
+          limit_breached = time_limit && (Time.now - poll_start > time_limit)
+          if limit_breached
+            fail ExecutionLimitExceeded, "The time limit #{time_limit} secs for polling on #{link} is over"
+          end
+          sleep sleep_interval
+          GoodData::Rest::Client.retryable(:tries => 3, :refresh_token => proc { connection.refresh_token }) do
+            response = get(link, process: process)
+          end
+        end
+        response
+      end
+
+      # HTTP PUT
+      #
+      # @param uri [String] Target URI
+      def put(uri, data, opts = {})
+        @connection.put uri, data, opts
+      end
+
+      # HTTP POST
+      #
+      # @param uri [String] Target URI
+      def post(uri, data, opts = {})
+        @connection.post uri, data, opts
+      end
+
+      # Uploads file to staging
+      #
+      # @param file [String] file to be uploaded
+      # @param options [Hash] must contain :staging_url key (file will be uploaded to :staging_url + File.basename(file))
+      def upload(file, options = {})
+        @connection.upload file, options
+      end
+
+      # Downloads file from staging
+      #
+      # @param source_relative_path [String] path relative to @param options[:staging_url]
+      # @param target_file_path [String] path to be downloaded to
+      # @param options [Hash] must contain :staging_url key (file will be downloaded from :staging_url + source_relative_path)
+      def download(source_relative_path, target_file_path, options = {})
+        @connection.download source_relative_path, target_file_path, options
+      end
+
+      def download_from_user_webdav(source_relative_path, target_file_path, options = { client: GoodData.client, project: project })
+        download(source_relative_path, target_file_path, options.merge(:directory => options[:directory],
+                                                                       :staging_url => user_webdav_path))
+      end
+
+      def upload_to_user_webdav(file, options = {})
+        upload(file, options.merge(:directory => options[:directory],
+                                   :staging_url => user_webdav_path))
+      end
+
+      def with_project(pid, &block)
+        GoodData.with_project(pid, client: self, &block)
+      end
+
+      def links
+        GoodData::Helpers.get_path(get('/gdc'), %w(about links))
+      end
+    end
+  end
+end