open_conference_ware 1.0.0.pre1

data/app/models/open_conference_ware/room.rb

@@ -0,0 +1,42 @@
+module OpenConferenceWare
+
+  # == Schema Information
+  #
+  # Table name: rooms
+  #
+  #  id                    :integer          not null, primary key
+  #  name                  :string(255)      not null
+  #  capacity              :integer
+  #  size                  :string(255)
+  #  seating_configuration :string(255)
+  #  description           :text
+  #  event_id              :integer
+  #  created_at            :datetime
+  #  updated_at            :datetime
+  #  image_file_name       :string(255)
+  #  image_content_type    :string(255)
+  #  image_file_size       :integer
+  #  image_updated_at      :datetime
+  #
+
+  class Room < OpenConferenceWare::Base
+    # Associations
+    belongs_to :event
+    has_many :proposals, dependent: :nullify
+    has_many :schedule_items, dependent: :nullify
+
+    # Validations
+    validates_presence_of :name, :event
+    validates_numericality_of :capacity, unless: lambda{|obj| obj.capacity.blank? }
+
+    # Image Attachment
+    has_attached_file :image,
+      path: ":rails_root/public/system/:attachment/:id/:style/:filename",
+      url: "/system/:attachment/:id/:style/:filename",
+      styles: {
+        large: "650>",
+        medium: "350>",
+        small: "150>"
+      }
+  end
+end

data/app/models/open_conference_ware/schedule.rb

@@ -0,0 +1,216 @@
+module OpenConferenceWare
+  class Schedule
+    attr_accessor :items
+    attr_accessor :is_admin
+
+    def initialize(event_or_items, is_admin=false)
+      self.items = []
+      self.is_admin = is_admin
+
+      case event_or_items
+      when Event
+        self.items = event_or_items.calendar_items(is_admin)
+      when Array
+        self.items = event_or_items
+      else
+        raise TypeError, "Unknown type: #{event_or_items.class.name}"
+      end
+      self.items = self.items.select(&:start_time).sort_by{|t| [t.start_time.to_i, t.end_time.to_i]}
+    end
+
+    def days
+      @days ||= ScheduleDay.new_array_from(items)
+    end
+
+    def sections
+      @sections ||= self.days.map(&:sections).flatten
+    end
+
+    def slices
+      @slices ||= self.sections.map(&:slices).flatten
+    end
+
+    def blocks
+      @blocks ||= self.slices.map(&:blocks).flatten
+    end
+
+    def room_conflicts
+      @room_conflicts ||= [].tap do |conflicts|
+        self.items.select(&:room).group_by(&:room).each do |room, items|
+          items.each do |item|
+            if (conflicts_with = items.find{ |o| o.overlaps?(item) }) && conflicts_with != item
+              conflicts << {
+                room: room,
+                item: item,
+                conflicts_with: conflicts_with
+              }
+            end
+          end
+        end
+      end
+    end
+
+    def user_conflicts
+      @user_conflicts ||= [].tap do |conflicts|
+        self.items.select{|item| item.respond_to?(:users)}.inject({}){|u2i, item| item.users.each{|user| u2i[user] ||= Set.new; u2i[user] << item}; u2i}.each do |user, items|
+          items.each do |item|
+            if (conflicts_with = items.find{ |o| o.overlaps?(item) }) && conflicts_with != item
+              conflicts << {
+                user: user,
+                room: item.room,
+                item: item,
+                conflicts_with: conflicts_with
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+
+  module Schedulable
+    def self.included(mixee)
+      mixee.class_eval do
+        attr_accessor :start_time
+        attr_accessor :end_time
+        attr_accessor :duration
+
+        include ScheduleOverlapsMixin
+
+        def end_time=(value)
+          raise ArgumentError, "End time cannot be set without a start time" unless @start_time
+          raise ArgumentError, "End time cannot be before start time" if value < @start_time
+          @end_time = value
+          @duration = (@end_time - @start_time) / 1.minutes
+        end
+
+        def duration=(value)
+          raise ArgumentError, "End time cannot be set without a start time" unless @start_time
+          raise ArgumentError, "Duration cannot be negative" if value < 0
+          @duration = value
+          @end_time = @start_time + value.minutes
+        end
+      end
+    end
+  end
+
+  class ScheduleDay
+    attr_accessor :date
+    attr_accessor :items
+
+    def initialize(items=[], date=nil)
+      self.items = items
+      self.date = date
+    end
+
+    def self.new_array_from(items)
+      [].tap do |days|
+        items.group_by{|item| item.start_time.to_date}.each do |date, collection|
+          days << self.new(collection, date)
+        end
+      end.sort_by(&:date)
+    end
+
+    def sections
+      @sections ||= ScheduleSection.new_array_from(self.items)
+    end
+
+    def slices
+      @slices ||= self.sections.map(&:slices).flatten
+    end
+
+    def blocks
+      @blocks ||= self.slices.map(&:blocks).flatten
+    end
+
+    def lcm_colspan
+      first, *rest = sections.map{ |section| section.slices.size }
+      rest.inject(first) { |l, n| l.lcm(n) }
+    end
+  end
+
+  class ScheduleSection
+    include Schedulable
+    attr_accessor :items
+
+    def initialize(items=[], start_time=nil, end_time=nil)
+      self.items = items
+      self.start_time = start_time if start_time
+      self.end_time = end_time if end_time
+    end
+
+    def self.new_array_from(items)
+      [].tap do |sections|
+        for item in items
+          if section = sections.find{|section| section.overlaps?(item)}
+            section.items << item
+            section.start_time = item.start_time if section.start_time > item.start_time
+            section.end_time = item.end_time if section.end_time < item.end_time
+          else
+            sections << self.new([item], item.start_time, item.end_time)
+          end
+        end
+      end.sort_by{|section| [section.start_time, section.end_time, section.items.first.title]}
+    end
+
+    def slices
+      @slices ||= ScheduleSlice.new_array_from(self.items)
+    end
+
+    def blocks
+      @blocks ||= self.slices.map(&:blocks).flatten
+    end
+
+    def lcm_rowspan
+      first, *rest = slices.map{ |slice| slice.blocks.size }
+      rest.inject(first) { |l, n| l.lcm(n) }
+    end
+  end
+
+  class ScheduleSlice
+    include Schedulable
+    attr_accessor :items
+    attr_accessor :blocks
+
+    def initialize(items=[], start_time=nil, end_time=nil, blocks=[])
+      self.items = items
+      self.start_time = start_time
+      self.end_time = end_time
+      self.blocks = blocks.empty? ? ScheduleBlock.new_array_from(self.items) : blocks
+    end
+
+    def self.new_array_from(items)
+      [].tap do |slices|
+        for block in ScheduleBlock.new_array_from(items)
+          if slice = slices.find{|slice| ! slice.overlaps?(block)}
+            slice.blocks << block
+            slice.items += block.items
+            slice.start_time = block.start_time if slice.start_time > block.start_time
+            slice.end_time = block.end_time if slice.end_time < block.end_time
+          else
+            slices << self.new(block.items, block.start_time, block.end_time, [block])
+          end
+        end
+      end.sort_by{|slice| [slice.start_time, slice.end_time, slice.items.first.title]}
+    end
+  end
+
+  class ScheduleBlock
+    include Schedulable
+    attr_accessor :items
+
+    def initialize(items=[], start_time=nil, end_time=nil)
+      self.items = items.sort_by{|item| [item.start_time, item.end_time, (item.room.try(:name) || ""), item.title]}
+      self.start_time = start_time
+      self.end_time = end_time
+    end
+
+    def self.new_array_from(items)
+      [].tap do |blocks|
+        items.group_by{|item| [item.start_time, item.end_time]}.each do |range, collection|
+          blocks << self.new(collection, range.first, range.last)
+        end
+      end.sort_by{|block| [block.start_time, block.end_time, block.items.first.title]}
+    end
+  end
+end

data/app/models/open_conference_ware/schedule_item.rb

@@ -0,0 +1,55 @@
+module OpenConferenceWare
+
+  # == Schema Information
+  #
+  # Table name: schedule_items
+  #
+  #  id          :integer          not null, primary key
+  #  title       :string(255)
+  #  excerpt     :text
+  #  description :text
+  #  start_time  :datetime
+  #  duration    :integer
+  #  event_id    :integer
+  #  room_id     :integer
+  #  created_at  :datetime
+  #  updated_at  :datetime
+  #
+
+  class ScheduleItem < OpenConferenceWare::Base
+
+    # Associations
+    belongs_to :event
+    belongs_to :room
+
+    # Provides #overlaps?
+    include ScheduleOverlapsMixin
+
+    # Public attributes for export
+    include PublicAttributesMixin
+    set_public_attributes :id, :title, :excerpt, :description, :start_time, :end_time, :duration,
+      :event_id, :event_title,
+      :room_id, :room_title,
+      :created_at, :updated_at
+
+    # Return the time this session ends.
+    def end_time
+      if self.start_time
+        self.start_time + (self.duration || 0).minutes
+      else
+        nil
+      end
+    end
+
+    #---[ Accessors for getting the titles of related objects ]-------------
+
+    def room_title
+      return self.room.try(:name)
+    end
+
+    def event_title
+      return self.event.try(:slug)
+    end
+    alias_method :event_slug, :event_title
+  end
+end

data/app/models/open_conference_ware/selector_vote.rb

@@ -0,0 +1,22 @@
+module OpenConferenceWare
+
+  # == Schema Information
+  #
+  # Table name: selector_votes
+  #
+  #  id          :integer          not null, primary key
+  #  user_id     :integer          not null
+  #  proposal_id :integer          not null
+  #  rating      :integer          not null
+  #  comment     :text
+  #
+
+  class SelectorVote < OpenConferenceWare::Base
+    belongs_to :user
+    belongs_to :proposal
+
+    validates_presence_of :user
+    validates_presence_of :proposal
+    validates_presence_of :rating
+  end
+end

data/app/models/open_conference_ware/session_type.rb

@@ -0,0 +1,33 @@
+module OpenConferenceWare
+
+  # == Schema Information
+  #
+  # Table name: session_types
+  #
+  #  id          :integer          not null, primary key
+  #  title       :string(255)
+  #  description :text
+  #  duration    :integer
+  #  event_id    :integer
+  #  created_at  :datetime
+  #  updated_at  :datetime
+  #
+
+  class SessionType < OpenConferenceWare::Base
+
+    # Associations
+    belongs_to :event
+    has_many :proposals, dependent: :nullify
+
+    # Validations
+    validates_presence_of \
+      :title,
+      :description,
+      :event_id
+    validates_numericality_of :duration, if: :duration
+
+    def <=>(against)
+      self.title <=> (against.nil? ? '' : against.title)
+    end
+  end
+end

data/app/models/open_conference_ware/snippet.rb

@@ -0,0 +1,58 @@
+module OpenConferenceWare
+
+  # == Schema Information
+  #
+  # Table name: snippets
+  #
+  #  id          :integer          not null, primary key
+  #  slug        :string(255)      not null
+  #  description :text             default(""), not null
+  #  content     :text
+  #  value       :integer
+  #  public      :boolean          default(TRUE)
+  #  created_at  :datetime
+  #  updated_at  :datetime
+  #
+
+  class Snippet < OpenConferenceWare::Base
+
+    # Provide cached Snippet.lookup(slug) method.
+    include CacheLookupsMixin
+    cache_lookups_for :slug, order: :slug
+
+    # Load the Snippets as defined in the "spec/fixtures/snippets.yml" file and
+    # load them into the current database, overwriting any existing records.
+    def self.load_from_fixtures(overwrite = false)
+      [].tap do |records|
+        data = YAML::load(ERB.new(File.read(OpenConferenceWare::Engine.root.join("spec", "fixtures", "open_conference_ware_snippets.yml"))).result(binding))
+        for attributes in data.values
+          record = self.find_by_slug(attributes["slug"].to_s)
+          if record
+            record.update_attributes(attributes) if overwrite
+          else
+            record = self.create!(attributes)
+          end
+          records << record
+        end
+      end
+    end
+
+    def self.reload_from_fixtures!
+      load_from_fixtures(true)
+    end
+
+    # Returns the content for a Snippet match +slug+, else raise an ActiveRecord::RecordNotFound.
+    def self.content_for(slug)
+      if record = self.lookup(slug.to_s)
+        return record.content
+      else
+        raise ActiveRecord::RecordNotFound, "Couldn't find snippet: #{slug}"
+      end
+    end
+
+    # Alternate syntax for ::content_for.
+    def self.[](slug)
+      return self.content_for(slug)
+    end
+  end
+end

data/app/models/open_conference_ware/track.rb

@@ -0,0 +1,51 @@
+module OpenConferenceWare
+
+  # == Schema Information
+  #
+  # Table name: tracks
+  #
+  #  id          :integer          not null, primary key
+  #  title       :string(255)
+  #  description :text
+  #  color       :string(255)
+  #  event_id    :integer
+  #  created_at  :datetime
+  #  updated_at  :datetime
+  #  excerpt     :text
+  #
+
+  class Track < OpenConferenceWare::Base
+
+    # Associations
+    belongs_to :event
+    has_many :proposals, dependent: :nullify
+
+    # Validations
+    validates_presence_of \
+      :color,
+      :description,
+      :excerpt,
+      :event_id,
+      :title
+      
+    def <=>(against)
+      self.title <=> (against.nil? ? '' : against.title)
+    end
+
+    def color
+      (stored_color = read_attribute(:color)).nil? ? nil : Color::RGB.from_html(stored_color)
+    end
+
+    def color=(value)
+      case value
+      when Color::RGB
+        new_color = value
+      when String
+        new_color = Color::RGB.from_html(value)
+      else
+        raise TypeError
+      end
+      write_attribute(:color,new_color.html)
+    end
+  end
+end