Class: Edi::MiraklSeller::OrderMessageProcessor

# File 'app/services/edi/mirakl_seller/order_message_processor.rb', line 232

def adjust_shipping_cost(order, order_hash)
  return unless order.line_items.shipping_only.present? # If we are not pulling the shipping then there is nothing to adjust

  # first calculate the adjustment
  order.reload
  order_sc = order.shipping_cost # This can be nil?
  marketplace_sc_with_vat = order_hash[:shipping_price]
  tax_rate = order.customer.catalog.tax_rate + 1 # We use the first line item to get the shipping tax rate
  marketplace_sc = marketplace_sc_with_vat / tax_rate
  adjustment = marketplace_sc - order_sc
  # add the price match coupon
  coupon = Coupon.find_by(code: 'EDI_SHIPPING_ADJ')
  discount = Discount.new(itemizable: order, coupon_id: coupon.id, effective_date: Date.current)

  shipping_li = order.line_items.shipping_only.first
  discount.line_discounts.build(coupon_id: coupon.id, amount: adjustment, line_item_id: shipping_li.id)

  if discount.line_discounts.any?
    discount.amount = discount.user_amount = discount.line_discounts.to_a.sum(&:amount)
    discount.save!
  end

  order.reload
end

#apply_payment(order, order_hash) ⇒ `Object`

# File 'app/services/edi/mirakl_seller/order_message_processor.rb', line 257

def apply_payment(order, order_hash)
  order.reload
  order.pending_payment!
  total_due = order.total
  order.payments.build.tap do |payment|
    payment.category = Payment::PO
    payment.currency = order.currency
    payment.amount = total_due
    payment.state = 'authorized'
    payment.po_number = order_hash[:order_id]
    payment.delivery = order.deliveries.quoting.first
    payment.save!
  end
end

#create_line_items(order, order_hash) ⇒ `Object`

# File 'app/services/edi/mirakl_seller/order_message_processor.rb', line 280

def create_line_items(order, order_hash)
  line_total = BigDecimal(0)
  cust = order.customer
  all_skus_valid = true
  errors = []
  bad_vendor_skus = []
  bad_merchant_skus = []
  catalog_items = cust.catalog.catalog_items.where(state: %w[active active_hidden require_vendor_update pending_vendor_update pending_discontinue]).order('state ASC')
  order_hash[:order_lines].each_with_index do |line_hash, i|
    # First we try by promo sku
    vendor_upc = line_hash[:offer_sku]
    merchant_sku = line_hash[:product_sku]
    raise 'Missing identifier UPC in file' if vendor_upc.blank? && merchant_sku.blank?

    matched_catalog_item = nil
    # All products in Channel Engine are identified with their EAN13
    if vendor_upc.present?
      case vendor_upc.size
      when 12
        normalized_upc = vendor_upc
      when 13
        normalized_upc = vendor_upc[1..-1] # remove the first character that will most likely be a zero
      end
    end
    matched_catalog_item ||= catalog_items.by_upcs(normalized_upc).first if normalized_upc.present?
    matched_catalog_item ||= catalog_items.where(third_party_promo_part_number: merchant_sku).first if merchant_sku.present?
    # If no match on that, try by merchant sku
    matched_catalog_item ||= catalog_items.where(third_party_part_number: merchant_sku).first if merchant_sku.present?
    # If no match, try third party sku
    matched_catalog_item ||= catalog_items.where(third_party_sku: merchant_sku).first if merchant_sku.present?
    if matched_catalog_item
      order.line_items.build.tap do |line_item|
        line_item.quantity = line_hash[:quantity].to_i # 2
        line_item.edi_reference = line_hash[:order_line_id]
        line_item.edi_line_number = i + 1
        line_item.catalog_item = matched_catalog_item

        if orchestrator.vat_breakdown_available
          vat_rate = (line_hash[:taxes].first[:rate] / 100) + 1
          price_with_vat = BigDecimal(line_hash[:price_unit].to_s)
          price = price_with_vat / vat_rate
        else
          vat_rate = cust.catalog.tax_rate + 1
          price_with_vat = BigDecimal(line_hash[:price_unit].to_s)
          price = price_with_vat / vat_rate
        end
        # line_item.edi_unit_cost = price # Mirakl doesn't provide the original price if we have a sale so this edi_unit_cost field becomes unreliable. better to remove it.
        line_total += price * line_item.quantity
      end
      if matched_catalog_item.state_requires_edi_warning_on_order?
        subj = "EDI order for orchestrator: #{orchestrator.partner}, processed, but catalog item with SKU #{matched_catalog_item.sku} in state #{matched_catalog_item.state} (i.e. not active state)"
        msg = "EDI order for orchestrator: #{orchestrator.partner}, catalog item with SKU #{matched_catalog_item.sku} in state #{matched_catalog_item.state} (i.e. not active state). The order #{order.reference_number} has been processed but this is an indication of a possible issue with this catalog item."
        InternalMailer.notify_edi_admin_of_warning(subj, msg).deliver_later
      end
    else
      all_skus_valid = false
      bad_vendor_skus << vendor_upc.presence
      bad_merchant_skus << merchant_sku.presence
      errors << "Unknown vendor UPC: #{vendor_upc} / merchant sku: #{merchant_sku}"
    end
  end
  order.save!
  LineCreationResult.new(line_total: line_total, lines_created: order.line_items.size, all_skus_valid: all_skus_valid, error_message: errors.to_sentence.capitalize, bad_vendor_skus: bad_vendor_skus.compact,
bad_merchant_skus: bad_merchant_skus.compact)
end

#create_shipping_address(order_hash) ⇒ `Object`

# File 'app/services/edi/mirakl_seller/order_message_processor.rb', line 346

def create_shipping_address(order_hash)
  address_hash = order_hash[:customer][:shipping_address]

  raw_street1 = address_hash[:street_1]&.squish
  raw_street2 = address_hash[:street_2]&.squish
  originals = collect_street_originals(street1: raw_street1, street2: raw_street2)

  address = Address.new
  address.person_name_override = "#{address_hash[:firstname]} #{address_hash[:lastname]}".titleize.squish
  address.street1 = abbreviate_street(raw_street1)
  address.street2 = abbreviate_street(raw_street2)
  address.city = address_hash[:city]&.squish
  address.state_code = address_hash[:state]&.squish&.truncate(20)
  address.country_iso3 = address_hash[:country_iso_code]&.squish
  address.zip = address_hash[:zip_code].to_s.upcase.delete(' ')&.squish
  address.disable_address_correction = true
  address.override_all_address_validation = true
  address.save!
  [address, originals]
end

#create_sold_to_billing_address(order_hash) ⇒ `Object`

# File 'app/services/edi/mirakl_seller/order_message_processor.rb', line 367

def create_sold_to_billing_address(order_hash)
  address = Address.new
  address_hash = order_hash[:customer][:billing_address]
  address.person_name_override = "#{address_hash[:firstname]} #{address_hash[:lastname]}".titleize&.squish
  address.company_name_override = address_hash[:company]&.squish
  address.street1 = address_hash[:street_1]&.squish
  address.street2 = address_hash[:street_2]&.squish
  address.city = address_hash[:city]&.squish
  address.state_code = address_hash[:state]&.squish&.truncate(20)
  address.country_iso3 = address_hash[:country_iso_code]&.squish
  address.zip = address_hash[:zip_code].to_s.upcase.delete(' ')&.squish
  address.disable_address_correction = true
  address.override_all_address_validation = true
  address.save!
  address
end

#customer(segment = nil) ⇒ `Object`



20
21
22

# File 'app/services/edi/mirakl_seller/order_message_processor.rb', line 20

def customer(segment = nil)
  orchestrator.customer(segment)
end

#get_customer(order_hash) ⇒ `Object`

# File 'app/services/edi/mirakl_seller/order_message_processor.rb', line 113

def get_customer(order_hash)
  if orchestrator.partner.to_s == 'leroymerlin_adeo'
    # The actual channel country comes from the order ID.
    chanel_order_number = order_hash[:commercial_id]
    country_code = chanel_order_number.split('-')[0]
    case country_code
    when '001' # France
      cus_id = LM_FR_CID
    when '002' # Spain
      cus_id = LM_ES_CID
    when '003' # Portugal
      cus_id = LM_PT_CID
    when '005' # Italy
      cus_id = LM_IT_CID
    end
  else
    # This assumes there is only 1 customer id for this partner.
    cus_id = orchestrator.customer_id.values.first
  end
  Customer.find(cus_id)
end

#process(edi_logs = nil, edi_transaction_id: nil) ⇒ `Object`

Picks up the edi communication log in the queue ready to process, generate acknowledgements

# File 'app/services/edi/mirakl_seller/order_message_processor.rb', line 25

def process(edi_logs = nil, edi_transaction_id: nil)
  edi_logs ||= EdiCommunicationLog.requiring_processing.where(partner: orchestrator.partner, category: 'order_batch')
  edi_logs = [edi_logs].flatten # This way you can pass a single edi communication log
  # Wrap in one big transaction
  batch_process_results = []
  edi_logs.each do |edi_log|
    log_info "Starting processing edi communication log #{edi_log.id}"
    EdiCommunicationLog.transaction do
      # Process the orders in the batch
      batch_process_result = process_orders(edi_log.data, edi_transaction_id: edi_transaction_id, edi_log_id: edi_log.id)
      # Record some meta data in file info
      edi_log.file_info ||= {}
      edi_log.file_info[:orders_in_batch] = batch_process_result.orders_in_batch
      batch_process_result.orders_created.each do |order| # This will only take care of new orders created in AWAITING_CONFIRM
        # Associate the created orders
        edi_log.edi_documents.create!(order: order)
        # Acknowledge the orders so we can send our order ID back to Channel Engine
        orchestrator.fa_message_processor.process(order) if orchestrator.orders_require_acceptance
        # retrieve related packing slips for this batch of orders
        # orchestrator.packing_slip_retriever.process(order)
      end
      batch_process_result.orders_confirmed.each do |order|
        # Associate the created orders only if is not associated yet
        edi_log.edi_documents.create!(order: order) if order.present? && !edi_log.edi_documents.any? { |a| a.resource_id == order.id }
      end
      batch_process_results << batch_process_result
      edi_log.complete!
      # Mark our edi log as processed, we need some error handling at one point
    rescue StandardError => e
      edi_log.notes = "#{e} at #{e&.backtrace_locations&.first}"
      edi_log.error!
      ErrorReporting.error(e, edi_communication_log_id: edi_log.id)
      # End begin rescue block
    end # End transaction
  end # End edi log iteration
  report_order_creation_issues(batch_process_results)
  Result.new(batch_process_results: batch_process_results)
end

#process_confirmed_order(order_hash = nil) ⇒ `Object`

Process a single order

# File 'app/services/edi/mirakl_seller/order_message_processor.rb', line 182

def process_confirmed_order(order_hash = nil)
  order = Order.find_by(edi_po_number: order_hash[:order_id]) # if order is pending it means it hasn't been fully processed yet
  if order.present? && order.pending?
    address, address_originals = create_shipping_address(order_hash)
    order.shipping_address = address
    order.sold_to_billing_address = create_sold_to_billing_address(order_hash)
    recipient_name = order.shipping_address.person_name_override || order.shipping_address.company_name_override
    # Customer info
    order.attention_name_override = recipient_name
    order.shipping_phone = order_hash[:customer][:shipping_address][:phone]
    email = order_hash[:customer_notification_email].presence
    order.tracking_email = [email].compact
    order.billing_emails = [email].compact # This is where the invoice will be sent
    order.edi_shipping_option_name = set_shipping_option(order, order_hash)
    order.edi_channel_order_support = order_hash[:commercial_id]
    order.save!
    record_address_abbreviation_notes(order, address_originals, order.shipping_address)

    apply_payment(order, order_hash)
    order.state = 'in_cr_hold' # Set this as the default state
    order.recalculate_shipping = true
    order.save!

    if (same_po_orders = Order.where(edi_po_number: order.edi_po_number).where.not(id: order.id)).any?
      # warn but don't release orders for every duplicate PO, let someone do it manually
      subj = "EDI order message for orchestrator: #{orchestrator.partner}, order #{order.reference_number} CREATED, order message PO: #{order.edi_po_number}, duplicate"
      msg = "EDI order for orchestrator: #{orchestrator.partner}, order #{order.reference_number}, has the same PO #{order.edi_po_number} as the following older EDI orders: #{same_po_orders.map do |o|
        "#{o.reference_number} (created #{o.created_at.to_date})"
      end.join(', ')}. It has been processed but this is an indication of a possible duplicate order or other issue."
      InternalMailer.notify_edi_admin_of_warning(subj, msg).deliver_later
    else
      order.reload.release_order # Then try to release, if there's any issue (discrepancy, etc) the order will remain on hold
    end
  else
    # Order is already past processing
    logger.warn "Order #{order_hash[:order_id]} already processed and in state #{order.state}"
  end
  order
end

#process_orders(orders_data, edi_transaction_id: nil, edi_log_id: nil) ⇒ `Object`

Iterates through the batch order data

# File 'app/services/edi/mirakl_seller/order_message_processor.rb', line 65

def process_orders(orders_data, edi_transaction_id: nil, edi_log_id: nil)
  json_hash = JSON.parse(orders_data).with_indifferent_access
  orders_created = []
  orders_confirmed = []
  orders_in_batch = 0
  json_hash[:orders].each do |order_hash|
    log_info "Processing order #{order_hash.inspect}"
    po_number = order_hash[:order_id]
    if orchestrator.orders_require_acceptance
      if order_hash[:order_state] == 'WAITING_ACCEPTANCE'
        orders_in_batch += 1
        if Order.where('created_at > ?', 12.months.ago).where(edi_po_number: po_number).count.zero? # only process these once, allow for duplicate EDI PO numbers (it has happened), as long as it has been at least 12 months old. We want to eliminate duplicate orders with the same PO, from message to message i.e. within ~the same day
          orders_created << process_unconfirmed_order(order_hash)
        elsif (same_po_orders = Order.where(created_at: ..4.days.ago).where(created_at: 12.months.ago..).where(edi_po_number: po_number)).any? # otherwise warn that we skipped creating order because we found a matching PO order created older than four days ago, which might indicate the small chance of an order PO collision from another EDI partner
          # Only send notification if we haven't already notified about this duplicate PO
          unless duplicate_po_already_notified?(po_number, edi_log_id)
            subj = "EDI order message for orchestrator: #{orchestrator.partner}, SKIPPED, order message PO: #{po_number}, duplicate"
            msg = "EDI order message for orchestrator: #{orchestrator.partner}, EDI Communication log ID: #{edi_log_id}, order message PO: #{po_number}, has the same PO as the following recent EDI orders: #{same_po_orders.map do |o|
              "#{o.reference_number} (created #{o.created_at.to_date})"
            end.join(', ')}. It has been NOT been processed but SKIPPED as this is an indication of a duplicate order. Please ensure there is no PO number from another partner that might inadvertently match."
            InternalMailer.notify_edi_admin_of_warning(subj, msg).deliver_later
            mark_duplicate_po_as_notified(po_number, edi_log_id)
          end
        end
      elsif order_hash[:order_state] == 'SHIPPING'
        ord = process_confirmed_order(order_hash)
        orders_confirmed << ord if ord.present?
      end
    elsif order_hash[:order_state] == 'SHIPPING'
      orders_in_batch += 1
      if Order.where(created_at: 12.months.ago..).where(edi_po_number: po_number).count.zero? # only process these once, allow for duplicate EDI PO numbers (it has happened), as long as it has been at least 12 months old. We want to eliminate duplicate orders with the same PO, from message to message i.e. within ~the same day
        orders_created << process_unconfirmed_order(order_hash)
        ord = process_confirmed_order(order_hash)
        orders_confirmed << ord if ord.present?
      elsif (same_po_orders = Order.where(created_at: ..4.days.ago).where(created_at: 12.months.ago..).where(edi_po_number: po_number)).any? # otherwise warn that we skipped creating order because we found a matching PO order created older than four days ago, which might indicate the small chance of an order PO collision from another EDI partner
        "EDI order message for orchestrator: #{orchestrator.partner}, EDI Communication log ID: #{edi_log_id}, order message PO: #{po_number}, has the same PO as the following recent EDI orders: #{same_po_orders.map do |o|
          "#{o.reference_number} (created #{o.created_at.to_date})"
        end.join(', ')}. It has been NOT been processed but SKIPPED as this is an indication of a duplicate order. Please ensure there is no PO number from another partner that might inadvertently match."
        # InternalMailer.notify_edi_admin_of_warning(subj, msg).deliver_later
      end
    end
  end
  BatchProcessResult.new(batch_number: nil,
                         orders_created: orders_created,
                         orders_confirmed: orders_confirmed,
                         orders_in_batch: orders_in_batch)
end

#process_unconfirmed_order(order_hash = nil) ⇒ `Object`

Process a single order

# File 'app/services/edi/mirakl_seller/order_message_processor.rb', line 136

def process_unconfirmed_order(order_hash = nil)
  cust = get_customer(order_hash)
  order = cust.orders.build
  order.edi_original_order_message = order_hash.to_json
  order.edi_orchestrator_partner = orchestrator.partner.to_s
  order.edi_order_date = Date.parse(order_hash[:created_date])
  order.edi_transaction_id = order_hash[:order_id]
  order.edi_po_number = order_hash[:order_id]
  order.customer_reference = "OrderNumber: #{order_hash[:order_id]}"
  # original currency
  order.currency = cust.store.currency
  order.single_origin = Store::PUBLIC_STORE_IDS.include?(cust.store.id)
  order.edi_is_pick_slip_required = cust.customer_record&.always_custom_packing_list?
  # Prevent auto coupons on EDI imports with externally set pricing/discounts
  order.disable_auto_coupon = true
  order.save!
  # line items
  line_creation_result = create_line_items(order, order_hash)
  raise line_creation_result.error_message unless line_creation_result.all_skus_valid

  adjust_shipping_cost(order, order_hash) # Roman

  # Revenue before taxes (for price comparison), if price differs, problem, cr hold
  order.line_total
  line_creation_result.line_total
  order.price_match = line_creation_result.line_total # will get save when we call the event
  order.recalculate_shipping = true
  order.save!
  order.reset_discount # temporary measure to force sanity and have revenue show on the order
  order.save!

  if (same_po_orders = Order.where(edi_po_number: order.edi_po_number).where.not(id: order.id)).any?
    # warn but don't release orders for every duplicate PO, let someone do it manually
    subj = "EDI order message for orchestrator: #{orchestrator.partner}, order #{order.reference_number} CREATED, order message PO: #{order.edi_po_number}, duplicate"
    msg = "EDI order for orchestrator: #{orchestrator.partner}, order #{order.reference_number}, has the same PO #{order.edi_po_number} as the following older EDI orders: #{same_po_orders.map do |o|
      "#{o.reference_number} (created #{o.created_at.to_date})"
    end.join(', ')}. It has been processed but this is an indication of a possible duplicate order or other issue."
    InternalMailer.notify_edi_admin_of_warning(subj, msg).deliver_later
  end

  # simplest thing to do is to flag the issue and raise an exception, don't even create the order

  order
end

#set_shipping_option(order, order_hash) ⇒ `Object`

# File 'app/services/edi/mirakl_seller/order_message_processor.rb', line 272

def set_shipping_option(order, order_hash)
  shipping_code = order_hash[:shipping_carrier_code]
  order.country.eu_country?
  order.edi_original_ship_code = shipping_code
  order.signature_confirmation = false
  order.shipping_method = 'override'
end

#shipping_invalid?(order) ⇒ `Boolean`

Returns:

(Boolean)

# File 'app/services/edi/mirakl_seller/order_message_processor.rb', line 222

def shipping_invalid?(order)
  dq = order.deliveries.quoting.first
  return true unless dq
  return true if dq.shipping_option.is_override?
  return true unless dq.shipping_option.name == order.edi_shipping_option_name
  return true unless dq.signature_confirmation == order.signature_confirmation

  false
end

Class: Edi::MiraklSeller::OrderMessageProcessor

Defined Under Namespace

Constant Summary collapse

Constants included from AddressAbbreviator

Instance Attribute Summary

Attributes inherited from BaseEdiService

Instance Method Summary collapse

Methods inherited from BaseEdiService

Methods included from AddressAbbreviator

Methods inherited from BaseService

Constructor Details

Instance Method Details

#adjust_shipping_cost(order, order_hash) ⇒ Object

#apply_payment(order, order_hash) ⇒ Object

#create_line_items(order, order_hash) ⇒ Object

#create_shipping_address(order_hash) ⇒ Object

#create_sold_to_billing_address(order_hash) ⇒ Object

#customer(segment = nil) ⇒ Object

#get_customer(order_hash) ⇒ Object

#process(edi_logs = nil, edi_transaction_id: nil) ⇒ Object

#process_confirmed_order(order_hash = nil) ⇒ Object

#process_orders(orders_data, edi_transaction_id: nil, edi_log_id: nil) ⇒ Object

#process_unconfirmed_order(order_hash = nil) ⇒ Object

#set_shipping_option(order, order_hash) ⇒ Object

#shipping_invalid?(order) ⇒ Boolean

#adjust_shipping_cost(order, order_hash) ⇒ `Object`

#apply_payment(order, order_hash) ⇒ `Object`

#create_line_items(order, order_hash) ⇒ `Object`

#create_shipping_address(order_hash) ⇒ `Object`

#create_sold_to_billing_address(order_hash) ⇒ `Object`

#customer(segment = nil) ⇒ `Object`

#get_customer(order_hash) ⇒ `Object`

#process(edi_logs = nil, edi_transaction_id: nil) ⇒ `Object`

#process_confirmed_order(order_hash = nil) ⇒ `Object`

#process_orders(orders_data, edi_transaction_id: nil, edi_log_id: nil) ⇒ `Object`

#process_unconfirmed_order(order_hash = nil) ⇒ `Object`

#set_shipping_option(order, order_hash) ⇒ `Object`

#shipping_invalid?(order) ⇒ `Boolean`