RMA Events

@app.route('/api/rmaEvent', methods=['POST'])
def handle_rma_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 RMA update
        for rma in payload['data']:
            rma_id = rma['customer_identifier']
            status = rma['status']
            tracking = rma.get('package_id')

            # Update RMA status
            update_rma_status(rma_id, status)

            if status == 'tendered':
                logger.info(f"RMA {rma_id} tendered to carrier")

            elif status == 'inTransit':
                logger.info(f"RMA {rma_id} in transit")
                notify_customer_return_in_transit(rma_id)

            elif status == 'delivered':
                logger.info(f"RMA {rma_id} delivered to warehouse")

            elif status == 'received':
                # Process returned items
                line_items = rma.get('line_items', [])
                notes = rma.get('notes', '')

                for item in line_items:
                    order_id = item['customer_order_id']
                    sku = item['customer_sku_id']
                    expected = item['quantity']
                    received = item['quantity_received']
                    reason = item['return_reason_code']
                    inv_status = item['return_inventory_status']
                    unexpected = item['not_on_original_rma']

                    # Update inventory based on status
                    if inv_status == 'available':
                        # Add to sellable inventory
                        restock_inventory(sku, received)
                        logger.info(f"Restocked {received} units of {sku}")

                    elif inv_status == 'damaged':
                        # Mark as damaged, don't add to available
                        mark_inventory_damaged(sku, received)
                        logger.warning(f"{received} units of {sku} marked damaged")

                    elif inv_status == 'quality-control':
                        # Hold for QC decision
                        hold_for_quality_control(sku, received)

                    # Process refund
                    if inv_status in ['available', 'quality-control']:
                        process_refund(order_id, sku, received)

                    # Check for discrepancies
                    if received < expected:
                        log_rma_shortage(rma_id, sku, expected - received)

                    if unexpected:
                        log_unexpected_return(rma_id, sku, received)

                # Notify customer
                notify_customer_return_processed(rma_id)
                logger.info(f"RMA {rma_id} processing complete")

            elif status == 'undeliverable':
                logger.error(f"RMA {rma_id} undeliverable")
                notify_customer_return_failed(rma_id)

        mark_message_processed(message_id)
        return 'OK', 200

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

app.post('/api/rmaEvent', 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 RMA update
    for (const rma of payload.data) {
      const rmaId = rma.customer_identifier;
      const status = rma.status;

      // Update RMA status
      await updateRMAStatus(rmaId, status);

      if (status === 'tendered') {
        console.log(`RMA ${rmaId} tendered to carrier`);

      } else if (status === 'inTransit') {
        console.log(`RMA ${rmaId} in transit`);
        await notifyCustomerReturnInTransit(rmaId);

      } else if (status === 'delivered') {
        console.log(`RMA ${rmaId} delivered to warehouse`);

      } else if (status === 'received') {
        // Process returned items
        const lineItems = rma.line_items || [];

        for (const item of lineItems) {
          const orderId = item.customer_order_id;
          const sku = item.customer_sku_id;
          const received = item.quantity_received;
          const invStatus = item.return_inventory_status;

          // Update inventory based on status
          if (invStatus === 'available') {
            await restockInventory(sku, received);
            console.log(`Restocked ${received} units of ${sku}`);

          } else if (invStatus === 'damaged') {
            await markInventoryDamaged(sku, received);
            console.warn(`${received} units of ${sku} marked damaged`);

          } else if (invStatus === 'quality-control') {
            await holdForQualityControl(sku, received);
          }

          // Process refund
          if (['available', 'quality-control'].includes(invStatus)) {
            await processRefund(orderId, sku, received);
          }

          // Check for unexpected items
          if (item.not_on_original_rma) {
            await logUnexpectedReturn(rmaId, sku, received);
          }
        }

        // Notify customer
        await notifyCustomerReturnProcessed(rmaId);
        console.log(`RMA ${rmaId} processing complete`);

      } else if (status === 'undeliverable') {
        console.error(`RMA ${rmaId} undeliverable`);
        await notifyCustomerReturnFailed(rmaId);
      }
    }

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

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