erp_base_erp_svcs 4.0.0 → 4.2.0

data/db/migrate/20130713171653_create_party_unit_of_measurements.rb

@@ -0,0 +1,28 @@
+class CreatePartyUnitOfMeasurements < ActiveRecord::Migration
+  def up
+    unless table_exists? :party_unit_of_measurements
+      create_table :party_unit_of_measurements do |t|
+
+        t.string :description
+        t.string :internal_identifier
+        t.string :scope_filter
+        t.references :party
+        t.references :unit_of_measurement
+
+        t.timestamps
+      end
+    end
+
+    unless index_exists? :party_unit_of_measurements, :party_id, name: 'party_uom_party_idx'
+      add_index :party_unit_of_measurements, :party_id, name: 'party_uom_party_idx'
+    end
+
+    unless index_exists? :party_unit_of_measurements, :unit_of_measurement_id, name: 'party_uom_uom_idx'
+      add_index :party_unit_of_measurements, :unit_of_measurement_id, name: 'party_uom_uom_idx'
+    end
+  end
+
+  def down
+    drop_table :party_unit_of_measurements
+  end
+end

data/db/migrate/20150716201200_add_record_to_contact.rb

@@ -0,0 +1,42 @@
+class AddRecordToContact < ActiveRecord::Migration
+  def up
+    add_column :contacts, :contact_record_type, :string unless column_exists? :contacts, :contact_record_type
+    add_column :contacts, :contact_record_id, :integer unless column_exists? :contacts, :contact_record_id
+
+    if column_exists? :contacts, :party_id
+      Contact.find_in_batches do |batch|
+        batch.each do |contact|
+          contact.contact_record = Party.find contact.party_id
+          contact.save
+        end
+      end
+    end
+
+    remove_column :contacts, :party_id if column_exists? :contacts, :party_id
+
+    add_index :contacts, [:contact_record_type, :contact_record_id], name: 'contacts_contact_record_idx' unless index_exists? :contacts, name: 'contacts_record_idx'
+  end
+
+  def down
+    remove_column :contacts, :contact_record_type if column_exists? :contacts, :contact_record_type
+    remove_column :contacts, :contact_record_id if column_exists? :contacts, :contact_record_id
+
+    add_column :contacts, :party_id, :integer unless column_exists? :contacts, :party_id
+
+    if column_exists? :contacts, :record_id
+
+      Contact.find_in_batches do |batch|
+        batch.each do |contact|
+          record = contact.contact_record
+          if record and record.is_a? Party
+            contact.party_id = record.id
+            contact.save
+          end
+
+        end
+      end
+    end
+
+    remove_index :contacts, name: 'contacts_contact_record_idx' if index_exists? :contacts, name: 'contacts_contact_record_idx'
+  end
+end

data/db/migrate/20150814202823_add_party_id_to_status_application.rb

@@ -0,0 +1,10 @@
+class AddPartyIdToStatusApplication < ActiveRecord::Migration
+  def up
+    add_column :status_applications, :party_id, :integer unless column_exists? :status_applications, :party_id
+    add_index :status_applications, :party_id, name: 'status_application_party_idx' unless index_exists? :status_applications, 'status_application_party_idx'
+  end
+
+  def down
+    remove_column :status_applications, :party_id if column_exists? :status_applications, :party_id
+  end
+end

data/db/migrate/20160310163040_add_created_by_updated_by_to_erp_base_erp_svcs.rb

@@ -0,0 +1,44 @@
+class AddCreatedByUpdatedByToErpBaseErpSvcs < ActiveRecord::Migration
+  def up
+    %w{parties
+       contacts
+       descriptive_assets
+       notes
+       unit_of_measurements
+       }.each do |table|
+
+      unless column_exists? table.to_sym, :created_by_party_id
+        add_column table.to_sym, :created_by_party_id, :integer
+
+        add_index table.to_sym, :created_by_party_id, name: "#{table}_created_by_pty_idx"
+      end
+
+      unless column_exists? table.to_sym, :updated_by_party_id
+        add_column table.to_sym, :updated_by_party_id, :integer
+
+        add_index table.to_sym, :updated_by_party_id, name: "#{table}_updated_by_pty_idx"
+      end
+
+    end
+
+  end
+
+  def down
+    %w{parties
+       contacts
+       descriptive_assets
+       notes
+       unit_of_measurements}.each do |table|
+
+      if column_exists? table.to_sym, :created_by_party_id
+        remove_column table.to_sym, :created_by_party_id
+      end
+
+      if column_exists? table.to_sym, :updated_by_party_id
+        remove_column table.to_sym, :updated_by_party_id
+      end
+    end
+
+  end
+
+end

data/lib/erp_base_erp_svcs.rb

@@ -3,6 +3,7 @@ require "erp_base_erp_svcs/extensions"
 require "erp_base_erp_svcs/ar_fixtures"
 require "erp_base_erp_svcs/config"
 require "erp_base_erp_svcs/non_escape_json_string"
+require "erp_base_erp_svcs/time_zone_helper"
 
 module ErpBaseErpSvcs
   class << self

data/lib/erp_base_erp_svcs/config.rb

@@ -1,11 +1,12 @@
 module ErpBaseErpSvcs
   module Config
     class << self
-      attr_accessor :compass_ae_engines
+      attr_accessor :compass_ae_engines, :encryption_key
 
       def init!
         @defaults = {
-          :@compass_ae_engines => []
+          :@compass_ae_engines => [],
+          :@encryption_key => '314465fe-9c2b-11e4-89d3-123b93f75cba'
         }
       end
 

data/lib/erp_base_erp_svcs/engine.rb

@@ -7,6 +7,8 @@ module ErpBaseErpSvcs
   class Engine < Rails::Engine
     isolate_namespace ErpBaseErpSvcs
 
+    Mime::Type.register "tree", :tree
+
     config.erp_base_erp_svcs = ErpBaseErpSvcs::Config
 
     ActiveSupport.on_load(:active_record) do
@@ -15,9 +17,14 @@ module ErpBaseErpSvcs
       include ErpBaseErpSvcs::Extensions::ActiveRecord::ActsAsNoteType
       include ErpBaseErpSvcs::Extensions::ActiveRecord::ActsAsErpType
       include ErpBaseErpSvcs::Extensions::ActiveRecord::ActsAsCategory
-      include ErpBaseErpSvcs::Extensions::ActiveRecord::HasContact
+      include ErpBaseErpSvcs::Extensions::ActiveRecord::IsContactMechanism
       include ErpBaseErpSvcs::Extensions::ActiveRecord::ActsAsFixedAsset
       include ErpBaseErpSvcs::Extensions::ActiveRecord::ActsAsFacility
+      include ErpBaseErpSvcs::Extensions::ActiveRecord::CanBeGenerated
+      include ErpBaseErpSvcs::Extensions::ActiveRecord::HasPartyRoles
+      include ErpBaseErpSvcs::Extensions::ActiveRecord::HasContacts
+      include ErpBaseErpSvcs::Extensions::ActiveRecord::TracksCreatedByUpdatedBy
+      include ErpBaseErpSvcs::Extensions::ActiveRecord::IsTenantable
       extend ErpBaseErpSvcs::Extensions::ActiveRecord::StiInstantiation::ActMacro
     end
 

data/lib/erp_base_erp_svcs/extensions.rb

@@ -3,6 +3,7 @@ require 'erp_base_erp_svcs/extensions/core/array'
 require 'erp_base_erp_svcs/extensions/core/hash'
 require 'erp_base_erp_svcs/extensions/core/numbers'
 require 'erp_base_erp_svcs/extensions/core/object'
+require 'erp_base_erp_svcs/extensions/core/string'
 require 'erp_base_erp_svcs/extensions/core/acts_as_aspector_on'
 
 #active record extensions
@@ -12,10 +13,15 @@ require 'erp_base_erp_svcs/extensions/active_record/has_tracked_status'
 require 'erp_base_erp_svcs/extensions/active_record/has_notes'
 require 'erp_base_erp_svcs/extensions/active_record/acts_as_note_type'
 require 'erp_base_erp_svcs/extensions/active_record/is_describable'
-require 'erp_base_erp_svcs/extensions/active_record/has_contact'
+require 'erp_base_erp_svcs/extensions/active_record/is_contact_mechanism'
 require 'erp_base_erp_svcs/extensions/active_record/sti_instantiation'
 require 'erp_base_erp_svcs/extensions/active_record/to_hash'
 require 'erp_base_erp_svcs/extensions/active_record/migration'
 require 'erp_base_erp_svcs/extensions/active_record/acts_as_fixed_asset'
 require 'erp_base_erp_svcs/extensions/active_record/acts_as_facility'
+require 'erp_base_erp_svcs/extensions/active_record/can_be_generated'
+require 'erp_base_erp_svcs/extensions/active_record/has_party_roles'
+require 'erp_base_erp_svcs/extensions/active_record/has_contacts'
+require 'erp_base_erp_svcs/extensions/active_record/tracks_created_by_updated_by'
+require 'erp_base_erp_svcs/extensions/active_record/is_tenantable'
 

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

@@ -44,7 +44,8 @@ module ErpBaseErpSvcs
             end
 				  end
 				end
-			end
-		end
-	end
-end
+			end # ActsAsCategory
+    end # ActiveRecord
+  end # Extensions
+end # ErpBaseErpSvcs
+

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

@@ -2,9 +2,16 @@ module ErpBaseErpSvcs
 	module Extensions
 		module ActiveRecord
 			module ActsAsErpType
+
+        @@models = []
+
 				def self.included(base)
 				  base.extend(ClassMethods) 	        	      	
-				end
+        end
+
+        def self.models
+          @@models
+        end
 
 				# declare the class level helper methods which
 				# will load the relevant instance methods
@@ -20,7 +27,7 @@ module ErpBaseErpSvcs
 							
             if ::ActiveRecord::Base.connection.tables.include?(self.table_name)
               # find each valid value for the domain type (erp_type) in question
-              # we will then create a class method with the name of the internal idenfifier
+              # we will then create a class method with the name of the internal indentifier
               # for that type
               valid_values = self.all
 							
@@ -29,6 +36,9 @@ module ErpBaseErpSvcs
                 (class << self; self; end).instance_eval { define_method vv.internal_identifier, Proc.new{vv} } unless vv.internal_identifier.nil?
               end
             end
+
+            ActsAsErpType.models.push(self.name)
+            ActsAsErpType.models.uniq!
 				  end
 
 				  def belongs_to_erp_type(model_id = nil, options = {})
@@ -60,7 +70,26 @@ module ErpBaseErpSvcs
 							
 				  def iid( internal_identifier_string )
             where('internal_identifier = ?', internal_identifier_string.to_s).first
-				  end
+          end
+
+          def generate_unique_iid(name)
+            iid = name.to_iid
+
+            iid_exists = true
+            iid_test = iid
+            iid_counter = 1
+            while iid_exists
+              if self.where(internal_identifier: iid_test).first
+                iid_test = "#{iid}_#{iid_counter}"
+                iid_counter += 1
+              else
+                iid_exists = false
+                iid = iid_test
+              end
+            end
+
+            iid
+          end
 						
 				end
 
@@ -120,16 +149,26 @@ module ErpBaseErpSvcs
 							
             where(fk_str + ' in (?)', in_clause_array)
 							
-				  end			
-				end
+          end
+
+        end
 
 					
 				# Adds instance methods.
 				module ActsAsInstanceMethods
-						
-				  # def instance_method_for_acts_as
-				  #   puts "Instance with ID #{self.id}"
-				  # end
+
+          def to_s
+            self.try(:description) ? self.try(:description) : self.try(:id)
+          end
+
+          # Alias for to_s
+          def to_label
+            to_s
+          end
+
+          def to_data_hash
+            to_hash(only: [:id, :description, :internal_identifier, :created_at, :updated_at])
+          end
 					  
 				end
 

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

@@ -0,0 +1,54 @@
+module ErpBaseErpSvcs
+  module Extensions
+    module ActiveRecord
+      module CanBeGenerated
+        def self.included(base)
+          base.extend(ClassMethods)
+        end
+
+        module ClassMethods
+          def can_be_generated
+            extend CanBeGenerated::SingletonMethods
+            include CanBeGenerated::InstanceMethods
+
+            has_many :generated_items, :as => :generated_record
+          end
+        end # ClassMethods
+
+        module SingletonMethods
+
+          def items_generated_by(record)
+            entity_record_type = (record.class.superclass == ::ActiveRecord::Base) ? record.class.name.to_s : record.class.superclass.to_s
+
+            joins(:generated_items)
+                .where('generated_items.generated_by_type = ?', entity_record_type)
+                .where('generated_items.generated_by_id = ?', record.id)
+          end
+
+        end # SingletonMethods
+
+        module InstanceMethods
+          def generated_by
+            if generated_items.length == 1
+              generated_items.first.generated_by
+            else
+              generated_items.collect(&:generated_by)
+            end
+          end
+
+          def generated_by=(record)
+            if record.is_a?(Array)
+              record.each do |item|
+                GeneratedItem.create(generated_record: self, generated_by: item)
+              end
+            else
+              GeneratedItem.create(generated_record: self, generated_by: record)
+            end
+          end
+
+        end # InstanceMethods
+
+      end # CanBeGenerated
+    end # ActiveRecord
+  end # Extensions
+end # ErpBaseErpSvcs

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

@@ -0,0 +1,383 @@
+module ErpBaseErpSvcs
+  module Extensions
+    module ActiveRecord
+      module HasContacts
+
+        def self.included(base)
+          base.extend(ClassMethods)
+        end
+
+        module ClassMethods
+          def has_contacts
+            extend HasContacts::SingletonMethods
+            include HasContacts::InstanceMethods
+
+            after_initialize :build_contact_methods
+
+            has_many :contacts, :as => :contact_record, :dependent => :destroy
+
+          end
+        end
+
+        module SingletonMethods
+
+          def find_by_email(email, contact_purpose=nil)
+            if contact_purpose
+              self.joins(:contacts => [:contact_purposes])
+                  .joins("INNER JOIN email_addresses on email_addresses.id = contacts.contact_mechanism_id
+                and contacts.contact_mechanism_type = 'EmailAddress'")
+                  .where('contact_mechanism_type = ?', 'EmailAddress')
+                  .where('contact_purposes.internal_identifier = ?', contact_purpose)
+                  .where('email_address = ?', email).readonly(false).first
+            else
+              self.joins(:contacts)
+                  .joins("INNER JOIN email_addresses on email_addresses.id = contacts.contact_mechanism_id
+                and contacts.contact_mechanism_type = 'EmailAddress'")
+                  .where('contact_mechanism_type = ?', 'EmailAddress')
+                  .where('email_address = ?', email).readonly(false).first
+            end
+          end
+
+        end
+
+        module InstanceMethods
+
+          def postal_addresses
+            find_all_contacts_by_contact_mechanism(PostalAddress)
+          end
+
+          def emails
+            find_all_contacts_by_contact_mechanism(EmailAddress)
+          end
+
+          def phone_numbers
+            find_all_contacts_by_contact_mechanism(PhoneNumber)
+          end
+
+          def has_phone_number?(phone_number)
+            result = nil
+            self.contacts.each do |c|
+              if c.contact_mechanism_type == 'PhoneNumber'
+                if c.contact_mechanism.phone_number == phone_number
+                  result = true
+                end
+              end
+            end
+            result
+          end
+
+          def has_zip_code?(zip)
+            result = nil
+            self.contacts.each do |c|
+              if c.contact_mechanism_type == 'PostalAddress'
+                if c.contact_mechanism.zip == zip
+                  result = true
+                end
+              end
+            end
+            result
+          end
+
+          # Check if record has contact with purpose
+          #
+          # @param contact_mechanism_klass [Class] the contact mechanism class (Email, PhoneNumber, PostalAddress)
+          #  the passed contact purposes)
+          #
+          # @return result [Boolean] True if record has contact false if not
+          def has_contact?(contact_mechanism_klass, contact_purpose)
+            !contact_mechanisms_to_hash(contact_mechanism_klass, [contact_purpose]).empty?
+          end
+
+          # Converts PhoneNumber contact mechanisms related to this record to an array of hashes
+          # containing the contact records data
+          #
+          # @param contact_purposes [Array] an array of contact purposes to filter by (only return contacts with
+          #  the passed contact purposes)
+          #
+          # @return contact_mechanisms_data [Array] an Array of hashes containing contact data
+          def phone_numbers_to_hash(contact_purposes=nil)
+            contact_mechanisms_to_hash(PhoneNumber, contact_purposes)
+          end
+
+          # Converts EmailAddress contact mechanisms related to this record to an array of hashes
+          # containing the contact records data
+          #
+          # @param contact_purposes [Array] an array of contact purposes to filter by (only return contacts with
+          #  the passed contact purposes)
+          #
+          # @return contact_mechanisms_data [Array] an Array of hashes containing contact data
+          def email_addresses_to_hash(contact_purposes=nil)
+            contact_mechanisms_to_hash(EmailAddress, contact_purposes)
+          end
+
+          # Converts PostalAddress contact mechanisms related to this record to an array of hashes
+          # containing the contact records data
+          #
+          # @param contact_purposes [Array] an array of contact purposes to filter by (only return contacts with
+          #  the passed contact purposes)
+          #
+          # @return contact_mechanisms_data [Array] an Array of hashes containing contact data
+          def postal_addresses_to_hash(contact_purposes=nil)
+            contact_mechanisms_to_hash(PostalAddress, contact_purposes)
+          end
+
+          # Converts contact mechanisms related to this record to an array of hashes
+          # containing the contact records data
+          #
+          # @param contact_mechanism_klass [Class] the contact mechanism class (Email, PhoneNumber, PostalAddress)
+          # @param contact_purposes [Array] an array of contact purposes to filter by (only return contacts with
+          #  the passed contact purposes)
+          #
+          # @return contact_mechanisms_data [Array] an Array of hashes containing contact data
+          def contact_mechanisms_to_hash(contact_mechanism_klass, contact_purposes=nil)
+            contact_mechanisms_data = []
+
+            # if the passed contact purpose is a string convert to an Array
+            if contact_purposes && contact_purposes.is_a?(String)
+              contact_purposes = [contact_purposes]
+            end
+
+            if contact_purposes
+              contact_purposes.each do |contact_purpose|
+                contact_mechanisms = find_contact_mechanisms_with_purpose(contact_mechanism_klass, contact_purpose)
+
+                unless contact_mechanisms.empty?
+                  contact_mechanisms.collect do |item|
+                    data = item.to_data_hash
+                    data[:contact_purpose] = contact_purpose
+
+                    contact_mechanisms_data.push(data)
+                  end
+                end
+              end
+            else
+              contact_mechanisms = find_all_contacts_by_contact_mechanism(contact_mechanism_klass)
+              contact_mechanisms.each do |contact_mechanism|
+                data = contact_mechanism.to_data_hash
+                data[:contact_purpose] = contact_mechanism.contact.contact_purpose.first.internal_identifier
+
+                contact_mechanisms_data.push(data)
+              end
+            end
+
+            contact_mechanisms_data
+          end
+
+          def primary_phone_number
+            contact_mechanism = nil
+
+            contact = self.get_primary_contact(PhoneNumber)
+            contact_mechanism = contact.contact_mechanism unless contact.nil?
+
+            contact_mechanism
+          end
+
+          alias primary_phone primary_phone_number
+
+          def primary_phone_number=(phone_number)
+            self.set_primary_contact(PhoneNumber, phone_number)
+          end
+
+          alias primary_phone= primary_phone_number=
+
+          def primary_email_address
+            contact_mechanism = nil
+
+            contact = self.get_primary_contact(EmailAddress)
+            contact_mechanism = contact.contact_mechanism unless contact.nil?
+
+            contact_mechanism
+          end
+
+          alias primary_email primary_email_address
+
+          def primary_email_address=(email_address)
+            self.set_primary_contact(EmailAddress, email_address)
+          end
+
+          alias primary_email= primary_email_address=
+
+          def primary_postal_address
+            contact_mechanism = nil
+
+            contact = self.get_primary_contact(PostalAddress)
+            contact_mechanism = contact.contact_mechanism unless contact.nil?
+
+            contact_mechanism
+          end
+
+          alias primary_address primary_postal_address
+
+          def primary_postal_address=(postal_address)
+            self.set_primary_contact(PostalAddress, postal_address)
+          end
+
+          alias primary_address= primary_postal_address=
+
+          def set_primary_contact(contact_mechanism_class, contact_mechanism_instance)
+            # set is_primary to false for any current primary contacts of this type
+            primary_contact_mechanism = get_primary_contact(contact_mechanism_class)
+            if primary_contact_mechanism
+              primary_contact_mechanism.is_primary = false
+              primary_contact_mechanism.save!
+            end
+
+            contact_mechanism_instance.is_primary = true
+            contact_mechanism_instance.save!
+
+            contact_mechanism_instance
+          end
+
+          def get_primary_contact(contact_mechanism_class)
+            table_name = contact_mechanism_class.name.tableize
+
+            self.contacts.joins("inner join #{table_name} on #{table_name}.id = contact_mechanism_id and contact_mechanism_type = '#{contact_mechanism_class.name}'")
+                .where('contacts.is_primary = ?', true).readonly(false).first
+          end
+
+          # find first contact mechanism with purpose
+          def find_contact_mechanism_with_purpose(contact_mechanism_class, contact_purpose)
+            contact = self.find_contact_with_purpose(contact_mechanism_class, contact_purpose)
+
+            contact.contact_mechanism unless contact.nil?
+          end
+
+          # find all contact mechanisms with purpose
+          def find_contact_mechanisms_with_purpose(contact_mechanism_class, contact_purpose)
+            contacts = self.find_contacts_with_purpose(contact_mechanism_class, contact_purpose)
+
+            contacts.empty? ? [] : contacts.collect(&:contact_mechanism)
+          end
+
+          # find first contact with purpose
+          def find_contact_with_purpose(contact_mechanism_class, contact_purpose)
+            #if a symbol or string was passed get the model
+            unless contact_purpose.is_a? ContactPurpose
+              contact_purpose = ContactPurpose.find_by_internal_identifier(contact_purpose.to_s)
+            end
+
+            self.find_contact(contact_mechanism_class, nil, [contact_purpose])
+          end
+
+          def has_contact_with_purpose?(contact_mechanism_class, contact_purpose)
+            !find_contact_with_purpose(contact_mechanism_class, contact_purpose).nil?
+          end
+
+          # find all contacts with purpose
+          def find_contacts_with_purpose(contact_mechanism_class, contact_purpose)
+            #if a symbol or string was passed get the model
+            unless contact_purpose.is_a? ContactPurpose
+              contact_purpose = ContactPurpose.find_by_internal_identifier(contact_purpose.to_s)
+            end
+
+            self.find_contacts(contact_mechanism_class, nil, [contact_purpose])
+          end
+
+          # find all contacts by contact mechanism
+          def find_all_contacts_by_contact_mechanism(contact_mechanism_class)
+            table_name = contact_mechanism_class.name.tableize
+
+            contacts = self.contacts.joins("inner join #{table_name} on #{table_name}.id = contact_mechanism_id and contact_mechanism_type = '#{contact_mechanism_class.name}'")
+
+            contacts.collect(&:contact_mechanism)
+          end
+
+          # find first contact
+          def find_contact(contact_mechanism_class, contact_mechanism_args={}, contact_purposes=[])
+            find_contacts(contact_mechanism_class, contact_mechanism_args, contact_purposes).first
+          end
+
+          # find all contacts
+          def find_contacts(contact_mechanism_class, contact_mechanism_args={}, contact_purposes=[])
+            table_name = contact_mechanism_class.name.tableize
+
+            query = self.contacts.joins("inner join #{table_name} on #{table_name}.id = contact_mechanism_id and contact_mechanism_type = '#{contact_mechanism_class.name}'
+                                   inner join contact_purposes_contacts on contact_purposes_contacts.contact_id = contacts.id
+                                   and contact_purposes_contacts.contact_purpose_id in (#{contact_purposes.collect { |item| item.attributes["id"] }.join(',')})")
+
+            contact_mechanism_args.each do |key, value|
+              next if key == 'updated_at' or key == 'created_at' or key == 'id' or key == 'is_primary'
+              query = query.where("#{table_name}.#{key} = ?", value) unless value.nil?
+            end unless contact_mechanism_args.nil?
+
+            query
+          end
+
+          # Adds contact
+          def add_contact(contact_mechanism_class, contact_mechanism_args={}, contact_purposes=[])
+            is_primary = contact_mechanism_args['is_primary']
+            contact_purposes = [contact_purposes] if !contact_purposes.kind_of?(Array) # gracefully handle a single purpose not in an array
+
+            contact_mechanism_args.delete_if { |k, v| ['created_at', 'updated_at', 'is_primary'].include? k.to_s }
+            contact_mechanism = contact_mechanism_class.new(contact_mechanism_args)
+            contact_mechanism.contact.contact_record = self
+            contact_purposes.each do |contact_purpose|
+              if contact_purpose.is_a?(String)
+                contact_mechanism.contact.contact_purposes << ContactPurpose.iid(contact_purpose)
+              else
+                contact_mechanism.contact.contact_purposes << contact_purpose
+              end
+            end
+            contact_mechanism.contact.save!
+            contact_mechanism.save!
+
+            set_primary_contact(contact_mechanism_class, contact_mechanism) if is_primary
+
+            contact_mechanism
+          end
+
+          # tries to update contact by purpose
+          # if contact doesn't exist, it adds it
+          def update_or_add_contact_with_purpose(contact_mechanism_class, contact_purpose, contact_mechanism_args)
+            contact_mechanism = update_contact_with_purpose(contact_mechanism_class, contact_purpose, contact_mechanism_args)
+
+            unless contact_mechanism
+              contact_mechanism = add_contact(contact_mechanism_class, contact_mechanism_args, [contact_purpose])
+            end
+
+            contact_mechanism
+          end
+
+          # looks for a contact matching on purpose
+          # if it exists, it updates it, if not returns false
+          def update_contact_with_purpose(contact_mechanism_class, contact_purpose, contact_mechanism_args)
+            contact = find_contact_with_purpose(contact_mechanism_class, contact_purpose)
+            contact.nil? ? false : update_contact(contact_mechanism_class, contact, contact_mechanism_args)
+          end
+
+          def update_contact(contact_mechanism_class, contact, contact_mechanism_args)
+            set_primary_contact(contact_mechanism_class, contact.contact_mechanism) if contact_mechanism_args[:is_primary] == true
+
+            contact_mechanism_args.delete_if { |k, v| ['client_utc_offset'].include? k.to_s }
+            contact.contact_mechanism.update_attributes!(contact_mechanism_args)
+
+            contact.contact_mechanism
+          end
+
+          #
+          # Builds methods based on contacts and contact purposes associated to this record
+          # For example if there is a PhoneNumber with a contact purpose of Home associated it would
+          # create a method like home_phone_number
+          #
+          def build_contact_methods
+            self.contacts.each do |contact|
+              contact.contact_purposes.each do |contact_purpose|
+                klass = contact.contact_mechanism.class.name
+
+                self.class.send 'define_method', "#{contact_purpose.internal_identifier}_#{contact.contact_mechanism.class.name.underscore}" do
+                  _klass_const = klass.camelize.constantize
+                  _contact_purpose = contact_purpose
+                  find_contact_mechanism_with_purpose(_klass_const, _contact_purpose)
+                end
+
+              end
+
+            end
+          end # build_contact_methods
+
+        end
+
+      end # HasContacts
+    end # ActiveRecord
+  end # Extensions
+end # ErpBaseErpSvcs