droom 0.4.3 → 0.5.3

data/app/models/droom/agenda_category.rb

@@ -1,6 +1,5 @@
 module Droom
   class AgendaCategory < ActiveRecord::Base
-    attr_accessible :event_id, :category_id
     belongs_to :category
     belongs_to :event
     belongs_to :created_by, :class_name => "Droom::User"

data/app/models/droom/calendar.rb

@@ -1,18 +1,23 @@
 module Droom
   class Calendar < ActiveRecord::Base
-    attr_accessible :name, :created_by_id, :events_private, :documents_private
+    include Droom::Concerns::Slugged
+    
     belongs_to :created_by, :class_name => "Droom::User"
-
-    before_save :ensure_slug
-
     has_many :events
+
+    before_validation :slug_from_name
+    validates :slug, :presence => true, :uniqueness => true
     
     def self.for_selection
       self.all.map{|c| [c.name, c.id] }
     end
-
-    def ensure_slug
-      ensure_presence_and_uniqueness_of(:slug, name.parameterize)
+    
+    def self.default_calendar
+      where(:name => "main").first_or_create
+    end
+    
+    def self.stream_calendar
+      where(:name => "stream").first_or_create
     end
 
   end

data/app/models/droom/category.rb

@@ -1,25 +1,19 @@
 module Droom
   class Category < ActiveRecord::Base
-    attr_accessible :name, :description, :slug
-    
+    include Droom::Concerns::Slugged
+
     belongs_to :created_by, :class_name => "Droom::User"
     has_many :document_attachments
     
-    before_validation :ensure_slug
+    before_validation :slug_from_name
     validates :slug, :presence => true, :uniqueness => true
     
-    default_scope order("droom_categories.name ASC")
+    default_scope -> { order("droom_categories.name ASC") }
         
     # *for_selection* returns a set of [name, id] pairs suitable for use as select options.
     def self.for_selection
       self.all.map{|c| [c.name, c.id] }
     end
 
-  protected
-  
-    def ensure_slug
-      ensure_presence_and_uniqueness_of(:slug, name.parameterize)
-    end
-
   end
 end

data/app/models/droom/concerns/slugged.rb

@@ -0,0 +1,21 @@
+module Droom::Concerns::Slugged
+  extend ActiveSupport::Concern
+  
+  def slug_from_name
+    ensure_presence_of_unique(:slug, name.parameterize)
+  end
+
+  def slug_from_name_and_year
+    ensure_presence_of_unique(:slug, "#{year} #{name}".parameterize)
+  end
+
+  def ensure_presence_of_unique(column, base, skope=self.class.all)
+    unless self.send "#{column}?".to_sym
+      value = base
+      addendum = 0
+      value = "#{base}_#{addendum+=1}" while skope.find_by(column => value)
+      self.send :"#{column}=", value
+    end
+  end
+
+end

data/app/models/droom/document.rb

@@ -4,10 +4,9 @@ require 'yomu'
 
 module Droom
   class Document < ActiveRecord::Base
-    attr_accessible :name, :file, :description, :folder, :folder_id
-
     belongs_to :created_by, :class_name => "Droom::User"
     belongs_to :folder
+    belongs_to :scrap, :dependent => :destroy
     has_many :dropbox_documents
     has_attached_file :file
 
@@ -15,39 +14,38 @@ module Droom
     after_destroy :mark_dropbox_documents_deleted
 
     validates :file, :presence => true
+    do_not_validate_attachment_file_type :file
+    
+    scope :all_private, -> { where("private = 1") }
+    scope :not_private, -> { where("private <> 1 OR private IS NULL") }
+    scope :all_public, -> { where("public = 1 AND private <> 1 OR private IS NULL") }
+    scope :not_public, -> { where("public <> 1 OR private = 1)") }
 
-    scope :all_private, where("private = 1")
-    scope :not_private, where("private <> 1 OR private IS NULL")
-    scope :all_public, where("public = 1 AND private <> 1 OR private IS NULL")
-    scope :not_public, where("public <> 1 OR private = 1)")
-
-    scope :visible_to, lambda { |person|
-      if person
+    scope :visible_to, -> user {
+      if user
         select('droom_documents.*')
           .joins('LEFT OUTER JOIN droom_folders AS df ON droom_documents.folder_id = df.id')
           .joins('LEFT OUTER JOIN droom_personal_folders AS dpf ON df.id = dpf.folder_id')
-          .where(["(droom_documents.public = 1 OR dpf.person_id = ?)", person.id])
+          .where(["(droom_documents.public = 1 OR dpf.user_id = ?)", user.id])
           .group('droom_documents.id')
       else
         all_public
       end
     }
 
-    scope :matching, lambda { |fragment|
+    scope :matching, -> fragment {
       fragment = "%#{fragment}%"
       where('droom_documents.name LIKE :f OR droom_documents.file_file_name LIKE :f', :f => fragment)
     }
     
-    scope :in_folders, lambda{ |folders|
+    scope :in_folders, -> folders{
       placeholders = folders.map { "?" }.join(',')
       where(["folder_id IN(#{placeholders})", *folders.map(&:id)])
     }
 
-    scope :by_date, order("droom_documents.updated_at DESC, droom_documents.created_at DESC")
+    scope :by_date, -> { order("droom_documents.updated_at DESC, droom_documents.created_at DESC") }
 
-    scope :latest, lambda {|limit|
-      order("droom_documents.updated_at DESC, droom_documents.created_at DESC").limit(limit)
-    }
+    scope :latest, -> limit { order("droom_documents.updated_at DESC, droom_documents.created_at DESC").limit(limit) }
 
     def attach_to(holder)
       self.folder = holder.folder
@@ -100,7 +98,7 @@ module Droom
     end
 
     def copy_to_dropbox(user)
-      dropbox_documents.create(:person_id => user.person.id)
+      dropbox_documents.create(:user => user)
     end
 
     def mark_dropbox_documents_deleted

data/app/models/droom/dropbox_document.rb

@@ -1,14 +1,11 @@
 module Droom
   class DropboxDocument < ActiveRecord::Base
-    attr_accessible :person_id
-
-    belongs_to :person
+    belongs_to :user
     belongs_to :document
 
-    validates_uniqueness_of :person_id, :scope => :document_id
+    validates_uniqueness_of :user_id, :scope => :document_id
 
     after_save  :get_file
-
     after_destroy :remove_dropbox_document
 
     def get_file
@@ -22,7 +19,7 @@ module Droom
     end
 
     def dropbox_client
-      person.user.dropbox_client
+      user.dropbox_client
     end
 
     def deleted=(boolean)

data/app/models/droom/dropbox_token.rb

@@ -1,11 +1,10 @@
 module Droom
   class DropboxToken < ActiveRecord::Base
-    attr_accessible :access_token, :access_token_secret, :created_by
     belongs_to :created_by, :class_name => "Droom::User"
     after_create :delete_previous
     
-    scope :by_date, order("created_at DESC")
-    scope :other_than, lambda { |token| where "id <> ?", token.id }
+    scope :by_date, -> {order("created_at DESC")}
+    scope :other_than, -> token { where "id <> ?", token.id }
     
     def dropbox_session
       unless @dbsession

data/app/models/droom/event.rb

@@ -1,18 +1,21 @@
 require 'open-uri'
 require 'uuidtools'
-require 'chronic'
-require 'ri_cal'
+require 'icalendar'
+require 'date_validator'
+require 'tod'
 
 module Droom
   class Event < ActiveRecord::Base
-    attr_accessible :start, :finish, :name, :description, :event_set_id, :created_by_id, :uuid, :all_day, :master_id, :url, :start_date, :start_time, :finish_date, :finish_time, :venue, :venue_id, :private, :public, :venue_name, :calendar_id
+    include Droom::Concerns::Slugged
+    include ActionView::Helpers::SanitizeHelper
 
     belongs_to :created_by, :class_name => "Droom::User"
 
-    has_folder #... and subfolders via agenda_categories
+    belongs_to :event_type
+    has_folder :within => :event_type #... and subfolders via agenda_categories
 
     has_many :invitations, :dependent => :destroy
-    has_many :people, :through => :invitations
+    has_many :users, :through => :invitations
 
     has_many :group_invitations, :dependent => :destroy
     has_many :groups, :through => :group_invitations
@@ -27,106 +30,72 @@ module Droom
     accepts_nested_attributes_for :event_set
 
     belongs_to :calendar
-
     has_many :scraps
 
-    belongs_to :master, :class_name => 'Event'
-    has_many :occurrences, :class_name => 'Event', :foreign_key => 'master_id', :dependent => :destroy
-    has_many :recurrence_rules, :dependent => :destroy, :conditions => {:active => true}
-    accepts_nested_attributes_for :recurrence_rules, :allow_destroy => true
-
     validates :start, :presence => true, :date => true
     validates :finish, :date => {:after => :start, :allow_nil => true}
     validates :uuid, :presence => true, :uniqueness => true
     validates :name, :presence => true
+    validates :event_type_id, :presence => true
 
     before_validation :set_uuid
-    before_save :ensure_slug
-    after_save :update_occurrences
-
-    scope :primary, where("master_id IS NULL")
-    scope :recurrent, where(:conditions => "master_id IS NOT NULL")
+    before_validation :slug_from_name_and_year
+    before_validation :set_default_event_type
 
     ## Event retrieval in various ways
     #
     # Events differ from other models in that they are visible to all unless marked 'private'.
     # The documents attached to them are only visible to all if marked 'public'.
     #
-    scope :all_private, where("private = 1")
-    scope :not_private, where("private <> 1 OR private IS NULL")
-    scope :all_public, where("public = 1 AND private <> 1 OR private IS NULL")
-    scope :not_public, where("public <> 1 OR private = 1)")
-
-    # events are visible by default. Private events are made invisible except to the people
-    # invited to them.
-
-    scope :visible_to, lambda { |person|
-      if person
-        select('droom_events.*')
-          .joins('LEFT OUTER JOIN droom_invitations ON droom_events.id = droom_invitations.event_id')
-          .where(["(NOT(droom_events.private = 1) OR droom_invitations.person_id = ?)", person.id])
-          .group('droom_events.id')
-      else
-        all_public
-      end
-    }
+    
+    scope :all_private, -> { where("private = 1") }
+    scope :not_private, -> { where("private <> 1 OR private IS NULL") }
+    scope :all_public, -> { where("public = 1 AND private <> 1 OR private IS NULL") }
+    scope :not_public, -> { where("public <> 1 OR private = 1)") }
 
-    scope :after, lambda { |datetime| # datetime. eg calendar.occurrences.after(Time.now)
-      where(['start > ?', datetime])
-    }
+    scope :after, -> datetime { where(['start > ?', datetime]) }
 
-    scope :before, lambda { |datetime| # datetime. eg calendar.occurrences.before(Time.now)
-      where(['start < :date AND (finish IS NULL or finish < :date)', :date => datetime])
-    }
+    scope :before, -> datetime { where(['start < :date AND (finish IS NULL or finish < :date)', :date => datetime]) }
 
-    scope :between, lambda { |start, finish| # datetimable objects. eg. Event.between(reader.last_login, Time.now)
-      where(['start > :start AND start < :finish AND (finish IS NULL or finish < :finish)', :start => start, :finish => finish])
-    }
+    scope :between, -> start, finish { where(['start > :start AND start < :finish AND (finish IS NULL or finish < :finish)', :start => start, :finish => finish]) }
 
-    scope :future_and_current, lambda {
-      where(['(finish > :now) OR (finish IS NULL AND start > :now)', :now => Time.now])
-    }
+    scope :future_and_current, -> { where(['(finish > :now) OR (finish IS NULL AND start > :now)', :now => Time.zone.now]) }
 
-    scope :finished, lambda {
-      where(['(finish < :now) OR (finish IS NULL AND start < :now)', :now => Time.now])
-    }
+    scope :finished, -> { where(['(finish < :now) OR (finish IS NULL AND start < :now)', :now => Time.zone.now]) }
     
-    scope :unbegun, lambda {
-      where(['start > :now', :now => Time.now])
-    }
+    scope :unbegun, -> { where(['start > :now', :now => Time.zone.now])}
 
-    scope :by_finish, order("finish ASC")
+    scope :by_finish, -> { order("finish ASC") }
 
-    scope :coincident_with, lambda { |start, finish| # datetimable objects.
-      where(['(start < :finish AND finish > :start) OR (finish IS NULL AND start > :start AND start < :finish)', {:start => start, :finish => finish}])
-    }
+    scope :coincident_with, -> start, finish { where(['(start < :finish AND finish >= :start) OR (finish IS NULL AND start >= :start AND start < :finish)', {:start => start, :finish => finish}]) }
 
-    scope :limited_to, lambda { |limit|
-      limit(limit)
-    }
+    scope :limited_to, -> limit { limit(limit) }
 
-    scope :at_venue, lambda { |venue| # EventVenue object
-      where(["venue_id = ?", venue.id])
-    }
+    scope :at_venue, -> venue { where(:venue_id => venue.id) }
+
+    scope :in_calendar, -> calendar { where(:calendar_id => calendar.id) }
 
-    scope :except_these_uuids, lambda { |uuids| # array of uuid strings
+    scope :added_since, -> date { where("created_at > ?", date)}
+
+    scope :except_these_uuids, -> uuids {
       placeholders = uuids.map{'?'}.join(',')
       where(["uuid NOT IN (#{placeholders})", *uuids])
     }
 
-    scope :without_invitations_to, lambda { |person| # Person object
+    scope :without_invitations_to, -> user {
       select("droom_events.*")
-        .joins("LEFT OUTER JOIN droom_invitations ON droom_events.id = droom_invitations.event_id AND droom_invitations.person_id = #{sanitize(person.id)}")
+        .joins("LEFT OUTER JOIN droom_invitations ON droom_events.id = droom_invitations.event_id AND droom_invitations.user_id = #{sanitize(user.id)}")
         .group("droom_events.id")
         .having("COUNT(droom_invitations.id) = 0")
     }
 
-    scope :with_documents, 
+    scope :with_documents, -> {
       select("droom_events.*")
         .joins("INNER JOIN droom_document_attachments ON droom_events.id = droom_document_attachments.attachee_id AND droom_document_attachments.attachee_type = 'Droom::Event'")
         .group("droom_events.id")
+    }
 
-    scope :matching, lambda { |fragment| 
+    scope :matching, -> fragment { 
       fragment = "%#{fragment}%"
       where('droom_events.name like :f OR droom_events.description like :f', :f => fragment)
     }
@@ -134,7 +103,7 @@ module Droom
     # All of these class methods also return scopes.
     #
     def self.in_the_last(period)           # seconds. eg calendar.occurrences.in_the_last(1.week)
-      finish = Time.now
+      finish = Time.zone.now
       start = finish - period
       between(start, finish)
     end
@@ -181,8 +150,8 @@ module Droom
 
     ## Instance methods
     #
-    def invite(person)
-      self.people << person
+    def invite(user)
+      self.users << user
     end
 
     def attach(doc)
@@ -196,7 +165,7 @@ module Droom
     #   event.start = "Tuesday at 11pm"
     #   event.start = "12/12/1969 at 10pm"
     #   event.start = "1347354111"
-    #   event.start = Time.now + 1.hour
+    #   event.start = Time.zone.now + 1.hour
     #
     def start=(value)
       write_attribute :start, parse_date(value)
@@ -205,56 +174,53 @@ module Droom
     def finish=(value)
       write_attribute :finish, parse_date(value)
     end
-    
+
     # For interface purposes we often want to separate date and time parts. These getters will return the 
     # corresponding Date or Time object.
     #
-    # The `time_of_day` gem makes time handling a bit more intuitive by concealing the date part of a Time object.
+    # The `tod` gem makes time handling a bit more intuitive by concealing the date part of a Time object.
     #
+    
+    def start
+      tz = timezone || Time.zone
+      if start = read_attribute(:start)
+        start.in_time_zone(tz)
+      end
+    end
+    
     def start_time
-      start.time_of_day if start
+      start.to_time_of_day if start
     end
 
     def start_date
       start.to_date if start
     end
     
+    def finish
+      tz = timezone || Time.zone
+      if finish = read_attribute(:finish)
+        finish.in_time_zone(tz)
+      end
+    end
+
     def finish_time
-      finish.time_of_day if finish
+      finish.to_time_of_day if finish
     end
 
     def finish_date
       finish.to_date if finish
     end
-    
-    # And these setters will adjust the current value so that its date or time part corresponds to the given
-    # value. The value is passed through the same parsing mechanism as above, so:
-    #
-    #   event.start = "Tuesday at 11pm"       -> next Tuesday at 11pm
-    #   event.start_time = "8pm"              -> next Tuesday at 8pm
-    #   event.start_date = "Wednesday"        -> next Wednesday at 8pm
-    #   event.start_date = "26 February 2016" -> 26/2/16 at 8pm
-    #   event.start_time = "18:00"            -> 26/2/16 at 6pm
-    #
-    # If the time is set before the date, we default to that time today. Times default to 00:00 in the usual way.
-    #
-    def start_time=(value)
-      self.start = (start_date || Date.today).to_time + parse_date(value).seconds_since_midnight
-    end
 
-    def start_date=(value)
-      self.start = parse_date(value).to_date# + start_time
+    def month
+      start.strftime("%m")
     end
 
-    def finish_time=(value)
-      if value && !value.blank?
-        time_portion = parse_date(value).seconds_since_midnight
-        self.finish = (finish_date || start_date || Date.today).to_time + time_portion
-      end
+    def month_name
+      start.strftime("%b")
     end
 
-    def finish_date=(value)
-      self.finish = parse_date(value).to_date# + finish_time
+    def year
+      start.strftime("%Y")
     end
 
     def duration
@@ -264,17 +230,17 @@ module Droom
         0
       end
     end
-
+    
     def venue_name
       venue.name if venue
     end
 
     def venue_name=(name)
-      self.venue = Droom::Venue.find_or_create_by_name(name)
+      self.venue = Droom::Venue.where(name: name).first_or_create
     end
 
     def find_or_create_agenda_category(category)
-      agenda_categories.find_or_create_by_category_id(category.id)
+      agenda_categories.where(category_id: category.id).first_or_create
     end
         
     def categories_for_selection
@@ -283,27 +249,26 @@ module Droom
       cats
     end
 
-    def attended_by?(person)
-      person && person.invited_to?(self)
+    def attended_by?(user)
+      user && user.invited_to?(self)
     end
 
-    def visible_to?(user_or_person)
+    def visible_to?(user)
       return true if self.public?
       return false if self.private?# || Droom.events_private_by_default?
       return true
     end
     
-    def detail_visible_to?(user_or_person)
+    def detail_visible_to?(user)
       return true if self.public?
-      return false unless user_or_person
-      return true if user_or_person.admin?
-      return true if user_or_person.privileged?
-      return true if user_or_person.person.invited_to?(self)
+      return false unless user
+      return true if user.admin?
+      return true if user.invited_to?(self)
       return false if self.private?
       return true
     end
     
-    def has_people?
+    def has_anyone?
       invitations.any?
     end
 
@@ -320,48 +285,50 @@ module Droom
     end
 
     def continuing?
-      finish && start < Time.now && finish > Time.now
+      finish && start < Time.zone.now && finish > Time.zone.now
     end
 
     def finished?
-      start < Time.now && (!finish || finish < Time.now)
-    end
-
-    def recurs?
-      master || occurrences.any?
-    end
-
-    def recurrence
-      recurrence_rules.first.to_s
-    end
-
-    def add_recurrence(rule)
-      self.recurrence_rules << Droom::RecurrenceRule.from(rule)
+      start < Time.zone.now && (!finish || finish < Time.zone.now)
     end
     
     def url_with_protocol
-      url =~ /^https?:\/\// ? url : "http://#{url}"
+      if url? && url !~ /^https?:\/\//
+        "http://#{url}"
+      else
+        url
+      end
     end
 
     def url_without_protocol
-      url.sub(/^https?:\/\//, '')
-    end
-
-    def to_rical
-      RiCal.Event do |cal_event|
-        cal_event.uid = uuid
-        cal_event.summary = name
-        cal_event.description = description if description
-        cal_event.dtstart =  (all_day? ? start_date : start) if start
-        cal_event.dtend = (all_day? ? finish_date : finish) if finish
-        cal_event.url = url_with_protocol if url
-        cal_event.rrules = recurrence_rules.map(&:to_rical) if recurrence_rules.any?
-        cal_event.location = venue.name if venue
+      if url?
+        url.sub(/^https?:\/\//, '')
+      else
+        ""
       end
     end
+    
+    def plain_description
+      strip_tags(description)
+    end
+
+    def icalendar_event
+      event = Icalendar::Event.new
+      event.uid = uuid
+      event.summary = name
+      event.description = plain_description if description?
+      event.dtstart = (all_day? ? start_date : start) if start?
+      event.dtend = (all_day? ? finish_date : finish) if finish?
+      event.url = url_with_protocol if url?
+      event.attendees = invitations.accepted.map{|inv| "mailto:#{inv.user.email}"} if invitations.accepted.any?
+      event.location = venue.name if venue
+      event
+    end
 
     def to_ics
-      to_rical.to_s
+      cal = Icalendar::Calendar.new
+      cal.add_event(icalendar_event)
+      cal.to_ical
     end
 
     def as_json(options={})
@@ -387,34 +354,21 @@ module Droom
         :id => id
       }
     end
-
-  protected
-
-    def ensure_slug
-      ensure_presence_and_uniqueness_of(:slug, "#{start.strftime("%Y %m %d")} #{name}".parameterize)
+    
+    def folder_name
+      "#{name} (#{month_name} #{year})"
     end
 
+  protected
+    
+    # This is mostly for ical/webcal distributions but we also use it in the API.
+    #
     def set_uuid
       self.uuid = UUIDTools::UUID.timestamp_create.to_s if uuid.blank?
     end
 
-    # doesn't yet observe exceptions
-    def update_occurrences
-      occurrences.destroy_all
-      if recurrence_rules.any?
-        recurrence_horizon = Time.now + 10.years
-        to_rical.occurrences(:before => recurrence_horizon).each do |occ|
-          occurrences.create!({
-            :name => self.name,
-            :url => self.url_with_protocol,
-            :description => self.description,
-            :venue => self.venue,
-            :start => occ.dtstart,
-            :finish => occ.dtend,
-            :uuid => nil
-          }) unless occ.dtstart == self.start
-        end
-      end
+    def set_default_event_type
+      self.event_type ||= Droom::EventType.default
     end
 
     def parse_date(value)
@@ -422,7 +376,7 @@ module Droom
       when Numeric
         Time.at(value)
       when String
-        Chronic.parse(value)
+        Time.zone.parse(value)
       else
         value
       end