Class: Edi::BaseEdiService

# File 'app/services/edi/base_edi_service.rb', line 14

def initialize(orchestrator, options = {})
  @orchestrator = orchestrator
  super(options)
end

Instance Attribute Details

#orchestrator ⇒ `Object` (readonly)

Returns the value of attribute orchestrator.



9
10
11

# File 'app/services/edi/base_edi_service.rb', line 9

def orchestrator
  @orchestrator
end

Instance Method Details

#amazon_feed_product_type(catalog_item) ⇒ `String`^? (protected)

Resolve the Amazon productType for a Listings feed PATCH. Delegates to the
Listings-Items path so the two can never drift — the feed and the
listing PUT/PATCH must submit the SAME productType for the same item. See
Models::CatalogItemAmazonHelper#amazon_product_type_in_effect for the precedence (reported
before desired) and why an unlaunched desired type must never be submitted.

Returns nil when nothing is known — callers MUST skip the item rather than
guessing, so we never register a wrong product type.

Parameters:

catalog_item (CatalogItem)

Returns:

(String, nil)



59
60
61

# File 'app/services/edi/base_edi_service.rb', line 59

def amazon_feed_product_type(catalog_item)
  catalog_item.amazon_product_type_in_effect
end

#duplicate_po_already_notified?(po_number, current_edi_log_id) ⇒ `Boolean` (protected)

Check if we've already sent a notification about this duplicate PO
Looks for processed EDI logs with this PO that have no associated order
(meaning they detected a duplicate and sent a notification)

Returns:

(Boolean)

# File 'app/services/edi/base_edi_service.rb', line 73

def duplicate_po_already_notified?(po_number, current_edi_log_id)
  return false if po_number.blank?

  # Find processed EDI logs for this partner that:
  # 1. Contain this PO in their data
  # 2. Have NO associated orders (meaning they didn't create an order = duplicate detection)
  EdiCommunicationLog
    .where(partner: orchestrator.partner, category: 'order_batch')
    .where(state: 'processed')
    .where('edi_communication_logs.created_at > ?', 30.days.ago)
    .where.not(edi_communication_logs: { id: current_edi_log_id.to_i })
    .where('edi_communication_logs.data LIKE ?', "%#{po_number}%")
    .where.missing(:orders)
    .exists?
end

#mark_duplicate_po_as_notified(po_number, edi_log_id) ⇒ `Object` (protected)

No-op: notification tracking is now based on processed logs without orders

# File 'app/services/edi/base_edi_service.rb', line 90

def mark_duplicate_po_as_notified(po_number, edi_log_id)
  # Tracking is implicit: when this log is marked 'processed' without creating an order,
  # future checks will find it and skip sending duplicate notifications
end

#onboard_ordered_catalog_items(order) ⇒ `void` (protected)

This method returns an undefined value.

Promote every ordered catalog item still parked in pending_onboarding.
A retailer only transmits an order for a SKU it actually sells, so the
order is proof the listing is live — see CatalogItem#onboarded_by_order!.

Call this ONLY once the order is fully built. Promoting mid-build would
survive a rejected order: several processors rescue per-order INSIDE the
batch transaction (Edi::Amazon::OrderMessageProcessor#process_orders),
so the transaction commits even when a line raised.

Parameters:

order (Order)



45
46
47

# File 'app/services/edi/base_edi_service.rb', line 45

def onboard_ordered_catalog_items(order)
  order.line_items.each { |line_item| line_item.catalog_item&.onboarded_by_order! }
end

#report_order_creation_issues(batch_process_results) ⇒ `Object` (protected)

# File 'app/services/edi/base_edi_service.rb', line 63

def report_order_creation_issues(batch_process_results)
  orders_created = batch_process_results.flat_map(&:orders_created)
  if (orders_to_report = orders_created.to_a.select(&:requires_intervention?)).present?
    EdiMailer.edi_orders_notification(orders_to_report).deliver_later
  end
end

#safe_process_edi_communication_log(ecl) ⇒ `Object`

Contains a failure to the one log it belongs to, so the rest of the batch
still gets processed. can_error? matters: a processor that already
errored the record before raising would otherwise hit InvalidTransition
here, and that escapes the rescue and kills the whole loop.

# File 'app/services/edi/base_edi_service.rb', line 23

def safe_process_edi_communication_log(ecl)
  process_communication_log(ecl)
rescue StandardError => e
  msg = "Exception while processing edi_communication_log #{ecl.id}: #{e}"
  ErrorReporting.error(e, msg)
  ecl.notes = msg
  ecl.can_error? ? ecl.error! : ecl.save
  logger.error msg
end

Class: Edi::BaseEdiService

Overview

Direct Known Subclasses

Constant Summary

Constants included from RequestIdentifiable

Constants included from AddressAbbreviator

Instance Attribute Summary collapse

Attributes inherited from BaseService

Instance Method Summary collapse

Methods included from RequestIdentifiable

Methods included from AddressAbbreviator

Methods inherited from BaseService

Constructor Details

#initialize(orchestrator, options = {}) ⇒ BaseEdiService

Instance Attribute Details

#orchestrator ⇒ Object (readonly)

Instance Method Details

#amazon_feed_product_type(catalog_item) ⇒ String? (protected)

#duplicate_po_already_notified?(po_number, current_edi_log_id) ⇒ Boolean (protected)

#mark_duplicate_po_as_notified(po_number, edi_log_id) ⇒ Object (protected)

#onboard_ordered_catalog_items(order) ⇒ void (protected)

#report_order_creation_issues(batch_process_results) ⇒ Object (protected)

#safe_process_edi_communication_log(ecl) ⇒ Object

#initialize(orchestrator, options = {}) ⇒ `BaseEdiService`