pshq_engine 0.0.1

data/app/models/shift.rb

@@ -0,0 +1,364 @@
+# == Schema Information
+#
+# Table name: shifts
+#
+#  id          :integer          not null, primary key
+#  day_of_week :integer
+#  start_time  :time
+#  end_time    :time
+#  hours       :time
+#  schedule_id :integer
+#  created_at  :datetime
+#  updated_at  :datetime
+#  due_date    :date
+#  absence     :boolean          default(FALSE)
+#
+
+class Shift < ActiveRecord::Base
+
+  belongs_to :schedule
+  belongs_to :job
+  belongs_to :shift_offs
+  
+  has_one :swap, :dependent => :destroy
+  has_one :cancellation, :dependent => :destroy
+  has_one :lateness, :dependent => :destroy
+  has_one :unavailable, :dependent => :destroy
+
+  #validate :should_real_time
+  validate :should_have_no_time_off
+  #validate :detect_overlap
+  #validates_presence_of :schedule
+  validates_presence_of :job
+  # validates_inclusion_of :day_of_week, :in => 0..6
+  # validates_uniqueness_of :day_of_week, :scope => :schedule
+  #validates_uniqueness_of :due_date, :scope => :schedule
+  validates_time :start_time
+  validates_time :end_time, :after => :start_time
+  validates_date :due_date
+
+  after_create :calculate_schedule_hours
+  after_save :calculate_schedule_hours
+  after_destroy { |record| check_schedule_for_deletion(record.schedule_id) }
+
+  def job_name
+    self.job.name
+  end
+  
+  def user_name
+    self.schedule.user.name
+  end
+  
+  def get_week_hours(user)
+    if user and user != 0
+      user = User.find(user)
+      user.shifts.where("due_date >= ? AND due_date <= ?",self.due_date.beginning_of_week,self.due_date.end_of_week ).sum(:hours).to_i
+    else
+      self.schedule.shifts.where("due_date >= ? AND due_date <= ?",self.due_date.beginning_of_week,self.due_date.end_of_week ).sum(:hours).to_i
+    end
+  end
+  
+  def if_swap_approved(user)
+    if user and user != 0
+      swapped = Candidate.find_by_alert_type_id(self.id)
+      return (get_week_hours(user) + swapped.swap.shift.hours.strftime('%H').to_i)
+    else
+      swapped = Candidate.find_by_alert_type_id(self.id)
+      return (get_week_hours(0) + swapped.swap.shift.hours.strftime('%H').to_i)
+    end
+  end
+
+  def formatted_due_date
+    "#{due_date.strftime('%m')}/#{due_date.strftime('%d')}/#{due_date.strftime('%Y')}"
+  end
+  def status
+    state = 'normal'
+    if swap && swap.pending?
+      state = 'swap_pending'
+    end
+
+    if cancellation && cancellation.pending?
+      state = 'cancellation_pending'
+    end
+
+    state
+  end
+  
+  def shift_detail
+    "AS #{self.job_name} from #{self.start_time.strftime('%H:%M')} to #{self.end_time.strftime('%H:%M')} on #{self.formatted_due_date}"
+  end
+  
+  def published?
+    self.schedule.published?
+  end
+
+  def is_timeoff? 
+    timeoff = Timeoff.where(:user_id => self.schedule.user_id, :off_date=>self.due_date,:status=>"approved")
+    timeoff.size > 0
+  end
+  
+  def timeoff_reason
+    timeoff = self.schedule.user.timeoffs.where(:off_date => self.due_date,:status=>"approved").first
+    "The Reason : #{timeoff.reason}, All day : #{timeoff.all_day}, Vacation : #{timeoff.vacation} " if timeoff
+  end
+  
+  def is_cancelled? 
+    cancellation = Cancellation.where('shift_id = ? AND (status = ? OR status = ?)',self.id,"approved excused","approved unexcused")
+    cancellation.size > 0
+  end
+  
+  def is_swapped? 
+    swap = Swap.where(:shift_id=>self.id,:status=>"approved")
+    swap.size > 0
+  end
+  
+  def swap_shift dest_sch, org, date
+    curr = self.schedule
+    dates = Date.parse(dest_sch[:due_date])
+    if dest_sch[:schedule_id].present?
+      new_schedule = Schedule.find_by_id(dest_sch[:schedule_id])
+    else
+      new_schedule = Schedule.new(user_id: dest_sch[:employee_id], organization_id: org.id,
+           total_hours: '0:0', start_date: curr.start_date, end_date: curr.end_date)
+      unless new_schedule.save!
+        return new_schedule
+      end
+    end
+    self.update_attributes!(schedule_id: new_schedule.id, day_of_week: dest_sch[:day_of_week], due_date: dates)
+    curr.destroy! if curr.shifts.count == 0
+    return self
+  end
+
+  def has_issue?
+    if swp = swap and swp.status == "pending" 
+      return { "status"=> true, "type"=> "swap pending" }
+    elsif unavail = unavailable and unavail.status == "pending" 
+      return { "status"=> true, "type"=> "unavailable pending" }
+    elsif cancel = cancellation and cancel.status == "pending" 
+      return { "status"=> true, "type"=> "cancel pending" }
+    elsif Timeoff.where('user_id = ? AND off_date = ? AND status = ?',self.schedule.user_id, self.due_date, "pending").count > 0
+      return { "status"=> true, "type"=> "timeoff pending" }
+    elsif late = lateness 
+      return { "status"=> true, "type"=> "lateness" }
+    end
+    return { "status"=> false }
+  end
+  
+  def can_edit?
+    edit_possible = true
+    if self.swap && swap.approved?
+      edit_possible = true
+    elsif self.cancellation && self.cancellation.approved?
+      edit_possible = true
+    end
+    edit_possible
+  end
+
+  def avail?
+    self.published? && self.can_edit?
+  end
+
+  #private
+  #def detect_overlap
+  #  if self.schedule_id
+  #    schedule = Schedule.find(self.schedule_id)
+  #    if schedule
+  #      overlap = schedule.user.shifts.where(:due_date => self.due_date).first
+  #      if overlap && overlap.id != self.id
+  #        errors.add(:due_date, "can't create because already user has shift #{self.due_date} ")
+  #      end
+  #    end
+  #  end
+  #end
+
+  #private
+  #def should_real_time
+  #  if self.start_time > self.end_time
+  #    errors.add(:start_time, "can't be in later than end time")
+  #  end
+  #end
+
+  private
+  def should_have_no_time_off
+    if self.schedule_id
+      schedule = Schedule.find(self.schedule_id)
+      if schedule
+        timeoff = schedule.user.timeoffs.where(:off_date => self.due_date).first
+        if timeoff && timeoff.approved?
+          if timeoff.all_day_absence?
+            errors.add(:due_date, "can't create because already user requested time off on #{self.due_date} all day.")
+          elsif timeoff.interfere?(self.start_time, self.end_time)
+            errors.add(:due_date, "can't create because already user requested time off on #{self.due_date} #{self.start_time} #{self.end_time}")
+          end
+        end
+      end
+    end
+  end
+
+  def check_schedule_for_deletion schedule_id
+    schedule = Schedule.find_by_id(schedule_id)
+    if schedule and schedule.shifts.count == 0
+      schedule.destroy
+    else
+      schedule.calculate_total_hours
+    end
+  end
+
+  def self.create_with_json(schedule, data,changed)
+    data.each do |shift|
+      if shift["hours"] == ""
+        shift["hours"] = "0:0"
+      end
+      if shift["training_hours"] == ""
+        shift["training_hours"] = "0:0"
+      end
+      if shift["id"].nil?
+        # create new one
+        new_shift = schedule.shifts.new(:start_time => shift["start_time"],
+          :end_time => shift["end_time"],
+          :day_of_week => shift["day_of_week"],
+          :hours => shift["hours"],
+          :training_hours => shift["training_hours"],
+          :due_date => shift["due_date"],
+          :job_id => shift["job_id"],
+          :shift_off_id => shift["shift_off_id"]
+        )
+
+        unless new_shift.save
+          return new_shift.errors
+        end
+      else
+        # modify existing one
+        ext_shift = Shift.find(shift["id"])
+        if ext_shift
+          ext_shift.start_time = shift["start_time"]
+          ext_shift.end_time = shift["end_time"]
+          ext_shift.job_id = shift["job_id"]
+          ext_shift.day_of_week = shift["day_of_week"]
+          ext_shift.hours = shift["hours"]
+          ext_shift.due_date = shift["due_date"]
+          ext_shift.job_id = shift["job_id"]
+          ext_shift.shift_off_id = shift["shift_off_id"]
+          shift_changed = ext_shift.changed?
+          result = ext_shift.save
+          if shift_changed 
+            changed = true
+          end
+          unless result
+            return ext_shift.errors
+          end
+        end
+      end
+    end
+    # if changed and schedule.publish?
+    #   schedule.notify_employee
+    # end
+    true
+  end
+
+
+  def self.week_shifts schedule, user, org, date
+    w_shifts = []
+    shifts = schedule.try(:shifts)
+    daily_shifts = shifts.sort_by(&:start_time).group_by(&:day_of_week) if shifts.present?
+    weekdaysrange(org.m_to_s).each do |i|
+      if daily_shifts.present? && daily_shifts[i].present?
+        w_shifts << self.format_shift(schedule, daily_shifts[i], i)
+      else
+        w_shifts << self.fill_shift(schedule, user, i, org, date)
+      end
+    end
+
+    w_shifts
+  end
+
+  def self.day(day, m_to_s)
+   days =  m_to_s ? ["Mon","Tue","Wed","Thur","Fri","Sat", "Sun"] : ["Sun", "Mon","Tue","Wed","Thur","Fri","Sat"];
+   days[day]
+  end
+
+  def self.days(m_to_s, date)
+    days  = []
+    currdate = Date.parse(date).at_beginning_of_week
+    currdate = m_to_s ? currdate - 1 : currdate - 2 ;
+    (0..6).each do |day_of_week|
+      currdate = currdate + 1
+      obj = {'month'=> currdate.month,'date'=> currdate.day,'year'=> currdate.year, 'day'=> day(day_of_week, m_to_s)}
+      days.push(obj)
+    end
+    days
+  end
+
+  def self.get_day m_to_s, day_of_week, date
+    dates = Date.parse(date).at_beginning_of_week + day_of_week
+    dates = dates - 1 if m_to_s
+    dates
+  end
+
+  def self.weekdaysrange(m_to_s)
+    m_to_s ? (1..7) : (0..6)
+  end
+
+  def self.format_shift schedule, shifts, day
+    d_shifts = []
+    shifts.each do |shift|
+      dshift = {}
+      job = shift.job
+      dshift["id"]             = shift.id
+      dshift["job_id"]         = job.id
+      dshift["job_name"]       = job.name
+      dshift["start_time"]     = shift.try(:start_time).try(:strftime, '%I:%M%P') || 0.0
+      dshift["end_time"]       = shift.try(:end_time).try(:strftime,'%I:%M%P') || 0.0
+      dshift["hours"]          = shift.try(:hours).try(:strftime,'%H:%M') || 0.0
+      dshift["training_hours"] = shift.try(:training_hours).try(:strftime,'%H:%M') || 0.0
+      dshift["shift_off_id"]   = shift.shift_off_id
+      dshift["due_date"]       = shift.due_date
+      dshift["is_timeoff"]     = shift.is_timeoff?
+      dshift["is_cancelled"]   = shift.is_cancelled?
+      dshift["cancel_reason"]  = shift.cancellation.try(:reason)
+      dshift["timeoff_reason"] = shift.timeoff_reason
+      dshift["is_swapped"]     = shift.is_swapped?
+      dshift["color"]          = job.color
+      dshift["has_issue"]      = shift.has_issue?
+      dshift["day_of_week"]    = day%7
+      dshift["schedule_id"]    = schedule.try(:id)
+      dshift["employee_id"]    = schedule.user_id
+      dshift["shift_off"]      = ShiftOff.where(:id => shift.shift_off_id).first.name if shift.try(:shift_off_id)
+      d_shifts << dshift
+    end
+    d_shifts
+  end
+
+  def self.fill_shift schedule, emp, day, org, date
+    shift = {}
+    shift["id"]             = nil
+    shift["hours"]          = ""
+    shift["start_time"]     = ""
+    shift["end_time"]       = ""
+    shift["shift_off_id"]   = nil
+    shift["day_of_week"]    = day
+    shift["employee_id"]    = emp.id
+    shift["due_date"]       = get_day(org.m_to_s, day, date)
+    shift["training_hours"] = ""
+    shift["job_id"]         = nil
+    shift["schedule_id"]    = schedule.try(:id)
+    return [shift]
+  end
+
+  def self.daily  schedules, date
+    filtered_shifts = []
+    shifts = self.where(:schedule_id => schedules, :due_date => date)
+    shifts.each do |shift|
+      user = shift.schedule.user
+      filtered_shifts << shift.attributes.merge(:user_id => user.id, :user_name => user.name)
+    end
+    filtered_shifts
+  end
+
+  def calculate_schedule_hours
+    if self.schedule
+      self.schedule.calculate_total_hours
+    end
+  end
+
+end

data/app/models/shift_off.rb

@@ -0,0 +1,4 @@
+class ShiftOff < ActiveRecord::Base
+  belongs_to :organization
+  has_many :shifts
+end

data/app/models/shift_trade.rb

@@ -0,0 +1,43 @@
+# == Schema Information
+#
+# Table name: shift_trades
+#
+#  id           :integer          not null, primary key
+#  status       :string(255)      default("initial")
+#  candidate_id :integer
+#  shift_id     :integer
+#  created_at   :datetime
+#  updated_at   :datetime
+#
+
+class ShiftTrade < ActiveRecord::Base
+
+  belongs_to :candidate
+  belongs_to :shift
+  belongs_to :organization
+  belongs_to :user
+  validates_presence_of :candidate
+
+  def affirm
+    self.status = 'affirmative'
+    save
+  end
+
+  def negate
+    self.status = 'negative'
+    save
+  end
+
+  def ignore
+    self.status = 'ignored'
+    save
+  end
+
+  def confirm()
+    self.status = 'confirmed'
+    save
+
+    self.candidate.confirm(self.id)
+  end
+
+end

data/app/models/subdomain.rb

@@ -0,0 +1,5 @@
+class Subdomain < ActiveRecord::Base
+  belongs_to :organization
+  validates_uniqueness_of :name
+  validates_uniqueness_of :name, :case_sensitive => false
+end

data/app/models/swap.rb

@@ -0,0 +1,82 @@
+# == Schema Information
+#
+# Table name: swaps
+#
+#  id            :integer          not null, primary key
+#  shift_id      :integer
+#  reason        :string(255)
+#  status        :string(255)      default("pending")
+#  in_trash      :boolean          default(FALSE)
+#  viewed        :boolean          default(FALSE)
+#  created_at    :datetime
+#  updated_at    :datetime
+#  alert         :boolean          default(FALSE)
+#  approved_date :datetime
+#  approved_by   :integer
+#
+
+class Swap < ActiveRecord::Base
+
+  belongs_to :shift
+
+  has_many :candidates, :dependent => :destroy
+  has_many :shift_trades, :through => :candidates
+
+  validates_presence_of :shift
+  validates_uniqueness_of :shift_id
+
+  def notify
+    if alert 
+      employees = shift.schedule.user.organization.get_employees
+      employees.each do |candidate|
+        candidate.notify_alert(self)
+      end
+    end
+  end
+  def shift_detail
+    "AS #{shift.job_name} from #{shift.start_time.strftime('%H:%M')} to #{shift.end_time.strftime('%H:%M')} on #{shift.formatted_due_date}"
+    
+  end
+  def pending?
+    self.status == 'pending'
+  end
+
+  def approved?
+    self.status == 'approved'
+  end
+  
+  def user_name
+    self.shift.schedule.user.name
+  end
+  
+
+  def get_shift
+       @swap = Swap.find_by_id(self.alert_type_id)
+       if !@swap.nil? 
+        @swap.shift
+       end 
+  end
+
+  def shift_hours
+    self.shift.hours.strftime('%H')
+  end
+  
+  def due_date
+    self.shift.due_date
+  end
+
+  def approve
+    #self.approved_by = manager.id
+    #self.approved_date = Time.zone.now
+    self.status = 'approved'
+    save
+  end
+
+  def cancel
+    #self.approved_by = manager.id
+    #self.approved_date = Time.zone.now
+    self.status = 'cancelled'
+    save
+  end
+
+end

data/app/models/task.rb

@@ -0,0 +1,26 @@
+# == Schema Information
+#
+# Table name: tasks
+#
+#  id              :integer          not null, primary key
+#  organization_id :integer
+#  user_id         :integer
+#  task_name       :string(255)
+#  duty_time       :time
+#  accept          :boolean          default(FALSE)
+#  done            :boolean          default(FALSE)
+#  duty_date       :date
+#  created_at      :datetime
+#  updated_at      :datetime
+#
+
+class Task < ActiveRecord::Base
+
+  belongs_to :organization
+  belongs_to :user
+
+#  validates_time :duty_time
+  validates_date :duty_date
+  validates_presence_of :task_name
+
+end

data/app/models/template.rb

@@ -0,0 +1,59 @@
+class Template < ActiveRecord::Base
+  has_many :template_assets
+  belongs_to :organization
+  has_many :schedules
+  
+# function for MT2W
+  def add_schedules schedules
+    Schedule.where(:id => schedules).each do |schedule|
+          sch = Schedule.new(schedule.attributes.merge({:id => nil,  :template_id => self.id}))
+          if sch.save!(:validate => false)
+            schedule.shifts.each do |shf|
+              shift = Shift.new(shf.attributes.merge({:id => nil, :schedule_id => sch.id}))
+              shift.save!(:validate => false)
+            end
+          end
+    end
+  end
+
+  def add_schedules_from_date date, org
+    Schedule.where(:organization_id => org. id).not_template.week_schedule_by_date(date).each do |schedule|
+          sch = Schedule.new(schedule.attributes.merge({:id => nil,  :template_id => self.id}))
+          if sch.save!(:validate => false)
+            schedule.shifts.each do |shf|
+              shift = Shift.new(shf.attributes.merge({:id => nil, :schedule_id => sch.id}))
+              shift.save!(:validate => false)
+            end
+          end
+    end
+  end
+
+  def load_schedules date, m_to_s
+    date = Date.parse date
+    if m_to_s
+      start_day = date - date.wday + 1.day
+      end_day = date - date.wday + 7.day
+    else
+      start_day = date - date.wday + 0.day
+      end_day = date - date.wday + 6.day
+    end
+
+    curr_schedules = Schedule.week_schedule_by_date(date).not_template
+    curr_schedules.delete_all if curr_schedules.length > 0
+    self.schedules.includes(:shifts).each do |schedule|
+      sch_attr = schedule.attributes.merge({ :id => nil,  :template_id => nil, :start_date => start_day,
+                                            :end_date =>  end_day, :publish => false })
+      sch = Schedule.new(sch_attr)
+      schedule.shifts.each do |shift|
+        attributes = shift.attributes.merge({id: nil}).except("schedule_id")
+        attributes['due_date'] = start_day + attributes['day_of_week']
+        attributes['due_date'] = attributes['due_date'] - 1 if m_to_s
+        sch.shifts.build(attributes)
+      end
+      sch.save!(:validate => false)
+    end
+
+    return true
+  end
+
+end

data/app/models/template_asset.rb

@@ -0,0 +1,3 @@
+class TemplateAsset < ActiveRecord::Base
+  belongs_to :asset
+end

data/app/models/timeoff.rb

@@ -0,0 +1,101 @@
+# == Schema Information
+#
+# Table name: timeoffs
+#
+#  id             :integer          not null, primary key
+#  day_of_week    :integer
+#  reason         :string(255)
+#  all_day        :boolean          default(FALSE)
+#  start_time     :time
+#  end_time       :time
+#  status         :string(255)      default("pending")
+#  user_id        :integer
+#  created_at     :datetime
+#  updated_at     :datetime
+#  off_date       :date
+#  approved_date  :datetime
+#  approved_by    :integer
+#  cancelled_date :datetime
+#  vacation       :boolean          default(FALSE)
+#
+
+class Timeoff < ActiveRecord::Base
+  belongs_to :user
+  validates_presence_of :user
+  validates_inclusion_of :day_of_week, :in => 0..6
+  validates_date :off_date, :on => :create, :on_or_after => :today
+  validates_time :start_time, :if => lambda { self.all_day == false }
+  validates_time :end_time, :after => :start_time, :if => lambda { self.all_day == false }
+
+  # before_save :create_vacation_info
+
+  def all_day_absence?
+    self.all_day == true
+  end
+
+  def approved?
+    self.status == 'approved'
+  end
+
+  def interfere?(start_time, end_time)
+    if ( self.start_time < start_time && self.end_time > start_time ) ||
+        ( end_time > self.start_time && end_time < self.end_time ) ||
+        ( self.start_time > start_time && self.end_time < end_time )
+      true
+    else
+      false
+    end
+  end
+
+  def detail
+    return "Your TimeOff Request for #{off_date} has been approved"
+  end
+
+  def formatted_due_date
+    "#{off_date.strftime('%A')},#{off_date.strftime('%B')} #{off_date.day}, #{off_date.year}"
+  end
+
+  def approve(manager)
+    create_vacation_info
+    self.approved_by = manager.id
+    self.approved_date = DateTime.now
+    self.status = 'approved'
+    save
+  end
+
+  def cancel
+    self.status = 'cancelled'
+    self.cancelled_date = DateTime.now
+    save
+  end
+
+  private
+  def create_vacation_info
+    if self.vacation
+      if self.user.user_vacation_info
+        already_spent_hours = self.user.user_vacation_info.spent_hours
+        if self.all_day
+          new_spent_hours = already_spent_hours + 24
+        else
+          new_spent_hours = already_spent_hours + (end_time - start_time)/3600
+        end
+
+        self.user.user_vacation_info.update_attribute(:spent_hours, new_spent_hours)
+      else
+        if self.all_day
+          new_spent_hours = 24
+        else
+          new_spent_hours = end_time - start_time
+        end
+
+        if self.user.vacation
+          user_vacation_info = UserVacationInfo.create(:user_id => self.user_id,
+                                                       :vacation_id => self.user.vacation.id,
+                                                       :spent_hours => new_spent_hours
+          )
+        end
+      end
+    end
+  end
+
+end