droom 0.0.1 → 0.2.1

data/app/models/droom/personal_folder.rb

@@ -0,0 +1,31 @@
+module Droom
+  class PersonalFolder < ActiveRecord::Base
+    belongs_to :person
+    belongs_to :folder
+    
+    def copy_to_dropbox
+      
+    end
+    
+    def copy_to_dav
+      
+    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

@@ -0,0 +1,35 @@
+# Preferences...
+
+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
+    
+    def set(value)
+      if boolean?
+        self.value = value ? 1 : 0
+      else
+        self.value = value
+      end
+      self.save if changed?
+    end
+    
+    def get
+      if boolean?
+        value.to_i == 1
+      else
+        value
+      end
+    end
+    
+    def boolean?
+      key.last == "?"
+    end
+    
+    def uuid
+      self[:uuid] ||= SecureRandom.uuid
+    end
+  
+  end
+end

data/app/models/droom/recurrence_rule.rb

@@ -1,7 +1,7 @@
 module Droom
   class RecurrenceRule < ActiveRecord::Base
   
-    belongs_to :created_by, :class_name => 'User'
+    belongs_to :created_by, :class_name => "Droom::User"
     belongs_to :event
     
     attr_accessible :period, :interval, :basis, :limiting_count, :limiting_date

data/app/models/droom/scrap.rb

@@ -0,0 +1,110 @@
+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 :document, :class_name => "Droom::Document", :dependent => :destroy
+    accepts_nested_attributes_for :document
+
+    has_upload :image, 
+               :geometry => "580x326#",
+               :styles => {
+                 :icon => "32x18#",
+                 :thumb => "160x90#",
+                 :precrop => "1200x1200^"
+               }
+
+    searchable do
+      text :name, :boost => 10, :stored => true
+      text :body, :stored => true
+      text :note
+    end
+
+    def self.highlight_fields
+      [:name, :body]
+    end
+
+    attr_accessible :name, :body, :image, :description, :scraptype, :note, :created_by, :event, :event_attributes, :document, :document_attributes
+    before_save :get_youtube_thumbnail
+
+    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 :matching, lambda { |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")
+    }
+
+    Droom.scrap_types.each do |t|
+      define_method(:"#{t}?") { scraptype == t.to_s }
+      scope t.pluralize.to_sym, where(["scraptype == ?", t])
+    end
+
+    def wordiness
+      if body.length < 48
+        'word'
+      elsif body.length < 320
+        'phrase'
+      elsif body.length < 800
+        'paragraph'
+      else
+        'text'
+      end
+    end
+
+    def text_size
+      if l = body.length
+        ((560.0/(1.4 * l+150.0)) + 0.25) / 1.5
+      else
+        1
+      end
+    end
+    
+    def url_with_protocol
+      body =~ /^https?:\/\// ? body : "http://#{body}"
+    end
+
+    def url_without_protocol
+      body.sub(/^https?:\/\//, '')
+    end
+
+    def as_search_result
+      {
+        :type => 'scrap',
+        :prompt => name,
+        :value => name,
+        :id => id
+      }
+    end
+    
+    def next_younger
+      Droom::Scrap.later_than(self).first
+    end
+    
+    def next_older
+      Droom::Scrap.earlier_than(self).first
+    end
+
+  protected
+  
+    def get_youtube_thumbnail
+      # youtube id is held in the 'note' column.
+      if scraptype == "video" && body?
+        self.image = URI.parse("http://img.youtube.com/vi/#{body}/0.jpg")
+      end
+    end
+    
+  end
+end

data/app/models/droom/tag.rb

@@ -0,0 +1,120 @@
+# 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.
+
+module Droom
+  class Tag < ActiveRecord::Base
+    # They are attached to people through many-to-many taggings.
+    #
+    has_many :taggings
+    has_many :taggees, :through => :taggings
+    before_save :downcase
+    
+    ## Suggestions
+    #
+    # 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| 
+      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.
+    #
+    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|
+      these = [these].flatten
+      type = these.first.class.to_s
+      placeholders = these.map{"?"}.join(',')
+      select("droom_tags.*, count(droom_taggings.id) as use_count")
+        .joins("INNER JOIN droom_taggings ON droom_taggings.tag_id = droom_tags.id")
+        .where(["droom_taggings.taggee_type = ? and droom_taggings.taggee_id IN (#{placeholders})", *these.map(&:id).unshift(type)])
+        .group('droom_tags.id')
+    }
+
+    # Suggestions are returned in a minimal format and need only contain name and (for the public search
+    # where there are more possibilities) the type of suggestion.
+    #
+    def as_json(options={})
+      {
+        :id => id,
+        :name => name,
+        :type => 'tag'
+      }
+    end
+
+    ## Keyword lists
+    #
+    # Sometimes we want the interface to present a simple comma-separated list.
+    # These methods help to move to and from that form.
+    #
+    def self.from_list(list=[], or_create=true)
+      list = list.split(/[,;]\s*/) if String === list
+      list.uniq.map{|t| self.for(t, or_create) }.compact if list && list.any?
+    end
+
+    # Renders a set of tags as a comma-separated list.
+    #
+    def self.to_list(tags=[])
+      tags.uniq.map(&:name).join(', ')
+    end
+
+    # Finds or creates a tag with the supplied title
+    #
+    def self.for(name, or_create=true)
+      if or_create
+        find_or_create_by_name(name)
+      else
+        find_by_name(name)
+      end
+    end
+
+
+    ## Clouds
+    #
+    # The administrative interface offers a big tag cloud and drag and drop tag-merging. Tag size in the
+    # cloud is based on a usage count that is retrieved here in a join with the taggings table. The cloud
+    # display logic can be found in the [application_helper](../controllers/application_helper.html).
+    #
+    attr_accessor :cloud_size
+    scope :with_usage_count, lambda { |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)
+    }
+
+    # *self.for_cloud* uses that scope to return a list of the most popular tags, weighted for display as a tag cloud
+    # and re-sorted into alphabetical order (since to select the most popular we originally had to sort by weighting).
+    #
+    def self.for_cloud(limit=100)
+      with_usage_count(limit).sort_by(&:name)
+    end
+
+    # This is here just to make tag interpolation a bit more readable.
+    #
+    def to_s
+      name
+    end
+  
+    ## Admin
+    # 
+    def assimilate(tag)
+      self.taggees << tag.taggees
+      tag.destroy
+    end
+
+  protected
+  
+    def downcase
+      self.name = self.name.downcase
+    end
+
+  end
+end

data/app/models/droom/tagging.rb

@@ -0,0 +1,13 @@
+# Taggings are the many to many links that associated tags with people. There isn't much to see here.
+
+module Droom
+  class Tagging < ActiveRecord::Base
+    belongs_to :tag
+    belongs_to :taggee, :polymorphic => true
+  
+    # The tagging interface allows the creation of new tags on save but in normal use this would never be hit:
+    # the ajax-based tag-adder creates tags in the background so the form needs only the nested tagging fields.
+    #
+    accepts_nested_attributes_for :tag, :reject_if => :all_blank
+  end
+end

data/app/models/droom/user.rb

@@ -0,0 +1,211 @@
+module Droom
+  class User < ActiveRecord::Base
+
+    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
+
+    receives_messages# :groups => [:unconfirmed, :personed, :administrative]
+  
+    devise :database_authenticatable,
+           :encryptable,
+           :recoverable,
+           :rememberable,
+           :trackable,
+           :confirmable,
+           :token_authenticatable,
+           :encryptor => :sha512
+  
+    before_create :ensure_authentication_token
+
+    attr_accessor :newly_activated, :update_person_email, :confirm, :remove_person
+  
+    # validates :password, :length => { :minimum => 6 }, :if => :password_required?
+  
+    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")
+    
+    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)
+    }
+
+    # 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
+    end
+
+    def confirm=(confirmed)
+      confirm! if confirmed
+    end
+
+    def remove_person=(boolean)
+      if boolean
+        p = Droom::Person.find(person.id)
+        p.user = nil
+        p.save!
+      end
+    end
+
+    # Password is not required on creation, contrary to the devise defaults.
+    def password_required?
+      confirmed? && (!password.blank?)
+    end
+
+    def password_match?
+      Rails.logger.warn ">>> password_match? '#{password}' == '#{password_confirmation}'"
+      self.errors[:password] << "can't be blank" if password.blank?
+      self.errors[:password_confirmation] << "can't be blank" if password_confirmation.blank?
+      self.errors[:password_confirmation] << "does not match password" if password != password_confirmation
+      password == password_confirmation && !password.blank?
+    end
+
+    def is_person?(person)
+      person == self.person
+    end
+
+    def organisation
+      person.organisation if person
+    end
+
+    # Current user is pushed into here to make it available in models
+    # such as the UserActionObserver that sets ownership before save.
+    #
+    def self.current
+      Thread.current[:user]
+    end
+    def self.current=(user)
+      Thread.current[:user] = user
+    end
+
+    # Personal DAV repository is accessed via a DAV4rack endpoint but we have to take care of its creation and population.
+    #
+    def dav_root
+      dav_path = Rails.root + "webdav/#{id}"
+      Dir.mkdir(dav_path, 0600) unless File.exist?(dav_path)
+      dav_path
+    end
+  
+    def full_name
+      [forename, name].compact.join(' ').strip
+    end
+
+    def formal_name
+      [title, forename, name].compact.join(' ').strip
+    end
+    
+    def informal_name
+      if Droom.use_forenames
+        forename
+      else
+        name
+      end
+    end
+
+    def dropbox_token
+      unless @dropbox_token
+        @dropbox_token = dropbox_tokens.by_date.last || 'nope'
+      end
+      @dropbox_token unless @dropbox_token == 'nope'
+    end
+
+    def dropbox_client
+      dropbox_token.dropbox_client if dropbox_token
+    end
+    
+    def privileged?
+      admin? || person && person.privileged?
+    end
+    
+    
+    ## Preferences
+    #
+    # User settings are held as an association with Preference objects, which are simple key:value pairs.
+    # The keys are usually colon:separated for namespacing purposes, eg:
+    #
+    #   current_user.pref("email:enabled?")
+    #   current_user.pref("dropbox:enabled?")
+    #
+    # Default settings are defined in Droom.user_defaults and can be defined in an initializer if the default droom
+    # defaults are not right for your application.
+    #
+    # `User#pref(key)` returns the **value** of the preference (whether set or default) for the given key. It is intended
+    # for use in views:
+    #
+    #   - if current_user.pref("dropbox:enabled?")
+    #     = link_to "copy to dropbox", dropbox_folder_url(folder)
+    #
+    def pref(key)
+      if pref = preferences.find_by_key(key)
+        pref.value
+      else
+        Droom.user_default(key)
+      end
+    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.
+    #
+    def preference(key)
+      pref = preferences.find_or_initialize_by_key(key)
+      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. 
+    #
+    # Preferences are set in a simple key:value way, where key usually includes some namespacing prefixes:
+    #
+    #   user.set_pref("email:enabled", true)
+    #
+    def set_pref(key, value)
+      preferences.find_or_create_by_key(key).set(value)
+    end
+    
+    ## Email
+    #
+    # If using `msg`, this defines the variables available in message templates.
+    #
+    def for_email
+      {
+        :informal_name => informal_name,
+        :formal_name => formal_name,
+        :forename => forename,
+        :name => name,
+        :email => email,
+        :confirmation_url => Droom::Engine.routes.url_helpers.new_user_confirmation_url(self, :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.new_user_password_path(self, :host => ActionMailer::Base.default_url_options[:host])
+      }
+    end
+    
+
+  end
+end