erp_base_erp_svcs 4.0.0 → 4.2.0

data/lib/erp_base_erp_svcs/extensions/active_record/has_notes.rb

@@ -10,9 +10,10 @@ module ErpBaseErpSvcs
 				  def has_notes
 
             has_many :notes, :as => :noted_record, :dependent => :delete_all do
-              def by_type(note_type)
-                find_by_note_type_id(note_type.id)
+              def by_type(note_type_iid)
+                where('note_type_id = ?', NoteType.iid(note_type_iid))
               end
+
             end
 					
             extend SingletonMethods
@@ -26,13 +27,23 @@ module ErpBaseErpSvcs
 
 				module InstanceMethods
 
-          def create_or_update_note_by_type(note_type_iid='basic_note', content='', user=nil)
+          # adds note to model
+          def add_note(note_type_iid, content, party=nil)
+            note = Note.new
+            note.note_type = NoteType.iid(note_type_iid)
+            note.noted_record = self
+            note.created_by = party unless party.nil?
+            note.content = content
+            note if note.save
+          end
+
+          def create_or_update_note_by_type(note_type_iid='basic_note', content='', party=nil)
             note = note_by_type(note_type_iid)
             if note.nil?
               note = Note.new if note.nil?
               note.note_type_id = NoteType.find_by_internal_identifier(note_type_iid).id
               note.noted_record = self
-              note.created_by_id = user.id unless user.nil?
+              note.created_by_id = party unless party.nil?
             end
             note.content = content
             note.save

data/lib/erp_base_erp_svcs/extensions/active_record/has_party_roles.rb

@@ -0,0 +1,94 @@
+module ErpBaseErpSvcs
+  module Extensions
+    module ActiveRecord
+      module HasPartyRoles
+        def self.included(base)
+          base.extend(ClassMethods)
+        end
+
+        module ClassMethods
+          def has_party_roles
+            extend HasPartyRoles::SingletonMethods
+            include HasPartyRoles::InstanceMethods
+
+            has_many :entity_party_roles, :as => :entity_record, dependent: :destroy
+            has_many :role_types, :through => :entity_party_roles
+          end
+        end
+
+        module SingletonMethods
+          # Scope by a set of RoleTypes
+          #
+          # @param role_types [Integer | RoleType | Array] either a id of RoleType record, a RoleType record,
+          # an array of RoleType records or an array of RoleType ids
+          def with_party_role_types(role_types)
+            joins(:entity_party_roles)
+                .where(entity_party_roles: {role_type_id: role_types})
+          end
+
+          # Scope by a set of parties with the passed role_types
+          #
+          # @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 role_types [Integer | RoleType | Array] either a id of RoleType record, a RoleType record,
+          # an array of RoleType records or an array of RoleType ids
+          def with_party_role(parties, role_types)
+            joins(:entity_party_roles).where(entity_party_roles: {role_type_id: role_types})
+                .where(entity_party_roles: {party_id: parties})
+          end
+        end
+
+        module InstanceMethods
+          def add_party_with_role(party, role_type)
+            entity_party_role = EntityPartyRole.where(party_id: party,
+                                                      role_type_id: role_type,
+                                                      entity_record_id: self.id,
+                                                      entity_record_type: self.class.name).first
+
+            unless entity_party_role
+              entity_party_role = EntityPartyRole.create(party: party,
+                                                         role_type: role_type,
+                                                         entity_record: self)
+            end
+
+            entity_party_role
+          end
+
+          def remove_party_with_role(party, role_type)
+            entity_party_role = EntityPartyRole.where(party_id: party,
+                                                      role_type_id: role_type,
+                                                      entity_record_id: self.id,
+                                                      entity_record_type: self.class.name).first
+
+            if entity_party_role
+              entity_party_role.destroy
+            end
+          end
+
+          def find_parties_by_role(role_type)
+            if role_type.is_a?(String)
+              role_type = RoleType.iid(role_type)
+            end
+
+            entity_party_roles.where(role_type_id: role_type.id).collect(&:party)
+          end
+
+          def find_party_with_role(role_type)
+            if role_type.is_a?(String)
+              role_type = RoleType.iid(role_type)
+            end
+
+            entity_party_role = entity_party_roles.where(role_type_id: role_type.id).first
+
+            if entity_party_role
+              entity_party_role.party
+            else
+              nil
+            end
+          end
+        end
+
+      end # HasPartyRoles
+    end # ActiveRecord
+  end # Extensions
+end # ErpBaseErpSvcs

data/lib/erp_base_erp_svcs/extensions/active_record/has_tracked_status.rb

@@ -11,27 +11,89 @@ module ErpBaseErpSvcs
             extend HasTrackedStatus::SingletonMethods
             include HasTrackedStatus::InstanceMethods
 
-            has_many :status_applications, :as => :status_application_record, :dependent => :destroy
+            has_many :status_applications, :as => :status_application_record
 
-            scope :with_status, lambda { |status_type_iids|
-              joins(:status_applications => :tracked_status_type).
-                  where("status_applications.thru_date IS NULL AND tracked_status_types.internal_identifier IN (?)",
-                        status_type_iids)
-            }
-
-            scope :with_current_status, lambda {
-              model_table = self.arel_table
-              status_applications_tbl = StatusApplication.arel_table
-
-              #determine status_application_record_type
-              status_application_record_type = (self.superclass == ::ActiveRecord::Base) ? self.name.to_s : self.superclass.to_s
+            before_destroy :destroy_status_applications
 
-              current_status_select = status_applications_tbl.project(status_applications_tbl[:id].maximum)
-              .where(model_table[:id].eq(status_applications_tbl[:status_application_record_id])
-                     .and(status_applications_tbl[:status_application_record_type].eq(status_application_record_type)))
-
-              joins(:status_applications).where(status_applications_tbl[:id].in(current_status_select))
-            }
+            scope :with_status, lambda { |status_type_iids|
+                                joins(:status_applications => :tracked_status_type).
+                                    where("status_applications.thru_date IS NULL AND tracked_status_types.internal_identifier IN (?)",
+                                          status_type_iids)
+                              }
+
+            # scope record by its current status application
+            # status_type_iids can either be an Array of status to scope by or a Hash with the parent status
+            # as the key and the children statues to scope by as the value
+            scope :with_current_status, lambda { |status_type_iids=[]|
+                                        model_table = self.arel_table
+                                        status_applications_tbl = StatusApplication.arel_table
+
+                                        #determine status_application_record_type
+                                        status_application_record_type = (self.superclass == ::ActiveRecord::Base) ? self.name.to_s : self.superclass.to_s
+
+                                        current_status_select = status_applications_tbl.project(status_applications_tbl[:id].maximum)
+                                                                    .where(model_table[:id].eq(status_applications_tbl[:status_application_record_id])
+                                                                               .and(status_applications_tbl[:status_application_record_type].eq(status_application_record_type)))
+
+                                        statement = joins(:status_applications => :tracked_status_type).where(status_applications_tbl[:id].in(current_status_select))
+
+                                        if status_type_iids
+                                          status_ids = []
+
+                                          if status_type_iids.is_a?(Hash)
+                                            parent_status = TrackedStatusType.iid(status_type_iids.keys.first)
+                                            status_ids = parent_status.children.where(:internal_identifier => status_type_iids.values.first).pluck(:id)
+
+                                          elsif status_type_iids.is_a?(Array)
+                                            unless status_type_iids.empty?
+                                              status_ids = TrackedStatusType.where(:internal_identifier => status_type_iids).pluck(:id)
+                                            end
+                                          end
+
+                                          unless status_ids.empty?
+                                            statement = statement.where(TrackedStatusType.arel_table[:id].in status_ids)
+                                          end
+                                        end
+
+                                        statement
+                                      }
+
+            # scope record by its current status application and exclude records with the passed statuses
+            # status_type_iids can either be an Array of status to scope by or a Hash with the parent status
+            # as the key and the children statues to scope by as the value
+            scope :without_current_status, lambda { |status_type_iids=[]|
+                                           model_table = self.arel_table
+                                           status_applications_tbl = StatusApplication.arel_table
+
+                                           #determine status_application_record_type
+                                           status_application_record_type = (self.superclass == ::ActiveRecord::Base) ? self.name.to_s : self.superclass.to_s
+
+                                           current_status_select = status_applications_tbl.project(status_applications_tbl[:id].maximum)
+                                                                       .where(model_table[:id].eq(status_applications_tbl[:status_application_record_id])
+                                                                                  .and(status_applications_tbl[:status_application_record_type].eq(status_application_record_type)))
+
+                                           statement = joins(:status_applications => :tracked_status_type).where(status_applications_tbl[:id].in(current_status_select))
+
+                                           if status_type_iids
+                                             status_ids = []
+
+                                             if status_type_iids.is_a?(Hash)
+                                               parent_status = TrackedStatusType.iid(status_type_iids.keys.first)
+                                               status_ids = parent_status.children.where(:internal_identifier => status_type_iids.values.first).pluck(:id)
+
+                                             elsif status_type_iids.is_a?(Array)
+                                               unless status_type_iids.empty?
+                                                 status_ids = TrackedStatusType.where(:internal_identifier => status_type_iids).pluck(:id)
+                                               end
+                                             end
+
+                                             unless status_ids.empty?
+                                               statement = statement.where(TrackedStatusType.arel_table[:id].not_in status_ids)
+                                             end
+                                           end
+
+                                           statement
+                                         }
           end
         end
 
@@ -40,6 +102,12 @@ module ErpBaseErpSvcs
 
         module InstanceMethods
 
+          def destroy_status_applications
+            self.status_applications.each do |status_application|
+              status_application.destroy
+            end
+          end
+
           # does this status match the current_status?
           def has_status?(tracked_status_iid)
             current_status == tracked_status_iid
@@ -93,37 +161,52 @@ module ErpBaseErpSvcs
             self.current_status_type.internal_identifier unless self.current_status_type.nil?
           end
 
-          #set current status of entity.
-          #takes a TrackedStatusType internal_identifier and creates a StatusApplication
-          #with from_date set to today and tracked_status_type set to passed TrackedStatusType internal_identifier
-          #optionally can passed from_date and thru_date to manually set these
-          #it will set the thru_date on the current StatusApplication to now
+          # set current status of entity.
+          #
+          # @param args [String, TrackedStatusType, Array] This can be a string of the internal identifier of the
+          # TrackedStatusType to set, a TrackedStatusType instance, or three params the status, options and party_id
           def current_status=(args)
             options = {}
 
             if args.is_a?(Array)
               status = args[0]
               options = args[1]
+              party_id = args[2]
             else
               status = args
             end
+
             tracked_status_type = status.is_a?(TrackedStatusType) ? status : TrackedStatusType.find_by_internal_identifier(status.to_s)
             raise "TrackedStatusType does not exist #{status.to_s}" unless tracked_status_type
 
-            #set current StatusApplication thru_date to now
-            cta = self.current_status_application
-            unless cta.nil?
-              cta.thru_date = options[:thru_date].nil? ? Time.now : options[:thru_date]
-              cta.save
+            # if passed status is current status then do nothing
+            unless self.current_status_type && (self.current_status_type.id == tracked_status_type.id)
+              #set current StatusApplication thru_date to now
+              cta = self.current_status_application
+              unless cta.nil?
+                cta.thru_date = options[:thru_date].nil? ? Time.now : options[:thru_date]
+                cta.save
+              end
+
+              status_application = StatusApplication.new
+              status_application.tracked_status_type = tracked_status_type
+              status_application.from_date = options[:from_date].nil? ? Time.now : options[:from_date]
+              status_application.party_id = party_id
+              status_application.save
+
+              self.status_applications << status_application
+              self.save
             end
 
-            status_application = StatusApplication.new
-            status_application.tracked_status_type = tracked_status_type
-            status_application.from_date = options[:from_date].nil? ? Time.now : options[:from_date]
-            status_application.save
+          end
 
-            self.status_applications << status_application
-            self.save
+          def previous_status
+            result = self.status_applications.joins(:tracked_status_type).order("status_applications.id desc").limit(2).all
+            if result.count == 2
+              result[1].tracked_status_type.internal_identifier
+            else
+              nil
+            end
           end
 
           # add_status aliases current_status= for legacy support

data/lib/erp_base_erp_svcs/extensions/active_record/is_contact_mechanism.rb

@@ -0,0 +1,94 @@
+module ErpBaseErpSvcs
+  module Extensions
+    module ActiveRecord
+      module IsContactMechanism
+        def self.included(base)
+          base.extend(ClassMethods)
+        end
+
+        module ClassMethods
+          def is_contact_mechanism
+            extend IsContactMechanism::SingletonMethods
+            include IsContactMechanism::InstanceMethods
+
+            after_initialize :initialize_contact
+            after_create :save_contact
+            after_update :save_contact
+            after_destroy :destroy_contact
+
+            has_one :contact, :as => :contact_mechanism, :dependent => :destroy
+
+            [:purpose,
+             :purposes,
+             :is_primary,
+             :is_primary=,
+             :is_primary?].each { |m| delegate m, :to => :contact }
+          end
+        end
+
+        module SingletonMethods
+          # return all contact mechanism instances for parties
+          #
+          # @param parties [Array] Array of parties to get contacts for
+          # @param contact_purposes [Array] Array of ContactPurposes to look up
+          def for_parties(parties, contact_purposes=[])
+            query = self.joins(contact: [:contact_purposes])
+
+            unless contact_purposes.empty?
+              query = query.where(contact_purposes: {id: contact_purposes})
+            end
+
+            query.where(contacts: {contact_record_type: 'Party', contact_record_id: parties})
+          end
+        end
+
+        module InstanceMethods
+
+          def save_contact
+            self.contact.save
+          end
+
+          # return all contact purposes in one comma separated string
+          def contact_purposes_to_s
+            contact.contact_purposes.collect(&:description).join(', ')
+          end
+
+          def add_contact_purpose(contact_purpose)
+            unless contact_purpose.is_a?(ContactPurpose)
+              contact_purpose = ContactPurpose.iid(contact_purpose)
+            end
+
+            # don't add the contact purpose if its already there
+            unless contact_purpose_iids.include?(contact_purpose.internal_identifier)
+              contact.contact_purposes << contact_purpose
+              contact.save
+            end
+          end
+
+          # return all contact purpose iids in one comma separated string
+          def contact_purpose_iids
+            contact.contact_purposes.collect(&:internal_identifier).join(',')
+          end
+
+          # return all contact purposes
+          def contact_purposes
+            contact.contact_purposes
+          end
+
+          def destroy_contact
+            self.contact.destroy unless self.contact.nil?
+          end
+
+          def initialize_contact
+            if self.new_record? and self.contact.nil?
+              self.contact = Contact.new
+              self.contact.description = self.description
+            end
+          end
+
+        end
+
+      end #HasContact
+    end #ActiveRecord
+  end #Extensions
+end #ErpBaseErpSvcs

data/lib/erp_base_erp_svcs/extensions/active_record/is_describable.rb

@@ -1,44 +1,48 @@
 module ErpBaseErpSvcs
-	module Extensions
-		module ActiveRecord
-			module IsDescribable
-			
-				def self.included(base)
-					base.extend(ClassMethods)  	        	      	
-				end
-
-				module ClassMethods
-			  
-					def is_describable
-						has_many :descriptions, :class_name => 'DescriptiveAsset', :as => :described_record, :dependent => :destroy
-					
-						extend IsDescribable::SingletonMethods
-						include IsDescribable::InstanceMethods
-																		
-					end
-				end
-				
-				module SingletonMethods			
-				end
-						
-				module InstanceMethods
-				  def find_descriptions_by_view_type(view_iid)
-					self.descriptions.where('view_type_id = ?', ViewType.find_by_internal_identifier(view_iid).id)
-				  end
-
-				  def find_description_by_iid(iid)
-					self.descriptions.where('internal_identifier = ?', iid).first
-				  end
-
-				  def add_description(view_type, description)
-					descriptive_asset = DescriptiveAsset.create(
-					  :view_type => view_type,
-					  :description => description)
-					descriptive_asset.described_record = self
-					self.descriptions << descriptive_asset
-				  end
-				end
-			end
-		end
-	end
+  module Extensions
+    module ActiveRecord
+      module IsDescribable
+
+        def self.included(base)
+          base.extend(ClassMethods)
+        end
+
+        module ClassMethods
+
+          def is_describable
+            has_many :descriptions, :class_name => 'DescriptiveAsset', :as => :described_record, :dependent => :destroy
+
+            extend IsDescribable::SingletonMethods
+            include IsDescribable::InstanceMethods
+
+          end
+        end
+
+        module SingletonMethods
+        end
+
+        module InstanceMethods
+          def find_descriptions_by_view_type(view_iid)
+            self.descriptions.where('view_type_id = ?', ViewType.find_by_internal_identifier(view_iid).id).collect(&:description).join(' ')
+          end
+
+          def find_description_by_iid(iid)
+            self.descriptions.where('internal_identifier = ?', iid).first
+          end
+
+          def find_description_by_view_type(view_iid)
+            self.descriptions.where('view_type_id = ?', ViewType.find_by_internal_identifier(view_iid).id).first
+          end
+
+          def add_description(view_type, description)
+            descriptive_asset = DescriptiveAsset.create(
+                :view_type => view_type,
+                :description => description)
+            descriptive_asset.described_record = self
+            self.descriptions << descriptive_asset
+          end
+        end
+      end
+    end
+  end
 end