radiant-event_calendar-extension 1.0.0

data/app/models/event_calendar_page.rb

@@ -0,0 +1,138 @@
+require 'rack/utils'
+
+class EventCalendarPage < Page
+  include WillPaginate::ViewHelpers
+
+  attr_accessor :filters, :calendar_parameters, :calendar_filters, :calendar_year, :calendar_month, :calendar_page, :calendar_category, :calendar_slug, :calendar_period
+
+  description %{ Create a viewer for calendar data. }
+
+  def self.sphinx_indexes
+    []
+  end
+
+  def cache?
+    true
+  end
+
+  def find_by_url(url, live = true, clean = false)
+    url = clean_url(url) if clean
+    my_url = self.url_without_parts
+    if url =~ /^#{Regexp.quote(my_url)}(.*)/
+      read_parameters($1)
+      self
+    else
+      super
+    end
+  end
+  
+  def read_parameters(path)
+    @calendar_parameters = []
+    unless path.blank?
+      parts = path.split(/\/+/)
+      @calendar_page = parts.pop if parts.last =~ /^\d{1,3}$/
+      @period = {}
+      parts.each do |part|
+        if part.match(/^\d\d\d\d$/)
+          @calendar_year = part
+        elsif part.match(/^\d+$/)
+          @calendar_day = part
+        elsif Date::MONTHNAMES.include?(part.titlecase)
+          @calendar_month = Date::MONTHNAMES.index(part.titlecase)
+        elsif Calendar.categories.include?(part)
+          @calendar_category = part
+        elsif Calendar.slugs.include?(part)
+          @calendar_slug = part
+        else 
+          @calendar_parameters.push(part)
+        end
+      end
+      
+      if @calendar_year && @calendar_month
+        start = Date.civil(@calendar_year.to_i, @calendar_month.to_i)
+        @calendar_period = CalendarPeriod.between(start, start.to_datetime.end_of_month)
+      elsif calendar_year
+        start = Date.civil(@calendar_year.to_i)
+        @calendar_period = CalendarPeriod.between(start, start.to_datetime.end_of_year)
+      end
+
+      @calendar_parameters
+    end
+  end
+    
+  def calendar_set
+    if calendar_category and calendar_slug 
+      calendars.in_category(calendar_category).with_slugs(calendar_slug)
+    end
+  end
+  
+  def url_parts
+    {
+      :path => url_without_parts,
+      :day => @calendar_day,
+      :month => @calendar_month,
+      :year => @calendar_year,
+      :category => @calendar_category,
+      :slug => @calendar_slug
+    }
+  end
+  
+  def url_with_parts(overrides={})
+    parts = url_parts.merge(overrides)
+    page = parts.delete(:page)
+    path = parts.delete(:path)
+    parts[:month] = month_names[parts[:month]].downcase unless parts[:month].blank? || parts[:month] =~ /[a-zA-Z]/
+    clean_url([path, parts.values, page].select{|p| !p.blank?}.join('/'))
+  end
+  alias_method_chain :url, :parts
+
+  def month_names
+    @month_names ||= Date::MONTHNAMES.dup
+  end
+  
+  def day_names
+    unless @day_names
+      @day_names = Date::DAYNAMES.dup
+      @day_names.push(@day_names.shift) # Class::Date and ActiveSupport::CoreExtensions::Time::Calculations have different ideas of when is the start of the week. we've gone for the rails standard.
+    end
+    @day_names
+  end
+
+
+  desc %{
+    Renders a trail of breadcrumbs to the current page. On an event calendar page this tag is 
+    overridden to show the filters applied to calendar data (including category, slug and date rage) 
+    as well as the path to this page.
+
+    *Usage:*
+
+    <pre><code><r:breadcrumbs [separator="separator_string"] [nolinks="true"] /></code></pre>
+  }
+  tag 'breadcrumbs' do |tag|
+    page = tag.locals.page
+    nolinks = (tag.attr['nolinks'] == 'true')
+    
+    if calendar_category
+      crumbs = nolinks ? [page.breadcrumb] : [%{<a href="#{url}">#{tag.render('breadcrumb')}</a>}]
+      if calendar_slug
+        crumbs << (nolinks ? calendar_category : %{<a href="#{url}/#{calendar_category}">#{calendar_category}</a>})
+        crumbs << calendar_slug
+      else
+        crumbs << calendar_category
+      end
+    else
+     crumbs = [page.breadcrumb]
+    end
+    page.ancestors.each do |ancestor|
+      tag.locals.page = ancestor
+      if nolinks
+        crumbs.unshift tag.render('breadcrumb')
+      else
+        crumbs.unshift %{<a href="#{tag.render('url')}">#{tag.render('breadcrumb')}</a>}
+      end
+    end
+    separator = tag.attr['separator'] || ' &gt; '
+    crumbs.join(separator)
+  end
+
+end

data/app/models/event_occurrence.rb

@@ -0,0 +1,89 @@
+class EventOccurrence < ActiveRecord::Base
+  
+  belongs_to :event
+  belongs_to :calendar          # for efficient retrieval
+  belongs_to :event_venue       # we can just grab occurrences
+  
+  has_site if respond_to? :has_site
+
+  delegate :title, :description, :location, :postcode, :url, :keywords, :contact, :all_day, :one_day?, :within_day?, :to => :event
+
+  before_validation_on_create :set_defaults
+  
+  named_scope :imported, { :conditions => ["status_id = ?", Status[:imported].to_s] }
+  named_scope :submitted, { :conditions => ["status_id = ?", Status[:submitted].to_s] }
+  named_scope :approved, { :conditions => ["status_id >= (?)", Status[:published].to_s] }
+  
+  named_scope :in_calendars, lambda { |calendars| # list of calendar objects
+    ids = calendars.map{ |c| c.id }
+    { :conditions => [ ids.map{"calendar_id = ?"}.join(" OR "), *ids] }
+  }
+  
+  named_scope :after, lambda { |datetime| # datetime. eg calendar.occurrences.after(Time.now)
+    { :conditions => ['start_date > ?', datetime] }
+  }
+  
+  named_scope :before, lambda { |datetime| # datetime. eg calendar.occurrences.before(Time.now)
+    { :conditions => ['start_date < ?', datetime] }
+  }
+  
+  named_scope :between, lambda { |start, finish| # datetimable objects. eg. Event.between(reader.last_login, Time.now)
+    { :conditions => ['(start_date < :finish AND end_date > :start) OR (end_date IS NULL AND start_date < :finish AND start_date > :start)', {:start => start, :finish => finish}] }
+  }
+
+  named_scope :within, lambda { |period| # seconds. eg calendar.occurrences.within(6.months)
+    start = Time.now
+    finish = start + period
+    between(start, finish)
+  }
+
+  named_scope :in_the_last, lambda { |period| # seconds. eg calendar.occurrences.in_the_last(1.week)
+    finish = Time.now
+    start = finish - period
+    between(start, finish)
+  }
+
+  named_scope :in_year, lambda { |year| # just a number. eg calendar.occurrences.in_year(2010)
+    start = DateTime.civil(year)
+    finish = start + 1.year
+    between(start, finish)
+  }
+
+  named_scope :in_month, lambda { |year, month| # numbers. eg calendar.occurrences.in_month(2010, 12)
+    start = DateTime.civil(year, month)
+    finish = start + 1.month
+    between(start, finish)
+  }
+  
+  named_scope :in_week, lambda { |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)
+  }
+  
+  named_scope :on_day, lambda { |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)
+  }
+
+  def status
+    Status.find(self.status_id)
+  end
+
+  def status=(value)
+    self.status_id = value.id
+  end
+
+protected
+
+  # the default occurrence just echoes the event
+  # recurrences will override at least start_date.
+
+  def set_defaults
+    [:start_date, :end_date, :calendar_id, :event_venue_id, :status_id].each do |col|
+      self[col] ||= event.send(col)
+    end
+  end
+
+end

data/app/models/event_recurrence_rule.rb

@@ -0,0 +1,85 @@
+class EventRecurrenceRule < ActiveRecord::Base
+  include ActionView::Helpers::TextHelper
+  
+  belongs_to :created_by, :class_name => 'User'
+  belongs_to :updated_by, :class_name => 'User'
+  belongs_to :event
+  has_site if respond_to? :has_site
+  
+  def active
+    new_record? ? false : read_attribute(:active)
+  end
+
+  def basis
+    basis = read_attribute(:basis)
+    return nil unless basis == 'count' || basis == 'limit'
+    basis
+  end
+  
+  def unbounded?
+    basis.nil?
+  end
+  
+  def single?
+    true if basis == 'limit' && limiting_count == 1
+  end
+
+  def to_s
+    summary = []
+    if interval > 1
+      unit = period.downcase.sub(/ly$/, '')
+      unit = "day" if unit == 'dai'
+      summary << "every #{interval} #{unit.pluralize}"
+    else 
+      summary << period.downcase
+    end
+    if unbounded?
+      summary.last << ","
+      summary << 'indefinitely'
+    elsif basis == 'limit' && limiting_date
+      summary << "until #{limiting_date.to_datetime.strftime('%d %B %Y')}" if limiting_date
+    elsif basis == 'count' && limiting_count
+      summary.last << ","
+      summary << "#{limiting_count} times"
+    end
+    summary.join(' ')
+  end
+  
+  def rule=(rule)
+    rule = RiCal::PropertyValue::RecurrenceRule.convert(nil, rule) unless rule.is_a? RiCal::PropertyValue::RecurrenceRule
+    self.period = rule.freq
+    self.interval = rule.interval
+    if rule.until
+      self.basis = 'limit'
+      self.limiting_date = rule.until.value
+    elsif rule.count
+      self.basis = 'count'
+      self.limiting_count = rule.count
+    end
+  end
+  
+  def rule
+    rule = RiCal::PropertyValue::RecurrenceRule.convert(nil, "") unless rule.is_a? RiCal::PropertyValue::RecurrenceRule
+    rule.freq = period.upcase
+    rule.until = limiting_date if basis == 'limit' && limiting_date
+    rule.count = limiting_count if basis == 'count' && limiting_count
+    rule.interval = interval
+    rule
+  end
+
+  def self.from(rule)         # ical string or RiCal::PropertyValue::RecurrenceRule
+    rrule = self.new
+    rrule.rule = rule
+    rrule.active = true
+    rrule
+  end
+  
+  def to_ical
+    rule.to_ical
+  end
+
+end
+
+
+
+

data/app/models/event_venue.rb

@@ -0,0 +1,17 @@
+class EventVenue < ActiveRecord::Base
+  has_many :events, :dependent => :nullify
+  has_site if respond_to? :has_site
+  validates_presence_of :title, :address
+  default_scope :order => 'title asc'
+  
+  def to_s
+    %{#{title}, #{address}}
+  end
+  
+  def location
+    address
+  end
+  def location=(location)
+    address = location
+  end
+end

data/app/models/ical.rb

@@ -0,0 +1,132 @@
+require 'rubygems' 
+require 'net/http'
+require 'ri_cal'
+require 'date'
+require 'ftools'
+
+class Ical < ActiveRecord::Base
+  belongs_to :calendar
+  validates_presence_of :url
+  has_site if respond_to? :has_site
+
+  @@calendars_path = Radiant::Config["event_calendar.icals_path"]
+  
+  def refresh
+    retrieve_file
+    parse_file
+    logger.info self.calendar.category + "/" + self.calendar.name + " - iCalendar subscription refreshed on " + Time.now.strftime("%m/%d at %H:%M")
+  end
+
+  def retrieve_file
+    File.makedirs filepath
+    begin
+      uri = URI.parse(url)
+      if authenticated?
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == 'https'
+        req = Net::HTTP::Get.new(uri.path)
+        req.basic_auth username, password
+        response = http.request(req)
+      else
+        response = Net::HTTP.get_response(uri)
+      end
+      File.open(filename, "w") do |file|
+        file << response.body
+      end
+    rescue => error
+      logger.error "iCal url or file error with: #{self.calendar.name} - #{url} -> (#{filename}): #{error}."
+      raise
+    end
+  end
+
+  def parse_file(thisfile=filename)
+    begin
+      Ical.transaction do
+        self.last_refresh_count = 0
+        event_count = 0
+        File.open(thisfile, "r") do |file|
+          components = RiCal.parse(file)
+          cal = components.first
+          cal.events.each do |cal_event|
+            if event = Event.find_by_uuid(cal_event.uid)
+              if cal_event.dtstamp > event.updated_at
+                event.update_from(cal_event) 
+              else
+              end
+              event_count += 1
+            else
+              event = Event.create_from(cal_event)
+              event.site = self.calendar.site if event.respond_to? :site=
+              self.calendar.events << event
+              event.save!
+            end
+          end
+        end
+        self.last_refresh_count = event_count
+        self.last_refresh_date = Time.now.utc
+        self.save!
+      end
+    rescue => error
+      logger.error "RiCal parse error with: #{self.calendar.name}: #{error}."
+      raise
+    end 
+  end
+  
+  def filepath
+    File.join RAILS_ROOT, "public", ics_path
+  end
+  
+  def filename
+    File.join filepath, ics_file
+  end
+
+  def ics_path
+    File.join @@calendars_path, self.calendar.category
+  end
+  
+  def ics_file
+    "#{self.calendar.slug}.ics"
+  end
+  
+  def to_ics
+    File.join "", ics_path, ics_file
+  end
+
+  # I've changed this to make the ical refresh decision a simple yes or no
+  # and to make the refresh interval a global value
+  def refresh_interval
+    (Radiant::Config['event_calendar.refresh_interval'] || 3600).to_i.seconds
+  end
+  
+  def refresh_automatically?
+    refresh_interval.nil? || refresh_interval.to_i != 0
+  end
+    
+  def needs_refreshment?
+    last_refresh_date.nil? || Time.now > last_refresh_date + refresh_interval
+  end
+  
+  def self.check_refreshments
+    find(:all).each do |i|
+      i.refresh if i.refresh_automatically? && i.needs_refreshment?
+    end
+  end
+  
+  def self.refresh_all
+    find(:all).each do |i|
+      i.refresh 
+    end
+    return true
+  end
+  
+  protected
+  
+    def authenticated?
+      !username.blank?
+    end
+    
+    def secured?
+      url.match(/^https/)
+    end
+    
+end