Class: Edi::Amazon::OrderRetriever

Inherits:
Retriever show all
Defined in:
app/services/edi/amazon/order_retriever.rb

Overview

I connect to a transport, retrieve files and save them in the Edi Communication log

Instance Method Summary collapse

Methods inherited from BaseService

#initialize, #log_debug, #log_error, #log_info, #log_warning, #logger, #options, #tagged_logger

Constructor Details

This class inherits a constructor from BaseService

Instance Method Details

#instantiate_transporter(transporter, transporter_profile = nil) ⇒ Object 



73
74
75
76
77
78
79
80
 
# File 'app/services/edi/amazon/order_retriever.rb', line 73

def instantiate_transporter(transporter, transporter_profile = nil)
  case transporter
  when :http_seller_api
    Transport::HttpSellerApiConnection.new({ profile: transporter_profile })
  else
    raise "Unknown transporter: #{transporter}"
  end
end

#process(partner:, category:, transporter: :http_seller_api, transporter_profile: nil, remote_path: nil, data_type: 'json', orchestrator:, store_to_upload: false, file_info: {}) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
# File 'app/services/edi/amazon/order_retriever.rb', line 6

def process(partner:, category:, transporter: :http_seller_api,
            transporter_profile: nil, # Transporter profile for sftp connection, see secrets.yml
            remote_path: nil, # Name of partner for creating log entry, # Category for log entry
            data_type: 'json',
            orchestrator:,
            store_to_upload: false,
            file_info: {}) # By default the file content is stored to the log directly, if true then an upload is created )
  Rails.logger.debug { "Edi::Amazon::OrderRetriever, remote_path: #{remote_path}" }
  transport = instantiate_transporter(transporter, transporter_profile)
  begin
    res = transport.send_data('', remote_path, 'GET')
  rescue HTTP::RateLimitExceededError => e
    logger.warn "Amazon SP-API rate limited fetching orders list. Skipping run; next scheduled run will retry. #{e.message}"
    return []
  end
  Rails.logger.debug { "Edi::Amazon::OrderRetriever, res: #{res}" }
  edi_logs = []
  EdiCommunicationLog.transaction do
    json_hash = nil
    if res[:success] && (data = res[:http_result]&.body.to_s).present?
      # Our problem here is to not only pull the order data which has no PII, but then as a secondary pull on each order the address PII and orderItems so that we can fulfill it
      # See: https://developer-docs.amazon.com/sp-api/docs/orders-api-v0-reference
      # See getOrders: https://developer-docs.amazon.com/sp-api/docs/orders-api-v0-reference#getorders
      # See getOrderAddress: https://developer-docs.amazon.com/sp-api/docs/orders-api-v0-reference#getorderaddress
      # See getOrderItems: https://developer-docs.amazon.com/sp-api/docs/orders-api-v0-reference#getorderitems
      json_hash = JSON.parse(data).with_indifferent_access
      Rails.logger.debug { "Edi::Amazon::OrderRetriever, json_hash: #{json_hash}" }
      data_blob = nil
      if json_hash.present? && (order_hashes = (json_hash.dig(:payload, :Orders) || [])).any? # just skip generating edi communication logs if no records to process
        order_hashes.each do |order_hash|
          # extract AmazonOrderId
          order_id = order_hash.dig(:AmazonOrderId)
          # 1 getOrderAddress:
          address_res = transport.send_data('', "#{orchestrator.order_message_remote_path}/#{order_id}/address", 'GET')
          Rails.logger.debug { "Edi::Amazon::OrderRetriever, getOrderAddress, address_res: #{address_res}" }
          if address_res[:success] && (address_data = address_res[:http_result]&.body.to_s).present?
            address_json_hash = JSON.parse(address_data).with_indifferent_access
            order_hash[:ShippingAddressPii] = address_json_hash.dig(:payload, :ShippingAddress)
            # 2 getOrderItems:
            order_items_res = transport.send_data('', "#{orchestrator.order_message_remote_path}/#{order_id}/orderItems", 'GET')
            Rails.logger.debug { "Edi::Amazon::OrderRetriever, getOrderItems, order_items_res: #{order_items_res}" }
            if order_items_res[:success] && (order_items_data = order_items_res[:http_result]&.body.to_s).present?
              order_items_json_hash = JSON.parse(order_items_data).with_indifferent_access
              order_hash[:OrderItems] = order_items_json_hash.dig(:payload, :OrderItems)
            end
          end
        rescue HTTP::RateLimitExceededError => e
          logger.warn "Amazon SP-API rate limited fetching restricted data token for order #{order_id}. " \
                      "Rolling back batch; next run will retry all orders. #{e.message}"
          raise ActiveRecord::Rollback
        end
        data_blob = json_hash.to_json
        edi_log = EdiCommunicationLog.new(partner:,
                                          category:,
                                          data: data_blob,
                                          data_type:,
                                          transmit_datetime: Time.current)
        edi_log.save!
        logger.info "saved to edi log #{edi_log.id}"
        edi_logs << edi_log
      end
    end
  end
  Rails.logger.debug { "Edi::Amazon::OrderRetriever, edi_logs: #{edi_logs}" }
  edi_logs
end