erp_work_effort 4.0.0 → 4.2.0

data/app/models/associated_transportation_route.rb

@@ -1,9 +1,12 @@
-# EXAMPLE USAGE of has_many_polymorphic with AssociatedWorkEffort 
-# TransportationRoute.class_eval do     
-#     has_many_polymorphic :associated_records,
-#                :through => :associated_transportation_routes,
-#                :models => [:shipment_items, :shipments]
+# create_table :associated_transportation_routes do |t|
+#   t.integer :transportation_route_id
+#   t.integer :associated_record_id
+#   t.string :associated_record_type
 # end
+#
+# add_index :associated_transportation_routes, [:associated_record_id, :associated_record_type], :name => "associated_route_record_id_type_idx"
+# add_index :associated_transportation_routes, :transportation_route_id, :name => "associated_route_transportation_route_id_idx"
+
 class AssociatedTransportationRoute < ActiveRecord::Base
 	attr_protected :created_at, :updated_at
 

data/app/models/cal_evt_party_role.rb

@@ -0,0 +1,9 @@
+class CalEvtPartyRole < ActiveRecord::Base
+
+  attr_protected :created_at, :updated_at
+
+  belongs_to  :calendar_event
+  belongs_to  :party
+  belongs_to  :role_type
+
+end

data/app/models/calendar_event.rb

@@ -0,0 +1,46 @@
+class CalendarEvent < ActiveRecord::Base
+
+  # attr_accessible :title, :body
+  attr_accessor :invitee_status
+
+  has_many :cal_evt_party_roles, dependent: :destroy
+  has_many :parties, :through => :cal_evt_party_roles
+  has_many :calendar_invites, dependent: :destroy
+  has_file_assets
+
+  # serialize ExtJs attributes
+  is_json :custom_fields
+
+  def invitee_status_for_party( invitee_party_id )
+    invite = CalendarInvite.where( "invitee_id = ? and calendar_event_id = ?", invitee_party_id, self.id ).first
+    invite ? invite.current_status : nil
+  end
+
+  def get_invitees
+    self.calendar_invites.map { |i| i.invitee }.compact
+  end
+
+  def get_accepted_invitees
+    self.calendar_invites.select{ |i| i.current_status == 'accepted'}.map { |i| i.invitee }.compact
+  end
+
+  def primary_event_host
+    self.parties.where("role_type_id = ?", RoleType.iid('cal_evt_host')).first
+  end
+
+  def find_parties_by_role(role)
+    self.parties.where("role_type_id = ?", role.id).all
+  end
+
+  #This is a convenience method whose primary use is when a CalendarEvent starts out using specific invitations
+  #and later gets changed to being a public or network-type invite. You can clean up un-accepted invitations
+  #and invitees can still accept via the public or network invite.
+  def remove_unaccepted_invitations
+
+  end
+
+  def to_json
+    super methods: [:invitee_status]
+  end
+
+end

data/app/models/calendar_invite.rb

@@ -0,0 +1,10 @@
+class CalendarInvite < ActiveRecord::Base
+
+  belongs_to  :calendar_event
+  belongs_to  :inviter, :class_name => "Party", :foreign_key => "inviter_id"
+  belongs_to  :invitee, :class_name => "Party", :foreign_key => "invitee_id"
+
+  has_tracked_status
+  # attr_accessible :title, :body
+
+end

data/app/models/candidate_submission.rb

@@ -0,0 +1,37 @@
+class CandidateSubmission < ActiveRecord::Base
+
+  belongs_to :order_line_item
+
+  attr_protected :created_at, :updated_at
+
+  has_tracked_status
+  tracks_created_by_updated_by
+
+  is_json :custom_fields
+
+  #must be after is_json
+
+  def order_txn
+    self.order_line_item.order_txn
+  end
+
+  # helper method to get dba_organization related to this candidate_submission's
+  # order line item
+  def dba_organization
+    order_line_item = OrderLineItem.find(order_line_item_id)
+    unless order_line_item.nil?
+      order_line_item.dba_organization
+    end
+  end
+
+  def clone
+    new_candidate_submission = CandidateSubmission.new
+    new_candidate_submission.description = self.description
+    new_candidate_submission.internal_identifier = self.internal_identifier
+    new_candidate_submission.custom_fields = self.custom_fields
+    new_candidate_submission.save!
+
+    new_candidate_submission
+  end
+end
+

data/app/models/experience.rb

@@ -0,0 +1,11 @@
+class Experience < ActiveRecord::Base
+
+  tracks_created_by_updated_by
+
+  belongs_to :party
+  belongs_to :experience_type
+
+  attr_protected :created_at, :updated_at
+  attr_accessible :description
+
+end

data/app/models/extensions/biz_txn_events.rb

@@ -0,0 +1,35 @@
+module Api
+  module V1
+    module Extensions
+      module BizTxnEventFilters
+
+        # Filter records
+        #
+        # @param filters [Hash] a hash of filters to be applied,
+        # @param statement [ActiveRecord::Relation] the query being built
+        # @return [ActiveRecord::Relation] the query being built
+        def apply_filters(filters, statement=nil)
+          biz_txn_events = super(filters, statement)
+
+          if filters[:work_effort_id]
+            biz_txn_events = biz_txn_events.joins(:work_effort_biz_txn_events)
+                                 .where('work_effort_biz_txn_events.work_effort_id' => filters[:work_effort_id])
+          end
+
+          biz_txn_events
+        end
+
+      end # BizTxnEventFilters
+    end # Extensions
+  end # V1
+end # Api
+
+BizTxnEvent.singleton_class.prepend Api::V1::Extensions::BizTxnEventFilters
+
+BizTxnEvent.class_eval do
+
+  ## What WorkEfforts have been related to this BizTxnEvent
+  has_many :work_effort_biz_txn_events, :dependent => :destroy
+  has_many :work_efforts, :through => :work_effort_biz_txn_events
+
+end

data/app/models/extensions/finacial_txns.rb

@@ -0,0 +1,27 @@
+module Api
+  module V1
+    module Extensions
+      module FinancialTxnFilters
+
+        # Filter records
+        #
+        # @param filters [Hash] a hash of filters to be applied,
+        # @param statement [ActiveRecord::Relation] the query being built
+        # @return [ActiveRecord::Relation] the query being built
+        def apply_filters(filters, statement=nil)
+          financial_txns = super(filters, statement)
+
+          if filters[:work_effort_id]
+            financial_txns = financial_txns.joins(biz_txn_event: :work_effort_biz_txn_events)
+                                 .where('work_effort_biz_txn_events.work_effort_id' => filters[:work_effort_id])
+          end
+
+          financial_txns
+        end
+
+      end # BizTxnEventFilters
+    end # Extensions
+  end # V1
+end # Api
+
+FinancialTxn.singleton_class.prepend Api::V1::Extensions::FinancialTxnFilters

data/app/models/extensions/order_line_item.rb

@@ -0,0 +1,12 @@
+OrderLineItem.class_eval do
+
+  has_many :candidate_submissions, :dependent => :destroy
+
+
+  before_destroy :destroy_candidate_submissions
+
+  def destroy_candidate_submissions
+    self.candidate_submissions.destroy_all
+  end
+
+end

data/app/models/extensions/party.rb

@@ -1,3 +1,207 @@
 Party.class_eval do
   has_many :resource_availabilities, :class_name => 'PartyResourceAvailability', :dependent => :destroy
+  has_many :party_skills
+  has_many :position_fulfillments, foreign_key: "held_by_party_id"
+  has_many :experiences
+  has_many :wc_codes, dependent: :destroy
+  has_many :shifts, dependent: :destroy
+  has_many :resumes
+  has_many :work_effort_party_assignments, :dependent => :destroy
+  has_many :timesheet_party_roles, dependent: :destroy
+  has_many :timesheets, through: :timesheet_party_roles do
+    def current!(role_type)
+      party = proxy_association.owner
+
+      Timesheet.current!(party, role_type)
+    end
+  end
+  has_many :time_entries, through: :timesheets do
+    # Get TimeEntries where thru_datetime is null
+    #
+    # @return [ActiveRecord::Relation]
+    def open
+      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 TimeEntries by a WorkEffort
+    #
+    # @param work_effort [WorkEffort] WorkEffort to scope by
+    # @return [ActiveRecord::Relation]
+    def scope_by_work_effort(work_effort)
+      where('work_effort_id' => work_effort.id)
+    end
+  end
+
+  #
+  # scoping helpers
+  #
+
+  class << self
+
+    # scope by project
+    #
+    # @param project [Integer | Project | Array] either a id of Project record, a Project record, an array of Project records
+    # or an array of Project 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_project(project, options={})
+      statement = joins("join entity_party_roles project_epr on project_epr.party_id = parties.id")
+                      .where('project_epr.entity_record_type = ?', 'Project')
+                      .where('project_epr.entity_record_id' => project)
+
+      if options[:role_types]
+        statement = statement.joins("join role_types project_rt on project_rt.id = project_epr.role_type_id")
+                        .where('project_rt.id' => RoleType.find_child_role_types(options[:role_types]))
+      end
+
+      statement
+    end
+  end
+
+  #
+  # end scoping helpers
+  #
+
+  #
+  # relationship helpers
+  #
+
+  # create relationship between a party and a project
+  #
+  # @param project [Project] project to relate this party to
+  # @param options [Hash] options to apply to this scope
+  # @option options [Array] :role_types role types to use in the relationship
+  #
+  # @return [Party] self
+  def create_project_relationship(project, options)
+    # make sure role_types is passed
+    raise StandardError('Party to Project relationships require a role_types option') if options[:role_types].blank?
+
+    options[:role_types].each do |role_type|
+
+      current_relationship = EntityPartyRole.where("entity_record_type = 'Project' and entity_record_id = ?
+                                                    and party_id = ? and role_type_id = ?",
+                                                   project.id,
+                                                   self.id,
+                                                   role_type.id).first
+      unless current_relationship
+        EntityPartyRole.create(
+            entity_record: project,
+            party: self,
+            role_type: role_type
+        )
+      end
+    end
+
+    self
+  end
+
+  # destroy relationship between a party and a project
+  #
+  # @param project [Project] project to remove the relationship with
+  # @param options [Hash] options to apply to this scope
+  # @option options [Array] :role_types role types to remove in this relationship. Pass no role_types option
+  # to remove all relationships regardless of role_types
+  #
+  # @return [Party] self
+  def destroy_project_relationship(project, options)
+    if options[:role_types]
+      options[:role_types].each do |role_type|
+
+        relationship = EntityPartyRole.where("entity_record_type = 'Project' and entity_record_id = ?
+                                              and party_id = ? and role_type_id = ?",
+                                             project.id,
+                                             self.id,
+                                             role_type.id).first
+        if relationship
+          relationship.destroy
+        end
+      end
+
+    else
+      entity_party_roles.delete_all(entity_record_type: 'Project', entity_record_id: project.id)
+    end
+
+    self
+  end
+
+  # updates a relationship between a party and a project.  By using this method you are implying there should be only
+  # one relationship with the given role type between a party and a project.  Any other relationships will be
+  # destroyed.  If no current relationship is found it will create a new one.
+  #
+  # @param project [Project] project to update the relationship with
+  # @param options [Hash] options to apply to this scope
+  # @option options [Array] :role_types role types to update in this relationship.
+  #
+  # @return [Party] self
+  def update_project_relationship(project, options)
+    # make sure role_types is passed
+    raise StandardError('Party to Project relationships require a role_types option') if options[:role_types].blank?
+
+    if options[:role_types]
+      options[:role_types].each do |role_type|
+
+        relationship = EntityPartyRole.where("entity_record_type = 'Project'
+                                              and entity_record_id = ? and role_type_id = ?",
+                                             project.id,
+                                             role_type.id).first
+        if relationship
+          relationship.party = self
+          relationship.save!
+        else
+          create_project_relationship(project, options)
+        end
+      end
+
+    else
+      entity_party_roles.delete_all(entity_record_type: 'Project', entity_record_id: project.id)
+    end
+
+    self
+  end
+
+  #
+  # end relationship helpers
+  #
+
+  def transportation_routes
+    TransportationRoute.scope_by_party(self)
+  end
+
+  # Get array of assigned WorkEfforts
+  #
+  # @param role_types [Array] (['work_resource']) Array of role types to scope by
+  # @return [Array] Assigned WorkEfforts
+  def assigned_work_efforts(role_types=['work_resource'])
+    role_types = RoleType.find_child_role_types(role_types)
+
+    WorkEffort.joins(work_effort_party_assignments: :role_type)
+        .where(role_types: {id: role_types})
+        .where(work_effort_party_assignments: {party_id: self.id})
+  end
+
+  # Returns an open TimeEntry for this party if there is one, nil if not
+  #
+  # @return [TimeEntry] TimeEntry if present nil if not
+  def open_time_entry
+    self.time_entries.open_entries.first
+  end
+
+  # Returns the current Task this Party is working on if this is on, nil if not
+  #
+  # @return [WorkEffort] WorkEffort if present nil if not
+  def current_work_effort
+    self.time_entries.open_entries.try(:first).try(:work_effort)
+  end
+
+  # Returns True if there is an open TimeEntry, false if there is not
+  #
+  # @return [Boolean] True if there is an open TimeEntry, false if there is not
+  def has_open_time_entry?
+    !open_time_entry.nil?
+  end
 end

data/app/models/party_skill.rb

@@ -1,6 +1,8 @@
 class PartySkill < ActiveRecord::Base
   attr_protected :created_at, :updated_at
 
+  tracks_created_by_updated_by
+
   belongs_to :party
   belongs_to :skill_type
 end

data/app/models/pay_period.rb

@@ -0,0 +1,59 @@
+# create_table :pay_periods do |t|
+#   t.date :from_date
+#   t.date :thru_date
+#   t.integer :week_number
+#
+#   t.timestamps
+# end
+
+class PayPeriod < ActiveRecord::Base
+
+  attr_protected :created_at, :updated_at
+
+  has_many :timesheets
+  has_many :timesheet_party_roles
+
+  class << self
+    def current!
+      today = Date.today
+      pay_periods_tbl = self.arel_table
+
+      pay_period = self.where(pay_periods_tbl[:from_date].lteq(today))
+                       .where(pay_periods_tbl[:thru_date].gteq(today)).first
+
+      # create pay_period if it does not exist from Sunday to Saturday
+      # this will eventually be based on a Calender
+      unless pay_period
+        today = Time.now.strftime("%A")
+        if today == 'Saturday'
+          from_date = Chronic.parse('last Sunday')
+          thru_date = Time.now
+        elsif today == 'Sunday'
+          thru_date = Chronic.parse('next Saturday')
+          from_date = Time.now
+        else
+          thru_date = Chronic.parse('next Saturday')
+          from_date = Chronic.parse('last Sunday')
+        end
+
+        pay_period = PayPeriod.create!(
+            from_date: from_date,
+            thru_date: thru_date,
+            week_number: Time.now.strftime("%U").to_i
+        )
+      end
+
+      pay_period
+    end
+
+    def is_end_of_pay_period?(date)
+      pay_period = self.current
+      pay_period.nil? ? false : (pay_period.thru_date == date)
+    end
+  end
+
+  def to_s
+    "[#{self.week_number}] #{self.from_date.strftime('%m/%d/%Y')} - #{self.thru_date.strftime('%m/%d/%Y')}"
+  end
+
+end