droom 0.0.1

data/app/controllers/droom/suggestions_controller.rb

@@ -0,0 +1,58 @@
+module Droom
+  class SuggestionsController < Droom::EngineController
+    respond_to :json, :js
+    before_filter :authenticate_user!
+    before_filter :get_current_person
+    before_filter :get_classes
+
+    def index
+      fragment = params[:term]
+      max = params[:limit] || 10
+
+      if @types.include?('event') && span = Chronic.parse(fragment, :guess => false)
+        @suggestions = Droom::Event.falling_within(span).visible_to(@current_person)
+
+      else
+        @suggestions = @klasses.collect {|klass| 
+          klass.constantize.visible_to(@current_person).name_matching(fragment).limit(max)
+        }.flatten.sort_by(&:name).slice(0, max)
+      end
+            
+      respond_with @suggestions do |format|
+        format.json {
+          render :json => @suggestions.map { |suggestion| {
+            :type => suggestion.identifier,
+            :text => suggestion.name,
+            :id => suggestion.id
+          }}.to_json
+        }
+        format.js {
+          render :partial => "droom/shared/suggestions"
+        }
+      end
+    end
+
+  protected
+  
+    def get_classes
+      if params[:type].blank?
+        @types = searchable_classes.keys
+        @klasses = searchable_classes.values
+      else
+        @types = searchable_classes.keys & [params[:type]].flatten
+        @klasses = searchable_classes.values_at(*@types)
+      end
+    end
+  
+    def searchable_classes
+      {
+        "event" => "Droom::Event", 
+        "person" => "Droom::Person", 
+        "document" => "Droom::Document",
+        "group" => "Droom::Group",
+        "venue" => "Droom::Venue"
+      }
+    end
+    
+  end
+end

data/app/controllers/droom/venues_controller.rb

@@ -0,0 +1,39 @@
+module Droom
+  class VenuesController < Droom::EngineController
+    respond_to :json, :html
+  
+    before_filter :authenticate_user!  
+    before_filter :get_current_person
+    before_filter :get_venues, :only => ["index"]
+    before_filter :get_venue, :only => [:show, :update]
+
+    def index
+      respond_with @venues do |format|
+        format.json {
+          render :json => @venues.to_json(:person => @person)
+        }
+      end
+    end
+    
+    def show
+      respond_with @venue
+    end
+    
+    def update
+      @venue.update_attributes(params[:venue])
+      respond_with @venue
+    end
+    
+  protected
+  
+    def get_venues
+      @venues = Venue.all
+    end
+
+    def get_venue
+      @venue = Venue.find(params[:id])
+      @events = @venue.events.visible_to(@current_person).future_and_current
+    end
+
+  end
+end

data/app/helpers/droom/droom_helper.rb

@@ -0,0 +1,74 @@
+module Droom
+  module DroomHelper
+    
+    def nav_link_to(name, url, options={})
+      options[:class] ||= ""
+      options[:class] << "here" if (request.path == url) || (request.path =~ /^#{url}/ && url != "/")
+      link_to name, url, options
+    end
+
+    def month_header_for(date)
+      content_tag('h3', l(date, :format => :month_header))
+    end
+    
+    def pagination_summary(collection, options = {})
+      entry_name = options[:entry_name] || (collection.empty?? 'entry' : collection.first.class.name.underscore.sub('_', ' '))
+      summary = if collection.num_pages < 2
+        case collection.total_count
+        when 0; "No #{entry_name.pluralize} found"
+        when 1; "Displaying <strong>1</strong> #{entry_name}:"
+        else;   "Displaying <strong>all #{collection.total_count}</strong> #{entry_name.pluralize}:"
+        end
+      else
+        offset = (collection.current_page - 1) * collection.limit_value
+        %{Displaying <strong>%d&nbsp;-&nbsp;%d</strong> of <strong>%d</strong> #{entry_name.pluralize}: } % [
+          offset + 1,
+          offset + collection.length,
+          collection.total_count
+        ]
+      end
+      summary.html_safe
+    end
+
+    # This will apply cloud-weighting to any list of items.
+    # They must have a 'weight' attribute
+    # and be ready to accept a 'cloud_size' attribute.
+
+    def cloud(these, threshold=0, biggest=3.0, smallest=1.3)
+      counts = these.map{|t| t.weight.to_i}.compact
+      if counts.any?
+        max = counts.max
+        min = counts.min
+        if max == min
+          these.each do |this|
+            this.cloud_size = sprintf("%.2f", biggest/2 + smallest/2)
+          end
+        else
+          steepness = Math.log(max - (min-1))/(biggest - smallest)
+          these.each do |this|
+            offset = Math.log(this.weight.to_i - (min-1))/steepness
+            this.cloud_size = sprintf("%.2f", smallest + offset)
+          end
+        end
+        if block_given?
+          these.each do |this|
+            yield this
+          end
+        end
+      end
+    end
+    
+    def url_for_month(date)
+      calendar_url(:year => date.year, :month => date.month)
+    end
+
+    def url_for_date(date)
+      calendar_url(:year => date.year, :month => date.month, :mday => date.day)      
+    end
+    
+    def day_names
+      ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
+    end
+    
+  end
+end

data/app/models/droom/agenda_category.rb

@@ -0,0 +1,8 @@
+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_class
+  end
+end

data/app/models/droom/category.rb

@@ -0,0 +1,27 @@
+module Droom
+  class Category < ActiveRecord::Base
+    attr_accessible :name, :description, :slug
+    
+    belongs_to :created_by, :class_name => 'User'
+    has_many :document_attachments
+    
+    before_validation :check_slug
+    validates :slug, :presence => true, :uniqueness => true
+    
+    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
+      categories = self.all.map{|c| [c.name, c.id] }
+      categories.unshift(['', ''])
+      categories
+    end
+
+  protected
+  
+    def check_slug
+      ensure_presence_and_uniqueness_of(:slug, name.parameterize)
+    end
+
+  end
+end

data/app/models/droom/document.rb

@@ -0,0 +1,110 @@
+module Droom
+  class Document < ActiveRecord::Base
+    attr_accessible :name, :file, :description, :attachment_category_id, :event_id
+
+    # attachment_category and event_id are used on document creation to create an associated attachment
+    # this is a temporary shortcut 
+    attr_accessor :old_version, :attachment_category_id, :event_id
+
+    belongs_to :created_by, :class_name => 'User'
+
+    has_many :document_attachments, :dependent => :destroy
+    has_many :document_links, :through => :document_attachments
+    has_many :people, :through => :document_links
+    
+    has_attached_file :file
+    
+    before_save :set_version
+    validates :file, :presence => true
+
+    scope :all_private, where("secret = 1")
+    scope :not_private, where("secret <> 1")
+    scope :all_public, where("public = 1 AND secret <> 1")
+    scope :not_public, where("public <> 1 OR secret = 1)")
+    
+    scope :visible_to, lambda { |person|
+      if person
+        select('droom_documents.*')
+          .joins('LEFT OUTER JOIN droom_document_attachments ON droom_documents.id = droom_document_attachments.document_id')
+          .joins('LEFT OUTER JOIN droom_document_links ON droom_document_attachments.id = droom_document_links.document_attachment_id')
+          .where(["(droom_documents.public = 1 OR droom_document_links.person_id = ?)", person.id])
+          .group('droom_documents.id')
+      else
+        all_public
+      end
+    }
+    
+    scope :name_matching, lambda { |fragment|
+      fragment = "%#{fragment}%"
+      where('droom_documents.name like ?', fragment)
+    }
+    
+    scope :attached_to_these_groups, lambda { |groups|
+      placeholders = groups.map{'?'}.join(',')
+      select('droom_documents.*')
+        .joins('INNER JOIN droom_document_attachments ON droom_documents.id = droom_document_attachments.document_id AND droom_document_attachments.attachee_type = "Droom::Group"')
+        .where(["droom_document_attachments.attachee_id IN(#{placeholders})", *groups.map(&:id)])
+    }
+    
+    scope :with_latest_event, 
+      select('droom_documents.*, droom_categories.name AS category_name, droom_events.id AS latest_event_id, droom_events.name AS latest_event_name')
+        .joins('LEFT OUTER JOIN droom_document_attachments AS dda ON droom_documents.id = dda.document_id 
+                LEFT OUTER JOIN droom_categories ON dda.category_id = droom_categories.id
+                LEFT OUTER JOIN droom_events ON dda.attachee_id = droom_events.id AND dda.attachee_type = "Droom::Event"')
+        .group('droom_documents.id')
+
+    # so that we can apply the joined finders above to an existing object
+    #
+    scope :this_document, lambda { |doc|
+      where(["droom_documents.id = ?", doc.id])
+    }
+
+    scope :by_date, order("droom_documents.updated_at DESC, droom_documents.created_at DESC")
+
+    def identifier
+      'document'
+    end
+
+    def file_ok?
+      file.exists?
+    end
+    
+    def changed_since_creation?
+      file_updated_at > created_at
+    end
+    
+    def attachment_category_id=(id)
+      attach_to(Droom::Event.find(event_id), {:category_id => id})
+    end
+
+    def attach_to(attachee, attributes={})
+      save!
+      document_attachments.create(attributes.merge(:attachee => attachee))
+    end
+    
+    def detach_from(attachee)
+      document_attachments.attached_to(attachee).destroy_all
+    end
+    
+    def file_extension
+      if file_file_name
+        File.extname(file_file_name).sub(/^\./, '')
+      else
+        ""
+      end
+    end
+    
+    def with_event
+      self.class.this_document(self).with_latest_event.first
+    end
+    
+  protected
+    
+    def set_version
+      if file.dirty?
+        self.version = (version || 0) + 1
+      end
+    end
+
+  end
+end

data/app/models/droom/document_attachment.rb

@@ -0,0 +1,71 @@
+module Droom
+  class DocumentAttachment < ActiveRecord::Base
+    attr_accessible :attachee, :document, :agenda_section, :category_id
+    
+    belongs_to :document
+    belongs_to :attachee, :polymorphic => true
+    belongs_to :category
+    belongs_to :created_by, :class_name => "User"
+
+    has_many :document_links, :dependent => :destroy
+    has_many :people, :through => :document_links
+
+    after_destroy :remove_private_document_if_unattached
+    after_create :link_people
+
+    default_scope order("(CASE WHEN droom_document_attachments.category_id IS NULL THEN 0 ELSE 1 END), droom_documents.updated_at ASC, droom_documents.created_at ASC").includes(:document)
+        
+    scope :unfiled, where("category_id IS NULL")
+
+    scope :attached_to, lambda { |attachee| 
+      where(["droom_document_attachments.attachee_type = :class AND droom_document_attachments.attachee_id = :id", :class => attachee.class.to_s, :id => attachee.id])
+    }
+
+    scope :to_event, lambda { |event| 
+      where(["droom_document_attachments.attachee_type = 'Droom::Event' AND droom_document_attachments.attachee_id = ?", event.id])
+    }
+
+    scope :to_group, lambda { |group| 
+      where(["droom_document_attachments.attachee_type = 'Droom::Group' AND droom_document_attachments.attachee_id = ?", group.id])
+    }
+
+    scope :to_events, lambda { |events| 
+      placeholders = events.map{'?'}.join(',')
+      ids = events.map(&:id)
+      where(["droom_document_attachments.attachee_type = 'Droom::Event' AND droom_document_attachments.attachee_id IN (#{placeholders})", *ids])
+    }
+
+    scope :to_groups, lambda { |groups| 
+      placeholders = groups.map{'?'}.join(',')
+      ids = groups.map(&:id)
+      where(["droom_document_attachments.attachee_type = 'Droom::Group' AND droom_document_attachments.attachee_id IN (#{placeholders})", *ids])
+    }
+    
+    def slug
+      if attachee 
+        attachee.slug
+      else
+        'Unattached'
+      end
+    end
+    
+    def category_name
+      category ? category.name : "uncategorised"
+    end
+  
+  protected
+  
+    def remove_private_document_if_unattached
+      unless document.public? || document.document_attachments.count > 0
+        document.destroy
+      end
+    end
+    
+    # Upon creation we create document links to all the people who are newly entitled to see the document.
+    # Deletion takes care of itself, as document_links are :dependent => :destroy.
+    #
+    def link_people
+      people << attachee.people if attachee
+    end
+  end
+end

data/app/models/droom/document_link.rb

@@ -0,0 +1,31 @@
+# the links between a person and document are too various and too extended to make them
+# easy to retrieve in a single query. Instead we maintain an index of person-document links.
+
+module Droom
+  class DocumentLink < ActiveRecord::Base
+    attr_accessible :person, :document_attachment
+    belongs_to :person
+    belongs_to :document_attachment
+    has_one :personal_document, :dependent => :destroy
+    
+    delegate :slug, :category, :to => :document_attachment
+
+    def document
+      document_attachment.document
+    end
+    
+    def document=(doc)
+      create_document_attachment(:document => doc)
+    end
+    
+    def ensure_personal_document
+      create_personal_document unless personal_document
+    end
+    
+    def self.repair
+      Droom::Person.each do |person|
+        person.repair_document_links
+      end
+    end
+  end
+end

data/app/models/droom/event.rb

@@ -0,0 +1,409 @@
+require 'open-uri'
+require 'zip/zip'
+require 'uuidtools'
+require 'chronic'
+require 'ri_cal'
+
+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, :private, :public, :venue_name
+
+    belongs_to :created_by, :class_name => 'User'
+
+    has_many :invitations, :dependent => :destroy
+    has_many :people, :through => :invitations
+
+    has_many :group_invitations, :dependent => :destroy
+    has_many :groups, :through => :group_invitations
+
+    has_many :document_attachments, :as => :attachee, :dependent => :destroy
+    has_many :documents, :through => :document_attachments
+
+    has_many :agenda_categories, :dependent => :destroy
+    has_many :categories, :through => :agenda_categories
+  
+    belongs_to :venue
+    accepts_nested_attributes_for :venue
+
+    belongs_to :event_set
+    accepts_nested_attributes_for :event_set
+  
+    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
+
+    before_validation :set_uuid
+    before_save :check_slug
+    after_save :update_occurrences
+  
+    scope :primary, where("master_id IS NULL")
+    scope :recurrent, where(:conditions => "master_id IS NOT NULL")
+    default_scope order('start ASC').includes(:venue)
+  
+    ## Event retrieval in various ways
+    #
+    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(["(droom_events.public = 1 OR droom_invitations.person_id = ?)", person.id])
+          .group('droom_events.id')
+      else
+        all_public
+      end
+    }
+
+    scope :after, lambda { |datetime| # datetime. eg calendar.occurrences.after(Time.now)
+      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 :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 :future_and_current, lambda {
+      where(['(finish > :now) OR (finish IS NULL AND start > :now)', :now => Time.now])
+    }
+  
+    scope :unfinished, lambda { |start| # datetimable object.
+      where(['start < :start AND finish > :start', :start => start])
+    }
+    
+    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 :limited_to, lambda { |limit|
+      limit(limit)
+    }
+  
+    scope :at_venue, lambda { |venue| # EventVenue object
+      where(["venue_id = ?", venue.id])
+    }
+  
+    scope :except_these_uuids, lambda { |uuids| # array of uuid strings
+      placeholders = uuids.map{'?'}.join(',')
+      where(["uuid NOT IN (#{placeholders})", *uuids])
+    }
+    
+    scope :without_invitations_to, lambda { |person| # Person object
+      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)}")
+        .group("droom_events.id")
+        .having("COUNT(droom_invitations.id) = 0")
+    }
+    
+    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 :all_private, where("private = 1 OR private = 't'")
+    scope :not_private, where("private = 0 OR private = 'f'")
+    scope :all_public, where("public = 1 OR public = 't'")
+    scope :not_public, where("public = 0 OR public = 'f'")
+
+    scope :name_matching, lambda { |fragment| 
+      fragment = "%#{fragment}%"
+      where('droom_events.name like ?', fragment)
+    }
+
+    # 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
+      start = finish - period
+      between(start, finish)
+    end
+
+    def self.in_year(year)                 # just a number. eg calendar.occurrences.in_year(2010)
+      start = DateTime.civil(year)
+      finish = start + 1.year
+      between(start, finish)
+    end
+
+    def self.in_month(year, month)          # numbers. eg calendar.occurrences.in_month(2010, 12)
+      start = DateTime.civil(year, month)
+      finish = start + 1.month
+      between(start, finish)
+    end
+  
+    def self.in_week(year, week)            # numbers, with a commercial week: eg calendar.occurrences.in_week(2010, 35)
+      start = DateTime.commercial(year, week)
+      finish = start + 1.week
+      between(start, finish)
+    end
+  
+    def self.on_day (year, month, day)      # numbers: eg calendar.occurrences.on_day(2010, 12, 12)
+      start = DateTime.civil(year, month, day)
+      finish = start + 1.day
+      between(start, finish)
+    end
+    
+    def self.in_span(span)                  # Chronic::Span
+      between(span.begin, span.end)
+    end
+
+    def self.falling_within(span)           # Chronic::Span
+      coincident_with(span.begin, span.end)
+    end
+
+    def self.future
+      after(Time.now)
+    end
+
+    def self.past
+      before(Time.now)
+    end
+
+    ## Instance methods
+    #
+    def invite(person)
+      self.people << person
+    end
+    
+    def attach(doc)
+      self.documents << doc
+    end
+    
+    def identifier
+      'event'
+    end
+    
+    # We store the start and end points of the event as a single DateTime value to make comparison simple.
+    # The setters for date and time are overridden to pass strings through chronic's natural language parser
+    # and to treat numbers as epoch seconds. These should all work as you'd expect:
+    #
+    #   event.start = "Tuesday at 11pm"
+    #   event.start = "12/12/1969 at 10pm"
+    #   event.start = "1347354111"
+    #   event.start = Time.now + 1.hour
+    #
+    def start=(value)
+      write_attribute :start, parse_date(value)
+    end
+
+    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.
+    #
+    def start_time
+      start.time_of_day if start
+    end
+
+    def start_date
+      start.to_date if start
+    end
+    
+    def finish_time
+      finish.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
+    end
+  
+    def finish_time=(value)
+      self.finish = (finish_date || start_date || Date.today).to_time + parse_date(value).seconds_since_midnight
+    end
+    
+    def finish_date=(value)
+      self.finish = parse_date(value).to_date# + finish_time
+    end
+
+    def duration
+      if finish
+        finish - start
+      else
+        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)
+    end
+
+    # Agenda sections are global, and we don't want to have to manage the extra workload of associating a section with an event.
+    # This call retrieves all the agenda sections that are associated with any of our document attachments, and is suitable for looping
+    # on a template to display attachments per section.
+    #
+    def agenda_sections
+      Droom::AgendaSection.associated_with_event(self)
+    end
+    
+    # and this sorts our attachment list into agenda section buckets so that we don't have to go back to the database for each section.
+    def attachments_by_category
+      cats = {}
+      document_attachments.each_with_object({}) do |att, hash|
+        key = att.category_name
+        cats[key] ||= []
+        cats[key].push(att)
+      end
+      categories.each do |category|
+        key = category.name
+        cats[key] ||= []
+      end
+      cats
+    end
+    
+    def categories_for_selection
+      cats = categories.map{|c| [c.name, c.id] }
+      cats.unshift(['', ''])
+      cats
+    end
+    
+    def visible_to?(user_or_person)
+      return true if self.public?
+      return false unless user_or_person
+      return true if user_or_person.admin?
+      return true if user_or_person.person.invited_to?(self)
+      return false if self.private?
+      return true
+    end
+
+    def one_day?
+      all_day? && within_day?
+    end
+  
+    def within_day?
+      (!finish || start.to.jd == finish.to.jd || finish == start + 1.day)
+    end
+  
+    def continuing?
+      finish && start < Time.now && finish > Time.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)
+    end
+    
+    def documents_zipped
+      if self.documents.any?
+        tempfile = Tempfile.new("droom-temp-#{slug}-#{Time.now}.zip")
+        Zip::ZipOutputStream.open(tempfile.path) do |z|
+          self.documents.each do |doc|
+            z.add(doc.file_file_name, open(doc.file.url))
+          end
+        end
+        tempfile
+      end
+    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 if url
+        cal_event.rrules = recurrence_rules.map(&:to_rical) if recurrence_rules.any?
+        cal_event.location = venue.name if venue
+      end
+    end
+  
+    def to_ics
+      to_rical.to_s
+    end
+    
+    def as_json(options={})
+      json = super
+      json[:datestring] = I18n.l start, :format => :natural_with_date
+      json
+    end
+
+  protected
+  
+    def check_slug
+      ensure_presence_and_uniqueness_of(:slug, "#{start.strftime("%Y %m %d")} #{name}".parameterize)
+    end
+    
+    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,
+            :description => self.description,
+            :venue => self.venue,
+            :start => occ.dtstart,
+            :finish => occ.dtend,
+            :uuid => nil
+          }) unless occ.dtstart == self.start
+        end
+      end
+    end
+
+    def parse_date(value)
+      case value
+      when Numeric
+        Time.at(value)
+      when String
+        Chronic.parse(value)
+      else
+        value
+      end
+    end
+  
+  end
+end