erp_work_effort 4.0.0 → 4.2.0

data/app/models/position.rb

@@ -0,0 +1,8 @@
+class Position < ActiveRecord::Base
+
+  tracks_created_by_updated_by
+
+  belongs_to :party
+  belongs_to :position_type
+
+end

data/app/models/position_fulfillment.rb

@@ -0,0 +1,8 @@
+class PositionFulfillment < ActiveRecord::Base
+
+  tracks_created_by_updated_by
+
+  belongs_to :held_by_party, class_name: "Party"
+  belongs_to :position
+
+end

data/app/models/position_type.rb

@@ -0,0 +1,12 @@
+class PositionType < ActiveRecord::Base
+
+  attr_protected :created_at, :updated_at
+
+  tracks_created_by_updated_by
+
+  class << self
+    def iid(internal_identifier)
+      find_by_internal_identifier(internal_identifier)
+    end
+  end
+end

data/app/models/project.rb

@@ -0,0 +1,59 @@
+class Project < ActiveRecord::Base
+
+  attr_protected :created_at, :updated_at
+
+  has_many :work_efforts, :dependent => :destroy
+
+  tracks_created_by_updated_by
+  has_tracked_status
+  has_party_roles
+
+  class << self
+
+    #
+    # scoping helpers
+    #
+
+    # scope by dba organization
+    #
+    # @param dba_organization [Party] dba organization to scope by
+    #
+    # @return [ActiveRecord::Relation]
+    def scope_by_dba_organization(dba_organization)
+      scope_by_party(dba_organization, {role_types: [RoleType.iid('dba_org')]})
+    end
+
+    alias scope_by_dba scope_by_dba_organization
+
+    # scope by party
+    #
+    # @param party [Integer | Party | Array] either a id of Party record, a Party record, an array of Party records
+    # or an array of Party ids
+    # @param options [Hash] options to apply to this scope
+    # @option options [Array] :role_types role types to include in the scope
+    #
+    # @return [ActiveRecord::Relation]
+    def scope_by_party(party, options={})
+      table_alias = String.random
+
+      statement = joins("inner join entity_party_roles as \"#{table_alias}\" on \"#{table_alias}\".entity_record_id = projects.id
+                         and \"#{table_alias}\".entity_record_type = 'Project'")
+                      .where("#{table_alias}.party_id" => party).uniq
+
+      if options[:role_types]
+        statement = statement.where("#{table_alias}.role_type_id" => RoleType.find_child_role_types(options[:role_types]))
+      end
+
+      statement
+    end
+  end
+
+  def to_label
+    description
+  end
+
+  def to_data_hash
+    to_hash(only: [:id, :description, :created_at, :updated_at])
+  end
+
+end

data/app/models/requirement.rb

@@ -11,4 +11,6 @@ class Requirement < ActiveRecord::Base
   belongs_to :requirement_type
   belongs_to :requirement_record, :polymorphic => true
 
+  has_file_assets
+
 end

data/app/models/resume.rb

@@ -0,0 +1,11 @@
+class Resume < ActiveRecord::Base
+
+	attr_protected :created_at,:updated_at
+
+  belongs_to :party
+
+  has_file_assets
+
+  has_tracked_status
+
+end

data/app/models/shift.rb

@@ -0,0 +1,22 @@
+class Shift < ActiveRecord::Base
+  attr_protected :created_at, :updated_at
+
+  tracks_created_by_updated_by
+
+  belongs_to :party
+
+  # override getter to format time
+  def shift_start
+    read_attribute(:shift_start).strftime('%I:%M%p')
+  end
+
+  # override getter to format time
+  def shift_end
+    read_attribute(:shift_end).strftime('%I:%M%p')
+  end
+
+  def to_label
+    read_attribute(:description) + '  ' + self.shift_start + '-' + self.shift_end
+  end
+
+end

data/app/models/skill_type.rb

@@ -1,10 +1,18 @@
 class SkillType < ActiveRecord::Base
   attr_protected :created_at, :updated_at
 
+  tracks_created_by_updated_by
+
   acts_as_nested_set
   include ErpTechSvcs::Utils::DefaultNestedSetMethods
 
   has_many  :party_skills
   has_many  :parties, :through => :party_skills
 
+  class << self
+	  def iid(internal_identifier)
+	    find_by_internal_identifier(internal_identifier)
+	  end
+	end
+  
 end

data/app/models/staffing_position.rb

@@ -0,0 +1,9 @@
+class StaffingPosition < ActiveRecord::Base
+  attr_accessible :description, :internal_identifier, :shift
+
+  tracks_created_by_updated_by
+
+  #must be after is_json
+  acts_as_product_type
+
+end

data/app/models/time_entry.rb

@@ -0,0 +1,260 @@
+# create_table :time_entries do |t|
+#   t.datetime :from_datetime
+#   t.datetime :thru_datetime
+#   t.integer :regular_hours_in_seconds
+#   t.integer :overtime_hours_in_seconds
+#   t.text :comment
+#   t.references :timesheet
+#   t.references :work_effort
+#
+#   t.timestamps
+# end
+#
+# add_index :time_entries, :timesheet_id
+# add_index :time_entries, :work_effort_id
+
+class TimeEntry < ActiveRecord::Base
+  attr_protected :created_at, :updated_at
+
+  tracks_created_by_updated_by
+
+  belongs_to :timesheet
+  belongs_to :work_effort
+
+  class << self
+    def open_entries
+      where(TimeEntry.arel_table[:from_datetime].not_eq(nil))
+          .where(thru_datetime: nil)
+          .where(TimeEntry.arel_table[:manual_entry].eq(nil).or(TimeEntry.arel_table[:manual_entry].eq(false)))
+    end
+
+    # scope by work_effort
+    #
+    # @param work_effort [Integer | WorkEffort | Array] either a id of WorkEffort record, a WorkEffort record, an array of WorkEffort records
+    # or an array of WorkEffort ids
+    #
+    # @return [ActiveRecord::Relation]
+    def scope_by_work_effort(work_effort)
+      where(work_effort_id: work_effort)
+    end
+
+    # entries scoped by party
+    #
+    # @param party [Party] party to get time_entries by
+    def scope_by_party(party)
+      joins(:timesheet => :timesheet_party_roles).where('timesheet_party_roles.party_id' => party)
+    end
+
+    # total seconds by work_effort
+    #
+    # @param opts [Hash] opts to calculate the total with
+    # @option opts [WorkEffort] :work_effort WorkEffort to get total hours for
+    # @option opts [Party] :party Party to get total hours for
+    # @option opts [Date] :start start date range
+    # @option opts [Date] :end end date range
+    #
+    # @return [Integer] total seconds
+    def total_seconds(opts)
+      seconds = 0
+
+      statement = self
+
+      time_entry_arel_tbl = self.arel_table
+
+      if opts[:work_effort]
+        statement = statement.scope_by_work_effort(opts[:work_effort])
+      end
+
+      if opts[:party]
+        statement = statement.scope_by_party(opts[:party])
+      end
+
+      if opts[:start]
+        statement = statement.where(time_entry_arel_tbl[:from_datetime].gteq(opts[:start].utc).
+                                        or(time_entry_arel_tbl[:manual_entry_start_date].gteq(opts[:start].utc)))
+      end
+
+      if opts[:end]
+        statement = statement.where(time_entry_arel_tbl[:from_datetime].lteq(opts[:end].utc).
+                                        or(time_entry_arel_tbl[:manual_entry_start_date].lteq(opts[:end].utc)))
+      end
+
+      statement.each do |time_entry|
+        seconds += ((time_entry.regular_hours_in_seconds || 0) + (time_entry.overtime_hours_in_seconds || 0))
+      end
+
+      seconds
+    end
+
+    # total hours as decimal round to the nearest 15th
+    #
+    # @param opts [Hash] opts to calculate the total with
+    # @option opts [WorkEffort] :work_effort WorkEffort to get total hours for
+    # @option opts [Party] :party Party to get total hours for
+    # @option opts [Date] :start start date range
+    # @option opts [Date] :end end date range
+    #
+    # @return [BigDecimal] hours
+    def total_hours(opts)
+      _total_seconds = total_seconds(opts)
+
+      if _total_seconds.nil? or _total_seconds == 0
+        0
+      else
+        # get hours by dividing seconds by 3600 then get fractional minutes
+        ((_total_seconds / 3600).floor + (((_total_seconds % 3600) / 60)) / 100.0)
+      end
+    end
+
+    # total seconds by work_effort formatted as HH:MM:SS
+    #
+    # @param opts [Hash] opts to calculate the total with
+    # @option opts [WorkEffort] :work_effort WorkEffort to get total hours for
+    # @option opts [Party] :party Party to get total hours for
+    # @option opts [Date] :start start date range
+    # @option opts [Date] :end end date range
+    #
+    # @return [String] HH:MM:SS
+    def total_formatted(opts)
+      _total_seconds = total_seconds(opts)
+
+      if _total_seconds.nil? or _total_seconds == 0
+        '00:00:00'
+      else
+        seconds =_total_seconds % 60
+        minutes = (_total_seconds / 60) % 60
+        hours = _total_seconds / (60 * 60)
+
+        format("%02d:%02d:%02d", hours, minutes, seconds)
+      end
+    end
+  end
+
+  def calculate_regular_hours_in_seconds!
+    self.regular_hours_in_seconds = ((thru_datetime - from_datetime)).to_i
+    self.save!
+  end
+
+  #
+  # relationship helpers
+  #
+
+  # create relationship between a TimeEntry and WorkEffort
+  #
+  # @param work_effort [WorkEffort] work_effort to relate this time_entry to
+  #
+  # @return [TimeEntry] self
+  def create_work_effort_relationship(work_effort)
+    self.work_effort_id = work_effort.id
+
+    self
+  end
+
+  # destroy relationship between a TimeEntry and WorkEffort
+  #
+  # @return [TimeEntry] self
+  def destroy_work_effort_relationship
+    self.work_effort_id = nil
+
+    self
+  end
+
+  #
+  # end relationship helpers
+  #
+
+  # regular hours formatted as HH:MM:SS
+  #
+  # @return [String] HH:MM:SS
+  def regular_hours_formatted
+    if self.regular_hours_in_seconds.nil? or self.regular_hours_in_seconds == 0
+      '00:00:00'
+    else
+      seconds = self.regular_hours_in_seconds % 60
+      minutes = (self.regular_hours_in_seconds / 60) % 60
+      hours = self.regular_hours_in_seconds / (60 * 60)
+
+      format("%02d:%02d:%02d", hours, minutes, seconds)
+    end
+  end
+
+  # overtime hours formatted as HH:MM:SS
+  #
+  # @return [String] HH:MM:SS
+  def overtime_hours_formatted
+    if self.overtime_hours_in_seconds.nil? or self.overtime_hours_in_seconds == 0
+      '00:00:00'
+    else
+      seconds = self.overtime_hours_in_seconds % 60
+      minutes = (self.overtime_hours_in_seconds / 60) % 60
+      hours = self.overtime_hours_in_seconds / (60 * 60)
+
+      format("%02d:%02d:%02d", hours, minutes, seconds)
+    end
+  end
+
+  # get fractional hours for this TimeEntry
+  #
+  # @return [BigDecimal] hours
+  def hours
+    _total_seconds = (self.regular_hours_in_seconds || 0) + (self.overtime_hours_in_seconds || 0)
+
+    if _total_seconds.nil? or _total_seconds == 0
+      0
+    else
+      # get hours by dividing seconds by 3600 then get fractional minutes
+      ((_total_seconds / 3600).floor + (((_total_seconds % 3600) / 60)) / 100.0)
+    end
+  end
+
+  # finds party with passed role to this TimeEntry
+  #
+  # @param role_type [RoleType] role type to use in the association
+  # @return [Party] party
+  def find_party_by_role(role_type)
+    self.timesheet.find_party_by_role(role_type)
+  end
+
+  def to_data_hash
+    to_hash(only: [:id,
+                   :regular_hours_in_seconds,
+                   :overtime_hours_in_seconds,
+                   :comment],
+            from_datetime: (from_datetime.nil? ? nil : from_datetime.utc.iso8601),
+            thru_datetime: (thru_datetime.nil? ? nil : thru_datetime.utc.iso8601),
+            updated_at: (updated_at.nil? ? nil : updated_at.utc.iso8601),
+            created_at: (created_at.nil? ? nil : created_at.utc.iso8601)
+    )
+  end
+
+  # Sets the current status of the WorkEffort to In Progress
+  #
+  # @param status [String] Internal Identifier of TrackedStatusType to set
+  def update_task_status(status)
+    # make sure this TimeEntry is related to a WorkEffort
+    if self.work_effort
+      work_effort.current_status = status
+    end
+  end
+
+  # Sets the current status of the WorkEffortAssignment to In Progress
+  #
+  # @param status [String] Internal Identifier of TrackedStatusType to set
+  def update_task_assignment_status(status)
+    # make sure this TimeEntry is related to a WorkEffort
+    if self.work_effort
+      work_resource_role_types = RoleType.find_child_role_types(['work_resource'])
+
+      # find the party with work_resource related to this TimeEntry
+      work_resource_party = self.find_party_by_role(work_resource_role_types)
+
+      assignment = work_effort.work_effort_party_assignments.where(party_id: work_resource_party)
+                       .where(role_type_id: work_resource_role_types).first
+
+      if assignment
+        assignment.current_status = status
+      end
+    end
+  end
+
+end

data/app/models/timesheet.rb

@@ -0,0 +1,194 @@
+# create_table :timesheets do |t|
+#   t.text :comment
+#   t.references :pay_period
+#   t.string :status
+#
+#   t.timestamps
+# end
+#
+# add_index :timesheets, :party_id
+# add_index :timesheets, :pay_period_id
+
+class Timesheet < ActiveRecord::Base
+  attr_protected :created_at, :updated_at
+
+  include AASM
+
+  has_file_assets
+
+  has_many :timesheet_party_roles, dependent: :destroy
+  has_many :time_entries, dependent: :destroy
+  belongs_to :pay_period
+
+  scope :for_user, lambda { |user| where(["party_id = ?", user.party_id]) }
+
+  scope :submitted_between, lambda { |from_date, thru_date|
+                            includes(:pay_period)
+                                .where(:status => 'submitted', :pay_periods => {:from_date => from_date.to_date..thru_date.to_date})
+                          }
+
+  scope :existing_timesheets, lambda { |from_date, party_id|
+                              includes(:pay_period)
+                                  .where(:party_id => party_id)
+                                  .where(:pay_periods => {:from_date => from_date})
+                            }
+
+  class << self
+    # get current timesheet for party with passed role
+    # if no timesheet could be found it will create one
+    #
+    # @param party [Party] party to add
+    # @param role_type [RoleType] role type to use in the association
+    # @return [Timesheet] current timesheet
+    def current!(party, role_type)
+      pay_period = PayPeriod.current!
+
+      statement = self.joins(:timesheet_party_roles)
+                      .where('pay_period_id' => pay_period)
+                      .where('timesheet_party_roles.party_id' => party)
+                      .where('timesheet_party_roles.role_type_id' => role_type)
+
+      timesheet = statement.first
+
+      # create a new timesheet if one does not exist for the pay_period
+      unless timesheet
+        timesheet = Timesheet.create!(
+            pay_period: pay_period
+        )
+
+        timesheet.add_party_with_role(party, role_type)
+      end
+
+      timesheet
+    end
+  end
+
+  #aasm mixin
+  aasm_column :status
+  aasm_state :open, :initial => true
+  aasm_state :submitted
+  aasm_state :recalled
+  aasm_state :rejected
+  aasm_state :approved
+  aasm_state :resubmitted
+
+  aasm_event :submit do
+    transitions :to => :submitted, :from => [:open]
+  end
+
+  aasm_event :recall do
+    transitions :to => :recalled, :from => [:submitted, :resubmitted, :approved]
+  end
+
+  aasm_event :resubmit do
+    transitions :to => :resubmitted, :from => [:recalled, :rejected]
+  end
+
+  aasm_event :reject do
+    transitions :to => :rejected, :from => [:submitted, :resubmitted]
+  end
+
+  aasm_event :approve do
+    transitions :to => :approved, :from => [:submitted, :resubmitted]
+  end
+
+  def recalled?
+    self.status == 'recalled'
+  end
+
+  def rejeted?
+    self.status == 'rejected'
+  end
+
+  # pass through method to get week_number on pay period
+  #
+  def week_number
+    self.pay_period.week_number
+  end
+
+  # pass through method to get thru_date on pay period
+  #
+  def thru_date
+    self.pay_period.thru_date
+  end
+
+  # pass through method to get from_date on pay period
+  #
+  def from_date
+    self.pay_period.from_date
+  end
+
+  # add party with passed role to this timesheet
+  #
+  # @param party [Party] party to add
+  # @param role_type [RoleType] role type to use in the association
+  # @return [TimeSheetPartyRole] newly created relationship
+  def add_party_with_role(party, role_type)
+    self.timesheet_party_roles << TimesheetPartyRole.create(
+        party: party,
+        role_type: role_type
+    )
+  end
+
+  # finds party with passed role to this timesheet
+  #
+  # @param role_type [RoleType] role type to use in the association
+  # @return [Party] Party associated to this timesheet
+  def find_party_by_role(role_type)
+    timesheet_party_role = self.timesheet_party_roles.where(role_type_id: role_type).first
+
+    if timesheet_party_role
+      timesheet_party_role.party
+    else
+      nil
+    end
+  end
+
+  # get total seconds for given date
+  #
+  # @param opts [Hash] opts to calculate the total with
+  # @option opts [Date] :start start date range
+  # @option opts [Date] :end end date range
+  # @return [Decimal] total seconds
+  def total_seconds(opts)
+    seconds = 0
+    time_entry_arel_tbl = TimeEntry.arel_table
+
+    statement = self.time_entries
+
+    if opts[:start]
+      statement = statement.where(time_entry_arel_tbl[:from_datetime].gteq(opts[:start]))
+    end
+
+    if opts[:end]
+      statement = statement.where(time_entry_arel_tbl[:from_datetime].lteq(opts[:end]))
+    end
+
+    statement.each do |time_entry|
+      seconds += ((time_entry.regular_hours_in_seconds || 0) + (time_entry.overtime_hours_in_seconds || 0))
+    end
+
+    seconds
+  end
+
+  # get total seconds for a given day formatted as HH:MM:SS
+  #
+  # @param opts [Hash] opts to calculate the total with
+  # @option opts [Date] :start start date range
+  # @option opts [Date] :end end date range
+  # @return [String] HH:MM:SS
+  def total_formatted(opts)
+    _total_seconds = total_seconds(opts)
+
+    if _total_seconds.nil? or _total_seconds == 0
+      '00:00:00'
+    else
+      seconds =_total_seconds % 60
+      minutes = (_total_seconds / 60) % 60
+      hours = _total_seconds / (60 * 60)
+
+      format("%02d:%02d:%02d", hours, minutes, seconds)
+    end
+  end
+
+end