Class Timeslot
In: app/models/timeslot.rb
Parent: ActiveRecord::Base

Methods

by_time_distance   concurrent_with   current   default_tolerance_post   default_tolerance_pre   during_conference_days   effective_tolerance_post   effective_tolerance_pre   for_day   interval_to_seconds   no_overlapping_timeslots   seconds_to_start   short_start_time   single_current   time_to_start   tolerance_post=   tolerance_pre=   tolerances_correctly_formatted  

Public Class methods

by_time_distance(req={})

Produce a paginated list of timeslots, ordered by the absolute distance between their start_time and the current time.

It can take whatever parameters you would send to a WillPaginate#paginate call. Of course, you can specify a different ordering - in which case this would act as a normal paginator

concurrent_with(moment, req={})

Returns the paginated list of timeslots concurrent with the Time object passed as the first parameter - This means, those timeslots for which the current system clock is between tolerance_pre and tolerance_post. If either of them is not defined, we take the default values (see default_tolerance_pre, default_tolerance_post)

It can take whatever parameters you would send to a WillPaginate#paginate call. Of course, you can specify a different search criteria - in which case this would act as a normal paginator

current(req={})

Returns the paginated list of current timeslots - those for which attendance can be taken now.

It can take whatever parameters you would send to a WillPaginate#paginate call. Of course, you can specify a different search criteria - in which case this would act as a normal paginator

default_tolerance_post()

The systemwide default value for post-timeslot tolerance: Whatever is defined in SysConf for tolerance_post, or 30 minutes if not defined.

default_tolerance_pre()

The systemwide default value for pre-timeslot tolerance: Whatever is defined in SysConf for tolerance_pre, or 30 minutes if not defined.

for_day(date, req={})

Returns a paginated list with all of the timeslots for the specified date, ordered by start time

single_current()

There are many operations which want to get the current timeslot, in case there is only one - So, if there is only a single current timeslot, return it. If there is none (or there are more), return nil.

Public Instance methods

seconds_to_start()

The time difference between now and the timeslot‘s start_time, returned as the number of seconds for its beginning (i.e. Ruby‘s natural interval representation).

The result will be negative for timeslots which have already begun.

short_start_time()

An easier-on-the-eyes format…

time_to_start()

The time difference between now and the timeslot‘s start_time, returned as a d+hh:mm:ss string (‘d+’ is the number of days - I could not find a more natural notation).

tolerance_post=(time)

Intervals in Ruby are represented as a semi-opaque "thing" that becomes an integer number of seconds when needed… Treating them in any other way breaks applications. So, as soon as we get them, stringify them to something PostgreSQL will grok.

tolerance_pre=(time)

Intervals in Ruby are represented as a semi-opaque "thing" that becomes an integer number of seconds when needed… Treating them in any other way breaks applications. So, as soon as we get them, stringify them to something PostgreSQL will grok.

Protected Instance methods

no_overlapping_timeslots()

Two timeslots are overlapping if they happen at the same room, and their tolerance periods overlap.

Evaluate for the future: Will we implement proposal types per timeslot? If so, we could manage timeslot duration and have a more complete and real timeslot overlapping checks… Meanwhile, here we go

tolerances_correctly_formatted()

The tolerance periods are just strings. However, they must make sense - So, we limit them to be hh:mm:ss.

Nil/blank is acceptable (i.e. it means "default value is OK")

[Validate]