diff --git a/enterprise/app/models/enterprise/concerns/contact.rb b/enterprise/app/models/enterprise/concerns/contact.rb index 9139fc67e..09885a947 100644 --- a/enterprise/app/models/enterprise/concerns/contact.rb +++ b/enterprise/app/models/enterprise/concerns/contact.rb @@ -2,5 +2,30 @@ module Enterprise::Concerns::Contact extend ActiveSupport::Concern included do belongs_to :company, optional: true + + after_commit :associate_company_from_email, + on: [:create, :update], + if: :should_associate_company? + end + + private + + def should_associate_company? + # Only trigger if: + # 1. Contact has an email + # 2. Contact doesn't have a compan yet + # 3. Email was just set/changed + # 4. Email was previously nil (first time getting email) + email.present? && + company_id.nil? && + saved_change_to_email? && + saved_change_to_email.first.nil? + end + + def associate_company_from_email + Contacts::CompanyAssociationService.new.associate_company_from_email(self) + rescue StandardError => e + Rails.logger.error("Failed to associate company for contact #{id}: #{e.message}") + # Don't fail the contact save if the company association fails end end diff --git a/enterprise/app/services/contacts/company_association_service.rb b/enterprise/app/services/contacts/company_association_service.rb new file mode 100644 index 000000000..f2e2ffdd2 --- /dev/null +++ b/enterprise/app/services/contacts/company_association_service.rb @@ -0,0 +1,46 @@ +class Contacts::CompanyAssociationService + def associate_company_from_email(contact) + return nil if skip_association?(contact) + + company = find_or_create_company(contact) + # rubocop:disable Rails/SkipsModelValidations + # Intentionally using update_column here to: + # 1. Avoid triggering callbacks + # 2. Improve performance (We're only setting company_id, no need for validation) + contact.update_column(:company_id, company.id) if company + # rubocop:enable Rails/SkipsModelValidations + company + end + + private + + def skip_association?(contact) + return true if contact.company_id.present? + return true if contact.email.blank? + + detector = Companies::BusinessEmailDetectorService.new(contact.email) + return true unless detector.perform + + false + end + + def find_or_create_company(contact) + domain = extract_domain(contact.email) + company_name = derive_company_name(contact, domain) + + Company.find_or_create_by!(account: contact.account, domain: domain) do |company| + company.name = company_name + end + rescue ActiveRecord::RecordNotUnique + # If another process created it first, just find that + Company.find_by(account: contact.account, domain: domain) + end + + def extract_domain(email) + email.split('@').last&.downcase + end + + def derive_company_name(contact, domain) + contact.additional_attributes&.dig('company_name') || domain.split('.').first.tr('-_', ' ').titleize + end +end diff --git a/spec/enterprise/jobs/migration/company_account_batch_job_spec.rb b/spec/enterprise/jobs/migration/company_account_batch_job_spec.rb index 9a3e88c9d..499b96287 100644 --- a/spec/enterprise/jobs/migration/company_account_batch_job_spec.rb +++ b/spec/enterprise/jobs/migration/company_account_batch_job_spec.rb @@ -19,6 +19,12 @@ RSpec.describe Migration::CompanyAccountBatchJob, type: :job do let!(:contact) { create(:contact, account: account, email: 'user@acme.com') } it 'creates a company and associates the contact' do + # Clean up companies created by Part 2's callback + Company.delete_all + # rubocop:disable Rails/SkipsModelValidations + contact.update_column(:company_id, nil) + # rubocop:enable Rails/SkipsModelValidations + expect do described_class.perform_now(account) end.to change(Company, :count).by(1) @@ -71,6 +77,13 @@ RSpec.describe Migration::CompanyAccountBatchJob, type: :job do let!(:contact2) { create(:contact, account: account, email: 'user2@acme.com') } it 'creates only one company for the domain' do + # Clean up companies created by Part 2's callback + Company.delete_all + # rubocop:disable Rails/SkipsModelValidations + contact1.update_column(:company_id, nil) + contact2.update_column(:company_id, nil) + # rubocop:enable Rails/SkipsModelValidations + expect do described_class.perform_now(account) end.to change(Company, :count).by(1) diff --git a/spec/enterprise/models/contact_company_association_spec.rb b/spec/enterprise/models/contact_company_association_spec.rb new file mode 100644 index 000000000..065d5bc97 --- /dev/null +++ b/spec/enterprise/models/contact_company_association_spec.rb @@ -0,0 +1,61 @@ +require 'rails_helper' + +RSpec.describe Contact, type: :model do + describe 'company auto-association' do + let(:account) { create(:account) } + + context 'when creating a new contact with business email' do + it 'automatically creates and associates a company' do + expect do + create(:contact, email: 'john@acme.com', account: account) + end.to change(Company, :count).by(1) + contact = described_class.last + expect(contact.company).to be_present + expect(contact.company.domain).to eq('acme.com') + end + + it 'does not create company for free email providers' do + expect do + create(:contact, email: 'john@gmail.com', account: account) + end.not_to change(Company, :count) + end + end + + context 'when updating a contact to add email for first time' do + it 'creates and associates company' do + contact = create(:contact, email: nil, account: account) + expect do + contact.update(email: 'john@acme.com') + end.to change(Company, :count).by(1) + contact.reload + expect(contact.company.domain).to eq('acme.com') + end + end + + context 'when updating a contact that already has a company' do + it 'does not change company when email changes' do + existing_company = create(:company, domain: 'oldcompany.com', account: account) + contact = create(:contact, email: 'john@oldcompany.com', company: existing_company, account: account) + + expect do + contact.update(email: 'john@new_company.com') + end.not_to change(Company, :count) + contact.reload + expect(contact.company).to eq(existing_company) + end + end + + context 'when multiple contacts share the same domain' do + it 'associates all contacts with the same company' do + contacts = ['john@acme.com', 'jane@acme.com', 'bob@acme.com'] + contacts.each do |contact| + create(:contact, email: contact, account: account) + end + + expect(Company.where(domain: 'acme.com', account: account).count).to eq(1) + company = Company.find_by(domain: 'acme.com', account: account) + expect(company.contacts.count).to eq(contacts.length) + end + end + end +end diff --git a/spec/enterprise/services/contacts/company_association_service_spec.rb b/spec/enterprise/services/contacts/company_association_service_spec.rb new file mode 100644 index 000000000..ea9363bad --- /dev/null +++ b/spec/enterprise/services/contacts/company_association_service_spec.rb @@ -0,0 +1,83 @@ +require 'rails_helper' + +RSpec.describe Contacts::CompanyAssociationService, type: :service do + let(:account) { create(:account) } + let(:service) { described_class.new } + + describe '#associate_company_from_email' do + context 'when contact has business email and no company' do + it 'creates a new company and associates it' do + contact = create(:contact, email: 'john@acme.com', account: account, company_id: nil) + Company.delete_all # Delete any companies created by the callback + # rubocop:disable Rails/SkipsModelValidations + contact.update_column(:company_id, nil) # Delete the company association created by the callback + # rubocop:enable Rails/SkipsModelValidations + + valid_email_address = instance_double(ValidEmail2::Address, valid?: true, disposable_domain?: false) + allow(ValidEmail2::Address).to receive(:new).with('john@acme.com').and_return(valid_email_address) + allow(EmailProviderInfo).to receive(:call).with('john@acme.com').and_return(nil) + + expect do + service.associate_company_from_email(contact) + end.to change(Company, :count).by(1) + + contact.reload + expect(contact.company).to be_present + expect(contact.company.domain).to eq('acme.com') + expect(contact.company.name).to eq('Acme') + end + + it 'reuses existing company with same domain' do + existing_company = create(:company, domain: 'acme.com', account: account) + contact = create(:contact, email: 'john@acme.com', account: account, company_id: nil) + # rubocop:disable Rails/SkipsModelValidations + contact.update_column(:company_id, nil) # Delete the company association created by the callback + # rubocop:enable Rails/SkipsModelValidations + + valid_email_address = instance_double(ValidEmail2::Address, valid?: true, disposable_domain?: false) + allow(ValidEmail2::Address).to receive(:new).with('john@acme.com').and_return(valid_email_address) + allow(EmailProviderInfo).to receive(:call).with('john@acme.com').and_return(nil) + + expect do + service.associate_company_from_email(contact) + end.not_to change(Company, :count) + + contact.reload + expect(contact.company).to eq(existing_company) + end + end + + context 'when contact already has a company' do + it 'skips association and returns nil' do + existing_company = create(:company, account: account) + contact = create(:contact, email: 'john@acme.com', account: account, company_id: existing_company.id) + result = service.associate_company_from_email(contact) + + expect(result).to be_nil + contact.reload + expect(contact.company).to eq(existing_company) + end + end + + context 'when contact has free email provider' do + it 'skips association for email' do + contact = create(:contact, email: 'john@gmail.com', account: account, company_id: nil) + expect do + service.associate_company_from_email(contact) + end.not_to change(Company, :count) + contact.reload + expect(contact.company).to be_nil + end + end + + context 'when contact has no email' do + it 'skips association' do + contact = create(:contact, email: nil, account: account, company_id: nil) + + result = service.associate_company_from_email(contact) + expect(result).to be_nil + expect(contact.reload.company).to be_nil + end + end + end +end