@things-factory/operato-hub 4.3.804 → 4.3.806

package/server/routers/xilnex-router.ts

@@ -42,7 +42,9 @@ const debug = require('debug')('things-factory:integration-accounting:xilnex-rou
 export const xilnexRouter = new Router()
 
 xilnexRouter.post('/webhook-xilnex-po', async (context, next) => {
-  const originalContext = context
+  let accountWebhookOrder: any = null
+  let accountDomain: any = null
+
   try {
     await getConnection().transaction(async (tx: EntityManager) => {
       const { id, warehouseId } = context.query
@@ -52,7 +54,6 @@ xilnexRouter.post('/webhook-xilnex-po', async (context, next) => {
       logger.info(
         `xilnex-router[webhook-xilnex-po][raw-payload]: ${JSON.stringify({
           query: context.query,
-          headers: header,
           body
         })}`
       )
@@ -82,6 +83,17 @@ xilnexRouter.post('/webhook-xilnex-po', async (context, next) => {
         context.throw(400, `${id} not found in Account`)
       }
 
+      accountDomain = account.domain
+
+      // Prepare webhook order record early for persistence
+      accountWebhookOrder = {
+        name: uuidv4(),
+        request: body,
+        platform: ACCOUNT_PLATFORM.XILNEX,
+        domain: account.domain,
+        status: ACCOUNT_SYNC_STATUS.FAILED
+      }
+
       const { webhookKey } = account
       const signature = header['xilnex-webhook-signature']
 
@@ -98,6 +110,7 @@ xilnexRouter.post('/webhook-xilnex-po', async (context, next) => {
       }
 
       if (!xilnex.isValidSignature(payload, webhookKey, signature)) {
+        logger.error(`xilnex-router[webhook-xilnex-po][signature-failed]: accountId=${id}, source=${sourceType}`)
         context.throw(400, `Signature validation failed`)
       }
 
@@ -115,16 +128,9 @@ xilnexRouter.post('/webhook-xilnex-po', async (context, next) => {
         context.throw(400, `${warehouseId} not found in warehouse domain`)
       }
 
-      let accountWebhookOrder: any = {
-        name: uuidv4(),
-        request: body,
-        platform: ACCOUNT_PLATFORM.XILNEX,
-        domain: account.domain,
-        status: ACCOUNT_SYNC_STATUS.FAILED
-      }
-
       // Get order ID based on source type
       const orderId = sourceType === 'XilnexPortal' ? data?.purchaseOrder?.id : data?.id
+      logger.info(`xilnex-router[webhook-xilnex-po][processing]: orderId=${orderId}, source=${sourceType}`)
 
       if (orderId) {
         let orderInfo: any
@@ -189,8 +195,7 @@ xilnexRouter.post('/webhook-xilnex-po', async (context, next) => {
               `xilnex-router[webhook-xilnex-po]: Duplicate PO skipped, refNo ${orderInfo.orderId} already exists as ${existingPO.name}`
             )
             accountWebhookOrder.status = ACCOUNT_SYNC_STATUS.SUCCESS
-            await tx.getRepository(AccountWebhookOrder).save(accountWebhookOrder)
-            context.status = 200
+            accountWebhookOrder.response = `Duplicate PO skipped, already exists as ${existingPO.name}`
             return
           }
 
@@ -277,26 +282,64 @@ xilnexRouter.post('/webhook-xilnex-po', async (context, next) => {
         }
 
         accountWebhookOrder.status = ACCOUNT_SYNC_STATUS.SUCCESS
-        await tx.getRepository(AccountWebhookOrder).save(accountWebhookOrder)
       }
     })
 
+    // Save webhook order outside transaction so it persists even if tx rolled back
+    if (accountWebhookOrder) {
+      await getRepository(AccountWebhookOrder).save(accountWebhookOrder)
+    }
+
     context.status = 200
   } catch (err) {
-    logger.error(`xilnex-router[webhook-xilnex-po-original-context]: ${JSON.stringify(originalContext)}`)
-    logger.error(`xilnex-router[webhook-xilnex-po]: ${err}`)
+    const errorMessage = err instanceof ValidationError
+      ? JSON.stringify({ errorCode: err.errorCode, message: err.message, detail: err.detail })
+      : err?.message || String(err)
+    logger.error(`xilnex-router[webhook-xilnex-po]: ${errorMessage}`)
+
+    // Persist failed webhook order record for troubleshooting
+    try {
+      if (accountWebhookOrder) {
+        accountWebhookOrder.status = ACCOUNT_SYNC_STATUS.FAILED
+        accountWebhookOrder.response = errorMessage
+        await getRepository(AccountWebhookOrder).save(accountWebhookOrder)
+      } else if (accountDomain) {
+        await getRepository(AccountWebhookOrder).save({
+          name: uuidv4(),
+          request: JSON.stringify(context.request.body),
+          response: errorMessage,
+          platform: ACCOUNT_PLATFORM.XILNEX,
+          domain: accountDomain,
+          status: ACCOUNT_SYNC_STATUS.FAILED
+        })
+      }
+    } catch (saveErr) {
+      logger.error(`xilnex-router[webhook-xilnex-po][failed-to-save-webhook-order]: ${saveErr?.message}`)
+    }
+
     context.status = 400
-    context.throw(400, err)
+    context.body = { error: errorMessage }
   }
 })
 
 xilnexRouter.post('/webhook-xilnex-transfer-note', async (context, next) => {
-  const originalContext = context
+  // Save webhook order outside the main transaction so it persists even on failure
+  let accountWebhookOrder: any = null
+  let accountDomain: any = null
+
   try {
     await getConnection().transaction(async (tx: EntityManager) => {
       const { id, warehouseId } = context.query
       const { body, header } = context.request
 
+      // Log raw webhook payload for debugging
+      logger.info(
+        `xilnex-router[webhook-xilnex-transfer-note][raw-payload]: ${JSON.stringify({
+          query: context.query,
+          body
+        })}`
+      )
+
       // Detect source type and parse data accordingly
       const sourceType = body?.Source || 'Classic'
       let data: any = {}
@@ -322,6 +365,17 @@ xilnexRouter.post('/webhook-xilnex-transfer-note', async (context, next) => {
         context.throw(400, `${id} not found in Account`)
       }
 
+      accountDomain = account.domain
+
+      // Prepare webhook order record early for persistence
+      accountWebhookOrder = {
+        name: uuidv4(),
+        request: body,
+        platform: ACCOUNT_PLATFORM.XILNEX,
+        domain: account.domain,
+        status: ACCOUNT_SYNC_STATUS.FAILED
+      }
+
       const { webhookKey } = account
       const signature = header['xilnex-webhook-signature']
 
@@ -338,6 +392,7 @@ xilnexRouter.post('/webhook-xilnex-transfer-note', async (context, next) => {
       }
 
       if (!xilnex.isValidSignature(payload, webhookKey, signature)) {
+        logger.error(`xilnex-router[webhook-xilnex-transfer-note][signature-failed]: accountId=${id}, source=${sourceType}`)
         context.throw(400, `Signature validation failed`)
       }
 
@@ -355,18 +410,11 @@ xilnexRouter.post('/webhook-xilnex-transfer-note', async (context, next) => {
         context.throw(400, `${warehouseId} not found in warehouse domain`)
       }
 
-      let accountWebhookOrder: any = {
-        name: uuidv4(),
-        request: body,
-        platform: ACCOUNT_PLATFORM.XILNEX,
-        domain: account.domain,
-        status: ACCOUNT_SYNC_STATUS.FAILED
-      }
-
       let accountInfo: any = account?.accountInfo ? JSON.parse(account.accountInfo) : {}
 
       // Get order ID based on source type
       const orderId = sourceType === 'XilnexPortal' ? data?.transferNote?.id : data?.id
+      logger.info(`xilnex-router[webhook-xilnex-transfer-note][processing]: orderId=${orderId}, source=${sourceType}, accountOutlet=${accountInfo.outlet}`)
 
       if (orderId) {
         let orderInfo: any
@@ -419,6 +467,10 @@ xilnexRouter.post('/webhook-xilnex-transfer-note', async (context, next) => {
           orderItems = transferNote.orderItems
         }
 
+        logger.info(
+          `xilnex-router[webhook-xilnex-transfer-note][outlet-check]: orderId=${orderId}, from=${orderInfo.fromLocation}, to=${orderInfo.toLocation}, outlet=${accountInfo.outlet}, matchFrom=${orderInfo.fromLocation == accountInfo.outlet}, matchTo=${orderInfo.toLocation == accountInfo.outlet}`
+        )
+
         if (orderInfo.fromLocation == accountInfo.outlet || orderInfo.toLocation == accountInfo.outlet) {
           // VDC release
           if (accountInfo.outlet == orderInfo.fromLocation) {
@@ -597,6 +649,7 @@ xilnexRouter.post('/webhook-xilnex-transfer-note', async (context, next) => {
               status: 'INTRANSIT'
             }
             arrivalNotice = await tx.getRepository(ArrivalNotice).save(arrivalNotice)
+            logger.info(`xilnex-router[webhook-xilnex-transfer-note][arrival-notice-created]: orderId=${orderId}, ganNo=${arrivalNotice.name}, ganId=${arrivalNotice.id}`)
 
             let orderProducts: any[] = []
             await Promise.all(
@@ -647,27 +700,71 @@ xilnexRouter.post('/webhook-xilnex-transfer-note', async (context, next) => {
             )
             await tx.getRepository(OrderProduct).save(orderProducts)
           }
+        } else {
+          logger.info(`xilnex-router[webhook-xilnex-transfer-note][skipped-no-outlet-match]: orderId=${orderId}, outlet=${accountInfo.outlet}, from=${orderInfo.fromLocation}, to=${orderInfo.toLocation}`)
         }
+      } else {
+        logger.info(`xilnex-router[webhook-xilnex-transfer-note][skipped-no-order-id]: no orderId found in webhook payload`)
       }
 
       accountWebhookOrder.status = ACCOUNT_SYNC_STATUS.SUCCESS
-      await tx.getRepository(AccountWebhookOrder).save(accountWebhookOrder)
     })
 
+    // Save webhook order outside transaction so it persists even if tx rolled back
+    if (accountWebhookOrder) {
+      await getRepository(AccountWebhookOrder).save(accountWebhookOrder)
+    }
+
     context.status = 200
   } catch (err) {
-    logger.error(`xilnex-router[webhook-xilnex-transfer-note-original-context]: ${JSON.stringify(originalContext)}`)
-    logger.error(`xilnex-router[webhook-xilnex-transfer-note]: ${err}`)
+    const errorMessage = err instanceof ValidationError
+      ? JSON.stringify({ errorCode: err.errorCode, message: err.message, detail: err.detail })
+      : err?.message || String(err)
+    logger.error(`xilnex-router[webhook-xilnex-transfer-note]: ${errorMessage}`)
+
+    // Persist failed webhook order record for troubleshooting
+    try {
+      if (accountWebhookOrder) {
+        accountWebhookOrder.status = ACCOUNT_SYNC_STATUS.FAILED
+        accountWebhookOrder.response = errorMessage
+        await getRepository(AccountWebhookOrder).save(accountWebhookOrder)
+      } else if (accountDomain) {
+        // Error happened before webhook order was prepared — save with minimal info
+        await getRepository(AccountWebhookOrder).save({
+          name: uuidv4(),
+          request: JSON.stringify(context.request.body),
+          response: errorMessage,
+          platform: ACCOUNT_PLATFORM.XILNEX,
+          domain: accountDomain,
+          status: ACCOUNT_SYNC_STATUS.FAILED
+        })
+      }
+    } catch (saveErr) {
+      logger.error(`xilnex-router[webhook-xilnex-transfer-note][failed-to-save-webhook-order]: ${saveErr?.message}`)
+    }
+
     context.status = 400
-    context.throw(400, err)
+    context.body = { error: errorMessage }
   }
 })
 
 xilnexRouter.post('/webhook-xilnex-stock-request', async (context, next) => {
+  let accountWebhookOrder: any = null
+  let accountDomain: any = null
+
   try {
     await getConnection().transaction(async (tx: EntityManager) => {
       const { id, warehouseId } = context.query
       const { body, headers } = context.request
+
+      // Log raw webhook payload for debugging
+      logger.info(
+        `xilnex-router[webhook-xilnex-stock-request][raw-payload]: ${JSON.stringify({
+          query: context.query,
+          body
+        })}`
+      )
+
       const data = body?.Data ? JSON.parse(body.Data) : {}
 
       const account = await AccountingAPI.getAccounting(id)
@@ -675,6 +772,17 @@ xilnexRouter.post('/webhook-xilnex-stock-request', async (context, next) => {
         throw new Error(`${id} not found in Account`)
       }
 
+      accountDomain = account.domain
+
+      // Prepare webhook order record early for persistence
+      accountWebhookOrder = {
+        name: uuidv4(),
+        request: body,
+        platform: ACCOUNT_PLATFORM.XILNEX,
+        domain: account.domain,
+        status: ACCOUNT_SYNC_STATUS.FAILED
+      }
+
       const { webhookKey } = account
       const signature = headers['xilnex-webhook-signature']
 
@@ -683,6 +791,7 @@ xilnexRouter.post('/webhook-xilnex-stock-request', async (context, next) => {
       // webhook-xilnex-stock-request only supports Classic source (no Source field in body)
       // Use parsed body for Classic source
       if (!xilnex.isValidSignature(body, webhookKey, signature)) {
+        logger.error(`xilnex-router[webhook-xilnex-stock-request][signature-failed]: accountId=${id}`)
         context.throw(400, 'Signature validation failed')
       }
 
@@ -700,14 +809,6 @@ xilnexRouter.post('/webhook-xilnex-stock-request', async (context, next) => {
         context.throw(400, `${warehouseId} not found in warehouse domain`)
       }
 
-      let accountWebhookOrder: any = {
-        name: uuidv4(),
-        request: body,
-        platform: ACCOUNT_PLATFORM.XILNEX,
-        domain: account.domain,
-        status: ACCOUNT_SYNC_STATUS.FAILED
-      }
-
       let accountInfo: any = account?.accountInfo ? JSON.parse(account.accountInfo) : {}
 
       if (data?.id) {
@@ -931,14 +1032,42 @@ xilnexRouter.post('/webhook-xilnex-stock-request', async (context, next) => {
       }
 
       accountWebhookOrder.status = ACCOUNT_SYNC_STATUS.SUCCESS
-      await tx.getRepository(AccountWebhookOrder).save(accountWebhookOrder)
     })
 
+    // Save webhook order outside transaction so it persists even if tx rolled back
+    if (accountWebhookOrder) {
+      await getRepository(AccountWebhookOrder).save(accountWebhookOrder)
+    }
+
     context.status = 200
   } catch (err) {
-    logger.error(`xilnex-router[webhook-xilnex-stock-request]: ${err}`)
+    const errorMessage = err instanceof ValidationError
+      ? JSON.stringify({ errorCode: err.errorCode, message: err.message, detail: err.detail })
+      : err?.message || String(err)
+    logger.error(`xilnex-router[webhook-xilnex-stock-request]: ${errorMessage}`)
+
+    // Persist failed webhook order record for troubleshooting
+    try {
+      if (accountWebhookOrder) {
+        accountWebhookOrder.status = ACCOUNT_SYNC_STATUS.FAILED
+        accountWebhookOrder.response = errorMessage
+        await getRepository(AccountWebhookOrder).save(accountWebhookOrder)
+      } else if (accountDomain) {
+        await getRepository(AccountWebhookOrder).save({
+          name: uuidv4(),
+          request: JSON.stringify(context.request.body),
+          response: errorMessage,
+          platform: ACCOUNT_PLATFORM.XILNEX,
+          domain: accountDomain,
+          status: ACCOUNT_SYNC_STATUS.FAILED
+        })
+      }
+    } catch (saveErr) {
+      logger.error(`xilnex-router[webhook-xilnex-stock-request][failed-to-save-webhook-order]: ${saveErr?.message}`)
+    }
+
     context.status = 400
-    context.throw(400, err)
+    context.body = { error: errorMessage }
   }
 })