xteam_schedule 0.0.1

data/README.md

@@ -0,0 +1,324 @@
+## Introduction
+
+xTeam Schedule is a gem that provides full control over schedules for use with [adnX's xTeam](http://www.adnx.com/i/apps/xteam4mac) software.
+
+It is capable of reading and writing schedules, whilst providing access to all of its components through the [ActiveRecord](http://api.rubyonrails.org/classes/ActiveRecord/Base.html) interface, which every Ruby on Rails developer will be familiar with. This is absolutely, **the best solution** for managing agile teams.
+
+<img src="http://www.adnx.com/i/uploads/xTeam1.jpg" width="820" alt="xTeam Schedule" />
+
+### Features:
+
+* **Read and write schedules** and interact with in-memory models through the ActiveRecord interface
+* **Customise everything**; resources, assignments, groups, colours, interface settings..
+* **Intuitive naming** of models, that correspond to what you see on screen
+* **Full test coverage**, giving confidence to highly dynamic businesses everywhere
+
+### Disclaimer
+
+I am in no way associated with adnX. I work for an agile development company that makes use of xTeam. This project is open-source.
+
+## Getting Started
+
+It is not required that you have [xTeam](http://www.adnx.com/i/apps/xteam4mac) installed. However, you will not be able to visualise your schedules otherwise.
+
+**Install the gem:**
+
+```ruby
+gem install xteam_schedule
+```
+
+**Require it in your project:**
+
+```ruby
+require 'xteam_schedule'
+```
+
+You may need to require 'rubygems' too, if you are running an old version of Ruby.
+
+**Create a Schedule**
+
+You can create a new schedule, or read one from a file:
+
+```ruby
+schedule = XTeamSchedule.new
+schedule = XTeamSchedule.new('path/to/file.xtps')
+```
+
+## Schedules
+
+Schedules are the top level model through which you access everything. The inspect method is custom-made to give you an overview of the contents of the schedule:
+
+```ruby
+XTeamSchedule.new('path/to/file.xtps')
+=> #<XTeamSchedule resoruce_groups(9), resources(42), assignment_groups(14), assignments(118), working_times(79)>
+```
+
+A schedule has many resource groups and assignment groups. It also has many resources and assignments through resource groups and assignment groups respectively. Finally, a schedule has many working times through either resource groups then resources or assignment groups then assignments.
+
+```ruby
+schedule = XTeamSchedule.new('path/to/file.xtps')
+
+resource_groups   = schedule.resource_groups
+resources         = schedule.resources         # or schedule.resource_groups.map(&:resources).flatten
+assignment_groups = schedule.assignment_groups
+assignments       = schedule.assignments
+working_times     = schedule.working_times
+```
+
+There are numerous other models, for example a schedule has one 'interface' which contains various display settings. These are explained in detail below. It is also possible to convert a schedule to/from a hash. After serialisation, this could easily be written to a database.
+
+```ruby
+hash     = schedule.hash
+schedule = XTeamSchedule.new(hash)
+```
+
+## Resource Groups
+
+Resource groups contain resources. Typical names for resource groups might be 'Management', 'Sales', or 'Developers'.
+
+```ruby
+schedule.resource_groups.create!(
+  :name => 'Management',
+  :expanded_in_library => true
+)
+```
+
+**Required attributes:**
+name
+
+**Defaults:**
+expanded_in_library => true
+
+**Examples queries:**
+
+```ruby
+resource_groups = schedule.resource_groups
+
+number_of_groups  = resource_groups.count
+junior_developers = resource_groups.find_by_name('Junior Developers').resources
+developer_groups  = resource_groups.where('name like "%developer%"')
+```
+
+## Resources
+
+A resource is an employee. A resource can not be in multiple resource groups.
+
+```ruby
+developers = schedule.resource_groups.create!(:name => 'Developers')
+developers.resources.create!(
+  :name => 'Christopher Patuzzo',
+  :email => 'chris@example.com',
+  :mobile => '0123456789',
+  :phone => '9876543210',
+  :displayed_in_planning => true
+)
+```
+
+**Required attributes:**
+name
+
+**Defaults:**
+displayed_in_planning => true
+
+**Example queries:**
+
+```ruby
+resources = schedule.resources
+
+chris_mobile         = resources.find_by_name('Christopher Patuzzo').mobile
+gmail_resource_names = resources.where('email like "%gmail%"').map(&:name)
+resources.each { |r| r.update_attribute(:displayed_in_planning, true) }
+```
+
+## Assignment Groups
+
+Assignment groups are almost identical to resource groups. Typical names might be 'Training' and 'Research'.
+
+```ruby
+schedule.assignment_groups.create!(
+  :name => 'Training',
+  :expanded_in_library => true
+)
+```
+
+**Required attributes:**
+name
+
+**Defaults:**
+expanded_in_library => true
+
+**Example queries:**
+
+```ruby
+assignment_groups = schedule.assignment_groups
+
+final_group_name         = assignment_groups.last.name
+expanded_groups          = assignment_groups.where(:expanded_in_library => true)
+visible_assignment_count = expanded_groups.map(&:assignments).map(&:count).inject(:+)
+```
+
+## Assignments
+
+An assignment is a task. An assignment cannot be in multiple assignment groups.
+
+```ruby
+training = schedule.assignment_groups.create!(:name => 'Training')
+training.assignments.create!(
+  :name => 'Rails Conference',
+  :colour => { :red => 1, :green => 0, :blue => 0 }
+)
+```
+
+**Required attributes:**
+name
+
+**Defaults:**
+colour => { :red => 0.5, :green => 0.5, :blue => 0.5 }
+
+**Aliases:**
+color => colour
+
+**Example queries:**
+
+```ruby
+assignments = schedule.assignments
+
+rails_assignments       = assignments.where('name like "%rails%"')
+first_assignment_colour = assignments.first.colour
+singleton_assignments   = assignments.select { |a| a.assignment_group.assignments.count == 1 }
+```
+
+## Working Times
+
+A working time is a relationship between a resource and an assignment. This is equivalent to scheduling an employee on a specific task for a given duration. Assignments are assigned to resources by creating working times.
+
+```ruby
+developers        = schedule.resource_groups.create!(:name => 'Developers')
+chris             = developers.resources.create!(:name => 'Christopher Patuzzo')
+
+channel_5         = schedule.assignment_groups.create!(:name => 'Channel 5')
+the_gadget_show   = channel_5.assignments.create!(:name => 'The Gadget Show')
+
+chris.working_times.create!(
+  :assignment => the_gadget_show,
+  :begin_date => Date.new(2012, 01, 01),
+  :duration => 20,
+  :notes => 'Based in London'
+)
+```
+
+The creation can also be written from the assignment, or directly from the model:
+
+```ruby
+the_gadget_show.working_times.create!(
+  :resource => chris,
+  # etc.
+)
+
+XTeamSchedule::WorkingTime.create!(
+  :resource => chris,
+  :assignment => the_gadget_show,
+  # etc.
+)
+```
+
+**Required attributes:**
+begin_date, duration
+
+**Example queries:**
+
+```ruby
+working_times = schedule.working_times
+
+maximum_duration          = working_times.map(&:duration).max.to_s + ' days'
+recent_working_times      = working_times.where('begin_date > ?', Date.new(2012, 01, 01))
+resources_on_new_projects = recent_working_times.map(&:resource).uniq.map(&:name)
+```
+
+## Interface
+
+A schedule has one interface that is created automatically. The interface is responsible for the display settings of xTeam. Possible values to pass to the granularities constant are: :day, :week, :month and :year
+
+```ruby
+schedule.interface.update_attributes!(
+  :display_assignments_name => true,
+  :display_resources_name => false,
+  :display_working_hours => false,
+  :display_resources_pictures => true,
+  :display_total_of_working_hours => false,
+  :display_assignments_notes => true,
+  :display_absences => true,
+  :time_granularity => XTeamSchedule::Interface::TIME_GRANULARITIES[:month]
+)
+```
+
+**Defaults:**
+The same as the attributes shown above.
+
+**Aliases:**
+
+```ruby
+display_assignment_names    => display_assignments_name
+display_resource_names      => display_resources_name
+display_resource_pictures   => display_resources_pictures
+display_total_working_hours => display_total_of_working_hours
+display_assignment_notes    => display_assignments_notes
+```
+
+## Weekly Working Schedule
+
+The weekly working schedule determines the 'opening hours' of the company. Working days can be accessed directly, or through weekly_working_schedule.
+
+```ruby
+# Set all days to start at 9am, and finish at 5pm
+# Set a lunch break from 12pm - 1pm each day
+working_days = schedule.working_days
+working_days.each do |day|
+  day.update_attributes!(
+    :day_begin   => '09:00',
+    :day_end     => '17:00',
+    :break_begin => '12:00',
+    :break_end   => '13:00'
+  )
+end
+```
+
+Non working days are determined by setting the 'day_begin' attribute to nil. This works similarly for days without lunch breaks:
+
+```ruby
+wednesday = working_days.find_by_name('Wednesday')
+saturday = working_days.find_by_name('Saturday')
+sunday = working_days.find_by_name('Sunday')
+
+[saturday, sunday].each { |day| day.update_attributes!(:day_begin => nil) }
+wednesday.update_attribute(:break_begin, nil)
+```
+
+**Defaults:**
+The default weekly working schedule is identical to the same as the one set up above. i.e. 9am-5pm Mon-Fri, with lunch from 12pm-1pm.
+
+## Under Development
+
+This gem is far from complete. The following is a list of features that are under development:
+
+* Resource images
+* Sort by
+* Holidays
+* Absences
+* Remote access
+* To assign
+* Advanced colour controls
+* Schedule splicing between dates
+* Advanced image support
+* Built-in example
+* Documentation
+* Binary operators
+* File system hooks
+* Date/duration helpers
+* Generating reports
+
+## Contribution
+
+Please feel free to contribute, either through pull requests or feature requests here on Github.
+
+For news and latest updates, follow me on Twitter ([@cpatuzzo](https://twitter.com/#!/cpatuzzo)).

data/lib/xteam_schedule/core.rb

@@ -0,0 +1,31 @@
+class XTeamSchedule
+  
+  def initialize(hash_or_filename = nil)
+    if hash_or_filename.present?
+      hash = hash_or_filename.class == Hash ? hash_or_filename : IO.read(hash_or_filename)
+      @schedule = Parser.parse(hash)
+    else
+      @schedule = Schedule.create!
+    end
+  end
+  
+  def write(filename)
+    raise 'No filename provided' unless filename.present?
+    IO.write(hash, filename)
+  end
+  
+  def hash
+    Composer.compose(self)
+  end
+  
+  def method_missing(*args);
+    @schedule.send(*args)
+  end
+  
+  def inspect
+    stats = [:resource_groups, :resources, :assignment_groups, :assignments, :working_times].map { |s| [s, send(s).count] }
+    stats_string = stats.map { |s| "#{s.first}(#{s.second})" }.join(', ')
+    "#<XTeamSchedule #{stats_string}>"
+  end
+  
+end

data/lib/xteam_schedule/facilitation/composer.rb

@@ -0,0 +1,166 @@
+class XTeamSchedule::Composer
+  
+  attr_accessor :schedule, :hash
+  
+  def self.compose(schedule)
+    new(schedule).compose
+  end
+  
+  def initialize(schedule)
+    schedule.save!
+    self.schedule = schedule
+    self.hash = {}
+  end
+  
+  def compose
+    compose_resource_groups!
+    compose_resources!
+    compose_assignment_groups!
+    compose_assignments!
+    compose_working_times!
+    compose_interface!
+    compose_weekly_working_schedule!
+    compose_schedule!
+    hash
+  end
+  
+private
+  
+  def compose_resource_groups!
+    hash['resource groups'] ||= []
+    resource_groups = schedule.resource_groups
+    resource_groups.each do |rg|
+      hash['resource groups'] << {
+        'name' => rg.name,
+        'expanded in library' => rg.expanded_in_library
+      }
+    end
+  end
+  
+  def compose_resources!
+    hash['resources'] ||= []
+    resources = schedule.resource_groups.map(&:resources).flatten
+    resources.each do |r|
+      hash['resources'] << {
+        'displayedInPlanning' => r.displayed_in_planning,
+        'email' => r.email,
+        'image' => (StringIO.new(r.image) if r.image),
+        'mobile' => r.mobile,
+        'name' => r.name,
+        'phone' => r.phone,
+        'group' => r.resource_group.name
+      }
+    end
+  end
+  
+  def compose_assignment_groups!
+    hash['task categories'] ||= []
+    assignment_groups = schedule.assignment_groups
+    assignment_groups.each do |ag|
+      hash['task categories'] << {
+        'name' => ag.name,
+        'expanded in library' => ag.expanded_in_library
+      }
+    end
+  end
+  
+  def compose_assignments!
+    hash['tasks'] ||= []
+    assignments = schedule.assignment_groups.map(&:assignments).flatten
+    assignments.each do |a|
+      hash['tasks'] << {
+        'name' => a.name,
+        'category' => a.assignment_group.name,
+        'kind' => 0,
+        'color' => compose_colour(a.colour)
+      }
+    end
+  end
+  
+  def compose_working_times!
+    hash['objectsForResources'] ||= {}
+    resources = schedule.resource_groups.map(&:resources).flatten
+    resources.each do |r|
+      working_times_with_parents = r.working_times.select { |wt| wt.resource and wt.assignment }
+      next unless working_times_with_parents.any?
+      hash['objectsForResources'].merge!(r.name => [])
+      working_times_with_parents.each do |wt|
+        hash['objectsForResources'][r.name] << {
+          'task' => wt.assignment.name,
+          'begin date' => compose_date(wt.begin_date),
+          'duration' => wt.duration,
+          'notes' => wt.notes,
+          'title' => ''
+        }
+      end
+    end
+  end
+  
+  def compose_interface!
+    interface = schedule.interface
+    hash['display task names'] = interface.display_assignments_name
+    hash['display resource names'] = interface.display_resources_name
+    hash['display worked time'] = interface.display_working_hours
+    hash['display resource icons'] = interface.display_resources_pictures
+    hash['display resource totals'] = interface.display_total_of_working_hours
+    hash['display task notes'] = interface.display_assignments_notes
+    hash['display absence cells'] = interface.display_absences
+    hash['interface status'] = { 'latest time navigation mode' => interface.time_granularity }
+  end
+  
+  def compose_weekly_working_schedule!
+    weekly_working_schedule = schedule.weekly_working_schedule
+    working_days = weekly_working_schedule.working_days
+    
+    hash['settings'] ||= {}
+    hash['settings']['days off'] ||= []
+    hash['settings']['working schedule'] ||= {}
+    
+    working_days.each do |day|
+      day_name = day.name.downcase
+      hash['settings']['working schedule'][day_name] =
+      if day.day_begin.present?
+        { 'worked' => 'yes',
+          'begin' => compose_time(day.day_begin),
+          'end' => compose_time(day.day_end) }
+      else
+        { 'worked' => 'no' }
+      end
+      
+      hash['settings']['working schedule']["pause_#{day_name}"] =
+      if day.day_begin.present? and day.break_begin.present?
+        { 'worked' => 'yes',
+          'begin' => compose_time(day.break_begin),
+          'end' => compose_time(day.break_end),
+          'duration' => compose_time(day.break_end) - compose_time(day.break_begin) }
+      else
+        {}
+      end
+    end
+  end
+  
+  def compose_schedule!
+    hash['begin date'] = compose_date(schedule.begin_date)
+    hash['end date'] = compose_date(schedule.end_date)
+  end
+  
+  def compose_colour(colour_hash)
+    { 'alpha' => 1 }.merge([:red, :green, :blue].inject({}) { |h, c| h[c.to_s] = colour_hash[c]; h })
+  end
+  
+  def compose_date(date)
+    return unless date.present?
+    components = []
+    components << ("%02d" % date.month)
+    components << ("%02d" % date.day)
+    components << date.year
+    components.join('/')
+  end
+  
+  def compose_time(time_string)
+    return unless time_string.present?
+    hours, minutes = time_string.split(':').map(&:to_i)
+    
+    hours * 60 + minutes
+  end
+end

data/lib/xteam_schedule/facilitation/db.rb

@@ -0,0 +1,83 @@
+class XTeamSchedule::DB
+  
+  def self.connect
+    ActiveRecord::Base.establish_connection(
+      :adapter => 'sqlite3',
+      :database => ':memory:'
+    )
+  end
+  
+  def self.build_schema
+    ActiveRecord::Schema.verbose = false
+    ActiveRecord::Schema.define do
+      
+      create_table :schedules do |table|
+        table.column :begin_date, :date, :default => 10.years.ago.to_date
+        table.column :end_date, :date, :default => 10.years.from_now.to_date
+      end
+      
+      create_table :interfaces do |table|
+        table.column :schedule_id, :integer
+        table.column :display_assignments_name, :boolean, :default => true
+        table.column :display_resources_name, :boolean, :default => false
+        table.column :display_working_hours, :boolean, :default => false
+        table.column :display_resources_pictures, :boolean, :default => true
+        table.column :display_total_of_working_hours, :boolean, :default => false
+        table.column :display_assignments_notes, :boolean, :default => true
+        table.column :display_absences, :boolean, :default => true
+        table.column :time_granularity, :integer, :default => XTeamSchedule::Interface::TIME_GRANULARITIES[:month]
+      end
+      
+      create_table :weekly_working_schedules do |table|
+        table.column :schedule_id, :integer
+      end
+      
+      create_table :working_days do |table|
+        table.column :weekly_working_schedule_id, :integer
+        table.column :name, :string
+        table.column :day_begin, :string
+        table.column :day_end, :string
+        table.column :break_begin, :string
+        table.column :break_end, :string
+      end
+      
+      create_table :resource_groups do |table|
+        table.column :schedule_id, :integer
+        table.column :expanded_in_library, :boolean, :default => true
+        table.column :name, :string
+      end
+      
+      create_table :resources do |table|
+        table.column :resource_group_id, :integer
+        table.column :displayed_in_planning, :boolean, :default => true
+        table.column :email, :string
+        table.column :image, :string
+        table.column :mobile, :string
+        table.column :name, :string
+        table.column :phone, :string
+      end
+      
+      create_table :assignment_groups do |table|
+        table.column :schedule_id, :integer
+        table.column :expanded_in_library, :boolean, :default => true
+        table.column :name, :string
+      end
+      
+      create_table :assignments do |table|
+        table.column :assignment_group_id, :integer
+        table.column :name, :string
+        table.column :colour, :string
+      end
+      
+      create_table :working_times do |table|
+        table.column :resource_id, :integer
+        table.column :assignment_id, :integer
+        table.column :begin_date, :date
+        table.column :duration, :integer
+        table.column :notes, :string
+      end
+      
+    end
+  end
+  
+end

data/lib/xteam_schedule/facilitation/io.rb

@@ -0,0 +1,11 @@
+class XTeamSchedule::IO
+  
+  def self.read(filename)
+    Plist.parse_xml(filename)
+  end
+  
+  def self.write(hash, filename)
+    hash.save_plist(filename)
+  end
+  
+end

data/lib/xteam_schedule/facilitation/parser.rb

@@ -0,0 +1,168 @@
+class XTeamSchedule::Parser
+  
+  attr_accessor :hash, :schedule
+  
+  def self.parse(hash)
+    new(hash).parse
+  end
+  
+  def initialize(hash)
+    self.hash = hash
+    self.schedule = XTeamSchedule::Schedule.create!
+  end
+  
+  def parse
+    parse_resource_groups!
+    parse_resources!
+    parse_assignment_groups!
+    parse_assignments!
+    parse_working_times!
+    parse_interface!
+    parse_weekly_working_schedule!
+    parse_schedule!
+    schedule
+  end
+  
+private
+  
+  def parse_resource_groups!
+    hash['resource groups'].try(:each) do |rg|
+      schedule.resource_groups.create!(
+        :name => rg['name'],
+        :expanded_in_library => rg['expanded in library']
+      )
+    end
+  end
+  
+  def parse_resources!
+    hash['resources'].try(:each) do |r|
+      resource_group = schedule.resource_groups.find_by_name(r['group'])
+      if resource_group
+        image = r['image'].class == StringIO ? r['image'].read : ''
+        resource_group.resources.create!(
+          :displayed_in_planning => r['displayedInPlanning'],
+          :email => r['email'],
+          :image => image,
+          :mobile => r['mobile'],
+          :name => r['name'],
+          :phone => r['phone']
+        )
+      end
+    end
+  end
+  
+  def parse_assignment_groups!
+    hash['task categories'].try(:each) do |ag|
+      schedule.assignment_groups.create!(
+        :name => ag['name'],
+        :expanded_in_library => ag['expanded in library']
+      )
+    end
+  end
+  
+  def parse_assignments!
+    hash['tasks'].try(:each) do |a|
+      assignment_group = schedule.assignment_groups.find_by_name(a['category'])
+      if assignment_group
+        assignment_group.assignments.create!(
+          :name => a['name'],
+          :colour => parse_colour(a['color'])
+        )
+      end
+    end
+  end
+  
+  def parse_working_times!
+    resources = schedule.resource_groups.map(&:resources).flatten
+    assignments = schedule.assignment_groups.map(&:assignments).flatten
+    hash['objectsForResources'] ||= {}
+    hash['objectsForResources'].each do |r_name, wt_array|
+      resource = resources.detect { |r| r.name == r_name }
+      next unless resource
+      wt_array.each do |wt|
+        assignment = assignments.detect { |a| a.name == wt['task'] }
+        next unless assignment
+        resource.working_times.create!(
+          :assignment => assignment,
+          :begin_date => parse_date(wt['begin date']),
+          :duration => wt['duration'],
+          :notes => wt['notes']
+        )
+      end
+    end
+  end
+  
+  def parse_interface!
+    interface_status = hash['interface status']
+    time_granularity = interface_status['latest time navigation mode'] if interface_status.present?
+    schedule.interface.update_attributes!(
+      :display_assignments_name => hash['display task names'],
+      :display_resources_name => hash['display resource names'],
+      :display_working_hours => hash['display worked time'],
+      :display_resources_pictures => hash['display resource icons'],
+      :display_total_of_working_hours => hash['display resource totals'],
+      :display_assignments_notes => hash['display task notes'],
+      :display_absences => hash['display absence cells'],
+      :time_granularity => time_granularity
+    )
+  end
+  
+  def parse_weekly_working_schedule!
+    settings = hash['settings']
+    return unless settings.present?
+    working_schedule = settings['working schedule']
+    return unless working_schedule.present?
+    
+    weekly_working_schedule = schedule.weekly_working_schedule
+    working_days = weekly_working_schedule.working_days
+    
+    working_days.destroy_all
+    XTeamSchedule::WorkingDay::WORKING_DAY_NAMES.each do |name|
+      day = working_schedule[name.downcase]
+      pause = working_schedule["pause_#{name.downcase}"]
+      
+      if day.present?
+        day_begin = parse_time(day['begin']) if day['worked'] == 'yes'
+        day_end = parse_time(day['end']) if day_begin
+      end
+      
+      if pause.present?
+        break_begin = parse_time(pause['begin']) if pause['worked'] == 'yes'
+        break_end = parse_time(pause['end']) if break_begin
+      end
+      
+      working_days << XTeamSchedule::WorkingDay.create!(
+        :name => name,
+        :day_begin => day_begin, :day_end => day_end,
+        :break_begin => break_begin, :break_end => break_end
+      )
+    end
+  end
+  
+  def parse_schedule!
+    schedule.update_attributes!(
+      :begin_date => parse_date(hash['begin date']),
+      :end_date => parse_date(hash['end date'])
+    )
+  end
+  
+  def parse_colour(colour_data)
+    [:red, :green, :blue].inject({}) { |h, c| h[c] = colour_data[c.to_s]; h }
+  end
+  
+  def parse_date(date_string)
+    return unless date_string.present?
+    month, day, year = date_string.split('/').map(&:to_i)
+    Date.new(year, month, day)
+  end
+  
+  def parse_time(seconds)
+    return unless seconds.present?
+    hours = seconds / 60
+    minutes = seconds % 60
+    
+    hours = "%02d" % hours
+    minutes = "%02d" % minutes
+    [hours, minutes].join(':')
+  end
+end

data/lib/xteam_schedule/models/assignment.rb

@@ -0,0 +1,51 @@
+class XTeamSchedule::Assignment < ActiveRecord::Base
+  belongs_to :assignment_group
+  has_many :working_times, :dependent => :destroy
+  delegate :schedule, :to => :assignment_group
+  
+  validates_presence_of :name
+  validate :uniqueness_of_name_scoped_to_schedule
+  validates_presence_of :colour
+  validate :rgb_colour
+  
+  serialize :colour, Hash
+  after_initialize :set_default_colour
+  before_save :symbolize_colour!
+  after_validation :float_colour_values!
+
+  alias_attribute :color, :colour
+  
+private
+
+  def uniqueness_of_name_scoped_to_schedule
+    return unless new_record?
+    assignment_group = self.assignment_group or return
+    schedule = assignment_group.schedule or return
+    assignments = schedule.assignments or return
+    
+    if assignments.find_by_name(name).present?
+      errors.add(:name, 'must be unique within the schedule')
+    end
+  end
+  
+  def set_default_colour
+    self.colour = { :red => 0.5, :green => 0.5, :blue => 0.5 } if colour.empty?
+  end
+  
+  def symbolize_colour!
+    self.colour = colour.inject({}) { |h, (k, v)| h[k.to_sym] = v; h }
+  end
+  
+  def float_colour_values!
+    self.colour = colour.inject({}) { |h, (k, v)| h[k] = v.to_f; h } if colour.class == Hash
+  end
+  
+  def rgb_colour
+    is_out_of_range = proc { |c| f = Float(c); f < 0 || f > 1 }
+    raise 'invalid' if [:red, :green, :blue].any? { |c| is_out_of_range[colour[c]] }
+    raise 'invalid' if colour.count != 3
+  rescue
+    errors.add(:colour, 'is not a valid rgb hash')
+  end
+  
+end

data/lib/xteam_schedule/models/assignment_group.rb

@@ -0,0 +1,7 @@
+class XTeamSchedule::AssignmentGroup < ActiveRecord::Base
+  belongs_to :schedule
+  has_many :assignments, :dependent => :destroy
+
+  validates_presence_of :name
+  validates_uniqueness_of :name, :scope => :schedule_id
+end

data/lib/xteam_schedule/models/interface.rb

@@ -0,0 +1,11 @@
+class XTeamSchedule::Interface < ActiveRecord::Base
+  belongs_to :schedule
+  
+  alias_attribute :display_assignment_names, :display_assignments_name
+  alias_attribute :display_resource_names, :display_resources_name
+  alias_attribute :display_resource_pictures, :display_resources_pictures
+  alias_attribute :display_total_working_hours, :display_total_of_working_hours
+  alias_attribute :display_assignment_notes, :display_assignments_notes
+  
+  TIME_GRANULARITIES = { :day => 4, :week => 2, :month => 1, :year => 0 }
+end

data/lib/xteam_schedule/models/resource.rb

@@ -0,0 +1,22 @@
+class XTeamSchedule::Resource < ActiveRecord::Base
+  belongs_to :resource_group
+  has_many :working_times, :dependent => :destroy
+  delegate :schedule, :to => :resource_group
+  
+  validates_presence_of :name
+  validate :uniqueness_of_name_scoped_to_schedule
+  
+private
+  
+  def uniqueness_of_name_scoped_to_schedule
+    return unless new_record?
+    resource_group = self.resource_group or return
+    schedule = resource_group.schedule or return
+    resources = schedule.resources or return
+  
+    if resources.find_by_name(name).present?
+      errors.add(:name, 'must be unique within the schedule')
+    end
+  end
+  
+end

data/lib/xteam_schedule/models/resource_group.rb

@@ -0,0 +1,7 @@
+class XTeamSchedule::ResourceGroup < ActiveRecord::Base
+  belongs_to :schedule
+  has_many :resources, :dependent => :destroy
+  
+  validates_presence_of :name
+  validates_uniqueness_of :name, :scope => :schedule_id
+end

data/lib/xteam_schedule/models/schedule.rb

@@ -0,0 +1,25 @@
+class XTeamSchedule::Schedule < ActiveRecord::Base
+  has_many :resource_groups, :dependent => :destroy
+  has_many :resources, :through => :resource_groups
+  has_many :assignment_groups, :dependent => :destroy
+  has_many :assignments, :through => :assignment_groups
+  has_many :working_times, :through => :resources
+  has_many :working_days, :through => :weekly_working_schedule
+  
+  has_one :interface
+  after_initialize :set_default_interface
+  
+  has_one :weekly_working_schedule
+  after_initialize :set_default_weekly_working_schedule
+  
+private
+  
+  def set_default_interface
+    self.interface ||= XTeamSchedule::Interface.new
+  end
+  
+  def set_default_weekly_working_schedule
+    self.weekly_working_schedule = XTeamSchedule::WeeklyWorkingSchedule.new
+  end
+  
+end

data/lib/xteam_schedule/models/weekly_working_schedule.rb

@@ -0,0 +1,24 @@
+class XTeamSchedule::WeeklyWorkingSchedule < ActiveRecord::Base
+  belongs_to :schedule
+  has_many :working_days, :dependent => :destroy
+  
+  after_initialize :set_default_working_days
+  
+private
+  
+  def set_default_working_days
+    return unless self.working_days.empty?
+    day_names = XTeamSchedule::WorkingDay::WORKING_DAY_NAMES
+    weekdays = day_names[0..4]
+    day_names.each_with_index do |name, i|
+      self.working_days << XTeamSchedule::WorkingDay.new(
+        :name => name,
+        :day_begin => (weekdays.shift.present? ? '09:00' : nil),
+        :day_end => '17:00',
+        :break_begin => '12:00',
+        :break_end => '13:00'
+      )  
+    end
+  end
+  
+end

data/lib/xteam_schedule/models/working_day.rb

@@ -0,0 +1,28 @@
+class XTeamSchedule::WorkingDay < ActiveRecord::Base
+  belongs_to :weekly_working_schedule
+  delegate :schedule, :to => :weekly_working_schedule
+  
+  validate :format_of_times
+  
+  WORKING_DAY_NAMES = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
+  
+private
+  
+  def format_of_times
+    time_format = /\d{2}:\d{2}/
+    [:day_begin, :day_end, :break_begin, :break_end].each do |sym|
+      time = send(sym)
+      return if sym == :day_begin and time.nil?
+      return if sym == :break_begin and time.nil?
+      unless time =~ time_format
+        errors.add(sym, "is not a valid 24-hour time, must be hh:mm format: #{time}")
+        next
+      end
+      hours, minutes = time.split(':').map(&:to_i)
+      if hours > 23 or minutes > 59
+        errors.add(sym, "is not a valid 24-hour time, must be hh:mm format: #{time}")
+      end
+    end
+  end
+  
+end

data/lib/xteam_schedule/models/working_time.rb

@@ -0,0 +1,9 @@
+class XTeamSchedule::WorkingTime < ActiveRecord::Base
+  belongs_to :resource
+  belongs_to :assignment
+  delegate :resource_group, :to => :resource
+  delegate :assignment_group, :to => :assignment
+  delegate :schedule, :to => :resource
+  
+  validates_presence_of :begin_date, :duration
+end

data/lib/xteam_schedule.rb

@@ -0,0 +1,22 @@
+require 'plist'
+require 'active_record'
+require 'sqlite3'
+require 'xteam_schedule/core'
+
+require 'xteam_schedule/models/assignment'
+require 'xteam_schedule/models/assignment_group'
+require 'xteam_schedule/models/interface'
+require 'xteam_schedule/models/resource'
+require 'xteam_schedule/models/resource_group'
+require 'xteam_schedule/models/schedule'
+require 'xteam_schedule/models/weekly_working_schedule'
+require 'xteam_schedule/models/working_day'
+require 'xteam_schedule/models/working_time'
+
+require 'xteam_schedule/facilitation/composer'
+require 'xteam_schedule/facilitation/db'
+require 'xteam_schedule/facilitation/io'
+require 'xteam_schedule/facilitation/parser'
+
+XTeamSchedule::DB.connect
+XTeamSchedule::DB.build_schema

metadata

@@ -0,0 +1,163 @@
+--- !ruby/object:Gem::Specification 
+name: xteam_schedule
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Christopher Patuzzo
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-02-15 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: plist
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: sqlite3
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: factory_girl
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: database_cleaner
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id006
+description: Full control over schedules for use with adnX's xTeam software
+email: chris.patuzzo@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.md
+- lib/xteam_schedule/core.rb
+- lib/xteam_schedule/facilitation/composer.rb
+- lib/xteam_schedule/facilitation/db.rb
+- lib/xteam_schedule/facilitation/io.rb
+- lib/xteam_schedule/facilitation/parser.rb
+- lib/xteam_schedule/models/assignment.rb
+- lib/xteam_schedule/models/assignment_group.rb
+- lib/xteam_schedule/models/interface.rb
+- lib/xteam_schedule/models/resource.rb
+- lib/xteam_schedule/models/resource_group.rb
+- lib/xteam_schedule/models/schedule.rb
+- lib/xteam_schedule/models/weekly_working_schedule.rb
+- lib/xteam_schedule/models/working_day.rb
+- lib/xteam_schedule/models/working_time.rb
+- lib/xteam_schedule.rb
+homepage: https://github.com/cpatuzzo/xteam_schedule
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: XTeam Schedule
+test_files: []
+