droom 0.0.1

data/app/models/droom/personal_document.rb

@@ -0,0 +1,98 @@
+module Droom
+  class PersonalDocument < ActiveRecord::Base
+    attr_accessible :document_link, :person
+
+    belongs_to :document_link
+
+    has_attached_file :file, {
+      :storage => :filesystem,
+      :path => ":rails_root/:dav_root/:person/:category_and_slug/:filename",
+      :url => "/:dav_root/:person/:category_and_slug/:filename",
+    }
+    
+    before_create :clone_file
+    
+    scope :derived_from, lambda { |document|
+      select("droom_personal_documents.*")
+        .joins("INNER JOIN droom_document_links AS ddl ON droom_personal_documents.document_link_id = ddl.id")
+        .joins("INNER JOIN droom_document_attachments AS dda ON ddl.document_attachment_id = dda.id")
+        .where(["dda.document_id = ?", document.id])
+    }
+
+    scope :belonging_to, lambda { |person|
+      where(["person_id = ?", person.id])
+    }
+    
+    # document properties we have to retrieve across quite a long chain, 
+    # but it should be possible to rely on its existence. If not, we have
+    # other problems.
+    
+    delegate :slug, :category, :person_id, :to => :document_link
+    
+    def person
+      document_link.person
+    end
+
+    def document
+      document_link.document
+    end
+
+    def name
+      document.name
+    end
+
+    def description
+      document.description
+    end
+    
+    def file_changed?
+      file_fingerprint != Digest::MD5.file(file.path).to_s
+    end
+
+    def file_touched?
+      File.mtime(file.path) > Time.at(file.updated_at)
+    end
+  
+    def file_path
+      
+    end
+    
+    def url
+      file.url if file
+    end
+    
+    def file_extension
+      File.extname(file_file_name).sub(/^\./, '')
+    end
+    
+    def reclone_if_changed
+      reclone_file if document.version > self.version
+    end
+    
+  protected
+  
+    def clone_file
+      self.version = document.version
+      self.file = document.file
+    end
+    
+    def reclone_file
+      archive_file if file? && file_touched?
+      clone_file
+    end
+    
+    # If the previous file for some reason needs to be preserved - usually because it has been edited
+    # in some way by its owner - we archive it by interpolating _vX into the filename, where X is
+    # the current version of this personal document (which is the same as the old version of its
+    # document. Calling clone_file again will update our version as well as retrieving the new file.
+    # This way we can avoid storing all the files with redundant version suffixed (almost everything would
+    # be _v1), keep useful older versions in a comprebensible way and discard old versions that aren't special.
+    #
+    def archive_file
+      suffix = File.extname(file_file_name)
+      stem = File.basename(file_file_name, suffix)
+      dir = File.dirname(file.path)
+      FileUtils.move(file.path, "#{dir}/#{stem}_v#{version}#{suffix}")
+    end
+  end
+end

data/app/models/droom/recurrence_rule.rb

@@ -0,0 +1,82 @@
+module Droom
+  class RecurrenceRule < ActiveRecord::Base
+  
+    belongs_to :created_by, :class_name => 'User'
+    belongs_to :event
+    
+    attr_accessible :period, :interval, :basis, :limiting_count, :limiting_date
+  
+    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_rical
+      rule.to_ical
+    end
+
+  end
+end

data/app/models/droom/venue.rb

@@ -0,0 +1,125 @@
+require 'snail'
+
+module Droom
+  class Venue < ActiveRecord::Base
+    attr_accessible :name, :lat, :lng, :post_line1, :post_line2, :post_city, :post_country, :post_code
+    
+    belongs_to :created_by, :class_name => 'User'
+    has_many :events, :dependent => :nullify
+    acts_as_mappable
+
+    default_scope :order => 'name asc'
+    before_validation :geocode_and_get_address
+
+    scope :name_matching, lambda { |fragment| 
+      fragment = "%#{fragment}%"
+      where('droom_venues.name like ?', fragment)
+    }
+
+    # *for_selection* returns a set of [name, id] pairs suitable for use as select options.
+    def self.for_selection
+      self.all.map{|v| [v.proper_name, v.id] }
+    end
+
+    def proper_name
+      if prepend_article?
+        "the #{name}"
+      else
+        name
+      end
+    end
+
+    def to_s
+      name
+    end
+    
+    def identifier
+      'venue'
+    end
+    
+    # Snail is a library that abstracts away - as far as possible - the vagaries of international address formats. Here we map our data columns onto Snail's abstract representations so that they can be rendered into the correct format for their country.
+    def address
+      Snail.new(
+        :line_1 => post_line1,
+        :line_2 => post_line2,
+        :city => post_city,
+        :region => post_region,
+        :postal_code => post_code,
+        :country => post_country
+      )
+    end
+
+    def address?
+      post_line1? && post_city
+    end
+
+    def as_json(options={})
+      json = {
+        :id => id,
+        :name => name,
+        :postcode => post_code,
+        :address => address.to_s,
+        :lat => lat,
+        :lng => lng,
+        :events => events.visible_to(options[:person]).as_json(options)
+      }
+    end
+
+    def as_ri_cal_calendar
+      RiCal.Calendar do |cal|
+        events.primary.each do |event|
+          cal.add_subcomponent(event.to_ri_cal)
+        end
+      end
+    end
+
+    def to_ical
+      self.as_ri_cal_calendar.to_s
+    end
+
+    # We only go back to google for a new map location if there has been a change of address, but there are many places in which that could happen.
+    #
+    def address_changed?
+      name_changed? || post_line1_changed? || post_line2_changed? || post_city_changed? || post_region_changed?  || post_code_changed? || post_country_changed?
+    end
+
+  private
+
+    # This is the main geocoding routine, called before validation on every save. If there has been a significant change, 
+    # it will trigger the goecoding mechanism with a block that updates our address when a match is found. 
+    # It's fairly uncritical and probably needs to be more careful about overriding user-entered data.
+    #
+    def geocode_and_get_address(options={})
+      unless Rails.env.test?
+        if new_record? || address_changed? || options[:force]
+          geocode_with(:name) do |geo|
+            self.post_line1 = geo.street_address
+            self.post_city = geo.city
+            self.post_region = geo.province
+            self.post_country = geo.country
+            self.post_code = geo.zip
+            sleep(options[:delay].seconds) if options[:delay]
+          end
+        end
+      end
+    end
+
+    # *geocode_with* does the actual lookup, passing the value of the specified column to the google geocoder service (with help from Geokit)
+    # and yielding to the supplied block as soon as a match is found.
+    #
+    def geocode_with(attribute, &block)
+      value = send(attribute)
+      found = false
+      unless value.blank?
+        geo = Geokit::Geocoders::GoogleGeocoder3.geocode(value, :bias => Droom.geocode_bias, :language => 'en')
+        if geo.success
+          self.lat, self.lng = geo.lat, geo.lng
+          yield geo if block_given?
+          found = true
+        end
+      end
+      found
+    end
+
+  end
+end

data/app/views/droom/dashboard/_marginalia.html.haml

@@ -0,0 +1,3 @@
+#marginalia
+  = render :partial => "droom/shared/calendar_and_search"
+  .search_results

data/app/views/droom/dashboard/_my_future_events.html.haml

@@ -0,0 +1,9 @@
+- if current_user.person
+  - events = current_user.person.events.future_and_current
+  - if events.any?
+    %h2.quiet
+      = t :my_future_events
+    = render :partial => "droom/events/event", :collection => events
+  - else
+    - events = Droom::Event.future_and_current
+    

data/app/views/droom/dashboard/_my_group_documents.html.haml

@@ -0,0 +1,6 @@
+- if current_user.person && current_user.person.groups.any?
+  - documents = current_user.person.group_documents
+  - if documents.any?
+    %h2.quiet
+      = t :my_group_documents
+    = render :partial => "droom/documents/document", :collection => documents

data/app/views/droom/dashboard/_my_past_events.haml

@@ -0,0 +1,6 @@
+- if current_user.person
+  - events = current_user.person.events.past
+  - if events.any?
+    %h2.quiet
+      = t :my_past_events
+    = render :partial => "droom/events/event", :collection => events, :locals => {:brief => true}

data/app/views/droom/dashboard/index.html.haml

@@ -0,0 +1,5 @@
+#dashboard
+  - Droom.active_dashboard_modules.each do |mod|
+    = render :partial => "droom/dashboard/#{mod}"
+
+= render :partial => 'droom/dashboard/marginalia'

data/app/views/droom/documents/_created.html.haml

@@ -0,0 +1,2 @@
+%p.notification
+  = t :document_created, :name => @document.name

data/app/views/droom/documents/_document.html.haml

@@ -0,0 +1,14 @@
+- cssclasses = ["dl"]
+- cssclasses << document.file_extension
+- cssclasses << 'changed' if document.changed_since_creation?
+
+%div.document.holder
+  %h2.name<
+    = link_to truncate(document.name, :length => 33), document_url(document), :class => cssclasses, :title => t(:click_to_download, :name => document.file_file_name)
+    - if admin?
+      = link_to t(:edit_document), edit_document_url(document), :class => 'admin edit minimal', :remote => true, :data => {:action => "overlay", :type => "html"}
+
+  - if document.description
+    - cssclasses = document.changed_since_creation? ? "description changed" : "description"
+    %p{:class => cssclasses}
+      = document.description

data/app/views/droom/documents/_document_line.html.haml

@@ -0,0 +1,2 @@
+- document ||= document_line
+

data/app/views/droom/documents/_documents_list.html.haml

@@ -0,0 +1,31 @@
+- event ||= @event
+
+.documents{ :"data-url" => "#{event_documents_path(event)}.js", :"data-refreshable" => true}
+
+  %section.holder
+
+    - if event.document_attachments.any?
+      %h2
+        = t :attachments
+        = link_to t(:add_document), droom.new_event_document_url(event), :class => "add minimal admin", :remote => true, :data => {:action => "append_form", :type => "html", :affected => ".documents"}
+      / %p
+      /   = link_to t(:download_attachments_as_zipfile), event_url(event, :format => :zip), :class => "download"
+      
+      = render :partial => "droom/events/attachment_list", :object => event.document_attachments.unfiled, :locals => {:limit => 100}
+
+    - elsif admin?
+      .holder
+        = link_to t(:add_document), droom.new_event_document_url(event), :class => "add admin", :remote => true, :data => {:action => "append_form", :type => "html", :affected => ".documents"}
+      
+  - attachments = event.attachments_by_category
+  - attachments.each_pair do |cat_name, category_attachments|
+    - if admin? || category_attachments.any?
+      - unless cat_name == "uncategorised"
+        %section.holder
+          %h3
+            = cat_name
+            - if admin?
+              = link_to t(:add_document), droom.new_event_document_url(event, :category_name => cat_name), :class => "add minimal admin", :remote => true, :data => {:action => "append_form", :type => "html", :affected => ".documents"}
+
+          = render :partial => "droom/events/attachment_list", :object => category_attachments, :locals => {:limit => 100}
+

data/app/views/droom/documents/_documents_table.html.haml

@@ -0,0 +1,13 @@
+%tbody{:"data-url" => "#{documents_path}.js", :"data-refreshable" => true }
+  - if @documents.any?
+    = render :partial => 'table_document', :collection => @documents
+    %tr
+      %td{:colspan => 6}
+        .pagination
+          = paginate @documents, :params => {:format => :js}
+  - else
+    %tr
+      %td{:colspan => 6}
+        %p.nothing_to_see
+          = t :no_documents
+        

data/app/views/droom/documents/_event_document_form.html.haml

@@ -0,0 +1,15 @@
+= form_for [@event, @document], :html => {:class => 'edit document'} do |f|
+  .filepicker
+    = link_to "choose file", "#", :class => "ul minimal #{@document.file_extension}"
+    = f.file_field :file, :class => "file"
+  .other
+    %p.name
+      = f.text_field :name, :class => 'name', :placeholder => t(:document_name)
+    %p.description
+      = f.text_area :description, :class => 'description', :placeholder => t(:document_description)
+
+    .buttons
+      = link_to t(:save_doc), '#', :class => 'submit'
+      / = f.submit t(:save_doc)
+      = t :or
+      = link_to t(:cancel), "/", :class => 'cancel'

data/app/views/droom/documents/_form.html.haml

@@ -0,0 +1,22 @@
+= form_for @document, :html => { :multipart => true, :class => 'edit document', :remote => true, :data => {:type => :html}} do |f|
+  - if @event
+    = f.hidden_field :event_id, :value => @event.id
+  - if @category
+    = f.hidden_field :attachment_category_id, :value =>  @category.id
+
+  .filepicker
+    = link_to "choose file", "#", :class => "ul minimal #{@document.file_extension}"
+    = f.file_field :file, :class => "file"
+    %p.tip
+      = t :click_to_choose_file
+
+  .metadata
+    %p.name
+      = f.text_field :name, :class => 'name', :placeholder => t(:document_name)
+    %p.description
+      = f.text_area :description, :class => 'description', :placeholder => t(:document_description)
+
+    .buttons
+      = f.submit t(:save_document)
+      = t :or
+      = link_to t(:cancel), "/", :class => 'cancel'