Inbound Shipment Events

@app.route('/api/inboundShipmentEvent', methods=['POST'])
def handle_inbound_shipment_event():
    try:
        payload = request.get_json()
        message_id = payload['message_id']

        # Check if already processed
        if is_message_processed(message_id):
            return 'OK', 200

        # Process each shipment update
        for shipment in payload['data']:
            shipment_id = shipment['customer_identifier']
            status = shipment['status']
            details = shipment.get('details', {})

            # Update shipment status
            update_shipment_status(shipment_id, status)

            if status == 'onDock':
                logger.info(f"Shipment {shipment_id} arrived at dock")
                notify_ops_team_shipment_arrived(shipment_id)

            elif status == 'receivingStarted':
                started_at = details.get('started_receiving_at')
                logger.info(f"Receiving started for {shipment_id}")

            elif status == 'receivingComplete':
                # Process line items
                line_items = details.get('line_items', [])

                for item in line_items:
                    sku = item['customer_sku_id']
                    expected = item['quantity']
                    received = item['total_quantity_received']
                    unexpected = item['not_on_original_shipment']

                    # Update inventory records
                    update_inventory_received(sku, received)

                    # Check for discrepancies
                    if received < expected:
                        shortage = expected - received
                        log_shortage(shipment_id, sku, shortage)
                        alert_ops_team_shortage(shipment_id, sku, shortage)

                    elif received > expected:
                        overage = received - expected
                        log_overage(shipment_id, sku, overage)

                    if unexpected:
                        log_unexpected_item(shipment_id, sku, received)
                        notify_supplier_unexpected_item(shipment_id, sku)

                logger.info(f"Receiving complete for {shipment_id}")

        mark_message_processed(message_id)
        return 'OK', 200

    except Exception as e:
        logger.error(f"Inbound shipment webhook error: {e}")
        return 'Error', 500

app.post('/api/inboundShipmentEvent', async (req, res) => {
  try {
    const payload = req.body;
    const messageId = payload.message_id;

    // Check if already processed
    if (await isMessageProcessed(messageId)) {
      return res.status(200).send('OK');
    }

    // Process each shipment update
    for (const shipment of payload.data) {
      const shipmentId = shipment.customer_identifier;
      const status = shipment.status;
      const details = shipment.details || {};

      // Update shipment status
      await updateShipmentStatus(shipmentId, status);

      if (status === 'onDock') {
        console.log(`Shipment ${shipmentId} arrived at dock`);
        await notifyOpsTeamShipmentArrived(shipmentId);

      } else if (status === 'receivingStarted') {
        console.log(`Receiving started for ${shipmentId}`);

      } else if (status === 'receivingComplete') {
        // Process line items
        const lineItems = details.line_items || [];

        for (const item of lineItems) {
          const sku = item.customer_sku_id;
          const expected = item.quantity;
          const received = item.total_quantity_received;

          // Update inventory
          await updateInventoryReceived(sku, received);

          // Check for discrepancies
          if (received < expected) {
            const shortage = expected - received;
            await logShortage(shipmentId, sku, shortage);
            await alertOpsTeamShortage(shipmentId, sku, shortage);

          } else if (received > expected) {
            const overage = received - expected;
            await logOverage(shipmentId, sku, overage);
          }

          if (item.not_on_original_shipment) {
            await logUnexpectedItem(shipmentId, sku, received);
            await notifySupplierUnexpectedItem(shipmentId, sku);
          }
        }

        console.log(`Receiving complete for ${shipmentId}`);
      }
    }

    await markMessageProcessed(messageId);
    res.status(200).send('OK');

  } catch (error) {
    console.error('Inbound shipment webhook error:', error);
    res.status(500).send('Error');
  }
});