gooddata 0.6.3 → 0.6.4

data/lib/gooddata/models/profile.rb

@@ -1,32 +1,384 @@
 # encoding: UTF-8
 
+require_relative 'project'
+
 module GoodData
+  # Account settings representation with some added sugar
   class Profile
-    private_class_method :new
-    attr_reader :user, :json
+    attr_reader :json
+
+    EMPTY_OBJECT = {
+      'accountSetting' => {
+        'companyName' => nil,
+        'country' => nil,
+        'created' => nil,
+        'firstName' => nil,
+        'lastName' => nil,
+        'login' => nil,
+        'phoneNumber' => nil,
+        'position' => nil,
+        'timezone' => nil,
+        'updated' => nil,
+        'links' => {
+          'projects' => nil,
+          'self' => nil
+        },
+        'email' => nil,
+        'authenticationModes' => []
+      }
+    }
+
+    ASSIGNABLE_MEMBERS = [
+      :company,
+      :country,
+      :email,
+      :login,
+      :first_name,
+      :last_name,
+      :phone,
+      :position,
+      :timezone
+    ]
 
     class << self
-      def load
-        # GoodData.logger.info "Loading user profile..."
-        Profile.send 'new'
+      # Apply changes to object.
+      #
+      # @param obj [GoodData::Profile] Object to be modified
+      # @param changes [Hash] Hash with modifications
+      # @return [GoodData::Profile] Modified object
+      def apply(obj, changes)
+        changes.each do |param, val|
+          next unless ASSIGNABLE_MEMBERS.include? param
+          obj.send("#{param}=", val)
+        end
+        obj
+      end
+
+      # Creates new instance from hash with attributes
+      #
+      # @param attributes [Hash] Hash with initial attributes
+      # @return [GoodData::Profile] New profile instance
+      def create(attributes)
+        json = EMPTY_OBJECT.dup
+        res = GoodData::Profile.new(json)
+
+        attributes.each do |k, v|
+          res.send("#{k}=", v) if ASSIGNABLE_MEMBERS.include? k
+        end
+
+        res.save!
+        res
+      end
+
+      # Gets user currently logged in
+      # @return [GoodData::Profile] User currently logged-in
+      def current
+        json = GoodData.get GoodData.connection.user['profile']
+        GoodData::Profile.new(json)
+      end
+
+      # Gets hash representing diff of profiles
+      #
+      # @param user1 [GoodData::Profile] Original user
+      # @param user2 [GoodData::Profile] 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 => []
+        }
+
+        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
+            }
+          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
+
+    # 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)
+      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::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 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
+      GoodData.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
+
+    # 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
+
+    # Get full name
+    #
+    # @return [String] Full name
+    def name
+      "#{first_name} #{last_name}"
+    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']['phone'] || ''
+    end
+
+    # Set the phone
+    #
+    # @param val [String] Phone to be set
+    def phone=(val)
+      @dirty ||= phone != val
+      @json['accountSetting']['phone'] = val
+    end
+
+    # 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
-      @json['accountSetting']['links']['projects']
+      res = []
+
+      projects = GoodData.get @json['accountSetting']['links']['projects']
+      projects['projects'].each do |project|
+        res << GoodData::Project.new(project)
+      end
+
+      res
     end
 
-    alias_method :to_json, :json
+    # Saves object if dirty, clears dirty flag
+    def save!
+      if @dirty
+        raw = @json.dup
+        raw['accountSetting'].delete('login')
 
-    def [](key, options = {})
-      @json['accountSetting'][key]
+        if uri && !uri.empty?
+          url = "/gdc/account/profile/#{obj_id}"
+          @json = GoodData.put url, raw
+          @dirty = false
+        end
+      end
     end
 
-    private
+    # 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
 
-    def initialize
-      @json = GoodData.get GoodData.connection.user['profile']
-      @user = @json['accountSetting']['firstName'] + ' ' + @json['accountSetting']['lastName']
+    # Gets the resource REST URI
+    #
+    # @return [String] Resource URI
+    def uri
+      @json['accountSetting']['links']['self']
     end
   end
 end

data/lib/gooddata/models/project.rb

@@ -1,5 +1,6 @@
 # encoding: UTF-8
 
+require 'csv'
 require 'zip'
 require 'fileutils'
 
@@ -21,10 +22,7 @@ module GoodData
       # Returns an array of all projects accessible by
       # current user
       def all
-        json = GoodData.get GoodData.profile.projects
-        json['projects'].map do |project|
-          Project.new project
-        end
+        GoodData.profile.projects
       end
 
       # Returns a Project object identified by given string
@@ -74,7 +72,7 @@ module GoodData
                 'driver' => attributes[:driver] || 'Pg'
               }
             }
-          }
+        }
 
         json['project']['meta']['projectTemplate'] = attributes[:template] if attributes[:template] && !attributes[:template].empty?
         project = Project.new json
@@ -98,6 +96,23 @@ module GoodData
         sleep 3
         project
       end
+
+      # Takes one CSV line and creates hash from data extracted
+      #
+      # @param row CSV row
+      def user_csv_import(row)
+        {
+          'user' => {
+            'content' => {
+              'email' => row[0],
+              'login' => row[1],
+              'firstname' => row[2],
+              'lastname' => row[3]
+            },
+            'meta' => {}
+          }
+        }
+      end
     end
 
     # Creates a data set within the project
@@ -139,13 +154,6 @@ module GoodData
       @json['project']['meta']['author']
     end
 
-    # Adds user to project
-    #
-    # TODO: Discuss with @fluke777 if is not #invite sufficient
-    def add_user(email_address, domain)
-      fail 'Not implemented'
-    end
-
     # Returns web interface URI of project
     #
     # @return [String] Project URL
@@ -218,7 +226,7 @@ module GoodData
     #
     # @return [DateTime] Date time when created
     def created
-      DateTime.parse(@json['meta']['created'])
+      DateTime.parse(@json['project']['meta']['created'])
     end
 
     # Gets ruby wrapped raw project JSON data
@@ -234,6 +242,13 @@ module GoodData
       end
     end
 
+    # Gets processes for the project
+    #
+    # @return [Array<GoodData::Process>] Processes for the current project
+    def processes
+      GoodData::Process.all
+    end
+
     # Deletes project
     def delete
       fail "Project '#{title}' with id #{uri} is already deleted" if state == :deleted
@@ -249,10 +264,11 @@ module GoodData
     #
     # @param [String] role_name Title of role to look for
     # @return [GoodData::ProjectRole] Project role if found
-    def get_role_by_identifier(role_name)
-      tmp = roles
-      tmp.each do |role|
-        return role if role.identifier.downcase == role_name.downcase
+    def get_role_by_identifier(role_name, role_list = roles)
+      role_name = role_name.downcase.gsub(/role$/, '')
+      role_list.each do |role|
+        tmp_role_name = role.identifier.downcase.gsub(/role$/, '')
+        return role if tmp_role_name == role_name
       end
       nil
     end
@@ -261,9 +277,8 @@ module GoodData
     #
     # @param [String] role_summary Summary of role to look for
     # @return [GoodData::ProjectRole] Project role if found
-    def get_role_by_summary(role_summary)
-      tmp = roles
-      tmp.each do |role|
+    def get_role_by_summary(role_summary, role_list = roles)
+      role_list.each do |role|
         return role if role.summary.downcase == role_summary.downcase
       end
       nil
@@ -273,14 +288,47 @@ module GoodData
     #
     # @param [String] role_title Title of role to look for
     # @return [GoodData::ProjectRole] Project role if found
-    def get_role_by_title(role_title)
-      tmp = roles
-      tmp.each do |role|
+    def get_role_by_title(role_title, role_list = roles)
+      role_list.each do |role|
         return role if role.title.downcase == role_title.downcase
       end
       nil
     end
 
+    # Gets project role
+    #
+    # @param [String] role_title Title of role to look for
+    # @return [GoodData::ProjectRole] Project role if found
+    def get_role(role_name, role_list = roles)
+      return role_name if role_name.is_a? GoodData::ProjectRole
+
+      role_name.downcase!
+      role_list.each do |role|
+        return role if role.uri == role_name ||
+          role.identifier.downcase == role_name ||
+          role.identifier.downcase.gsub(/role$/, '') == role_name ||
+          role.title.downcase == role_name ||
+          role.summary.downcase == role_name
+      end
+      nil
+    end
+
+    # Gets user by its email, full_name, login or uri
+    #
+    # @param [String] name Name to look for
+    # @param [Array<GoodData::User>]user_list Optional cached list of users used for look-ups
+    # @return [GoodDta::Membership] User
+    def get_user(name, user_list = users)
+      return name if name.instance_of?(GoodData::Membership)
+      name.downcase!
+      user_list.each do |user|
+        return user if user.uri.downcase == name ||
+          user.login.downcase == name ||
+          user.email.downcase == name
+      end
+      nil
+    end
+
     # Initializes object instance from raw wire JSON
     #
     # @param json Json used for initialization
@@ -300,9 +348,8 @@ module GoodData
 
       role_url = nil
       if role.index('/gdc/') != 0
-        tmp = get_role_by_identifier(role)
-        tmp = get_role_by_title(role) if tmp.nil?
-        role_url = tmp['url'] if tmp
+        tmp = get_role(role)
+        role_url = tmp.uri if tmp
       else
         role_url = role if role_url.nil?
       end
@@ -352,6 +399,29 @@ module GoodData
       @md ||= Links.new GoodData.get(data['links']['metadata'])
     end
 
+    # Gets membership for profile specified
+    #
+    # @param [GoodData::Profile] profile - Profile to be checked
+    # @param [Array<GoodData::Membership>] list Optional list of members to check against
+    # @return [GoodData::Membership] Membership if found
+    def member(profile, list = members)
+      if profile.is_a? String
+        return list.find do |m|
+          m.uri == profile || m.login == profile
+        end
+      end
+      list.find { |m| m.login == profile.login }
+    end
+
+    # Checks if the profile is member of project
+    #
+    # @param [GoodData::Profile] profile - Profile to be checked
+    # @param [Array<GoodData::Membership>] list Optional list of members to check against
+    # @return [Boolean] true if is member else false
+    def member?(profile, list = members)
+      !member(profile, list).nil?
+    end
+
     # Gets raw resource ID
     #
     # @return [String] Raw resource ID
@@ -422,16 +492,11 @@ module GoodData
     # @return [Array<GoodData::ProjectRole>] List of roles
     def roles
       url = "/gdc/projects/#{pid}/roles"
-
-      res = []
-
       tmp = GoodData.get(url)
-      tmp['projectRoles']['roles'].each do |role_url|
+      tmp['projectRoles']['roles'].map do |role_url|
         json = GoodData.get role_url
-        res << GoodData::ProjectRole.new(json)
+        GoodData::ProjectRole.new(json)
       end
-
-      res
     end
 
     # Saves project
@@ -498,7 +563,7 @@ module GoodData
     #
     # @return [DateTime] Date time of last update
     def updated
-      DateTime.parse(@json['meta']['updated'])
+      DateTime.parse(@json['project']['meta']['updated'])
     end
 
     # Uploads file to project
@@ -521,12 +586,157 @@ module GoodData
 
       tmp = GoodData.get @json['project']['links']['users']
       tmp['users'].map do |user|
-        res << GoodData::User.new(user)
+        res << GoodData::Membership.new(user)
       end
 
       res
     end
 
+    alias_method :members, :users
+
+    def users_create(list, role_list = roles)
+      domains = {}
+      list.map do |user|
+        # TODO: Add user here
+        domain_name = user.json['user']['content']['domain']
+
+        # 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]
+        fail ArgumentError, "Trying to add user '#{user.login}' which is not valid user in domain '#{domain_name}'" if domain_user.nil?
+
+        # Lookup for role
+        role_name = user.json['user']['content']['role'] || 'readOnlyUser'
+        role = get_role(role_name, role_list)
+        fail ArgumentError, "Invalid role name specified '#{role_name}' for user '#{user.email}'" if role.nil?
+
+        # Assign user project role
+        set_user_roles(domain_user, [role.uri], role_list)
+      end
+    end
+
+    # Imports users from CSV
+    #
+    # # Features
+    # - Create new users
+    # - Delete old users
+    # - Update existing users
+    #
+    # CSV Format
+    # TODO: Describe CSV Format here
+    #
+    # @param path CSV file to be loaded
+    # @param opts Optional additional options
+    def users_import(new_users, domain = nil)
+      # Diff users
+      diff = GoodData::Membership.diff_list(users, new_users)
+
+      # Create domain users
+      GoodData::Domain.users_create(diff[:added], domain)
+
+      # Create new users
+      role_list = roles
+      users_create(diff[:added], role_list)
+
+      # Get changed users objects from hash
+      list = diff[:changed].map do |user|
+        user[:user]
+      end
+
+      # Join list of changed users with 'same' users
+      list = list.zip(diff[:same]).flatten.compact
+
+      new_users_map = Hash[new_users.map { |u| [u.email, u] }]
+
+      # Create list with user, desired_roles hashes
+      list = list.map do |user|
+        {
+          :user => user,
+          :roles => new_users_map[user.email].json['user']['content']['role'].split(' ').map { |r| r.downcase }.sort
+        }
+      end
+
+      # Update existing users
+      set_users_roles(list, role_list)
+
+      # Remove old users
+      users_remove(diff[:removed])
+    end
+
+    # Disable users
+    #
+    # @param list List of users to be disabled
+    def users_remove(list)
+      list.map do |user|
+        user.disable
+      end
+    end
+
+    # Update user
+    #
+    # @param user User to be updated
+    # @param desired_roles Roles to be assigned to user
+    # @param role_list Optional cached list of roles used for lookups
+    def set_user_roles(user, desired_roles, role_list = roles)
+      if user.is_a? String
+        user = get_user(user)
+        fail ArgumentError, "Invalid user '#{user}' specified" if user.nil?
+      end
+
+      desired_roles = [desired_roles] unless desired_roles.is_a? Array
+
+      roles = desired_roles.map do |role_name|
+        role = get_role(role_name, role_list)
+        fail ArgumentError, "Invalid role '#{role_name}' specified for user '#{user.email}'" if role.nil?
+        role.uri
+      end
+
+      url = "#{uri}/users"
+      payload = {
+        'user' => {
+          'content' => {
+            'status' => 'ENABLED',
+            'userRoles' => roles
+          },
+          'links' => {
+            'self' => user.uri
+          }
+        }
+      }
+
+      GoodData.post url, payload
+    end
+
+    alias_method :add_user, :set_user_roles
+
+    # Update list of users
+    #
+    # @param list List of users to be updated
+    # @param role_list Optional list of cached roles to prevent unnecessary server round-trips
+    def set_users_roles(list, role_list = roles)
+      list.map do |user_hash|
+        user = user_hash[:user]
+        roles = user_hash[:role] || user_hash[:roles]
+        {
+          :user => user,
+          :result => set_user_roles(user, roles, role_list)
+        }
+      end
+    end
+
     # Run validation on project
     # Valid settins for validation are (default all):
     # ldm - Checks the consistency of LDM objects.