droom 0.4.3 → 0.5.3

data/app/models/droom/organisation.rb

@@ -1,9 +1,12 @@
 module Droom
   class Organisation < ActiveRecord::Base
-    attr_accessible :name, :description, :created_by, :owner, :url
-    has_many :people
-    belongs_to :owner, :class_name => 'Droom::Person'
+    has_many :users
+    belongs_to :owner, :class_name => 'Droom::User'
     belongs_to :created_by, :class_name => 'Droom::User'
+    
+    scope :added_since, -> date { where("created_at > ?", date)}
+
+    default_scope -> {order("name ASC")}
 
     def self.for_selection
       organisations = self.order("name asc").map{|f| [f.name, f.id] }

data/app/models/droom/permission.rb

@@ -0,0 +1,19 @@
+require 'acts_as_list'
+
+module Droom
+  class Permission < ActiveRecord::Base
+    belongs_to :service
+    has_many :group_permissions, :dependent => :destroy
+    has_many :user_permissions, :dependent => :destroy
+    acts_as_list :scope => :service_id
+    before_save :set_slug
+    
+    validates :slug, :uniqueness => true
+    
+  protected
+    
+    def set_slug
+      self.slug = [service.slug, self.name].join('.')
+    end
+  end
+end

data/app/models/droom/personal_folder.rb

@@ -1,31 +1,19 @@
 module Droom
   class PersonalFolder < ActiveRecord::Base
-    belongs_to :person
+    belongs_to :user
     belongs_to :folder
     
-    def copy_to_dropbox
-      
-    end
+    scope :of_folder, -> folder {
+      where(["folder_id = ?", folder.id])
+    }
+
+    scope :for_user, -> user {
+      where(["user_id = ?", user.id])
+    }
     
-    def copy_to_dav
+    def copy_to_dropbox
       
     end
     
-    #todo: lifted from Person and awaiting translation
-    #
-    # def create_and_update_dav_directories
-    #   document_links.each do |dl|
-    #     p "-> creating DAV directory #{dl.slug}"
-    #     create_dav_directory(dl.slug)
-    #   end
-    # end
-    # 
-    # def create_dav_directory(name)
-    #   FileUtils.mkdir_p(Rails.root + "#{Droom.dav_root}/#{self.id}/#{name}")
-    # end
-    # 
-
-    # association helpers give us more readable logic elsewhere.
-    
   end
 end

data/app/models/droom/preference.rb

@@ -2,9 +2,8 @@
 
 module Droom
   class Preference < ActiveRecord::Base
-    attr_accessible :key, :value, :uuid
     belongs_to :created_by, :class_name => "Droom::User"
-    validates :key, :presence => true, :uniqueness => true
+    validates :key, :presence => true, :uniqueness => {:scope => :created_by_id}
     
     def set(value)
       if boolean?

data/app/models/droom/scrap.rb

@@ -1,47 +1,48 @@
 module Droom
   class Scrap < ActiveRecord::Base
     belongs_to :created_by, :class_name => "Droom::User"
-    belongs_to :event, :class_name => "Droom::Event"
-    accepts_nested_attributes_for :event
 
+    belongs_to :event, :class_name => "Droom::Event", :dependent => :destroy
+    accepts_nested_attributes_for :event
     belongs_to :document, :class_name => "Droom::Document", :dependent => :destroy
     accepts_nested_attributes_for :document
 
-    has_upload :image, 
-               :geometry => "580x326#",
-               :styles => {
-                 :icon => "32x18#",
-                 :thumb => "160x90#",
-                 :precrop => "1200x1200^"
-               }
+    has_attached_file :image, 
+                      :styles => {
+                        :stream => "1280x1280>",
+                        :popup => "1280x1280>",
+                        :icon => "32x32#",
+                        :thumb => "130x73#"
+                      }
 
-    attr_accessible :name, :body, :image, :description, :scraptype, :note, :created_by, :event, :event_attributes, :document, :document_attributes
     before_save :get_youtube_thumbnail
+    before_validation :name_associates
 
-    scope :by_date, order("droom_scraps.created_at DESC")
+    scope :by_date, -> { order("droom_scraps.created_at DESC") }
 
-    scope :later_than, lambda { |scrap| 
-      where(["created_at > ?", scrap.created_at]).order("droom_scraps.created_at ASC") 
-    }
-    
-    scope :earlier_than, lambda { |scrap| 
-      where(["created_at < ?", scrap.created_at]).order("droom_scraps.created_at DESC") 
-    }
+    scope :later_than, -> scrap { where(["created_at > ?", scrap.created_at]).order("droom_scraps.created_at ASC")  }
 
-    scope :matching, lambda { |fragment|
+    scope :earlier_than, -> scrap { where(["created_at < ?", scrap.created_at]).order("droom_scraps.created_at DESC")  }
+
+    scope :matching, -> fragment {
       fragment = "%#{fragment}%"
       where('droom_scraps.name LIKE :f OR droom_scraps.body LIKE :f OR droom_scraps.note LIKE :f', :f => fragment)
     }
     
-    scope :visible_to, lambda { |person|
-      where("1=1")
+    scope :visible_to, -> user { where("1=1") }
+    
+    scope :with_future_or_current_event, -> {
+      joins(:event)
+        .where(["droom_scraps.scraptype = 'event' AND (droom_events.finish > :now) OR (droom_events.finish IS NULL AND droom_events.start > :now)", :now => Time.zone.now])
+        .order('droom_events.start ASC')
     }
 
     Droom.scrap_types.each do |t|
-      define_method(:"#{t}?") { scraptype == t.to_s }
-      scope t.pluralize.to_sym, where(["scraptype == ?", t])
+      scope t.pluralize.to_sym, -> { where(:scraptype => t.to_s) }
     end
 
+    default_scope -> { includes(:event, :document) }
+
     def wordiness
       if body.length < 48
         'word'
@@ -90,11 +91,15 @@ module Droom
   protected
   
     def get_youtube_thumbnail
-      # youtube id is held in the 'body' column.
-      if scraptype == "video" && body?
-        self.image = URI("http://img.youtube.com/vi/#{body}/0.jpg")
+      if scraptype == "video" && youtube_id?
+        self.image = URI("http://img.youtube.com/vi/#{youtube_id}/0.jpg")
       end
     end
     
+    def name_associates
+      event.name = name if event
+      document.name = name if document
+    end
+    
   end
 end

data/app/models/droom/service.rb

@@ -0,0 +1,31 @@
+module Droom
+  class Service < ActiveRecord::Base
+    has_many :permissions, -> {order(:position)}, :dependent => :destroy
+    before_save :set_slug
+    after_create :create_basic_permissions
+    after_save :update_permissions
+    validates :slug, :uniqueness => true
+    
+    def self.for_selection
+      self.order("name asc").map{|f| [f.name, f.id] }
+    end
+    
+  protected
+  
+    def set_slug
+      self.slug ||= name.parameterize
+    end
+    
+    def create_basic_permissions
+      permissions.create(:name => 'login')
+      permissions.create(:name => 'admin')
+    end
+    
+    def update_permissions
+      permissions.all.each do |p|
+        p.send :set_slug
+        p.save
+      end
+    end
+  end
+end

data/app/models/droom/tag.rb

@@ -1,9 +1,9 @@
 # Tags are simple one-word descriptors. There is no hierarchy or other structure among them.
-# They are strictly catalogue data, used to locate people but not treated as part of the person record.
+# They are strictly catalogue data, used to locate people but not treated as part of the user record.
 
 module Droom
   class Tag < ActiveRecord::Base
-    # They are attached to people through many-to-many taggings.
+    # They are attached to people and other things through many-to-many taggings.
     #
     has_many :taggings
     has_many :taggees, :through => :taggings
@@ -14,24 +14,25 @@ module Droom
     # There is a tag-suggesting mechanism in the front end to encourage tag reuse and consistency.
     # It rests on this simple scope, which returns all tags matching a given string fragment.
     #
-    scope :matching, lambda { |fragment| 
+    scope :matching, -> fragment {
       fragment = "%#{fragment}%"
       where('tags.name like ?', fragment)
     }
   
     # The public-facing search engine is faceted and relies on a similar but broader suggestion mechanism
     # that offers both tags and institutions. In that situation we only want to display tags that will give
-    # give results, so we limit the suggestions to only those tags that have been applied to a person.
+    # give results, so we limit the suggestions to only those tags that have been applied to a user.
     #
-    scope :in_use, 
+    scope :in_use, -> {
       joins("INNER JOIN taggings ON taggings.tag_id = tags.id")
       .group('tags.id')
       .having('count(taggings.tag_id) > 0')
+    }
 
     # This returns a list of all the tags attached to any of a given set of objects.
     # In future it will support cloud-weighting. 
     #
-    scope :attached_to_any_of, lambda {|these|
+    scope :attached_to_any_of, -> these {
       these = [these].flatten
       type = these.first.class.to_s
       placeholders = these.map{"?"}.join(',')
@@ -72,9 +73,9 @@ module Droom
     #
     def self.for(name, or_create=true)
       if or_create
-        find_or_create_by_name(name)
+        where(name: name).first_or_create
       else
-        find_by_name(name)
+        find_by(name: name)
       end
     end
 
@@ -86,7 +87,7 @@ module Droom
     # display logic can be found in the [application_helper](../controllers/application_helper.html).
     #
     attr_accessor :cloud_size
-    scope :with_usage_count, lambda { |limit|
+    scope :with_usage_count, -> limit {
       select("tags.*, count(tt.id) AS weight").joins("INNER JOIN taggings as tt ON tt.tag_id = tags.id").group("tt.tag_id").order("weight DESC").limit(limit)
     }
 

data/app/models/droom/tagging.rb

@@ -1,4 +1,4 @@
-# Taggings are the many to many links that associated tags with people. There isn't much to see here.
+# Taggings are the many to many links that associated tags with people and other things. There isn't much to see here.
 
 module Droom
   class Tagging < ActiveRecord::Base

data/app/models/droom/user.rb

@@ -1,87 +1,108 @@
 module Droom
   class User < ActiveRecord::Base
+    validates :family_name, :presence => true
+    validates :given_name, :presence => true
+    validates :email, :uniqueness => true, :presence => true
+    validates :uid, :uniqueness => true, :presence => true
 
-    attr_accessible :name, :forename, :email, :password, :password_confirmation, :admin, :newly_activated, :update_person_email, :preferences_attributes, :confirm, :old_id, :remove_person
-    has_one :person
-    has_many :dropbox_tokens, :foreign_key => "created_by_id"
     has_many :preferences, :foreign_key => "created_by_id"
     accepts_nested_attributes_for :preferences, :allow_destroy => true
-
-    validates :email, :uniqueness => true, :presence => true
-    validates_format_of :email, :with => /@/
-    validates :name, :presence => true
-    # validates :password, :presence => true, :length => { :minimum => 6 }, :confirmation => true, :if => :password_required?
-
-    receives_messages# :groups => [:unconfirmed, :personed, :administrative]
-  
+    
+    ## Authentication
+    #
     devise :database_authenticatable,
-           :encryptable,
+           :cookie_authenticatable,
            :recoverable,
-           :rememberable,
            :trackable,
            :confirmable,
-           :token_authenticatable,
-           :encryptor => :sha512
-  
-    before_create :ensure_authentication_token  # provided by devise
-    before_create :ensure_confirmation_token  # provided by devise
-
-    attr_accessor :newly_activated, :update_person_email, :confirm, :remove_person
-  
-  
-    scope :unconfirmed, where("confirmed_at IS NULL")
-    scope :administrative, where(:admin => true)
-  
-    scope :personed, select("droom_users.*")
-                  .joins("INNER JOIN droom_people as dp ON dp.user_id = droom_users.id")
-
-    scope :unpersoned, select("droom_users.*")
-                  .joins("LEFT OUTER JOIN droom_people as dp ON dp.user_id = droom_users.id")
-                  .having("count(dp.id) = 0")
+           :rememberable,
+           :reconfirmable => false
     
-    scope :with_person_in_group, lambda { |group|
-      group = group.id if group.is_a? Droom::Group
-      select("droom_users.*")
-        .joins("INNER JOIN droom_people as dp ON dp.user_id = droom_users.id")
-        .joins("INNER JOIN droom_memberships as dm ON dp.id = dm.person_id")
-        .where("dm.group_id" => group)
-    }
+    before_validation :ensure_uid!
+    before_save :ensure_authentication_token
+    after_save :send_confirmation_if_directed
 
-    # Messaging groups are normally scopes passed through when receives_messages is called,
-    # but anything will work that can be called on the class and return a set of instances.
-    # Here we're overriding the getter so as to offer sending by group membership as well as
-    # the usual scoping.
-    #
-    def self.messaging_groups
-      unless @messaging_groups
-        @messaging_groups = {
-          :unconfirmed => lambda { Droom::User.unconfirmed},
-          :personed => lambda { Droom::User.personed },
-          :administrative => lambda { Droom::User.administrative }
-        }
-        Droom::Group.all.each do |group|
-          @messaging_groups[group.slug.to_sym] = lambda { Droom::User.with_person_in_group(group.id) }
-        end
-      end
-      @messaging_groups
+    # People are often invited into the system in batches or after offline contact. 
+    # set user.defer_confirmation to a true or call user.defer_confirmation! +before saving+
+    # if you want to create a user account without sending out any messages yet.
+    #
+    # When you do want to invite that person, call user.resend_confirmation_token or
+    # set the send_confirmation flag on a save.
+    #
+    attr_accessor :defer_confirmation, :send_confirmation
+    
+    def defer_confirmation!
+      self.defer_confirmation = true
     end
 
-    def confirm=(confirmed)
-      confirm! if confirmed
+    def defer_confirmation?
+      !!self.defer_confirmation
     end
-
-    def remove_person=(boolean)
-      if boolean
-        p = Droom::Person.find(person.id)
-        p.user = nil
-        p.save!
-      end
+    
+    # Called after save by our own late-confirmation mechanism.
+    # If the send_confirmation flag has been set, we confirm.
+    #
+    def send_confirmation?
+      !!self.send_confirmation
+    end
+    
+    # Called on create by devise's immediate confirmation mechanism.
+    # If the defer_confirmation flag has been set, we postpone.
+    #
+    def send_confirmation_notification?
+      super && !defer_confirmation?
+    end
+    
+    def active_for_authentication?
+      true
     end
 
-    # Password is not required on creation, contrary to the devise defaults.
     def password_required?
       confirmed? && (!password.blank?)
     end
+    
+    def password_set?
+      encrypted_password?
+    end
+    
+    ## Session ID
+    #
+    # Allows us to invalidate a session by remote control if someone signs out on a satellite site.
+    
+    def reset_session_id!
+      token = generate_authentication_token
+      self.update_column(:session_id, token)
+      token
+    end
+    
+    def clear_session_id!
+      self.update_column(:session_id, "")
+    end
+    
+    ## Auth tokens
+    #
+    # Are no longer native to devise but we use them for domain-cookie auth.
+    
+    def authenticate_token(token)
+      Devise.secure_compare(self.authentication_token, token)
+    end
+
+    def reset_authentication_token!
+      $cache.delete "/api/authenticate/#{authentication_token}" if $cache && authentication_token
+      token = generate_authentication_token
+      self.update_column(:authentication_token, token)
+      token
+    end
+    
+    def ensure_authentication_token
+      if authentication_token.blank?
+        self.authentication_token = generate_authentication_token
+      end
+    end
+    
+    def confirmed=(value)
+      self.confirmed_at = Time.now if value.present? and value != "false"
+    end
 
     def password_match?
       self.errors[:password] << "can't be blank" if password.blank?
@@ -90,48 +111,155 @@ module Droom
       password == password_confirmation && !password.blank?
     end
 
-    def is_person?(person)
-      person == self.person
-    end
+    # Our old user accounts store passwords as salted sha512 digests. Current best practice uses BCrypt
+    # so we migrate user accounts across in this rescue block whenever we hear BCrypt grumbling about the old hash.
+  
+    def valid_password?(password)
+      begin
+        super(password)
+      rescue BCrypt::Errors::InvalidHash
+        Rails.logger.warn "...trying sha512 on password input"
+        stretches = 10
+        salt = self.password_salt
+        pepper = nil
+        old_digest = Devise::Encryptable::Encryptors::Sha512.digest(password, stretches, salt, pepper)
+        if old_digest == self.encrypted_password   
+          self.password = password
+          self.save
+          return true
+        else
+          # Doesn't match the old format either: password is just wrong.
+          return false
+        end
+      end
+    end 
+    
+    scope :unconfirmed, -> { where("confirmed_at IS NULL") }
+    scope :administrative, -> { where(:admin => true) }
+    scope :this_month, -> { where("created_at > ?", Time.now - 1.month) }
+    scope :this_week, -> { where("created_at > ?", Time.now - 1.week) }
+    
+    scope :in_name_order, -> {
+      order("family_name ASC, given_name ASC")
+    }
 
-    def organisation
-      person.organisation if person
+    def as_json_for_coca(options={})
+      ensure_uid!
+      ensure_authentication_token
+      {
+        uid: uid,
+        authentication_token: authentication_token,
+        title: title,
+        given_name: given_name,
+        family_name: family_name,
+        chinese_name: chinese_name,
+        email: email,
+        permissions: permission_codes.join(','),
+        image: thumbnail
+      }
     end
 
-    # Current user is pushed into here to make it available in models
-    # such as the UserActionObserver that sets ownership before save.
+    ## Organisation affiliation
     #
-    def self.current
-      Thread.current[:user]
+    belongs_to :organisation
+    has_many :organisations, :foreign_key => :owner_id
+
+    ## Group memberships
+    #
+    has_many :memberships, :dependent => :destroy
+    has_many :groups, :through => :memberships
+    has_many :mailing_list_memberships, :through => :memberships
+
+    scope :in_any_directory_group, -> {
+      joins(:groups).where(droom_groups: {directory: true}).group("droom_users.id")
+    }
+
+    def admit_to(groups)
+      groups = [groups].flatten
+      groups.each do |group|
+        memberships.where(group_id: group.id).first_or_create
+      end
     end
-    def self.current=(user)
-      Thread.current[:user] = user
+    
+    def expel_from(group)
+      memberships.of_group(group).destroy_all
     end
 
-    # Personal DAV repository is accessed via a DAV4rack endpoint but we have to take care of its creation and population.
+    def member_of?(group)
+      group && memberships.of_group(group).any?
+    end
+    
+    def membership_of(group)
+      memberships.find_by(group_id: group.id)
+    end
+    
+    scope :in_group, -> group {
+      group = group.id if group.is_a? Droom::Group
+      select("droom_users.*")
+        .joins("INNER JOIN droom_memberships as dm ON droom_users.id = dm.user_id")
+        .where("dm.group_id" => group)
+    }
+
+    ## Event invitations
     #
-    def dav_root
-      dav_path = Rails.root + "webdav/#{id}"
-      Dir.mkdir(dav_path, 0600) unless File.exist?(dav_path)
-      dav_path
+    has_many :invitations, :dependent => :destroy
+    has_many :events, :through => :invitations
+
+    def invite_to(event)
+      invitations.where(event_id: event.id).first_or_create if event
     end
-  
-    def full_name
-      [forename, name].compact.join(' ').strip
+    
+    def uninvite_from(event)
+      invitations.to_event(event).destroy_all
     end
 
-    def formal_name
-      [title, forename, name].compact.join(' ').strip
+    def invited_to?(event)
+      event && !!invitation_to(event)
     end
     
-    def informal_name
-      if Droom.use_forenames
-        forename
-      else
-        name
-      end
+    def invitation_to(event)
+      invitations.to_event(event).first
     end
+    
+    scope :personally_invited_to_event, -> event {
+      joins('LEFT OUTER JOIN droom_invitations on droom_users.id = droom_invitations.user_id').where('droom_invitations.group_invitation_id is null AND droom_invitations.event_id = ?', event.id)
+    }
+
+    ## Folder permissions
+    #
+    # To simplify the business of showing and listing documents, we have adopted the convention that all
+    # documents live in a folder. User accounts have links to those folders through the very thin
+    # PersonalFolder joining class, and at the view level we only ever show folder and subfolder lists.
+    # The only place we ever need a list of all the documents visible to this person is when searching, and
+    # for that we use the Document.visible_to scope, usually by way of the #documents method defined below.
+    #
+    # Personal folders are created and destroyed along with invitations and memberships.
+    #
+    has_many :personal_folders
+    has_many :folders, :through => :personal_folders
 
+    def add_personal_folders(folders=[])
+      self.folders << folders if folders
+    end
+    
+    def remove_personal_folders(folders=[])
+      self.folders.delete(folders) if folders
+    end
+    
+    def has_folder?(folder)
+      folder && personal_folders.of_folder(folder).any?
+    end
+    
+    def documents
+      Document.visible_to(self)
+    end
+
+
+    ## Dropbox links
+    #
+    has_many :dropbox_tokens, :foreign_key => "created_by_id"
+    has_many :dropbox_documents
+    
     def dropbox_token
       unless @dropbox_token
         @dropbox_token = dropbox_tokens.by_date.last || 'nope'
@@ -142,12 +270,188 @@ module Droom
     def dropbox_client
       dropbox_token.dropbox_client if dropbox_token
     end
+
+    ## Mugshot
+    #
+    has_attached_file :image,
+                      :default_url => ActionController::Base.helpers.image_path("droom/missing/:style.png"),
+                      :styles => {
+                        :standard => "520x520#",
+                        :icon => "32x32#",
+                        :thumb => "130x130#"
+                      }
+
+    do_not_validate_attachment_file_type :image
+
+    def thumbnail
+      image.url(:thumb) if image?
+    end
+    
+    def icon
+      image.url(:icon) if image?
+    end
+ 
+    # For suggestion box
+    #
+    scope :matching, -> fragment {
+      where('droom_users.given_name LIKE :f OR droom_users.family_name LIKE :f OR droom_users.chinese_name LIKE :f OR droom_users.title LIKE :f OR droom_users.email LIKE :f OR droom_users.phone LIKE :f OR CONCAT(droom_users.given_name, " ", droom_users.family_name) LIKE :f OR CONCAT(droom_users.family_name, " ", droom_users.given_name) LIKE :f', :f => "%#{fragment}%")
+    }
+    
+    scope :matching_in_col, -> col, fragment {
+      where("droom_users.#{col} LIKE :f", :f => "%#{fragment}%")
+    }
+    
+    def as_suggestion
+      {
+        :type => 'person',
+        :prompt => formal_name,
+        :value => formal_name,
+        :id => id
+      }
+    end
+    
+    def as_search_result
+      {
+        :type => 'person',
+        :prompt => name,
+        :value => name,
+        :id => id
+      }
+    end
+    
+    
+    # For select box
+    #
+    def self.for_selection
+      self.published.map{|p| [p.name, p.id] }
+    end
+    
+    
+    ## Names
+    #
+    # With Anglo-Chinese Hong Kong names it is difficult to be sure of the right presentation.
+    #
+    # We hold the name in three fields: title, given name and family name. People with both a Chinese and an
+    # English forename are encouraged to enter their given name in the form Tai Wan, Jimmy. The family_name 
+    # should always be a single, usually Chinese, surname: Chan or Smith.
+    #
+    # When a comma is found in the given name, we assume that they have followed the chinese, english format.
+    # If not, we assume the whole name is Chinese.
+    #
+    # ### Polite informality
+    #
+    # People with an English forename would normally be addressed as Jimmy Chan. People with only a Chinese
+    # forename should be addressed as Chan Tai Wan.
+    #
+    def informal_name
+      # The standard form of the given name is Tai Wan, Ray
+      chinese, english = given_name.split(/,\s*/)
+      # But some people are known only as Ray.
+      # Here we can't tell the difference between people with one chinese given name and one anglo given name
+      # but the order of names is reversed in the latter case. For now we assume that the presence of a chinese
+      # name indicates that the chinese word ordering should be used.
+      unless chinese_name?
+        english ||= chinese.strip.split(/\s+/).first
+      end
+      if english
+        # People with an english name are called Ray Chan, by default
+        [english, family_name].join(' ')
+      else
+        # People without are called Chan Tai Wan
+        [family_name, chinese].join(' ')
+      end
+    end
+  
+    def name
+      chinese, english = given_name.split(/,\s*/)
+      unless chinese_name?
+        english ||= chinese.split(/\s+/).first
+      end
+      if english
+        [english, family_name].join(' ')
+      else
+        [family_name, chinese].join(' ')
+      end
+    end
+
+    # ### Formality
+    #
+    # The family name is held separately becaose for most purposes we will address people using the relatively 
+    # reliable 'Dr Chan' or 'Mr Smith'.
+    #
     
-    def privileged?
-      admin? || person && person.privileged?
+    def title_ordinary?
+      ['Mr', 'Ms', 'Mrs', '', nil].include?(title)
+    end
+    
+    def title_if_it_matters
+      title unless title_ordinary?
+    end
+  
+    def title
+      title = read_attribute(:title)
+      if title.blank?
+        title = (gender == 'f') ? 'Ms' : 'Mr'
+      end
+      title
+    end
+    
+    # This shuold be a reasonable formal first-person form of address.
+    #
+    def formal_name
+      [title, family_name].join(' ')
+    end
+
+    # This is our best shot at a representation of the usual third person form of this person's name. It combines
+    # the informal name (which includes some logic to show chinese, anglo and mixed names correctly) with the title,
+    # if the title is not ordinary.
+    #
+    def colloquial_name
+      [title_if_it_matters, informal_name, honours].compact.join(' ')
+    end
+
+    # ### Completeness
+    #
+    # For record-keeping purposes we show the whole name: Chan Tai Wan, Jimmy.
+    #
+    def full_name
+      [family_name, given_name].compact.join(' ')
+    end
+
+    # ### Compatibility
+    #
+    # An HKID card will normally show only the translitered Chinese name: Chan Tai Wan
+    #
+    def official_name
+      chinese, english = given_name.split(/,\s*/)
+      [family_name, chinese].join(' ')
     end
     
+    def to_vcf
+      @vcard ||= Vcard::Vcard::Maker.make2 do |maker|
+        maker.add_name do |n|
+          n.given = name || ""
+        end
+        maker.add_addr {|a| 
+          a.location = 'home' # until we do this properly with multiple contact sets
+          a.country = post_country || ""
+          a.region = post_region || ""
+          a.locality = post_city || ""
+          a.street = "#{post_line1}, #{post_line2}"
+          a.postalcode = post_code || ""
+        }
+        maker.add_tel phone { |t| t.location = 'home' } unless phone.blank?
+        maker.add_tel mobile { |t| t.location = 'cell' } unless mobile.blank?
+        maker.add_email email { |e| t.location = 'home' }
+      end
+      @vcard.to_s
+    end
     
+    def self.vcards_for(users=[])
+      users.map(&:vcf).join("\n")
+    end
+
+
     ## Preferences
     #
     # User settings are held as an association with Preference objects, which are simple key:value pairs.
@@ -166,13 +470,17 @@ module Droom
     #     = link_to "copy to dropbox", dropbox_folder_url(folder)
     #
     def pref(key)
-      if pref = preferences.find_by_key(key)
+      if pref = preferences.find_by(key: key)
         pref.value
       else
         Droom.user_default(key)
       end
     end
-    
+
+    def pref?(key)
+      !!pref(key)
+    end
+
     # `User#preference(key)` always returns a preference object and is used to build control panels. If no preference
     # is saved for the given key, we return a new (unsaved) one with that key and the default value.
     #
@@ -181,7 +489,7 @@ module Droom
       pref.value = Droom.user_default(key) unless pref.persisted?
       pref
     end
-    
+
     # Setting preferences is normally handled either by the PreferencesController or by nesting preferences
     # in a user form. `User#set_pref` is a convenient console method but not otherwise used much. 
     #
@@ -190,46 +498,61 @@ module Droom
     #   user.set_pref("email:enabled", true)
     #
     def set_pref(key, value)
-      preferences.find_or_create_by_key(key).set(value)
+      preferences.where(key: key).first_or_create.set(value)
     end
-    
-    ## Email
-    #
-    # If using `msg`, this defines the variables available in message templates.
+
+
+
+    ## Permissions
     #
-    def for_email
-      generate_confirmation_token! unless confirmation_token?
-      {
-        :informal_name => informal_name,
-        :formal_name => formal_name,
-        :forename => forename,
-        :name => name,
-        :email => email,
-        :confirmation_url => Droom::Engine.routes.url_helpers.welcome_url(:id => self.id, :confirmation_token => self.confirmation_token, :host => ActionMailer::Base.default_url_options[:host]),
-        :sign_in_url => Droom::Engine.routes.url_helpers.new_user_session_path(:host => ActionMailer::Base.default_url_options[:host]),
-        :password_reset_url => Droom::Engine.routes.url_helpers.edit_user_password_url(:reset_password_token => self.reset_password_token, :host => ActionMailer::Base.default_url_options[:host])
-      }
+    # Permissions are usually assigned by way of group membership, but the effect of this is to create a user-permission
+    # object. Additional user-permission objects can be created: all we need to do here is return that set.
+    
+    has_many :user_permissions
+    has_many :permissions, :through => :user_permissions
+    
+    def permission_codes
+      permissions.map(&:slug).compact.uniq
     end
     
-    ## Omniauth package
-    #
-    # This is returned to the client application in the final stage of oauth authentication, and may be used to create
-    # a new local account.
+    def permission_codes=(codes)
+      #TODO
+    end
     
-    def credentials(options={})
-      {
-        id: id,
-        title: title,
-        name: name,
-        forename: forename,
-        email: email,
-        admin: admin?,
-        image: thumbnail
-      }
+    def permitted?(key)
+      permission_codes.include?(key)
     end
     
-    def thumbnail
-      person.image.url(:icon) if person
+    def permissions_elsewhere?
+      permission_codes.select{|pc| pc !~ /droom/}.any?
+    end
+
+    def data_room_user?
+      admin? || permitted?('droom.login')
+    end
+
+    ## Other ownership
+    #
+    has_many :scraps, :foreign_key => "created_by_id"
+    has_many :documents, :foreign_key => "created_by_id"
+
+  protected
+  
+    def ensure_uid!
+      self.uid = SecureRandom.uuid unless self.uid?
+    end
+    
+    def send_confirmation_if_directed
+      self.send_confirmation_instructions if send_confirmation?
+    end
+
+  private
+  
+    def generate_authentication_token
+      loop do
+        token = Devise.friendly_token
+        break token unless User.where(authentication_token: token).first
+      end
     end
 
   end