Class: Merger::CustomerMerger

Inherits:

BasePartyMerger

Object
BasePartyMerger
Merger::CustomerMerger

show all

Defined in:: app/services/merger/customer_merger.rb

Overview

This class is designed to merge two customers

Class Method Summary collapse

.batch_merge(customer_master, customer_duplicates, options = {}) {|1, 31, 'Analyzing surviving customer'| ... } ⇒ Object
.create_contact_from_customer(customer) ⇒ Object
.inventory(customer) ⇒ Object
.report_errors(customers) ⇒ Object
Run the whole gamut of known validation to determine if the customer can be merged.

Instance Method Summary collapse

#initialize(customer_master, customer_duplicate, ignore_creation_date = false, options = {}) ⇒ CustomerMerger constructor
A new instance of CustomerMerger.
#perform_merge! {|31, 31, 'Removing Duplicate Contact Points'| ... } ⇒ Object

Constructor Details

#initialize(customer_master, customer_duplicate, ignore_creation_date = false, options = {}) ⇒ `CustomerMerger`

Returns a new instance of CustomerMerger.

# File 'app/services/merger/customer_merger.rb', line 120

def initialize(customer_master, customer_duplicate, ignore_creation_date = false, options = {})
  @options = options || {}
  if ignore_creation_date or customer_master.created_at < customer_duplicate.created_at
    @customer_master = customer_master
    @customer_duplicate = customer_duplicate
  else
    @customer_master = customer_duplicate
    @customer_duplicate = customer_master
  end
  @results = []
  @warnings = []
end

Class Method Details

.batch_merge(customer_master, customer_duplicates, options = {}) {|1, 31, 'Analyzing surviving customer'| ... } ⇒ `Object`

Yields:

(1, 31, 'Analyzing surviving customer')

# File 'app/services/merger/customer_merger.rb', line 55

def self.batch_merge(customer_master, customer_duplicates, options = {})
  logger = options[:logger] || Rails.logger
  yield(1, 31, 'Analyzing surviving customer') if block_given?
  customer_master.orders.where('primary_sales_rep_id = secondary_sales_rep_id').update_all(secondary_sales_rep_id: nil)
  customer_master.invoices.where('primary_sales_rep_id = secondary_sales_rep_id').update_all(secondary_sales_rep_id: nil)
  errors_master = report_errors(customer_master)

  report = { customer_errors: [], execution_errors: [], successes: [] }
  if errors_master.empty?
    customer_duplicates.each do |customer_duplicate|
      logger.info "Verifying if customer #{customer_duplicate.reference_number} can be merged"
      yield(2, 31, 'Analyzing duplicate customer') if block_given?
      customer_duplicate.orders.where('primary_sales_rep_id = secondary_sales_rep_id').update_all(secondary_sales_rep_id: nil)
      customer_duplicate.invoices.where('primary_sales_rep_id = secondary_sales_rep_id').update_all(secondary_sales_rep_id: nil)
      errors_duplicate = report_errors(customer_duplicate)
      order_shipping_states = customer_duplicate.orders.where('orders.state IN (?)', Order::SHIPPING_STATES)
      # active_support_cases = customer_duplicate.support_cases.where('state not in (?)', 'closed')

      if order_shipping_states.present?
        order_shipping_states.each do |o|
          errors_duplicate << { record_type: 'Order', record_id: o.id, record_description: o.state, errors: ['Order is under shipping states'], record: nil }
        end
      end

      # if active_support_cases.present?
      #   active_support_cases.each do |asc|
      #     errors_duplicate << { record_type: 'Support Case', record_id: asc.id, record_description: asc.state, errors: ['Customer duplicated is still participant of an active support case'], record: nil }
      #   end
      # end

      if errors_duplicate.empty?
        previous_state = customer_duplicate.state
        begin
          merger = new(customer_master, customer_duplicate, true, options)
          merger.perform_merge! do |current_step, total_steps, message|
            yield(current_step, total_steps, message) if block_given?
          end
          customer_master.reload
          msg = "Merging #{customer_duplicate.reference_number} #{customer_duplicate.full_name} into #{customer_master.reference_number} #{customer_master.full_name}"
          report[:successes] << msg
          logger.info msg
        rescue StandardError => e
          cd = Customer.where(id: customer_duplicate.id).first
          customer_duplicate.update_column(:state, previous_state) if cd.present? # if there is an execution error, customer_duplicate gets its previous state
          msg = "Cannot merge #{customer_duplicate.reference_number} into #{customer_master.reference_number} due to errors: #{e}"
          report[:execution_errors] << msg
          logger.error msg
          ErrorReporting.error(e, msg)
        end
      else
        msg = "Cannot merge #{customer_duplicate.reference_number} into #{customer_master.reference_number} due to errors: #{errors_duplicate.inspect}"
        report[:customer_errors] << { customer_id: customer_duplicate.id, customer_name: customer_duplicate.full_name, errors_detail: errors_duplicate }
        logger.error msg
      end
    end
    customer_master.reload
    Customer::SalesRepAssigner.auto_assign(customer_master)
  else
    msg = "Customer master #{customer_master.reference_number} has errors. #{errors_master.inspect}"
    logger.error msg
    report[:customer_errors] << { customer_id: customer_master.id, customer_name: customer_master.full_name, errors_detail: errors_master }
  end
  report
end

.create_contact_from_customer(customer) ⇒ `Object`

# File 'app/services/merger/customer_merger.rb', line 678

def self.create_contact_from_customer(customer)
  new_contact = customer.dup.becomes(Contact)
  new_contact.send(:type=, 'Contact')
  new_contact.id = nil
  new_contact.visit_id = nil
  new_contact.uuid = nil
  new_contact.customer = customer
  new_contact.save!

  # The dup above copies profile_image_id to the new contact. Detach the
  # image from the source customer so that when the customer is later
  # destroyed, dependent: :destroy doesn't cascade-delete the image that
  # now belongs to the new contact.
  if new_contact.profile_image_id.present?
    customer.update_column(:profile_image_id, nil)
  end

  customer.contact_points.each do |cp|
    cp.party = new_contact
    cp.save!
  end
  customer.opportunities.each do |opp|
    opp.contact = new_contact
    opp.save!
  end
  customer.reload
  new_contact
end

.inventory(customer) ⇒ `Object`

# File 'app/services/merger/customer_merger.rb', line 19

def self.inventory(customer)
  [
    customer,
    customer.contacts.map { |c| Merger::ContactMerger.inventory(c) },
    customer.account,
    customer.addresses.to_a,
    customer.contact_points.to_a,
    customer.opportunities.to_a,
    customer.opportunities.map(&:room_configurations),
    customer.orders.to_a,
    customer.orders.map(&:deliveries),
    customer.orders.map(&:shipping_address),
    customer.quotes.to_a,
    customer.invoices.to_a,
    customer.credit_memos.to_a,
    customer.rmas.to_a,
    customer.purchase_orders.to_a,
    customer.credit_applications.to_a, # customer.activities.to_a,
    customer.child_organizations.to_a,
    customer.tax_exemptions.to_a,
    customer.credit_card_vaults.to_a,
    customer.shipping_account_numbers.to_a,
    customer.identification_numbers.to_a,
    customer.notification_channels.to_a,
    customer.survey_enrollments.to_a,
    customer.course_enrollments.to_a,
    customer.certifications.to_a,
    customer.liability_insurances.to_a,
    customer.quick_estimators.to_a,
    customer.preset_jobs.to_a,
    customer.room_plans.to_a,
    customer.payments.to_a,
    customer.statement_of_accounts.to_a
  ].flatten.compact.uniq
end

.report_errors(customers) ⇒ `Object`

Run the whole gamut of known validation to determine if the customer
can be merged

# File 'app/services/merger/customer_merger.rb', line 6

def self.report_errors(customers)
  customer_errors = []
  [customers].flatten.each do |customer|
    customer_inventory = inventory(customer)
    # Reject all valid records
    customer_inventory.reject(&:valid?).each do |r|
      customer_errors << { record_type: r.class.name, record_id: r.id, record_description: r.to_s, errors: r.errors.full_messages, record: r }
    end
    customer_errors << { record_type: 'Customer', record_id: customer.id, record_description: customer.state, errors: ['Unsuitable state for merging'], record: nil } unless customer.can_be_merged?
  end
  customer_errors
end

Instance Method Details

#perform_merge! {|31, 31, 'Removing Duplicate Contact Points'| ... } ⇒ `Object`