erp_base_erp_svcs 4.0.0 → 4.2.0

data/app/models/contact.rb

@@ -1,9 +1,11 @@
 class Contact < ActiveRecord::Base
   attr_protected :created_at, :updated_at
 
+  tracks_created_by_updated_by
+
   has_and_belongs_to_many :contact_purposes
-  belongs_to :party
   belongs_to :contact_mechanism, :polymorphic => true, :dependent => :destroy
+  belongs_to :contact_record, :polymorphic => true
 
   #rather than carry our own description for the abstract -contact-, we'll
   #delegate that call to the implementer of the -contact_mechanism- interface
@@ -16,6 +18,18 @@ class Contact < ActiveRecord::Base
     @description=d
   end
 
+  def party
+    if self.contact_record_type == 'Party'
+      self.contact_record
+    else
+      nil
+    end
+  end
+
+  def party=(party)
+    self.contact_record = party
+  end
+
   #delegate our need to provide a label to scaffolds to the implementer of
   #the -contact_mechanism- interface.
 
@@ -26,7 +40,7 @@ class Contact < ActiveRecord::Base
   def summary_line
     "#{contact_mechanism.summary_line}"
   end
-  
+
   def is_primary?
     self.is_primary
   end

data/app/models/contact_purpose.rb

@@ -5,4 +5,17 @@ class ContactPurpose < ActiveRecord::Base
   acts_as_erp_type
 
   has_and_belongs_to_many :contacts
+
+  def to_data_hash
+    to_hash(
+        only: [
+            :id,
+            :description,
+            :internal_identifier,
+            :created_at,
+            :updated_at
+        ],
+        leaf: leaf?
+    )
+  end
 end

data/app/models/descriptive_asset.rb

@@ -1,6 +1,23 @@
+# create_table :descriptive_assets do |t|
+#   t.references :view_type
+#   t.string :internal_identifier
+#   t.text :description
+#   t.string :external_identifier
+#   t.string :external_id_source
+#   t.references :described_record, :polymorphic => true
+#
+#   t.timestamps
+# end
+#
+# add_index :descriptive_assets, :view_type_id
+# add_index :descriptive_assets, [:described_record_id, :described_record_type], :name => 'described_record_idx'
+
 class DescriptiveAsset < ActiveRecord::Base
   attr_protected :created_at, :updated_at
 
+  tracks_created_by_updated_by
+
   belongs_to :view_type
   belongs_to :described_record, :polymorphic => true
+
 end

data/app/models/email_address.rb

@@ -1,10 +1,19 @@
+#  create_table :email_addresses do |t|
+#    t.column :email_address, :string
+#    t.column :description, :string
+#
+#    t.timestamps
+#  end
+
 class EmailAddress < ActiveRecord::Base
   attr_protected :created_at, :updated_at
 
-  has_contact
+  is_contact_mechanism
+
+  validates_format_of :email_address,
+                      with: /\A[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]+\z/,
+                      message: "Must be a valid email address"
 
-  validates_format_of :email_address, :with => /\A[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]+\z/, :message => "Must be a valid email address"
- 
   def summary_line
     "#{description} : #{email_address}"
   end
@@ -17,4 +26,13 @@ class EmailAddress < ActiveRecord::Base
     "#{email_address}"
   end
 
+  def to_data_hash
+    to_hash(only: [
+                :email_address,
+                :description,
+                :created_at,
+                :updated_at
+            ])
+  end
+
 end

data/app/models/entity_party_role.rb

@@ -0,0 +1,8 @@
+class EntityPartyRole < ActiveRecord::Base
+  attr_protected :created_at, :updated_at
+
+  belongs_to :party
+  belongs_to :role_type
+  belongs_to :entity_record, :polymorphic => true
+
+end

data/app/models/fixed_asset.rb

@@ -1,6 +1,8 @@
 class FixedAsset < ActiveRecord::Base
   attr_protected :created_at, :updated_at
 
+  tracks_created_by_updated_by
+
   belongs_to :fixed_asset_type
   belongs_to :fixed_asset_record, :polymorphic => true
   has_many :fixed_asset_party_roles

data/app/models/fixed_asset_type.rb

@@ -1,6 +1,7 @@
 class FixedAssetType < ActiveRecord::Base
   attr_protected :created_at, :updated_at
 
+  acts_as_erp_type
   acts_as_nested_set
   include ErpTechSvcs::Utils::DefaultNestedSetMethods
 

data/app/models/generated_item.rb

@@ -0,0 +1,17 @@
+# create_table :generated_items do |t|
+#   t.references :generated_by, :polymorphic => true
+#   t.references :generated_record, :polymorphic => true
+#
+#   t.timestamps
+# end
+#
+# add_index :generated_items, [:generated_by_type, :generated_by_id], :name => 'generated_by_idx'
+# add_index :generated_items, [:generated_record_type, :generated_record_id], :name => 'generated_record_idx'
+
+class GeneratedItem < ActiveRecord::Base
+  attr_protected :created_at, :updated_at
+
+  belongs_to :generated_record, :polymorphic => true
+  belongs_to :generated_by, :polymorphic => true
+  
+end

data/app/models/geo_country.rb

@@ -7,5 +7,16 @@ class GeoCountry < ActiveRecord::Base
   validates :name, :presence => {:message => 'Name cannot be blank'}
   validates :iso_code_2, :presence => {:message => 'ISO code 2 cannot be blank'}
   validates :iso_code_3, :presence => {:message => 'ISO code 3 cannot be blank'}
-  
+
+  class << self
+
+    def countries_with_us_first
+      countries = where('iso_code_2 <> ? and display = ?', 'US', true)
+      countries.unshift(where('iso_code_2 = ?', 'US').first)
+
+      countries
+    end
+
+  end
+
 end

data/app/models/individual.rb

@@ -1,32 +1,20 @@
 class Individual < ActiveRecord::Base
   attr_protected :created_at, :updated_at
 
-  require 'attr_encrypted'
-
   after_create :create_party
   after_save :save_party
   after_destroy :destroy_party
 
   has_one :party, :as => :business_party
 
-  attr_encrypted :encrypted_ssn, :key => 'a secret key', :marshall => true
-  alias_attribute :unencypted_ssn, :social_security_number
+  attr_encrypted :ssn, :key => Rails.application.config.erp_base_erp_svcs.encryption_key, :attribute => :encrypted_ssn
 
   def after_initialize
     self.salt ||= Digest::SHA256.hexdigest((Time.now.to_i * rand(5)).to_s)
   end
 
-  def social_security_number=(ssn)
-    self.ssn_last_four = ssn[-4..-1]
-    self.encrypted_ssn = Individual.encrypt_encrypted_ssn(ssn)
-    self.save
-  end
-
-  def social_security_number
-    Individual.decrypt_encrypted_ssn(self.encrypted_ssn)
-  end
-
-  alias_method :ssn, :social_security_number
+  alias :social_security_number= :ssn=
+  alias :social_security_number :ssn
 
   def formatted_ssn_label
     (self.ssn_last_four.blank?) ? "" : "XXX-XX-#{self.ssn_last_four}"
@@ -48,11 +36,14 @@ class Individual < ActiveRecord::Base
   end
 
   def create_party
-    pty = Party.new
-    pty.description = [current_personal_title, current_first_name, current_last_name].join(' ').strip
-    pty.business_party = self
-    pty.save
-    self.save
+    unless self.party
+      pty = Party.new
+      pty.description = [current_personal_title, current_first_name, current_last_name].join(' ').strip
+      pty.business_party = self
+      pty.save
+      self.party = pty
+      self.save
+    end
   end
 
   def save_party

data/app/models/note.rb

@@ -1,10 +1,15 @@
 class Note < ActiveRecord::Base
   attr_protected :created_at, :updated_at
 
+  tracks_created_by_updated_by
+
   belongs_to :note_type
   belongs_to :noted_record, :polymorphic => true
   belongs_to :created_by, :class_name => 'Party', :foreign_key => 'created_by_id'
 
+  validates :content, presence: true
+  validates :note_type, presence: true
+
   def note_type_desc
     self.note_type.description
   end
@@ -13,4 +18,8 @@ class Note < ActiveRecord::Base
     (content.length > 20) ? "#{content[0..20]}..." : content
   end
 
+  def to_s
+    summary
+  end
+
 end

data/app/models/note_type.rb

@@ -2,8 +2,10 @@ class NoteType < ActiveRecord::Base
   attr_protected :created_at, :updated_at
   
   acts_as_nested_set
+  include ErpTechSvcs::Utils::DefaultNestedSetMethods
   acts_as_erp_type
 
   belongs_to :note_type_record, :polymorphic => true
   has_many   :notes
+
 end

data/app/models/organization.rb

@@ -1,32 +1,35 @@
 class Organization < ActiveRecord::Base
   attr_protected :created_at, :updated_at
-	
-	after_create  :create_party
-	after_save    :save_party
-	after_destroy :destroy_party
-	
+
+  after_create :create_party
+  after_save :save_party
+  after_destroy :destroy_party
+
   has_one :party, :as => :business_party
 
   def create_party
-    pty = Party.new
-    pty.description = self.description
-    pty.business_party = self
-    
-    pty.save
-    self.save
+    unless self.party
+      pty = Party.new
+      pty.description = self.description
+      pty.business_party = self
+
+      pty.save
+      self.party = pty
+      self.save
+    end
   end
-    
-	def save_party
+
+  def save_party
     self.party.description = self.description
     self.party.save
-	end
+  end
 
   def destroy_party
     if self.party
-	    self.party.destroy
+      self.party.destroy
     end
   end
- 
+
   def to_label
     "#{description}"
   end

data/app/models/party.rb

@@ -2,11 +2,14 @@ class Party < ActiveRecord::Base
   attr_protected :created_at, :updated_at
 
   has_notes
+  has_contacts
+  tracks_created_by_updated_by
 
-  has_many :contacts, :dependent => :destroy
   has_many :created_notes, :class_name => 'Note', :foreign_key => 'created_by_id'
   belongs_to :business_party, :polymorphic => true
 
+  has_many :entity_party_roles, dependent: :destroy
+
   has_many :party_roles, :dependent => :destroy #role_types
   has_many :role_types, :through => :party_roles
 
@@ -15,9 +18,94 @@ class Party < ActiveRecord::Base
   attr_reader :relationships
   attr_writer :create_relationship
 
-  # serialize ExtJs attributes
-  is_json :custom_fields
-  
+  class << self
+    # scope by dba organization
+    #
+    # @param dba_organization [Party, Array] dba organization to scope by or Array of dba organizations to
+    # scope by
+    #
+    # @return [ActiveRecord::Relation]
+    def scope_by_dba_organization(dba_organization)
+      joins("inner join party_relationships on party_relationships.role_type_id_to ='#{RoleType.iid('dba_org').id}'
+             and party_relationships.party_id_from = parties.id")
+      .where({party_relationships: {party_id_to: dba_organization}})
+    end
+
+    # Scopes parties by passed role types
+    #
+    # @param role_types [Array, RoleType] Array of RoleTypes to scope by
+    def with_role_types(role_types)
+      joins('inner join party_roles on party_roles.party_id = parties.id').where('party_roles.role_type_id' => role_types)
+    end
+
+  end
+
+  # helper method to get dba_organization related to this party
+  #
+  # @return [Party] DBA Organization
+  def dba_organization
+    find_related_parties_with_role('dba_org').first
+  end
+
+  # Get any child DBA Organizations related this party
+  #
+  # @param dba_orgs [Array] Array of current DBA Organizations to add to
+  # @return [Array] Child DBA Organizations
+  def child_dba_organizations(dba_orgs=[])
+    dba_org = RoleType.iid('dba_org')
+
+    PartyRelationship.joins('inner join parties on parties.id = party_relationships.party_id_from')
+    .joins('inner join party_roles on party_roles.party_id = party_relationships.party_id_from')
+    .where('party_id_to' => self.id)
+    .where('party_relationships.role_type_id_to' => dba_org)
+    .where('party_roles.role_type_id' => dba_org).each do |party_reln|
+
+      dba_orgs.push(party_reln.from_party)
+      if !dba_orgs.collect(&:id).include? party_reln.from_party.id
+        party_reln.from_party.child_dba_organizations(dba_orgs)
+      end
+
+    end
+
+    dba_orgs.uniq
+  end
+
+  # Get all parties that have a relationship to this party. If deep is passed then of those parties do the same
+  # all the way down the relationship chain
+  #
+  # @param parties [Array] Array of currently found related parties
+  # @return [Array] Array of related parties
+  def parties_in_relationships(parties=[], deep=false)
+    PartyRelationship.where('party_id_to' => self.id).each do |party_reln|
+
+      parties.push(party_reln.from_party) unless parties.include?(party_reln.from_party)
+      if deep and !parties.collect(&:id).include? party_reln.from_party.id
+        party_reln.from_party.parties_in_relationships(parties, deep)
+      else
+        parties
+      end
+
+    end
+
+    parties.uniq
+  end
+
+  # Get any parent DBA Organizations related this party
+  #
+  # @param dba_orgs [Array] Array of current DBA Organizations to add to
+  # @return [Array] Parent DBA Organizations
+  def parent_dba_organizations(dba_orgs=[])
+    PartyRelationship.
+      where('party_id_from = ?', id).
+    where('role_type_id_to' => RoleType.iid('dba_org')).each do |party_reln|
+
+      dba_orgs.push(party_reln.to_party)
+      party_reln.to_party.parent_dba_organizations(dba_orgs)
+    end
+
+    dba_orgs.uniq
+  end
+
   # Gathers all party relationships that contain this particular party id
   # in either the from or to side of the relationship.
   def relationships
@@ -32,10 +120,16 @@ class Party < ActiveRecord::Base
     @relationships ||= PartyRelationship.where('party_id_from = ?', id)
   end
 
+  def find_related_parties_with_role(role_type_iid)
+    Party.joins(:party_roles).joins("inner join party_relationships on (party_id_from = #{id} and parties.id = party_relationships.party_id_to)")
+    .where(PartyRole.arel_table[:role_type_id].eq(RoleType.iid(role_type_iid).id))
+    .where(Party.arel_table[:id].not_eq(id))
+  end
+
   def find_relationships_by_type(relationship_type_iid)
     PartyRelationship.includes(:relationship_type).
-        where('party_id_from = ? or party_id_to = ?', id, id).
-        where('relationship_types.internal_identifier' => relationship_type_iid.to_s)
+      where('party_id_from = ? or party_id_to = ?', id, id).
+      where('relationship_types.internal_identifier' => relationship_type_iid.to_s)
   end
 
   # Creates a new PartyRelationship for this particular
@@ -60,40 +154,23 @@ class Party < ActiveRecord::Base
     PartyRelationship.destroy_all("party_id_from = #{id} or party_id_to = #{id}")
   end
 
+  def add_role_type(role)
+    role = role.is_a?(RoleType) ? role : RoleType.iid(role)
+
+    PartyRole.create(party: self, role_type: role)
+  end
+
   def has_role_type?(*passed_roles)
     result = false
     passed_roles.flatten!
     passed_roles.each do |role|
       role_iid = role.is_a?(RoleType) ? role.internal_identifier : role.to_s
-      self.role_types.each do |this_role|
-        result = true if (this_role.internal_identifier == role_iid)
-        break if result
-      end
-      break if result
-    end
-    result
-  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
+      PartyRole.where(party_id: self.id).each do |party_role|
+        result = true if (party_role.role_type.internal_identifier == role_iid)
+        break if result
       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
@@ -107,207 +184,35 @@ class Party < ActiveRecord::Base
     "#{description}"
   end
 
-  #************************************************************************************************
-  #** Contact Methods
-  #************************************************************************************************
-
-  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
-
-  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
-
-  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 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
-
-  def find_contact(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.first
-  end
-
-  # looks for contacts matching on value and purpose
-  # if a contact exists, it updates, if not, it adds it
-  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.party = self
-    contact_mechanism.contact.contact_purposes = contact_purposes
-    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_class.update(contact.contact_mechanism, contact_mechanism_args)
-
-    contact.contact_mechanism
-  end
-
-  def get_contact_by_method(m)
-    method_name = m.split('_')
-    return nil if method_name.size < 3 or method_name.size > 4
-    # handles 1 or 2 segment contact purposes (i.e. home or employment_offer)
-    # contact mechanism must be 2 segments, (i.e. email_address, postal_address, phone_number)
-    if method_name.size == 4
-      purpose = method_name[0] + '_' + method_name[1]
-      klass = method_name[2] + '_' + method_name[3]
-    else
-      purpose = method_name[0]
-      klass = method_name[1] + '_' + method_name[2]
-    end
-
-    #constantize klass to make sure it exists and is loaded
-    begin
-      klass_const = klass.camelize.constantize
-      contact_purpose = ContactPurpose.find_by_internal_identifier(purpose)
-      if contact_purpose.nil?
-        return nil
+  # convert party record to hash of data
+  #
+  def to_data_hash
+    data = to_hash(only: [
+                     :id,
+                     :description,
+                     :created_at,
+                     :updated_at
+                   ],
+                   business_party_type: business_party.class.name
+                   )
+
+    # get business party data
+    if business_party
+      if business_party.is_a?(Individual)
+        data.merge!({
+                      first_name: business_party.current_first_name,
+                      last_name: business_party.current_last_name,
+                      middle_name: business_party.current_middle_name,
+                      gender: business_party.gender
+        })
       else
-        find_contact_mechanism_with_purpose(klass_const, contact_purpose)
+        data.merge!({
+                      tax_id_number: business_party.tax_id_number
+        })
       end
-    rescue NameError
-      return nil
     end
 
+    data
   end
 
-  def respond_to?(m, include_private_methods = false)
-    (super ? true : get_contact_by_method(m.to_s)) rescue super
-  end
-
-  def method_missing(m, *args, &block)
-    if self.respond_to?(m)
-      value = get_contact_by_method(m.to_s)
-      (value.nil?) ? super : (return value)
-    else
-      super
-    end
-  end
-
-  #************************************************************************************************
-  #** End
-  #************************************************************************************************
 end