gooddata 0.6.3 → 0.6.4

data/lib/gooddata/exceptions/validation_error.rb

@@ -0,0 +1,12 @@
+# encoding: UTF-8
+
+module GoodData
+  # Project Not Found
+  class ValidationError < RuntimeError
+    DEFAULT_MSG = 'Validation has failed'
+
+    def initialize(msg = DEFAULT_MSG)
+      super(msg)
+    end
+  end
+end

data/lib/gooddata/extensions/extensions.rb

@@ -0,0 +1,6 @@
+# encoding: UTF-8
+
+base = Pathname(__FILE__).dirname.expand_path
+Dir.glob(base + '*.rb').each do |file|
+  require_relative file
+end

data/lib/gooddata/goodzilla/goodzilla.rb

@@ -6,7 +6,7 @@ module GoodData
     # @param a_maql_string Input MAQL string
     # @return [Array<String>] List of IDS
     def self.get_ids(a_maql_string)
-      a_maql_string.scan(/!\[([^\"]+)\]/).flatten
+      a_maql_string.scan(/!\[([^\"\]]+)\]/).flatten.uniq
     end
 
     # Get Facts from MAQL string
@@ -67,7 +67,7 @@ module GoodData
       metric = interpolated[:facts].reduce(metric) { |a, e| a.sub("#\"#{e[0]}\"", "[#{e[1]}]") }
       metric = interpolated[:attributes].reduce(metric) { |a, e| a.sub("@\"#{e[0]}\"", "[#{e[1]}]") }
       metric = interpolated[:metrics].reduce(metric) { |a, e| a.sub("?\"#{e[0]}\"", "[#{e[1]}]") }
-      metric = interpolated_ids.reduce(metric) { |a, e| a.sub("![#{e[0]}]", "[#{e[1]}]") }
+      metric = interpolated_ids.reduce(metric) { |a, e| a.gsub("![#{e[0]}]", "[#{e[1]}]") }
       metric
     end
   end

data/lib/gooddata/helpers/csv_helper.rb

@@ -0,0 +1,57 @@
+# encoding: UTF-8
+
+require 'csv'
+
+module GoodData
+  module Helpers
+    class Csv
+      class << self
+        # Read data from CSV
+        #
+        # @param [Hash] opts
+        # @option opts [String] :path File to read data from
+        # @option opts [Boolean] :header File to read data from
+        # @return Array of rows with loaded data
+        def read(opts)
+          path = opts[:path]
+          res = []
+
+          line = 0
+
+          CSV.foreach(path) do |row|
+            line += 1
+            next if opts[:header] && line == 1
+
+            if block_given?
+              data = yield row
+            else
+              data = row
+            end
+
+            res << data if data
+          end
+
+          res
+        end
+
+        # Write data to CSV
+        # @option opts [String] :path File to write data to
+        # @option opts [Array] :data Mandatory array of data to write
+        # @option opts [String] :header Optional Header row
+        def write(opts, &block)
+          path = opts[:path]
+          header = opts[:header]
+          data = opts[:data]
+
+          CSV.open(path, 'w') do |csv|
+            csv << header unless header.nil?
+            data.each do |entry|
+              res = yield entry
+              csv << res if res
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/helpers/helpers.rb

@@ -0,0 +1,6 @@
+# encoding: UTF-8
+
+base = Pathname(__FILE__).dirname.expand_path
+Dir.glob(base + '*.rb').each do |file|
+  require_relative file
+end

data/lib/gooddata/models/domain.rb

@@ -1,6 +1,6 @@
 # encoding: UTF-8
 
-require_relative 'account_settings'
+require_relative 'profile'
 
 module GoodData
   class Domain
@@ -24,34 +24,76 @@ module GoodData
       # @param login [String] Login of user to be invited
       # @param password [String] Default preset password
       # @return [Object] Raw response
-      def add_user(domain, login, password)
+      def add_user(opts)
+        generated_pass = rand(10E10).to_s
         data = {
-          :accountSetting => {
-            :login => login,
-            :firstName => 'FirstName',
-            :lastName => 'LastName',
-            :password => password,
-            :verifyPassword => password,
-            :email => login
-          }
+          :login => opts[:login],
+          :firstName => opts[:first_name] || 'FirstName',
+          :lastName => opts[:last_name] || 'LastName',
+          :password => opts[:password] || generated_pass,
+          :verifyPassword => opts[:password] || generated_pass,
+          :email => opts[:login]
         }
 
-        url = "/gdc/account/domains/#{domain}/users"
-        GoodData.post(url, data)
+        # Optional authentication modes
+        tmp = opts[:authentication_modes]
+        if tmp
+          if tmp.kind_of? Array
+            data[:authenticationModes] = tmp
+          elsif tmp.kind_of? String
+            data[:authenticationModes] = [tmp]
+          end
+        end
+
+        # Optional company
+        tmp = opts[:company_name]
+        tmp = opts[:company] if tmp.nil? || tmp.empty?
+        data[:companyName] = tmp if tmp && !tmp.empty?
+
+        # Optional country
+        tmp = opts[:country]
+        data[:country] = tmp if tmp && !tmp.empty?
+
+        # Optional phone number
+        tmp = opts[:phone]
+        tmp = opts[:phone_number] if tmp.nil? || tmp.empty?
+        data[:phoneNumber] = tmp if tmp && !tmp.empty?
+
+        # Optional position
+        tmp = opts[:position]
+        data[:position] = tmp if tmp && !tmp.empty?
+
+        # Optional sso provider
+        tmp = opts[:sso_provider]
+        data['ssoProvider'] = tmp if tmp && !tmp.empty?
+
+        # Optional timezone
+        tmp = opts[:timezone]
+        data[:timezone] = tmp if tmp && !tmp.empty?
+
+        # TODO: It will be nice if the API will return us user just newly created
+        url = "/gdc/account/domains/#{opts[:domain]}/users"
+        response = GoodData.post(url, :accountSetting => data)
+
+        raw = GoodData.get response['uri']
+
+        # TODO: Remove this hack when POST /gdc/account/domains/{domain-name}/users returns full profile
+        raw['accountSetting']['links'] = {} unless raw['accountSetting']['links']
+        raw['accountSetting']['links']['self'] = response['uri'] unless raw['accountSetting']['links']['self']
+
+        GoodData::Profile.new(raw)
       end
 
       # Finds user in domain by login
       #
       # @param domain [String] Domain name
       # @param login [String] User login
-      # @return [GoodData::AccountSettings] User account settings
+      # @return [GoodData::Profile] User profile
       def find_user_by_login(domain, login)
         url = "/gdc/account/domains/#{domain}/users?login=#{login}"
         tmp = GoodData.get url
         items = tmp['accountSettings']['items'] if tmp['accountSettings']
-        if items && items.length > 0
-          return GoodData::AccountSettings.new(items.first)
-        end
+        return GoodData::Profile.new(items.first) if items && items.length > 0
         nil
       end
 
@@ -60,18 +102,81 @@ module GoodData
       # @param [Hash] opts Options.
       # @option opts [Number] :offset The subject
       # @option opts [Number] :limit From address
+      # TODO: Review opts[:limit] functionality
       def users(domain, opts = USERS_OPTIONS)
         result = []
 
         options = USERS_OPTIONS.merge(opts)
-
-        tmp = GoodData.get("/gdc/account/domains/#{domain}/users?offset=#{options[:offset]}&limit=#{options[:limit]}")
-        tmp['accountSettings']['items'].each do |account|
-          result << GoodData::AccountSettings.new(account)
+        offset = 0 || options[:offset]
+        uri = "/gdc/account/domains/#{domain}/users?offset=#{offset}&limit=#{options[:limit]}"
+        loop do
+          break unless uri
+          tmp = GoodData.get(uri)
+          tmp['accountSettings']['items'].each do |account|
+            result << GoodData::Profile.new(account)
+          end
+          uri = tmp['accountSettings']['paging']['next']
         end
 
         result
       end
+
+      # Create users specified in list
+      # @param [Array<GoodData::Membership>] list List of users
+      # @param [String] default_domain_name Default domain name used when no specified in user
+      # @return [Array<GoodData::User>] List of users created
+      def users_create(list, default_domain = nil)
+        default_domain_name = default_domain.respond_to?(:name) ? default_domain.name : default_domain
+        domains = {}
+        list.map do |user|
+          # TODO: Add user here
+          domain_name = user.json['user']['content']['domain'] || default_domain_name
+
+          # Lookup for domain in cache'
+          domain = domains[domain_name]
+
+          # Get domain info from REST, add to cache
+          if domain.nil?
+            domain = {
+              :domain => GoodData::Domain[domain_name],
+              :users => GoodData::Domain[domain_name].users
+            }
+
+            domain[:users_map] = Hash[domain[:users].map { |u| [u.email, u] }]
+            domains[domain_name] = domain
+          end
+
+          # Check if user exists in domain
+          domain_user = domain[:users_map][user.email]
+
+          # Create domain user if needed
+          unless domain_user
+            password = user.json['user']['content']['password']
+
+            # Fill necessary user data
+            user_data = {
+              :login => user.login,
+              :firstName => user.first_name,
+              :lastName => user.last_name,
+              :password => password,
+              :verifyPassword => password,
+              :email => user.login
+            }
+
+            tmp = user.json['user']['content']['sso_provider']
+            user_data[:sso_provider] = tmp if tmp && !tmp.empty?
+
+            tmp = user.json['user']['content']['authentication_modes']
+            user_data[:authentication_modes] = tmp && !tmp.empty?
+
+            # Add created user to cache
+            domain_user = domain[:domain].add_user(user_data)
+            domain[:users] << domain_user
+            domain[:users_map][user.email] = domain_user
+          end
+          domain_user
+        end
+      end
     end
 
     def initialize(domain_name)
@@ -90,14 +195,15 @@ module GoodData
     # domain = GoodData::Domain['gooddata-tomas-korcak']
     # domain.add_user 'joe.doe@example', 'sup3rS3cr3tP4ssW0rtH'
     #
-    def add_user(login, password)
-      GoodData::Domain.add_user(name, login, password)
+    def add_user(opts)
+      opts[:domain] = name
+      GoodData::Domain.add_user(opts)
     end
 
     # Finds user in domain by login
     #
     # @param login [String] User login
-    # @return [GoodData::AccountSettings] User account settings
+    # @return [GoodData::Profile] User account settings
     def find_user_by_login(login)
       GoodData::Domain.find_user_by_login(name, login)
     end
@@ -107,7 +213,7 @@ module GoodData
     # @param [Hash] opts Additional user listing options.
     # @option opts [Number] :offset Offset to start listing from
     # @option opts [Number] :limit Limit of users to be listed
-    # @return [Array<GoodData::AccountSettings>] List of user account settings
+    # @return [Array<GoodData::Profile>] List of user account settings
     #
     # Example
     #
@@ -119,6 +225,10 @@ module GoodData
       GoodData::Domain.users(name, opts)
     end
 
+    def users_create(list)
+      GoodData::Domain.users_create(list, name)
+    end
+
     private
 
     # Private setter of domain name. Used by constructor not available for external users.

data/lib/gooddata/models/membership.rb

@@ -0,0 +1,402 @@
+# encoding: UTF-8
+
+require 'multi_json'
+
+require_relative 'project'
+require_relative 'project_role'
+
+module GoodData
+  class Membership
+    attr_reader :json
+
+    ASSIGNABLE_MEMBERS = [
+      :email,
+      :first_name,
+      :last_name,
+      :login,
+      :phone,
+      :status,
+      :title
+    ]
+
+    class << self
+      # Apply changes to object.
+      #
+      # @param obj [GoodData::User] Object to be modified
+      # @param changes [Hash] Hash with modifications
+      # @return [GoodData::User] Modified object
+      def apply(obj, changes)
+        changes.each do |param, val|
+          next unless ASSIGNABLE_MEMBERS.include? param
+          obj.send("#{param}=", val)
+        end
+        obj
+      end
+
+      # Gets hash representing diff of users
+      #
+      # @param user1 [GoodData::User] Original user
+      # @param user2 [GoodData::User] User to compare with
+      # @return [Hash] Hash representing diff
+      def diff(user1, user2)
+        res = {}
+        ASSIGNABLE_MEMBERS.each do |k|
+          l_value = user1.send("#{k}")
+          r_value = user2.send("#{k}")
+          res[k] = r_value if l_value != r_value
+        end
+        res
+      end
+
+      def diff_list(list1, list2)
+        tmp = Hash[list1.map { |v| [v.email, v] }]
+
+        res = {
+          :added => [],
+          :removed => [],
+          :changed => [],
+          :same => []
+        }
+
+        list2.each do |user_new|
+          user_existing = tmp[user_new.email]
+          if user_existing.nil?
+            res[:added] << user_new
+            next
+          end
+
+          if user_existing != user_new
+            diff = self.diff(user_existing, user_new)
+            res[:changed] << {
+              :user => user_existing,
+              :diff => diff
+            }
+          else
+            res[:same] << user_existing
+          end
+        end
+
+        tmp = Hash[list2.map { |v| [v.email, v] }]
+        list1.each do |user_existing|
+          user_new = tmp[user_existing.email]
+          if user_new.nil?
+            res[:removed] << user_existing
+            next
+          end
+        end
+
+        res
+      end
+    end
+
+    def initialize(json)
+      @json = json
+    end
+
+    # Checks objects for equality
+    #
+    # @param right [GoodData::User] Project to compare with
+    # @return [Boolean] True if same else false
+    def ==(other)
+      res = true
+      ASSIGNABLE_MEMBERS.each do |k|
+        l_val = send("#{k}")
+        r_val = other.send("#{k}")
+        res = false if l_val != r_val
+      end
+      res
+    end
+
+    # Checks objects for non-equality
+    #
+    # @param right [GoodData::User] 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::User] Modified object
+    def apply(changes)
+      GoodData::User.apply(self, changes)
+    end
+
+    # Gets author (person who created)  of this object
+    #
+    # @return [String] Author
+    def author
+      url = @json['user']['meta']['author']
+      data = GoodData.get url
+      GoodData::Membership.new(data)
+    end
+
+    # Gets the contributor
+    #
+    # @return [String] Contributor
+    def contributor
+      url = @json['user']['meta']['contributor']
+      data = GoodData.get url
+      GoodData::Membership.new(data)
+    end
+
+    # Gets date when created
+    #
+    # @return [DateTime] Created date
+    def created
+      Time.parse(@json['user']['meta']['created'])
+    end
+
+    # Gets hash representing diff of users
+    #
+    # @param user [GoodData::User] Another profile to compare with
+    # @return [Hash] Hash representing diff
+    def diff(user)
+      GoodData::User.diff(self, user)
+    end
+
+    # Gets the email
+    #
+    # @return [String] Email address
+    def email
+      @json['user']['content']['email'] || ''
+    end
+
+    # Sets the email
+    #
+    # @param new_email [String] New email to be assigned
+    def email=(new_email)
+      @json['user']['content']['email'] = new_email
+    end
+
+    # Gets the first name
+    #
+    # @return [String] First name
+    def first_name
+      @json['user']['content']['firstname'] || ''
+    end
+
+    # Sets the first name
+    #
+    # @param new_first_name [String] New first name to be assigned
+    def first_name=(new_first_name)
+      @json['user']['content']['firstname'] = new_first_name
+    end
+
+    # Gets the invitations
+    #
+    # @return [Array<GoodData::Invitation>] List of invitations
+    def invitations
+      res = []
+
+      tmp = GoodData.get @json['user']['links']['invitations']
+      tmp['invitations'].each do |invitation|
+        # TODO: Something is missing here
+      end
+
+      res
+    end
+
+    # Gets the last name
+    #
+    # @return [String] Last name
+    def last_name
+      @json['user']['content']['lastname'] || ''
+    end
+
+    # Sets the last name
+    #
+    # @param new_last_name [String] New last name to be assigned
+    def last_name=(new_last_name)
+      @json['user']['content']['lastname'] = new_last_name
+    end
+
+    # Gets the login
+    #
+    # @return [String] Login
+    def login
+      @json['user']['content']['login'] || ''
+    end
+
+    # Sets the last name
+    #
+    # @param new_login [String] New login to be assigned
+    def login=(new_login)
+      @json['user']['content']['login'] = new_login
+    end
+
+    # Gets user raw object ID
+    #
+    # @return [String] Raw Object ID
+    def obj_id
+      uri.split('/').last
+    end
+
+    # Gets the permissions
+    #
+    # @return [Hash] Hash with permissions
+    def permissions
+      res = {}
+
+      tmp = GoodData.get @json['user']['links']['permissions']
+      tmp['associatedPermissions']['permissions'].each do |permission_name, permission_value|
+        res[permission_name] = permission_value
+      end
+
+      res
+    end
+
+    # Gets the phone number
+    #
+    # @return [String] Phone number
+    def phone
+      @json['user']['content']['phonenumber'] || ''
+    end
+
+    # Sets the phone number
+    #
+    # @param new_phone_number [String] New phone number to be assigned
+    def phone=(new_phone_number)
+      @json['user']['content']['phonenumber'] = new_phone_number
+    end
+
+    # Gets profile of this membership
+    def profile
+      raw = GoodData.get @json['user']['links']['self']
+      GoodData::Profile.new(raw)
+    end
+
+    # Gets URL of profile membership
+    def profile_url
+      @json['user']['links']['self']
+    end
+
+    # Gets project which this membership relates to
+    def project
+      raw = GoodData.get project_url
+      GoodData::Project.new(raw)
+    end
+
+    # Gets project id
+    def project_id
+      @json['user']['links']['roles'].split('/')[3]
+    end
+
+    # Gets project url
+    def project_url
+      @json['user']['links']['roles'].split('/')[0..3].join('/')
+    end
+
+    # Gets the projects of user
+    #
+    # @return [Array<GoodData::Project>] Array of projets
+    def projects
+      res = []
+
+      tmp = GoodData.get @json['user']['links']['projects']
+      tmp['projects'].each do |project_meta|
+        project_uri = project_meta['project']['links']['self']
+        project = GoodData.get project_uri
+        res << GoodData::Project.new(project)
+      end
+
+      res
+    end
+
+    # Gets first role
+    def role
+      roles.first
+    end
+
+    # Gets the project roles of user
+    #
+    # @return [Array<GoodData::ProjectRole>] Array of project roles
+    def roles
+      res = []
+
+      tmp = GoodData.get @json['user']['links']['roles']
+      tmp['associatedRoles']['roles'].each do |role_uri|
+        role = GoodData.get role_uri
+        res << GoodData::ProjectRole.new(role)
+      end
+
+      res
+    end
+
+    # Gets the status
+    #
+    # @return [String] Status
+    def status
+      @json['user']['content']['status'] || ''
+    end
+
+    # Sets the status
+    #
+    # @param new_status [String] New phone number to be assigned
+    def status=(new_status)
+      @json['user']['content']['status'] = new_status
+    end
+
+    # Gets the title
+    #
+    # @return [String] User title
+    def title
+      @json['user']['meta']['title'] || ''
+    end
+
+    # Sets the title
+    #
+    # @param new_title [String] New title to be assigned
+    def title=(new_title)
+      @json['user']['content']['title'] = new_title
+    end
+
+    # Gets the date when updated
+    #
+    # @return [DateTime] Date of last update
+    def updated
+      DateTime.parse(@json['user']['meta']['updated'])
+    end
+
+    # Gets the object URI
+    #
+    # @return [String] Object URI
+    def uri
+      @json['user']['links']['self']
+    end
+
+    # Enables membership
+    #
+    # @return result from post execution
+    def enable
+      self.status = 'enabled'
+    end
+
+    # Disables membership
+    #
+    # @return result from post execution
+    def disable
+      self.status = 'disabled'
+    end
+
+    private
+
+    # Sets status to 'ENABLED' or 'DISABLED'
+    def status=(new_status)
+      payload = {
+        'user' => {
+          'content' => {
+            'status' => new_status.to_s.upcase,
+            'userRoles' => @json['user']['content']['userRoles']
+          },
+          'links' => {
+            'self' => uri
+          }
+        }
+      }
+
+      @json = GoodData.post("/gdc/projects/#{project_id}/users", payload)
+    end
+  end
+end