your_platform 0.0.1 → 0.0.2

data/app/models/corporation.rb

@@ -0,0 +1,80 @@
+# A Corporation is one of the central organizational units in your_platform.
+# Being a Group, the Corporation adds certain features:
+# 
+# * The corporations of the current_user are listed as primary entry points 
+#   of navigation in the ui.
+# * The memebrships in corporations and their subgroups are listed in the
+#   users' "corporate vitae".
+#
+class Corporation < Group
+  after_save { Corporation.corporations_parent << self }
+
+  # This returns the group that has all Corporations as children.
+  # The corporations_parent itself is a Group, no Corporation.
+  # 
+  def self.corporations_parent
+    self.find_corporations_parent_group || self.create_corporations_parent_group
+  end
+  
+  def self.find_corporations_parent_group
+    Group.find_by_flag :corporations_parent
+  end
+  
+  def self.create_corporations_parent_group
+    new_group = Group.create name: 'all_corporations'
+    new_group.add_flag :corporations_parent
+    new_group.add_flag :group_of_groups
+    Group.everyone << new_group
+    return new_group
+  end
+
+  # This method returns true if this (self) is the one corporation
+  # the given user has joined first, i.e. before he joined any other
+  # corporation.
+  #
+  def is_first_corporation_this_user_has_joined?( user )
+    return false if not user.groups.include? self
+    return true if user.corporations.count == 1
+    this_membership_valid_from = UserGroupMembership.find_by_user_and_group( user, self ).valid_from
+    user.memberships.each do |membership|
+      return false if membership.valid_from.to_i < this_membership_valid_from.to_i
+    end
+    return true
+  end
+  
+  # This method returns all status groups of the corporation.
+  # In this general context, each leaf group of the corporation is a status group.
+  # But this is likely to be overridden by the main application.
+  #
+  def status_groups
+    cached { StatusGroup.find_all_by_corporation(self) }
+  end
+  
+  # This method returns the status group with the given name.
+  # 
+  def status_group(group_name)
+    status_groups.select { |g| g.name == group_name }.first
+  end
+  
+  # This method lists all former members of the corporation. This is not determined
+  # by the user group membership validity range but by the membership in the 
+  # former_members sub group, since all members of subgroups are considered also 
+  # members of the group.
+  #
+  def former_members
+    child_groups.find_by_flag(:former_members_parent).try(:members) || []
+  end
+  def former_members_memberships
+    child_groups.find_by_flag(:former_members_parent).try(:memberships) || []
+  end
+  
+  # This method lists all deceased members of the corporation.
+  #
+  def deceased_members
+    child_groups.find_by_flag(:deceased_parent).try(:members) || []
+  end
+  def deceased_members_memberships
+    child_groups.find_by_flag(:deceased_parent).try(:memberships) || []
+  end
+
+end

data/app/models/dag_link.rb

@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+class DagLink < ActiveRecord::Base
+
+  attr_accessible :ancestor_id, :ancestor_type, :count, :descendant_id, :descendant_type, :direct
+  acts_as_dag_links polymorphic: true
+
+  # We have to workaround a bug in Rails 3 here. But, since Rails 3 is no longer fully supported,
+  # this is not going to be fixed.
+  # 
+  # https://github.com/rails/rails/issues/7618
+  #
+  # With our workaround, the `delete_cache` method is called on the `DagLink` when
+  # `group.members.destroy(user)` is called.
+  # 
+  # See: app/models/active_record_associations_patches.rb
+  #
+  after_save { self.delay.delete_cache }
+  before_destroy :delete_cache
+  
+  def fill_cache
+    valid_from
+  end
+
+  def delete_cache
+    super
+    ancestor.try(:delete_cache)
+    descendant.try(:delete_cache)
+  end
+end

data/app/models/event.rb

@@ -0,0 +1,235 @@
+class Event < ActiveRecord::Base
+  attr_accessible :description, :location, :end_at, :name, :start_at, :localized_start_at, :localized_end_at, :publish_on_local_website, :publish_on_global_website
+
+  is_structureable ancestor_class_names: %w(Group), descendant_class_names: %w(Group Page)
+  is_navable
+
+  has_many :attachments, as: :parent, dependent: :destroy
+
+  
+  # General Properties
+  # ==========================================================================================
+
+  # The title, i.e. the caption of the event is its name.
+  def title
+    name
+  end
+  
+  def to_param
+    "#{id} #{name} #{start_at.year}-#{start_at.month}-#{start_at.day}".parameterize
+  end
+
+
+  # Groups
+  # ==========================================================================================
+
+  # Eeach event is assigned to zero,  one or several groups.
+  # Internally, this is modelled using the DAG structure, i.e. one can use
+  # the `event.parent_groups` association.
+  # But for convenience, here are a few more accessor methods:
+
+  def group
+    self.parent_groups.first
+  end
+  def group=( group )
+    self.destroy_dag_links
+    self.parent_groups << group
+  end
+  def groups
+    self.parent_groups
+  end
+  
+  # Times
+  # ==========================================================================================
+  
+  def localized_start_at
+    I18n.localize start_at.to_time if start_at.present?
+  end
+  def localized_start_at=(string)
+    attribute_will_change! :start_at
+    #self.start_at = string.present? ? Time.parse(string) : nil
+    self.start_at = string  # conversion handled by the delocalize gem
+  end
+  
+  def localized_end_at
+    I18n.localize end_at.to_time if end_at.present?
+  end
+  def localized_end_at=(string)
+    attribute_will_change! :end_at
+    #self.end_at = string.present? ? Time.parse(string) : nil
+    self.end_at = string  # conversion handled by the delocalize gem
+  end
+  
+
+
+  # Contact People and Attendees
+  # ==========================================================================================
+  
+  def find_contact_people_group
+    find_special_group :contact_people
+  end
+  def create_contact_people_group
+    create_special_group :contact_people
+  end
+  def contact_people_group
+    find_contact_people_group || create_contact_people_group
+  end
+  def contact_people
+    contact_people_group.members
+  end
+  
+  def find_attendees_group
+    find_special_group :attendees
+  end
+  def create_attendees_group
+    create_special_group :attendees
+  end
+  def attendees_group
+    find_attendees_group || create_attendees_group
+  end
+  def attendees
+    attendees_group.members
+  end
+  
+  def destroy
+    find_attendees_group.try(:destroy)
+    find_contact_people_group.try(:destroy)
+    super
+  end
+  
+
+  # Scopes
+  # ==========================================================================================
+
+  # We used to define `upcoming` as "from now on", i.e. `start_time > Time.zone.now`.
+  # However, it is more convenient to see events that are currently in progress.
+  # Therefore, redefining `upcoming` to hide events on the next day.#
+  #
+  #        yesterday  -----  today  ----  tomorrow
+  #                              |= event, today, 20h
+  #                         |--------------------------------------->  (upcoming)
+  #
+  # For events that are ongoing, e.g. started yesterday, but end tomorrow, we'll include
+  # these events this scope in order to show them as long as they might be interesting.
+  #
+  #        yesterday  -----  today  ----  tomorrow
+  #            |= event, yesterday to tomorrow =|
+  #                         |--------------------------------------->  (upcoming)
+  #
+  # Date.today.to_datetime is 0h.
+  #
+  scope :upcoming, lambda { where("(start_at > ? AND end_at IS NULL) OR (end_at IS NOT NULL AND end_at > ?)", Date.today.to_datetime, Date.today.to_datetime) }
+  
+  def upcoming?
+    Event.upcoming.pluck(:id).include? self.id
+  end
+  
+  scope :direct, lambda { includes( :links_as_descendant ).where( :dag_links => { :direct => true } ) }
+
+
+  # Finder Methods
+  # ==========================================================================================
+
+  def self.find_all_by_group( group )
+    ancestor_id = group.id if group
+    self.includes( :links_as_descendant )
+      .where( :dag_links => { 
+                :ancestor_type => "Group", :ancestor_id => ancestor_id
+              } )
+      .order('start_at')
+  end
+
+  def self.find_all_by_groups( groups )
+    group_ids = groups.collect { |g| g.id }
+    self.includes( :links_as_descendant )
+      .where( :dag_links => { 
+                :ancestor_type => "Group", :ancestor_id => group_ids
+              } )
+      .order('start_at')
+  end
+  
+  def self.find_all_by_user(user)
+    self.find_all_by_groups(user.groups).direct
+  end
+  
+
+  # Calendar Export
+  # ==========================================================================================
+
+  def to_icalendar_event
+    e = Icalendar::Event.new
+    e.dtstart = Icalendar::Values::DateTime.new(self.start_at)
+    e.dtend = Icalendar::Values::DateTime.new(self.end_at || self.start_at + 1.hour)
+    e.summary = self.name
+    e.description = self.description
+    e.location = self.location
+    if self.contact_people.first
+      e.organizer = self.contact_people.first.email
+      e.organizer.ical_params = {'CN' => self.contact_people.first.title}
+    end
+    e.url = self.url
+    e.uid = e.url
+    e.created = Icalendar::Values::DateTime.new(self.created_at)
+    e.last_modified = Icalendar::Values::DateTime.new(self.updated_at)
+    return e
+  end
+  
+  def to_icalendar
+    cal = Icalendar::Calendar.new
+    cal.add_event self.to_icalendar_event
+    cal.publish
+    return cal
+  end
+
+  def to_ics
+    self.to_icalendar.to_ical
+  end
+  
+  def to_ical
+    self.to_ics
+  end
+  
+  # Example:
+  #     Group.find(12).events.to_ics
+  #
+  def self.to_ics
+    self.to_icalendar.to_ical
+  end
+  
+  def self.to_icalendar
+    cal = Icalendar::Calendar.new
+    where(true).each do |event|
+      cal.add_event event.to_icalendar_event
+    end
+    cal.publish
+    return cal
+  end
+  
+  def self.to_ical
+    self.to_ics
+  end
+  
+
+  # Existane
+  # ==========================================================================================
+  
+  # For some strange reason, the callbacks of the creation of an event appear to
+  # prevent the event form being found in the database after its creation.
+  # 
+  # In the EventsController and in specs, we need to make sure that the event exists
+  # before continuing. Otherwise `ActiveRecord::RecordNotFound` is raised in the controller
+  # or when redirecting to the event.
+  #
+  # TODO: Check if this is still necessary when migrating to Rails 4.
+  #
+  def wait_for_me_to_exist
+    raise 'The event has no id, yet!' unless id
+    begin
+      Event.find self.id
+    rescue ActiveRecord::RecordNotFound => e
+      sleep 1
+      retry
+    end
+  end
+  
+end

data/app/models/flag.rb

@@ -0,0 +1,18 @@
+class Flag < ActiveRecord::Base
+  attr_accessible :flagable_id, :flagable_type, :key
+
+  belongs_to :flagable, polymorphic: true
+
+  def to_sym
+    key.to_sym
+  end
+
+  def to_s
+    key.to_s
+  end
+
+  def inspect
+    to_sym
+  end
+
+end

data/app/models/flagable.rb

@@ -0,0 +1,62 @@
+module Flagable
+
+  def has_many_flags
+    has_many :flags, :as => :flagable, :dependent => :destroy
+
+    include FlagableInstanceMethods
+
+    def find_all_by_flag( flag )
+      self.joins( :flags ).where( :flags => { :key => flag } )
+    end
+    
+    def find_by_flag( flag )
+      find_all_by_flag( flag ).limit( 1 ).readonly( false ).first
+    end
+
+  end
+
+  module FlagableInstanceMethods
+    
+    def add_flags( *new_flags )
+      if new_flags.kind_of? Array
+        for new_flag in new_flags
+          if new_flag.kind_of? String or new_flag.kind_of? Symbol 
+            if not self.has_flag? new_flag
+              self.flags.create( key: new_flag.to_sym )
+            end
+          end
+        end
+      end
+    end
+
+    def add_flag( new_flag )
+      self.add_flags new_flag
+    end
+
+    def remove_flags( *flags_to_remove )
+      for flag_to_remove in flags_to_remove
+        self.flags.find_all_by_key( flag_to_remove ).each do |flag|
+          flag.destroy
+        end
+      end
+    end
+
+    def remove_flag( flag_to_remove )
+      self.remove_flags flag_to_remove
+    end
+
+    def flags_to_syms
+      self.flags.pluck(:key).map(&:to_sym)
+    end
+
+    def has_flag?( flag )
+      self.flags_to_syms.include? flag
+    end
+
+  end
+
+end
+
+# The integration in ActiveRecord is done in
+# config/initializers/active_record_flagable_extension.rb
+

data/app/models/geo_location.rb

@@ -0,0 +1,92 @@
+class GeoLocation < ActiveRecord::Base
+  attr_accessible :address #, :city, :country, :country_code, :latitude, :longitude, :postal_code, :queried_at
+
+
+  # When to perform geocoding queries (to google)
+  # ==========================================================================================
+
+  after_validation :geocode, :if => [ 'address_changed?', 'latitude.nil?' ]
+  after_find :geocode_and_save, :if => 'latitude.nil?'
+
+
+  # What to do when performing a geocoding query (to google)
+  # ==========================================================================================
+
+  geocoded_by :address do |geo_location, geo_query_results|
+    result = geo_query_results.first
+    if result
+      geo_location.latitude = result.latitude
+      geo_location.longitude = result.longitude
+      geo_location.city = result.city
+      geo_location.country = result.country
+      geo_location.country_code = result.country_code
+      geo_location.postal_code = result.postal_code
+    end
+    self
+  end
+  
+  # This method performs the geociding query and stores the query datetime. 
+  #
+  def geocode
+    self.queried_at = DateTime.now
+    super
+  end
+
+  # Perform geocode query and save the record.
+  # This is needed after finding a record where no geocode query has been done, yet.
+  #
+  def geocode_and_save
+    geocode
+    save
+  end
+
+  # This method returns `true` if the geocoding query has been performed, already.  
+  #
+  # After a query, the attributes may still be empty, since this might be an
+  # invalid address. Therefore, it's good to know, whether the query has been
+  # done already.
+  #
+  def geocoded?
+    (queried_at.present? || country_code.present?)
+  end
+
+
+  # Finder Methods
+  # ==========================================================================================
+
+  # Find a geo_location object by address string. 
+  # If the address already exists in the database, return the object from
+  # the database. Otherwise, create a new database entry for the address
+  # and perform a geocoding query.
+  #
+  # This method is already defined be ActiveRecord.
+  #
+  # def self.find_or_create_by_address( address_string )
+  # end
+
+
+  # Country Specific Methods
+  # ==========================================================================================
+
+  # This method returns true if the location is in Europe.
+  #
+  def in_europe?
+    country_code.in?(%w(AD AL AT BA BE BG BY CH CY CZ DE DK EE ES FI FO FR GG GI GR GB HR HU IE IM IS IT JE LI LT LU LV MC MD\
+ MK MT NL NO PL PT RO RU SE SI SJ SK SM TR UA UK VA YU))
+  end
+
+  # The following method is a country-specific accessor to the the German
+  # Postleitzahl (PLZ). If returns the German postal code if the
+  # address is in Germany. Otherwise, it returns nil.
+  #
+  # There are cases when the maps api can't isolate the postal code. 
+  # In this case, the `postal_code` returns `nil`.
+  # Try to get it from the regex then.
+  #
+  def plz
+    if country_code == "DE"
+      postal_code || address.match(/(\d{5})/).try(:[], 1)
+    end
+  end
+
+end