your_platform 0.0.1 → 0.0.2

data/app/models/user_account.rb

@@ -0,0 +1,162 @@
+#
+# Every User may have an UserAccount that enables the user to log in to the website.
+# 
+#    user = User.create(...)       # This user may not log in.
+#    account = user.build_account
+#    account.password = "foo"
+#    account.save                  # Now, the user may log in.
+#    account.destroy               # Now, the user may not log in anymore. 
+#
+class UserAccount < ActiveRecord::Base
+  
+  # For authentication, we use devise, 
+  # https://github.com/plataformatec/devise.
+  # 
+  # Available Modules:
+  #   Database Authenticatable: 
+  #     encrypts and stores a password in the database to validate the authenticity of a user
+  #     while signing in. The authentication can be done both through POST requests or 
+  #     HTTP Basic Authentication.
+  #   Omniauthable: adds Omniauth (https://github.com/intridea/omniauth) support;
+  #   Confirmable: sends emails with confirmation instructions and verifies whether an account
+  #     is already confirmed during sign in.
+  #   Recoverable: resets the user password and sends reset instructions.
+  #   Registerable: handles signing up users through a registration process, also allowing 
+  #     them to edit and destroy their account.
+  #   Rememberable: manages generating and clearing a token for remembering the user from a 
+  #     saved cookie.
+  #   Trackable: tracks sign in count, timestamps and IP address.
+  #   Timeoutable: expires sessions that have no activity in a specified period of time.
+  #   Validatable: provides validations of email and password. It's optional and can be customized, 
+  #     so you're able to define your own validations.
+  #   Lockable: locks an account after a specified number of failed sign-in attempts. 
+  #     Can unlock via email or after a specified time period.
+  # 
+  devise :database_authenticatable, :recoverable, :rememberable, :validatable, :registerable
+  attr_accessible :password, :password_confirmation, :remember_me
+
+  # Virtual attribute for authenticating by either username, alias or email
+  attr_accessor :login
+
+  belongs_to               :user, inverse_of: :account
+
+  before_validation        :generate_password_if_unset
+                             # This needs to run before validation, since validation
+                             # requires a password to be set in order to allow saving the account.
+                             # See ressources of `has_secure_password` above.
+  
+  before_save              :generate_password_if_unset
+                             # This is required, because, apparently, the `before_validation` callback is not called
+                             # if the account is created via an association (like User.create( ... , create_account: true )).
+                             # But `before_save` callbacks are called.
+                             # Notice: Apparently, even `validates_associated :account` in the User model has no effect.
+
+  delegate :email, :to => :user, :allow_nil => true
+
+  def readonly?
+    false # Otherwise, the user is not able to login.
+  end
+  
+  # HACK: This method seems to be required by the PasswordController and is missing, 
+  # since we have a virtual email field.
+  # TODO: If we ever change the Password authentication 
+  def email= value
+    #dummy required by devise to create an 'error' user account
+  end
+
+  def email_changed?
+    false
+  end
+  
+  # Configure each account to *not* automatically log out when the browser is closed.
+  # After a system reboot, the user is still logged in, which is the expected behaviour
+  # for this application.
+  #
+  # This useses devise's rememberable module.
+  #
+  def remember_me
+    true
+  end
+
+  # Used by devise to identify the correct user account by the given strings.
+  #
+  def self.find_first_by_auth_conditions(warden_conditions)
+    login_string = warden_conditions[:login] || warden_conditions[:email]
+    return UserAccount.identify(login_string) if login_string
+    return UserAccount.where(warden_conditions).first # use devise identification system for auth tokens and the like.
+  end
+
+  # Tries to identify a user based on the given `login_string`.
+  # This can be one of those defined in `User.attributes_used_for_identification`,
+  # currently, `[:alias, :last_name, :name, :email]`.
+  #
+  # Bug fix: The alias is prioritized, such that a user having the alias *doe*
+  # can be identified by this alias even if there are other users with surname *Doe*.
+  #
+  def self.identify(login_string)
+    
+    # Priorization: Check alias first. (Bug fix)
+    user_identified_by_alias = User.find_by_alias(login_string)
+    users_that_match_the_login_string = [ User.find_by_alias(login_string) ] if user_identified_by_alias
+    
+    # What can go wrong?
+    # 1. No user could match the login string.
+    users_that_match_the_login_string ||= User.find_all_by_identification_string( login_string )
+    #raise 'no_user_found' unless users_that_match_the_login_string.count > 0
+    return nil unless users_that_match_the_login_string.count > 0
+
+    # 2. The user may not have an active user account.
+    users_that_match_the_login_string_and_have_an_account = users_that_match_the_login_string.select do |user|
+      user.has_account? 
+    end
+    raise 'user_has_no_account' unless users_that_match_the_login_string_and_have_an_account.count > 0
+    
+    # 3. The identification string may refer to several users with an active user account.
+    raise 'identification_not_unique' if users_that_match_the_login_string_and_have_an_account.count > 1
+    identified_user = users_that_match_the_login_string_and_have_an_account.first
+
+    return identified_user.account
+  end
+
+  def send_new_password
+    generate_password
+    self.save
+    send_welcome_email
+  end
+
+  def generate_password
+    self.password = Password.generate
+  end
+
+  # This generates a password if (1) no password is stored in the database
+  # and (2) no new password is set to be saved (in the `password` attribute).
+  def generate_password_if_unset
+    if self.encrypted_password.blank?
+      unless self.password
+        self.generate_password
+      end
+    end
+  end
+  
+  def auth_token
+    super || generate_auth_token!
+  end
+  
+  def generate_auth_token!
+    # see also: https://gist.github.com/josevalim/fb706b1e933ef01e4fb6
+    #
+    raise 'auth_token already set' if self.read_attribute(:auth_token)
+    token = ''
+    loop do
+      token = Devise.friendly_token + Devise.friendly_token
+      break token unless UserAccount.where(auth_token: token).first
+    end
+    self.update_attribute :auth_token, token
+    token
+  end
+
+  def send_welcome_email
+    raise 'attempt to send welcome email with empty password' unless self.password
+    UserAccountMailer.welcome_email( self.user, self.password ).deliver
+  end
+end

data/app/models/user_alias.rb

@@ -0,0 +1,112 @@
+# The UserAlias is a String that is used for identification during login.
+# It can be chosen by the user and defaults to a combination of first and last name.
+# The alias is unique, i.e. two users can't have the same alias.
+#
+#    UserAlias.taken?("foo")
+#    alias = user.generate_alias
+#    alias = UserAlias.generate_for(user)
+#
+class UserAlias < String
+  
+  # UserAlias.taken? "foo"  # => false
+  # User.create(alias: "foo", ...)
+  # UserAlias.taken? "foo"  # => <User ...>
+  #
+  def self.taken?( alias_to_check )
+    User.where( :alias => alias_to_check ).try(:first) || false
+  end
+
+  # Checks if the alias is already taken by a User stored in the database.
+  #
+  #    user = User.new(alias: "foo")
+  #    user.alias.taken?  # => false
+  #    user.save
+  #    user.alias.taken?  # => <User ...>
+  #
+  def taken?
+    UserAlias.taken? self
+  end
+  
+  # Generate an alias for a User based on the user's name.
+  # 
+  #     user.alias = UserAlias.generate_for(user)
+  #     user.generate_alias
+  #
+  def self.generate_for(user)
+    raise 'no user given' if not user
+    raise 'the given user has no last_name' if not user.last_name.present?
+    raise 'the given user has no first_name' if not user.first_name.present?
+    
+    suggestion = try_to_generate_from_last_name(user)                      # doe
+    suggestion ||= try_to_generate_from_first_and_last_name(user)          # j.doe
+    suggestion ||= try_to_generate_long_from_first_and_last_name(user)     # john.doe
+    suggestion ||= try_to_generate_long_from_name_and_year_of_birth(user)  # john.doe.1986
+    
+    # If the suggestion is still empty (no successful generation), the empty 
+    # alias will raise a validation error and the user will be asked to enter
+    # an alias.
+    
+    return UserAlias.new(suggestion) if suggestion
+    return nil
+  end
+  
+  private
+  
+  # If there is no other user having the same last name, use just the last name
+  # as alias.
+  #
+  def self.try_to_generate_from_last_name(user)
+
+    # TODO: Rails 4 way: User.where(...).where.not(...)
+    # http://stackoverflow.com/questions/5426421/rails-model-find-where-not-equal
+    
+    if User.where("last_name=? AND id!=?", user.last_name, user.id).count == 0
+      user.last_name.downcase
+    end
+  end
+  
+  # If there is no other user with the same last name and the same initial of the
+  # first name, use a combination like j.doe as alias.
+  #
+  def self.try_to_generate_from_first_and_last_name(user)
+    if User.where("last_name=? 
+                   AND first_name LIKE ?
+                   AND id!=?", 
+                   user.last_name, "#{user.first_name.first}%", user.id ).count == 0
+      "#{user.first_name.downcase.first}.#{user.last_name.downcase}"
+    end
+  end
+  
+  # If there is no other user with the same first and last name, use
+  # a combination like john.doe as alias.
+  #
+  def self.try_to_generate_long_from_first_and_last_name(user)
+    if User.where("last_name=? 
+                   AND first_name=? 
+                   AND id!=?", 
+                   user.last_name, user.first_name, user.id ).count == 0
+      "#{user.first_name.downcase}.#{user.last_name.downcase}"
+    end
+  end
+  
+  # If there is no other user with the same first name, last name and
+  # year of birth, use a combination like john.doe.1986 as alias.
+  #
+  def self.try_to_generate_long_from_name_and_year_of_birth(user)
+    if user.date_of_birth
+      if User.where("last_name=? 
+                     AND first_name=? 
+                     AND id!=?", 
+                     user.last_name, user.first_name, user.id ).select do |other_user|
+                       other_user.date_of_birth && 
+                         (other_user.date_of_birth.year != user.date_of_birth.year)
+                     end.count == 0
+        "#{user.first_name.downcase}.#{user.last_name.downcase}.#{user.date_of_birth.year}"
+      end
+    end
+  end  
+
+end
+
+
+

data/app/models/user_group_membership.rb

@@ -0,0 +1,300 @@
+#
+# In this application, all user group memberships, i.e. memberships of a certain
+# user in a certain group, are stored implicitly in the dag_links table in order
+# to minimize the number of database queries that are necessary to find out
+# whether a user is member in a certain group through an indirect membership.
+#
+# This class allows abstract access to the UserGroupMemberships themselves,
+# and to their properties like since when the membership exists.
+#
+class UserGroupMembership < DagLink
+
+  before_validation :ensure_correct_ancestor_and_descendant_type
+
+  # Validity Range
+  # ====================================================================================================
+
+  include UserGroupMembershipMixins::ValidityRange
+  include UserGroupMembershipMixins::ValidityRangeForIndirectMemberships
+  
+  
+  # May Need Review Flag
+  # ====================================================================================================
+
+  # Some memberships may contain information that need review, e.g. when a validity range
+  # was entered by assumption.
+  #
+  # This is stored as the flag :needs_review.
+  #
+  has_many_flags
+  may_need_review
+  attr_accessible :needs_review
+  
+
+  # General Properties
+  # ====================================================================================================
+
+  # Title, e.g. 'Membership of John Doe in GroupXY'
+  # 
+  def title
+    I18n.translate( :membership_of_user_in_group, user_name: self.user.title, group_name: self.group.name )
+  end
+
+  # Creation Class Method
+  # ====================================================================================================
+
+  # Create a membership of the `u` in the group `g`.
+  #
+  #    membership = UserGroupMembership.create( user: u, group: g )
+  #
+  def self.create( params )
+    if UserGroupMembership.find_by( params ).present?
+      raise 'Membership already exists: id = ' + UserGroupMembership.find_by( params ).id.to_s
+    else
+      user = params[:user]
+      user ||= User.find params[:user_id] if params[:user_id]
+      user ||= User.find_by_title params[:user_title] if params[:user_title]
+      raise "Could not create UserGroupMembership without user." unless user
+      
+      group = params[ :group ]
+      group ||= Group.find params[:group_id] if params[:group_id]
+      raise "Could not create UserGroupMembership without group." unless group
+      
+      new_membership = DagLink
+        .create(ancestor_id: group.id, ancestor_type: 'Group', descendant_id: user.id, descendant_type: 'User')
+        .becomes(UserGroupMembership)
+        
+      # This needs to be called manually, since DagLink won't call the proper callback.
+      #
+      new_membership.set_valid_from_to_now(true)
+      new_membership.save
+      
+      return new_membership
+    end
+  end
+
+
+  # Finder Class Methods
+  # ====================================================================================================
+
+  # Find all memberships that match the given parameters.
+  # This method returns an ActiveRecord::Relation object, which means that the result can
+  # be chained with scope methods.
+  #
+  #     memberships = UserGroupMembership.find_all_by( user: u )
+  #     memberships = UserGroupMembership.find_all_by( group: g )
+  #     memberships = UserGroupMembership.find_all_by( user: u, group: g ).now
+  #     memberships = UserGroupMembership.find_all_by( user: u, group: g ).in_the_past
+  #     memberships = UserGroupMembership.find_all_by( user: u, group: g ).now_and_in_the_past
+  #
+  def self.find_all_by( params )
+    user = params[ :user ]
+    user ||= User.find params[:user_id] if params[:user_id]
+    user ||= User.find_by_title params[:user_title] if params[:user_title]
+    group = params[ :group ]
+    group ||= Group.find params[:group_id] if params[:group_id]
+    links = UserGroupMembership
+      .where( :descendant_type => "User" )
+      .where( :ancestor_type => "Group" )
+    links = links.where( :descendant_id => user.id ) if user
+    links = links.where( :ancestor_id => group.id ) if group
+    links = links.order('valid_from')
+    return links
+  end
+
+  # Find the first membership that matches the parameters `params`.
+  # This is a shortcut for `find_all_by( params ).first`.
+  # Use this, if you only expect one membership to be found.
+  #
+  def self.find_by( params )
+    self.find_all_by( params ).limit( 1 ).first
+  end
+
+  def self.find_all_by_user( user )
+    self.find_all_by( user: user )
+  end
+
+  def self.find_all_by_group( group )
+    self.find_all_by( group: group )
+  end
+
+  def self.find_by_user_and_group( user, group )
+    self.find_by( user: user, group: group )
+  end
+
+  def self.find_all_by_user_and_group( user, group )
+    self.find_all_by( user: user, group: group )
+  end
+
+
+  # Access Methods to Associated User and Group
+  # ====================================================================================================   
+
+  def user
+    self.descendant
+  end
+  
+  def user=(new_user)
+    self.descendant_id = new_user.id
+    self.descendant_type = 'User'
+  end
+  
+  def user_id
+    self.descendant_id
+  end
+    
+  def user_title
+    user.try(:title)
+  end
+  def user_title=(new_user_title)
+    self.user = User.find_by_title(new_user_title)
+  end
+
+  def group
+    self.ancestor
+  end
+  
+  def group_id
+    self.ancestor_id
+  end
+  
+  def ensure_correct_ancestor_and_descendant_type
+    self.ancestor_type = 'Group'
+    self.descendant_type = 'User'
+  end
+  private :ensure_correct_ancestor_and_descendant_type
+
+  
+  # Associated Corporation
+  # ====================================================================================================
+
+  # If this membership is a subgroup membership of a corporation, this method will return the 
+  # corporation. Otherwise, this will return nil.
+  #
+  # corporation
+  #     |-------- group 
+  #                 |---( membership )---- user
+  #
+  #     membership = UserGroupMembership.find_by_user_and_group( user, group )
+  #     membership.corporation == corporation
+  #
+  def corporation
+    if self.group && self.user
+      ( ( self.group.ancestor_groups + [ self.group ] ) && self.user.corporations ).first
+    end
+  end
+
+
+  # Access Methods to Associated Direct Memberships
+  # ====================================================================================================  
+
+  # Returns the direct memberships corresponding to this membership (self).
+  # For clarification, consider the following structure:
+  #
+  #   group1
+  #     |---- group2
+  #             |---- user
+  #
+  # user is not a direct member of group1, but an indirect member. But user is a direct member of group2.
+  # Thus, this method, called on a membership of user and group1 will return the membership between
+  # user and group2.
+  #
+  #     UserGroupMembership.find_by( user: user, group: group1 ).direct_memberships.should 
+  #       include( UserGroupMembership.find_by( user: user, group: group2 ) )
+  #
+  # An indirect membership can also have several direct memberships, as shown in this figure:
+  # 
+  #   group1
+  #     |--------------- group2
+  #     |                  |
+  #     |---- group3       |
+  #             |------------- user
+  # 
+  # Here, group2 and grou3 are children of group1. user is member of group2 and group3.
+  # Hence, the indirect membership of user and group1 will include both direct memberships.
+  #
+  def direct_memberships(options = {})
+    descendant_groups_of_self_group = self.group.descendant_groups
+    descendant_group_ids_of_self_group = descendant_groups_of_self_group.pluck(:id)
+    group_ids = descendant_group_ids_of_self_group + [ self.group.id ]
+    
+    memberships = UserGroupMembership
+    if options[:with_invalid] || self.read_attribute( :valid_to )
+      # If the membership itself is invalidated, also consider the invalidated direct memberships.
+      # Otherwise, one has to call `direct_memberships_now_and_in_the_past` rather than
+      # `direct_memberships` in order to have the invalidated direct memberships included.
+      memberships = memberships.with_invalid 
+    end
+    
+    memberships = memberships
+      .find_all_by_user( self.user )
+      .where( :direct => true )
+      .where( :ancestor_id => group_ids, :ancestor_type => 'Group' )
+      
+    memberships = memberships.order('valid_from')
+    memberships
+  end
+  
+  def direct_memberships_now_and_in_the_past
+    direct_memberships(with_invalid: true)
+  end
+
+  # Returns the direct groups shown in the figures above in the description of
+  # `direct_memberships`.
+  #
+  def direct_groups
+    direct_memberships.collect { |membership| membership.group }
+  end
+
+
+  # Access Methods to Associated Indirect Memberships
+  # ====================================================================================================  
+
+  def indirect_memberships
+    self.group.ancestor_groups.collect do |ancestor_group|
+      UserGroupMembership.with_invalid.find_by_user_and_group(self.user, ancestor_group)
+    end.select do |item|
+      item != nil
+    end
+  end
+
+  # Methods to Change the Membership
+  # ====================================================================================================  
+
+  # Destroy the current membership and move the user over to the given group.
+  # 
+  #    group1                       group2
+  #      |---- user       =>          |---- user
+  # 
+  def move_to_group( group_to_move_in, options = {} )
+    time = (options[:time] || options[:date] || options[:at] || Time.zone.now).to_datetime
+    invalidate at: time
+    new_membership = UserGroupMembership.create(user: self.user, group: group_to_move_in)
+    new_membership.update_attribute(:valid_from, time)
+    return new_membership
+  end
+  def move_to(group, options = {})
+    move_to_group(group, options)
+  end
+
+  def promote_to( new_group, options = {} )
+    self.move_to_group( new_group, options )
+  end
+  
+  
+  # Destroy
+  # ==========================================================================================
+  
+  # The regular destroy method won't trigger DagLink's callbacks properly,
+  # causing the former dag link bug. By calling the DagLink's destroy method
+  # we'll ensure the callbacks are called and indirect memberships are destroyed
+  # correctly.
+  # 
+  def destroy
+    DagLink.where(id: self.id).first.destroy
+  end
+  
+  
+end
+
+