erp_work_effort 3.1.1 → 4.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ad5d23963efb2e5067ac139ef8d7886811a058d1
+  data.tar.gz: 0d51e61b9b9b83fe5d6080a4a543cffa27bc9c8f
+SHA512:
+  metadata.gz: 7f7a8b18fa29c8584836be2c62a412575163c2ea82acb3d9c8d5106a507efbe704c32ae7b46968949fbbcd765fc7235ab3f5e08ac41fb8a759655cda9a1ad0e3
+  data.tar.gz: d775e88305f33b49f9e54e0520638cf70b6bc408606f89acb994449f0204c55e6eaaf8260c3df506540434270c1bf2e6069e5e0dbc542a54f39fd52958d769f6

data/app/controllers/erp_work_effort/erp_app/organizer/tasks/base_controller.rb

@@ -0,0 +1,13 @@
+module ErpApp
+  module Organizer
+    module Tasks
+      class BaseController < ::ErpApp::Organizer::BaseController
+
+        def menu
+          render :json => [{:text => 'Menu Item', :leaf => true, :iconCls => 'icon-note_pinned', :applicationCardId => "tasks_example_panel"}]
+        end
+
+      end #BaseController
+    end #Tasks
+  end #Organizer
+end #ErpApp

data/app/controllers/erp_work_effort/erp_app/organizer/tasks/work_efforts_controller.rb

@@ -0,0 +1,128 @@
+module ErpWorkEffort
+  module ErpApp
+    module Organizer
+      module Tasks
+        class WorkEffortsController < ::ErpApp::Organizer::BaseController
+
+          def role_types
+            data = RoleType.iid('task_master').self_and_descendants.collect{|item| item.to_hash(:only => [:id, :description])}
+
+            render :json => {success: true, role_types: data}
+          end
+
+          def work_effort_types
+            data = WorkEffortType.all.collect{|item| item.to_hash(:only => [:id, :description])}
+
+            render :json => {success: true, work_effort_types: data}
+          end
+
+          def task_count
+            party = params[:party_id].blank? ? nil : Party.find(params[:party_id])
+
+            if party
+              work_efforts_statement = WorkEffort.work_efforts_for_party(party, 'pending')
+            else
+              work_efforts_statement = WorkEffort.work_efforts_for_party(current_user.party, 'pending')
+            end
+
+            count = work_efforts_statement.count
+
+            render :json => {success: true, count: count}
+          end
+
+          def index
+            offset = params[:offset] || 0
+            limit = params[:limit] || 25
+            party = params[:party_id].blank? ? nil : Party.find(params[:party_id])
+            all_tasks = params[:all_tasks].blank? ? false : true
+
+            if all_tasks
+              work_efforts_statement = WorkEffort
+            elsif party
+              work_efforts_statement = WorkEffort.work_efforts_for_party(party)
+            else
+              work_efforts_statement = WorkEffort.work_efforts_for_party(current_user.party)
+            end
+
+            total = work_efforts_statement.count
+            work_efforts = work_efforts_statement.limit(limit).offset(offset)
+
+            work_efforts.sort!
+
+            data = work_efforts.sort.collect { |item| item.to_hash(
+                :only => [
+                    :id,
+                    :description,
+                    :created_at,
+                    :current_status,
+                    ],
+                :current_status_description => (TrackedStatusType.find_by_internal_identifier(item.current_status).description),
+                :assigned_parties => item.assigned_parties,
+                :assigned_roles => item.assigned_roles
+              )
+            }
+
+            render :json => {:success => true, :total => total, :work_efforts => data}
+          end
+
+          def create
+            result = {}
+
+            begin
+              ActiveRecord::Base.transaction do
+                estimated_completion_time = params[:estimated_completion_time].to_i
+                description = params[:description].strip
+                work_effort_type_id = params[:work_effort_type]
+
+                work_effort_type = WorkEffortType.find(work_effort_type_id)
+
+                work_effort = WorkEffort.new
+                work_effort.work_effort_type = work_effort_type
+                work_effort.description = description
+                work_effort.projected_completion_time = estimated_completion_time
+                work_effort.save
+
+                work_effort.current_status = 'pending'
+
+                unless params[:assignment_type_role].blank?
+                  role_type = RoleType.find(params[:role_type])
+
+                  work_effort.role_types << role_type
+
+                end
+
+                unless params[:assignment_type_party].blank?
+                  party = Party.find(params[:assigned_party_id])
+
+                  work_effort_party_assignment = WorkEffortPartyAssignment.new
+                  work_effort_party_assignment.party = party
+                  work_effort_party_assignment.role_type = RoleType.iid('worker')
+
+                  work_effort.work_effort_party_assignments << work_effort_party_assignment
+                end
+
+                work_effort.save
+
+                result = {:success => true, :message => "Task Added"}
+
+              end
+            rescue => ex
+              Rails.logger.error ex.message
+              Rails.logger.error ex.backtrace.join("\n")
+              result = {:success => false, :message => "Error adding task"}
+            end
+
+            render :json => result
+          end
+
+          def destroy
+            work_effort = WorkEffort.find(params[:id])
+
+            render :json => {:success => work_effort.destroy}
+          end
+
+        end #WorkEffortsController
+      end #Tasks
+    end #Organizer
+  end #ErpApp
+end #ErpWorkEffort

data/app/models/associated_transportation_route.rb

@@ -0,0 +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]
+# end
+class AssociatedTransportationRoute < ActiveRecord::Base
+	attr_protected :created_at, :updated_at
+
+  belongs_to :transportation_route
+  belongs_to :associated_record, :polymorphic => true
+end

data/app/models/associated_work_effort.rb

@@ -0,0 +1,12 @@
+# EXAMPLE USAGE of has_many_polymorphic with AssociatedWorkEffort 
+# WorkEffort.class_eval do     
+#     has_many_polymorphic :associated_records,
+#                :through => :associated_work_efforts,
+#                :models => [:shipment_items]    
+# end
+class AssociatedWorkEffort < ActiveRecord::Base
+  attr_protected :created_at, :updated_at
+
+  belongs_to :work_effort
+  belongs_to :associated_record, :polymorphic => true
+end

data/app/models/deliverable.rb

@@ -0,0 +1,7 @@
+class Deliverable < ActiveRecord::Base
+  attr_protected :created_at, :updated_at
+
+  belongs_to :deliverable_type
+  belongs_to :deliverable_record, :polymorphic => true
+
+end

data/app/models/deliverable_type.rb

@@ -0,0 +1,9 @@
+class DeliverableType < ActiveRecord::Base
+  attr_protected :created_at, :updated_at
+
+  acts_as_nested_set
+  include ErpTechSvcs::Utils::DefaultNestedSetMethods
+
+  has_many :deliverables
+
+end

data/app/models/extensions/party.rb

@@ -1,5 +1,3 @@
 Party.class_eval do
   has_many :resource_availabilities, :class_name => 'PartyResourceAvailability', :dependent => :destroy
-  has_many :assigned_to_work_efforts, :as => 'assigned_to', :class_name => 'WorkEffortAssignment', :dependent => :destroy
-  has_many :assigned_by_work_efforts, :as => 'assigned_by', :class_name => 'WorkEffortAssignment', :dependent => :destroy
 end

data/app/models/good_type.rb

@@ -0,0 +1,11 @@
+## Types of goods required as a standard for the completion of work efforts. This is different from
+## inventory_items because it is not for planning. It is only for noting the type of good
+## that is required to perform the work effort. - See DMRB v1, pp 223-224
+
+class GoodType < ActiveRecord::Base
+  attr_protected :created_at, :updated_at
+
+  acts_as_nested_set
+  include ErpTechSvcs::Utils::DefaultNestedSetMethods
+
+end

data/app/models/party_fixed_asset_assignment.rb

@@ -0,0 +1,12 @@
+## Relationship between Parties and Fixed Assets to see who may been assigned or checked out
+## an asset.
+## IMPORTANT NOTE: The base framework does not extend Party or Fixed Asset to automatically show these
+## relationships. It is considered purpose-specific enough so that Party and Fixed asset can be given
+## the relationship code on a case-by-case basis.
+
+class PartyFixedAssetAssignment < ActiveRecord::Base
+  attr_protected :created_at, :updated_at
+
+  belongs_to  :party
+  belongs_to  :fixed_asset
+end

data/app/models/party_skill.rb

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

data/app/models/requirement.rb

@@ -0,0 +1,14 @@
+class Requirement < ActiveRecord::Base
+  attr_protected :created_at, :updated_at
+
+  has_many :requirement_party_roles, :dependent => :destroy
+  has_many :parties, :through => :requirement_party_roles
+
+  #link to support the relationship between requirements and the work_efforts necessary to fulfill them
+  has_many  :work_requirement_fulfillments
+  has_many  :work_efforts, :through => :work_requirement_fulfillments
+
+  belongs_to :requirement_type
+  belongs_to :requirement_record, :polymorphic => true
+
+end

data/app/models/requirement_party_role.rb

@@ -0,0 +1,8 @@
+class RequirementPartyRole < ActiveRecord::Base
+  attr_protected :created_at, :updated_at
+
+  belongs_to :party
+  belongs_to :role_type
+  belongs_to :requirement
+
+end

data/app/models/requirement_type.rb

@@ -0,0 +1,7 @@
+class RequirementType < ActiveRecord::Base
+  attr_protected :created_at, :updated_at
+
+  acts_as_nested_set
+  include ErpTechSvcs::Utils::DefaultNestedSetMethods
+
+end

data/app/models/skill_type.rb

@@ -0,0 +1,10 @@
+class SkillType < ActiveRecord::Base
+  attr_protected :created_at, :updated_at
+
+  acts_as_nested_set
+  include ErpTechSvcs::Utils::DefaultNestedSetMethods
+
+  has_many  :party_skills
+  has_many  :parties, :through => :party_skills
+
+end

data/app/models/transportation_route.rb

@@ -0,0 +1,71 @@
+class TransportationRoute < ActiveRecord::Base
+  attr_protected :created_at, :updated_at
+
+  #declare array to related models
+  attr_accessor :associated_records_array
+
+  # This class instance variable is needed to hold the models linked within :associated_transportation_routes
+  class << self; attr_accessor :associated_models end
+  @associated_models = []
+
+  # Needed for polymorophic relationship with other models
+  has_many :associated_transportation_routes, :dependent => :destroy
+
+  has_many :segments, :class_name => "TransportationRouteSegment", :after_add => :modify_stops, :dependent => :destroy
+  has_many :stops, :class_name => "TransportationRouteStop", :dependent => :destroy
+
+  #before we save this model make sure you save all the relationships.
+  before_save do |record|
+    record.send("associated_records").each do |reln_record|
+      #handle STI get superclass class_name if not sub class of ActiveRecord::Base
+      klass_name = (reln_record.class.superclass == ActiveRecord::Base) ? reln_record.class.name : reln_record.class.superclass.name
+      conditions = "associated_record_id = #{reln_record.id} and associated_record_type = '#{klass_name}'"
+      exisiting_record = record.send("associated_transportation_routes").where(conditions).first
+
+      if exisiting_record.nil?
+        values_hash = {}
+        values_hash["#{record.class.name.underscore}_id"] = record.id
+        values_hash["associated_record_type"] = klass_name
+        values_hash["associated_record_id"] = reln_record.id
+        
+        AssociatedTransportationRoute.create(values_hash)
+      end
+    end
+  end
+
+  # Gets all associated records (of any class) tied to this route
+  def associated_records
+    #used the declared instance variable array
+    records = self.send("associated_records_array")
+    records = records || []
+    self.class.associated_models.each do |model|
+      records = records | self.send(model.to_s)
+    end
+      
+    #set it back to the instance variable
+    self.send("associated_records_array=", records)
+      
+    records
+  end
+
+  # Ties a segment's from/to stops to its route, and then forces a reload of the route's stops array from its cached value
+  def modify_stops(segment)
+  	stops = []
+  	stops << segment.from_stop << segment.to_stop
+
+  	stops.each do |stop|
+	  	unless stop.nil? or stop.route == self
+	  		stop.route = self
+	  		stop.save
+	  	end
+	  end
+
+	  # Force reload of the stops array since it has changed
+	  self.stops(true)
+  end
+
+  def test
+    puts self.name
+  end
+
+end

data/app/models/transportation_route_segment.rb

@@ -0,0 +1,9 @@
+class TransportationRouteSegment < ActiveRecord::Base
+  attr_protected :created_at, :updated_at
+
+  belongs_to :route, :class_name => "TransportationRoute", :foreign_key => "transportation_route_id"
+
+  belongs_to :from_stop, :class_name => "TransportationRouteStop", :foreign_key => "from_transportation_route_stop_id"
+  belongs_to :to_stop, :class_name => "TransportationRouteStop", :foreign_key => "to_transportation_route_stop_id"
+
+end

data/app/models/transportation_route_stop.rb

@@ -0,0 +1,6 @@
+class TransportationRouteStop < ActiveRecord::Base
+  attr_protected :created_at, :updated_at
+
+  belongs_to :route, :class_name => "TransportationRoute", :foreign_key => "transportation_route_id"
+
+end

data/app/models/work_effort.rb

@@ -3,45 +3,106 @@ class WorkEffort < ActiveRecord::Base
 
   acts_as_nested_set
   include ErpTechSvcs::Utils::DefaultNestedSetMethods
+  has_tracked_status
 
+  belongs_to :work_effort_item, :polymorphic => true
+
+  belongs_to :work_effort_type
+  belongs_to :work_effort_purpose_type
+
+  ## How is this Work Effort related to Work Order Items (order_line_items)
+  has_many :work_order_item_fulfillments, :dependent => :destroy
+  has_many :order_line_items, :through => :work_order_item_fulfillments
+
+  ## How is a work effort assigned, it can be assigned to party roles which allow for generic assignment.
+  has_and_belongs_to_many :role_types
+  alias :role_type_assignments :role_types
+
+  ## How is this Work Effort related to business parties, requestors, workers, approvers
+  has_many :work_effort_party_assignments, :dependent => :destroy
+  has_many :parties, :through => :work_effort_party_assignments
+
+  ## What Inventory Items are used in the execution of this Work Effort
+  has_many :work_effort_inventory_assignments, :dependent => :destroy
+  has_many :inventory_entries, :through => :work_effort_inventory_assignments
+
+  ## What Fixed Assets (tools, equipment) are used in the execution of this Work Effort
+  has_many :work_effort_fixed_asset_assignments, :dependent => :destroy
+  has_many :fixed_assets, :through => :work_effort_fixed_asset_assignments
+
+  ## Allow for polymorphic subtypes of this class
   belongs_to :work_effort_record, :polymorphic => true
-  belongs_to :facility, :polymorphic => true
-  has_many   :work_effort_assignments
-  has_many   :work_effort_statuses
 
-  belongs_to :projected_cost, :class_name => 'Cost', :foreign_key => 'projected_cost_id'
-  belongs_to :actual_cost, :class_name => 'Cost', :foreign_key => 'actual_cost_id'
-  #has_one    :work_effort_deliverable
+  belongs_to :projected_cost, :class_name => 'Money', :foreign_key => 'projected_cost_money_id'
+  belongs_to :actual_cost, :class_name => 'Money', :foreign_key => 'actual_cost_money_id'
+  belongs_to :facility
+
+  class << self
+    def work_efforts_for_party(party, status=nil)
+      role_types_tbl = RoleType.arel_table
+      parties_tbl = Party.arel_table
+
+      statement = self
+
+      # apply status if passed
+      statement = statement.with_status(status) if status
+
+      statement.includes(:role_types)
+      .includes(:parties)
+      .where(role_types_tbl[:id].in(party.party_roles.collect(&:role_type_id)).or(parties_tbl[:id].eq(party.id)))
+    end
+  end
+
+  def <=>(an_other)
+    case an_other.current_status
+      when 'pending'
+        1
+      when 'complete'
+        2
+      else
+        3
+    end
+  end
+
+  def assigned_parties(role_type='worker')
+    self.work_effort_party_assignments.where('role_type_id = ?', RoleType.iid(role_type)).collect do |item|
+      item.party.description
+    end.join(',')
+  end
+
+  def assigned_roles
+    self.role_types.collect(&:description).join(',')
+  end
 
-  #get current status
   def status
-    work_effort_status = self.descendants.flatten!.nil? ? self.get_current_status : self.descendants.flatten!.last.get_current_status
-    work_effort_status.work_effort_status_type.description
+    # get status via has_tracked_status
+    current_status
   end
 
   # return true if this effort has been started, false otherwise
   def started?
-    get_current_status.nil? ? false : true
+    current_status.nil? ? false : true
   end
-  
+
   # return true if this effort has been completed, false otherwise
   def completed?
     finished_at.nil? ? false : true
   end
-  
-  #start initial work_status
-  def start(status_type)
+
+  def finished?
+    completed?
+  end
+
+  #start work effort with initial_status (string)
+  def start(initial_status='')
     effort = self
     unless self.descendants.flatten!.nil?
       children = self.descendants.flatten
       effort = children.last
     end
 
-    current_status = effort.get_current_status
-
     if current_status.nil?
-      work_effort_status = WorkEffortStatus.create(:started_at => DateTime.now, :work_effort_status_type => status_type)
-      effort.work_effort_statuses << work_effort_status
+      effort.current_status = initial_status
       effort.started_at = DateTime.now
       effort.save
     else
@@ -49,88 +110,17 @@ class WorkEffort < ActiveRecord::Base
     end
   end
 
-  # completes current status if current status is in progress
-  # start status passed in
-  # if status passed in is last status, starts parent status if status exists
-  def send_to_status(status_type, complete_effort=false, complete_status=false)
-    current_status = get_current_status
-    
-    unless current_status.nil?
-      new_work_effort_status = WorkEffortStatus.new
-      new_work_effort_status.started_at = DateTime.now
-      new_work_effort_status.finished_at = new_work_effort_status.started_at if complete_status
-      new_work_effort_status.work_effort_status_type = status_type
-      new_work_effort_status.work_effort = self
-      new_work_effort_status.save
-      current_status.finished_at = DateTime.now
-      current_status.save
-      complete_work_effort if complete_effort
-    else
-      raise 'Effort Has Not Started'
-    end
-  end
-  
-  #completes current status
-  #start next status if not last status
-  #starts parent status if parent exists
-  def send_to_next_status
-    current_status = get_current_status
-
-    unless current_status.nil?
-      next_status_type = current_status.work_effort_status_type.next_status_type
-
-      if next_status_type.nil?
-        complete_work_effort
-      else
-        new_work_effort_status = WorkEffortStatus.new
-        new_work_effort_status.started_at = DateTime.now
-        new_work_effort_status.work_effort_status_type = next_status_type
-        new_work_effort_status.work_effort = self
-        new_work_effort_status.save
-      end
-
-      current_status.finished_at = DateTime.now
-      current_status.save
-    else
-      raise 'Effort Has Not Started' if current_status.nil?
-    end
-  end
-
-  def send_to_previous_status
-    current_status = get_current_status
-
-    unless current_status.nil?
-      previous_status_type = current_status.work_effort_status_type.previous_status_type
-
-      if previous_status_type.nil?
-        raise 'Current status is initial status' if current_status.nil?
-      else
-        new_work_effort_status = WorkEffortStatus.new
-        new_work_effort_status.started_at = DateTime.now
-        new_work_effort_status.work_effort_status_type = previous_status_type
-        new_work_effort_status.work_effort = self
-        new_work_effort_status.save
-      end
-
-      current_status.finished_at = DateTime.now
-      current_status.save
-    else
-      raise 'Effort Has Not Started' if current_status.nil?
-    end
+  def finish
+    complete
   end
 
-  def complete_work_effort
+  def complete
     self.finished_at = Time.now
     self.actual_completion_time = time_diff_in_minutes(self.finished_at.to_time, self.started_at.to_time)
     self.save
-    self.parent.start_effort unless self.parent.nil?
   end
 
   protected
-  def get_current_status
-    self.work_effort_statuses.find_by_finished_at(nil)
-  end
-
   def time_diff_in_minutes (time_one, time_two)
     (((time_one - time_two).round) / 60)
   end