Order Cancel Resolutions

@app.route('/api/orderCancelResolution', methods=['POST'])
def handle_order_cancel_resolution():
    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 resolution
        for resolution in payload['data']:
            order_id = resolution['customer_order_id']
            status = resolution['status']
            reason = resolution.get('reason')

            if status == 'success':
                # Mark order as canceled
                mark_order_canceled(order_id)

                # Process refund
                process_refund(order_id)

                # Notify customer
                send_cancellation_confirmation(order_id)

                logger.info(f"Order {order_id} canceled successfully")

            else:  # failure
                # Log failure
                log_cancel_failure(order_id, reason)

                if reason == "Order already packed":
                    # Inform customer they need to return after delivery
                    notify_customer_return_required(order_id)

                    # Prepare RMA for when package arrives
                    prepare_return_label(order_id)

                elif reason == "Order already shipped":
                    # Initiate return process
                    create_rma(order_id)
                    send_return_instructions(order_id)

                logger.error(f"Order {order_id} cancel failed: {reason}")

        mark_message_processed(message_id)
        return 'OK', 200

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

app.post('/api/orderCancelResolution', 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 resolution
    for (const resolution of payload.data) {
      const orderId = resolution.customer_order_id;
      const status = resolution.status;
      const reason = resolution.reason;

      if (status === 'success') {
        // Mark order as canceled
        await markOrderCanceled(orderId);

        // Process refund
        await processRefund(orderId);

        // Notify customer
        await sendCancellationConfirmation(orderId);

        console.log(`Order ${orderId} canceled successfully`);

      } else {
        // Log failure
        await logCancelFailure(orderId, reason);

        if (reason === 'Order already packed') {
          // Customer needs to return after delivery
          await notifyCustomerReturnRequired(orderId);
          await prepareReturnLabel(orderId);

        } else if (reason === 'Order already shipped') {
          // Initiate return process
          await createRMA(orderId);
          await sendReturnInstructions(orderId);
        }

        console.error(`Order ${orderId} cancel failed: ${reason}`);
      }
    }

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

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