@things-factory/worksheet-base 4.3.130 → 4.3.132

package/server/controllers/pos/xilnex-controller.ts

@@ -0,0 +1,218 @@
+import { EntityManager } from 'typeorm'
+
+import { logger } from '@things-factory/env'
+import { Accounting, AccountingAPI } from '@things-factory/integration-accounting'
+import {
+  ArrivalNotice,
+  DeliveryOrder,
+  ORDER_SOURCE_TYPE,
+  OrderInventory,
+  ReleaseGood
+} from '@things-factory/sales-base'
+import { Inventory } from '@things-factory/warehouse-base'
+
+import { WorksheetDetail } from '../../entities'
+import { WorksheetController } from '../worksheet-controller'
+
+export class XilnexController extends WorksheetController {
+  async createInboundDocument(
+    tx: EntityManager,
+    xilnex: Accounting,
+    arrivalNoticeId: string,
+    inventoryIds: string[]
+  ): Promise<void> {
+    try {
+      const arrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
+        where: { id: arrivalNoticeId },
+        relations: ['domain', 'bizplace', 'bizplace.domain']
+      })
+
+      let qb = tx
+        .getRepository(Inventory)
+        .createQueryBuilder('iv')
+        .select('p.sku', 'productSku')
+        .addSelect('SUM(COALESCE(iv.qty,0))', 'totalQty')
+        .addSelect('SUM(COALESCE(iv.unit_cost,0))', 'unitCost')
+        .innerJoin('iv.location', 'loc')
+        .innerJoin('iv.product', 'p')
+        .where('"iv"."id" IN (:...inventoryIds)')
+        .groupBy('iv.product_id')
+        .addGroupBy('p.sku')
+        .setParameters({
+          inventoryIds: inventoryIds
+        })
+
+      let qbResult: any = await qb.getRawMany()
+      let orderProducts: any[] = qbResult.map(item => {
+        return {
+          product: {
+            sku: item.productSku
+          },
+          actualPackQty: item.totalQty,
+          unitPrice: item.unitCost
+        }
+      })
+
+      const orderSourceType: string = arrivalNotice.orderSourceType
+      switch (orderSourceType) {
+        case ORDER_SOURCE_TYPE.XILNEX_PO:
+          await AccountingAPI.createPurchaseReceive(xilnex, {
+            arrivalNotice,
+            orderProducts: orderProducts
+          })
+          break
+
+        case ORDER_SOURCE_TYPE.XILNEX_TRANSFER_NOTE:
+          await AccountingAPI.createGoodsReceivedNote(xilnex, {
+            arrivalNotice,
+            orderProducts: orderProducts
+          })
+          break
+
+        default:
+          break
+      }
+    } catch (error) {
+      logger.error(`xilnex-controller[createInboundDocument]: ${error}`)
+    }
+  }
+
+  async createPartialUnloadInboundDocument(
+    tx: EntityManager,
+    xilnex: Accounting,
+    arrivalNotice: ArrivalNotice,
+    worksheetDetails: any[]
+  ): Promise<void> {
+    try {
+      let orderProducts: any[] = []
+      await Promise.all(
+        worksheetDetails.map(async wd => {
+          let worksheetDetail: WorksheetDetail = await tx.getRepository(WorksheetDetail).findOne({
+            where: { name: wd.name, domain: arrivalNotice.domain, bizplace: arrivalNotice.bizplace },
+            relations: ['targetProduct', 'targetProduct.product']
+          })
+
+          orderProducts.push({
+            product: {
+              sku: worksheetDetail.targetProduct.product.sku
+            },
+            actualPackQty: wd.actualPackQty,
+            unitPrice: worksheetDetail.targetProduct.unitPrice
+          })
+        })
+      )
+
+      const orderSourceType: string = arrivalNotice.orderSourceType
+      switch (orderSourceType) {
+        case ORDER_SOURCE_TYPE.XILNEX_PO:
+          await AccountingAPI.createPurchaseReceive(xilnex, {
+            arrivalNotice,
+            orderProducts: orderProducts
+          })
+          break
+
+        case ORDER_SOURCE_TYPE.XILNEX_TRANSFER_NOTE:
+          await AccountingAPI.createGoodsReceivedNote(xilnex, {
+            arrivalNotice,
+            orderProducts: orderProducts
+          })
+          break
+
+        default:
+          break
+      }
+    } catch (error) {
+      logger.error(`xilnex-controller[createInboundDocument]: ${error}`)
+    }
+  }
+
+  async deliveryTransferNote(tx: EntityManager, xilnex: Accounting, releaseGoodId: string): Promise<void> {
+    try {
+      const releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
+        where: { id: releaseGoodId },
+        relations: ['domain', 'bizplace', 'bizplace.domain', 'deliveryOrders']
+      })
+
+      let deliveryOrders: DeliveryOrder[] = releaseGood.deliveryOrders
+      await Promise.all(
+        deliveryOrders.map(async deliveryOrder => {
+          let qb = tx
+            .getRepository(OrderInventory)
+            .createQueryBuilder('oi')
+            .select('op.ref_item_id', 'refItemId')
+            .addSelect('SUM(COALESCE(oi.release_qty,0))', 'totalReleaseQty')
+            .leftJoin('oi.order_product', 'op')
+            .where('"oi"."delivery_order_id" = :deliveryOrderId')
+            .andWhere('"oi"."domain_id" = :domainId')
+            .andWhere('"oi"."bizplace_id" = :bizplaceId')
+            .groupBy('op.ref_item_id')
+            .setParameters({
+              deliveryOrderId: deliveryOrder.id,
+              domainId: releaseGood.domain.id,
+              bizplaceId: releaseGood.bizplace.id
+            })
+
+          let qbResult: any = await qb.getRawMany()
+          let orderProducts: any[] = qbResult.map(item => {
+            return {
+              refItemId: item.refItemId,
+              releaseQty: item.totalReleaseQty
+            }
+          })
+
+          await AccountingAPI.deliveryTransferNote(xilnex, {
+            releaseGood,
+            orderProducts: orderProducts
+          })
+        })
+      )
+    } catch (error) {
+      logger.error(`xilnex-controller[createShipment]: ${error}`)
+    }
+  }
+
+  async createShipment(tx: EntityManager, xilnex: Accounting, releaseGoodId: string): Promise<void> {
+    try {
+      const releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
+        where: { id: releaseGoodId },
+        relations: ['domain', 'bizplace', 'bizplace.domain', 'deliveryOrders']
+      })
+
+      let deliveryOrders: DeliveryOrder[] = releaseGood.deliveryOrders
+      await Promise.all(
+        deliveryOrders.map(async deliveryOrder => {
+          let qb = tx
+            .getRepository(OrderInventory)
+            .createQueryBuilder('oi')
+            .select('op.ref_item_id', 'refItemId')
+            .addSelect('SUM(COALESCE(oi.release_qty,0))', 'totalReleaseQty')
+            .leftJoin('oi.order_product', 'op')
+            .where('"oi"."delivery_order_id" = :deliveryOrderId')
+            .andWhere('"oi"."domain_id" = :domainId')
+            .andWhere('"oi"."bizplace_id" = :bizplaceId')
+            .groupBy('op.ref_item_id')
+            .setParameters({
+              deliveryOrderId: deliveryOrder.id,
+              domainId: releaseGood.domain.id,
+              bizplaceId: releaseGood.bizplace.id
+            })
+
+          let qbResult: any = await qb.getRawMany()
+          let orderProducts: any[] = qbResult.map(item => {
+            return {
+              refItemId: item.refItemId,
+              releaseQty: item.totalReleaseQty
+            }
+          })
+
+          await AccountingAPI.createShipment(xilnex, {
+            releaseGood,
+            orderProducts: orderProducts
+          })
+        })
+      )
+    } catch (error) {
+      logger.error(`xilnex-controller[createShipment]: ${error}`)
+    }
+  }
+}

package/server/graphql/resolvers/worksheet/confirm-cancellation-release-order.ts

@@ -1,8 +1,8 @@
 import { EntityManager, In } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
-// import { logger } from '@things-factory/env'
-// import { Account, AccountingAPI } from '@things-factory/integration-accounting'
+import { logger } from '@things-factory/env'
+import { Account, AccountingAPI } from '@things-factory/integration-accounting'
 import {
   DeliveryOrder,
   ORDER_INVENTORY_STATUS,
@@ -30,8 +30,6 @@ export const confirmCancellationReleaseOrder = {
         'orderInventories',
         'orderInventories.inventory',
         'orderInventories.inventory.location',
-        'orderInventories.inventory.product',
-        'orderInventories.inventory.productDetail',
         'orderVass'
       ]
     })
@@ -196,40 +194,38 @@ export const confirmCancellationReleaseOrder = {
     releaseGood.updater = user
     await tx.getRepository(ReleaseGood).save(releaseGood)
 
-    // if (releaseGood?.refNo3 && releaseGood?.type == 'b2c') {
-    //   const account: Account = await tx
-    //     .getRepository(Account)
-    //     .findOne({ domain: releaseGood.bizplace.domain, status: 'active' })
-
-    //   // Xilnex create shipment and create sales return if sales invoice is completed
-    //   const createSalesReturn = async account => {
-    //     if (account) {
-    //       await getManager().transaction(async txMgr => {
-    //         if (account.platform == 'xilnex') {
-    //           try {
-    //             await AccountingAPI.createShipment(account, {
-    //               releaseGood,
-    //               orderProducts: releaseGood.orderProducts
-    //             })
-    //           } catch (error) {
-    //             logger.error(`confirm-cancellation-release-order[createShipment]: ${error}`)
-    //           }
-
-    //           try {
-    //             await AccountingAPI.createSalesReturn(account, {
-    //               releaseGood,
-    //               orderProducts: releaseGood.orderProducts
-    //             })
-    //           } catch (error) {
-    //             logger.error(`confirm-cancellation-release-order[createSalesReturn]: ${error}`)
-    //           }
-    //         }
-    //       })
-    //     }
-    //   }
-
-    //   createSalesReturn(account)
-    // }
+    if (releaseGood?.refNo3 && releaseGood?.type == 'b2c') {
+      const account: Account = await tx
+        .getRepository(Account)
+        .findOne({ domain: releaseGood.bizplace.domain, status: 'active' })
+
+      // Xilnex create shipment and create sales return if sales invoice is completed
+      const createSalesReturn = async account => {
+        if (account) {
+          if (account.platform == 'xilnex') {
+            try {
+              await AccountingAPI.createShipment(account, {
+                releaseGood,
+                orderProducts: releaseGood.orderProducts
+              })
+            } catch (error) {
+              logger.error(`confirm-cancellation-release-order[createShipment]: ${error}`)
+            }
+
+            try {
+              await AccountingAPI.createSalesReturn(account, {
+                releaseGood,
+                orderProducts: releaseGood.orderProducts
+              })
+            } catch (error) {
+              logger.error(`confirm-cancellation-release-order[createSalesReturn]: ${error}`)
+            }
+          }
+        }
+      }
+
+      createSalesReturn(account)
+    }
 
     return
   }

package/server/graphql/resolvers/worksheet/loading/complete-loading.ts

@@ -2,6 +2,7 @@ import { EntityManager } from 'typeorm'
 
 import { ApplicationType, User } from '@things-factory/auth-base'
 import { Bizplace, Company } from '@things-factory/biz-base'
+import { Account } from '@things-factory/integration-accounting'
 import { FulfillmentCenter } from '@things-factory/integration-fulfillment'
 import { Sftp, SftpAPI } from '@things-factory/integration-sftp'
 import { ORDER_INVENTORY_STATUS, ORDER_STATUS, OrderInventory, ReleaseGood } from '@things-factory/sales-base'
@@ -10,6 +11,7 @@ import { InventoryItem } from '@things-factory/warehouse-base'
 
 import { WORKSHEET_TYPE } from '../../../../constants'
 import { LoadingWorksheetController, ReturningWorksheetController } from '../../../../controllers'
+import { XilnexController } from '../../../../controllers/pos'
 import { Worksheet, WorksheetDetail } from '../../../../entities'
 
 export const completeLoadingResolver = {
@@ -98,6 +100,18 @@ export async function completeLoading(
       }
       break
 
+    case ApplicationType.XILNEX:
+      const xilnex: Account = await tx
+        .getRepository(Account)
+        .findOne({ where: { domain: releaseGood.bizplace.domain, status: 'active', platform: 'xilnex' } })
+
+      if (xilnex) {
+        const xilnexCtrl: XilnexController = new XilnexController(tx, domain, user)
+        await xilnexCtrl.deliveryTransferNote(tx, xilnex, releaseGood.id)
+      }
+
+      break
+
     default:
       break
   }

package/server/graphql/resolvers/worksheet/packing/complete-packing.ts

@@ -2,9 +2,13 @@ import { EntityManager } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
 import { Bizplace, getMyBizplace } from '@things-factory/biz-base'
+import { logger } from '@things-factory/env'
+import { Account } from '@things-factory/integration-accounting'
+import { ReleaseGood } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 
 import { PackingWorksheetController } from '../../../../controllers/'
+import { XilnexController } from '../../../../controllers/pos'
 import { WorksheetController } from '../../../../controllers/worksheet-controller'
 
 export const completePackingResolver = {
@@ -12,6 +16,26 @@ export const completePackingResolver = {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
     await completePacking(tx, domain, user, releaseGoodNo)
 
+    const releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
+      where: { name: releaseGoodNo, domain },
+      relations: ['bizplace', 'bizplace.domain']
+    })
+
+    if (releaseGood.type == 'b2c') {
+      const xilnex: Account = await tx
+        .getRepository(Account)
+        .findOne({ where: { domain: releaseGood.bizplace.domain, status: 'active', platform: 'xilnex' } })
+
+      if (xilnex) {
+        try {
+          const xilnexCtrl: XilnexController = new XilnexController(tx, domain, user)
+          await xilnexCtrl.createShipment(tx, xilnex, releaseGood.id)
+        } catch (error) {
+          logger.error(`worksheet-base[completePacking]: ${error}`)
+        }
+      }
+    }
+
     const bizplace: Bizplace = await getMyBizplace(domain, user)
     const worksheetController: WorksheetController = new WorksheetController(tx, domain, user)
     await worksheetController.notifyToCustomer(bizplace, {

package/server/graphql/resolvers/worksheet/picking/complete-batch-picking.ts

@@ -1,4 +1,4 @@
-import { EntityManager } from 'typeorm'
+import { EntityManager, getManager } from 'typeorm'
 
 import { ApplicationType, User } from '@things-factory/auth-base'
 import { Bizplace, getMyBizplace } from '@things-factory/biz-base'
@@ -76,26 +76,32 @@ export async function completeBatchPicking(
             .findOne({ domain: worksheet.bizplace.domain, status: SellercraftStatus.ACTIVE })
 
           if (sellercraft) {
-            const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
-            if (!foundReleaseGood?.packageId) {
-              foundReleaseGood = await sellercraftCtrl.packOrder(sellercraft, foundReleaseGood)
-              if (foundReleaseGood?.packageId) {
-                await tx
-                  .getRepository(ReleaseGood)
-                  .update(
-                    { id: foundReleaseGood.id },
-                    { packageId: foundReleaseGood.packageId, updater: foundReleaseGood.updater }
-                  )
-              }
+            const initSCOrderShipment = async (sellercraft: Sellercraft, foundReleaseGood: ReleaseGood) => {
+              await getManager().transaction(async txMgr => {
+                const sellercraftCtrl: SellercraftController = new SellercraftController(txMgr, domain, user)
+
+                if (!releaseGood?.packageId) {
+                  releaseGood = await sellercraftCtrl.packOrder(sellercraft, foundReleaseGood)
+
+                  if (releaseGood?.packageId) {
+                    await txMgr
+                      .getRepository(ReleaseGood)
+                      .update({ id: releaseGood.id }, { packageId: releaseGood.packageId, updater: releaseGood.updater })
+                  }
+                }
+
+                const rtsTriggerLevel: Setting = await tx.getRepository(Setting).findOne({
+                  where: { domain, category: 'id-rule', name: 'rts-trigger-level' }
+                })
+
+                if (rtsTriggerLevel && parseInt(rtsTriggerLevel?.value || 0) == 1) {
+                  await sellercraftCtrl.initiateOrderShipment(sellercraft, releaseGood)
+                }
+              })
             }
 
-            const rtsTriggerLevel: Setting = await tx.getRepository(Setting).findOne({
-              where: { domain, category: 'id-rule', name: 'rts-trigger-level' }
-            })
-
-            if (rtsTriggerLevel && parseInt(rtsTriggerLevel?.value || 0) == 1) {
-              sellercraftCtrl.initiateOrderShipment(sellercraft, foundReleaseGood)
-            }
+            // asynchronouly call to initiate sellercraft order shipment/ RTS
+            initSCOrderShipment(sellercraft, foundReleaseGood)
           }
           break
 

package/server/graphql/resolvers/worksheet/picking/complete-picking.ts

@@ -2,8 +2,8 @@ import { EntityManager, getManager } from 'typeorm'
 
 import { ApplicationType, User } from '@things-factory/auth-base'
 import { Bizplace, ContactPoint, getMyBizplace } from '@things-factory/biz-base'
-// import { logger } from '@things-factory/env'
-// import { Account, AccountingAPI } from '@things-factory/integration-accounting'
+import { logger } from '@things-factory/env'
+import { Account, AccountingAPI } from '@things-factory/integration-accounting'
 import { LastMileAPI, LastMileDelivery } from '@things-factory/integration-lmd'
 import { MarketplaceStore, MarketplaceTransporter } from '@things-factory/integration-marketplace'
 import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
@@ -97,8 +97,9 @@ export async function completePicking(
       const sellercraft: Sellercraft = await tx
         .getRepository(Sellercraft)
         .findOne({ domain: releaseGood.bizplace.domain, status: SellercraftStatus.ACTIVE })
-      const initSCOrderShipment = async sellercraft => {
-        if (sellercraft) {
+
+      if (sellercraft) {
+        const initSCOrderShipment = async sellercraft => {
           await getManager().transaction(async txMgr => {
             const sellercraftCtrl: SellercraftController = new SellercraftController(txMgr, domain, user)
 
@@ -125,10 +126,9 @@ export async function completePicking(
             }
           })
         }
+        // asynchronouly call to initiate sellercraft order shipment/ RTS
+        initSCOrderShipment(sellercraft)
       }
-
-      // asynchronouly call to initiate sellercraft order shipment/ RTS
-      initSCOrderShipment(sellercraft)
       break
 
     case ApplicationType.MMS:
@@ -255,51 +255,49 @@ export async function completePicking(
       break
   }
 
-  // const account: Account = await tx
-  //   .getRepository(Account)
-  //   .findOne({ domain: releaseGood.bizplace.domain, status: 'active' })
-
-  // // Xilnex Create Sales Order and Post Sales Order to Sales Invoice
-  // const createSalesOrder = async account => {
-  //   if (account) {
-  //     try {
-  //       await getManager().transaction(async txMgr => {
-  //         if (account.platform == 'xilnex') {
-  //           const salesOrder: any = await AccountingAPI.createSalesOrder(account, {
-  //             releaseGood,
-  //             orderProducts: releaseGood.orderProducts
-  //           })
-
-  //           if (salesOrder) {
-  //             const salesInvoice: any = await AccountingAPI.postSalesOrderToSalesInvoice(account, {
-  //               orderId: salesOrder?.id || null
-  //             })
-
-  //             const salesOrderItems: any = salesInvoice.sale.items
-  //             await Promise.all(
-  //               releaseGood.orderProducts.map(async op => {
-  //                 const matchedProduct: any = salesOrderItems.find(soi => soi.itemId == op.productDetail.refCode)
-  //                 if (matchedProduct) {
-  //                   await tx.getRepository(OrderProduct).update({ id: op.id }, { refItemId: matchedProduct.id })
-  //                 }
-  //               })
-  //             )
-
-  //             await txMgr
-  //               .getRepository(ReleaseGood)
-  //               .update({ id: releaseGood.id }, { refNo3: salesInvoice.salesId, updater: releaseGood.updater })
-  //           }
-  //         }
-  //       })
-  //     } catch (error) {
-  //       logger.error(`complete-picking[createSalesOrder]: ${error}`)
-  //     }
-  //   }
-  // }
-
-  // if (releaseGood.type == 'b2c') {
-  //   createSalesOrder(account)
-  // }
+  const account: Account = await tx
+    .getRepository(Account)
+    .findOne({ domain: releaseGood.bizplace.domain, status: 'active' })
+
+  // Xilnex Create Sales Order and Post Sales Order to Sales Invoice
+  const createSalesOrder = async (account, tx) => {
+    if (account) {
+      try {
+        if (account.platform == 'xilnex') {
+          const salesOrder: any = await AccountingAPI.createSalesOrder(account, {
+            releaseGood,
+            orderProducts: releaseGood.orderProducts
+          })
+
+          if (salesOrder) {
+            const salesInvoice: any = await AccountingAPI.postSalesOrderToSalesInvoice(account, {
+              orderId: salesOrder?.id || null
+            })
+
+            const salesOrderItems: any = salesInvoice.sale.items
+            await Promise.all(
+              releaseGood.orderProducts.map(async op => {
+                const matchedProduct: any = salesOrderItems.find(soi => soi.itemId == op.productDetail.refCode)
+                if (matchedProduct) {
+                  await tx.getRepository(OrderProduct).update({ id: op.id }, { refItemId: matchedProduct.id })
+                }
+              })
+            )
+
+            await tx
+              .getRepository(ReleaseGood)
+              .update({ id: releaseGood.id }, { collectionOrderNo: salesInvoice.salesId, updater: releaseGood.updater })
+          }
+        }
+      } catch (error) {
+        logger.error(`complete-picking[createSalesOrder]: ${error}`)
+      }
+    }
+  }
+
+  if (releaseGood.type == 'b2c') {
+    await createSalesOrder(account, tx)
+  }
 
   if (releaseGood.packingOption) {
     const packingWSCtrl: PackingWorksheetController = new PackingWorksheetController(tx, domain, user)

package/server/graphql/resolvers/worksheet/unloading/complete-unloading-partially.ts

@@ -1,13 +1,31 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
+import { Account } from '@things-factory/integration-accounting'
+import { ArrivalNotice } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
+
 import { UnloadingWorksheetController } from '../../../../controllers'
+import { XilnexController } from '../../../../controllers/pos'
 import { WorksheetDetail } from '../../../../entities'
 
 export const completeUnloadingPartiallyResolver = {
   async completeUnloadingPartially(_: any, { arrivalNoticeNo, worksheetDetail }, context: any) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
     await completeUnloadingPartially(tx, domain, user, arrivalNoticeNo, worksheetDetail)
+
+    const arrivalNotice: ArrivalNotice = await tx
+      .getRepository(ArrivalNotice)
+      .findOne({ where: { name: arrivalNoticeNo, domain }, relations: ['domain', 'bizplace', 'bizplace.domain'] })
+
+    const xilnex: Account = await tx
+      .getRepository(Account)
+      .findOne({ where: { domain: arrivalNotice.bizplace.domain, status: 'active', platform: 'xilnex' } })
+
+    if (xilnex) {
+      const xilnexCtrl: XilnexController = new XilnexController(tx, domain, user)
+      await xilnexCtrl.createPartialUnloadInboundDocument(tx, xilnex, arrivalNotice, worksheetDetail)
+    }
   }
 }
 

package/server/graphql/resolvers/worksheet/unloading/complete-unloading.ts

@@ -2,12 +2,14 @@ import { EntityManager, In } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
+import { Account } from '@things-factory/integration-accounting'
 import { ArrivalNotice, generateGoodsReceivalNote } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory, INVENTORY_STATUS } from '@things-factory/warehouse-base'
 
 import { WORKSHEET_STATUS } from '../../../../constants'
 import { PutawayWorksheetController, UnloadingWorksheetController } from '../../../../controllers'
+import { XilnexController } from '../../../../controllers/pos'
 import { Worksheet, WorksheetDetail } from '../../../../entities'
 
 export const completeUnloadingResolver = {
@@ -37,6 +39,8 @@ export const completeUnloadingResolver = {
       where: { domain, refOrderId: arrivalNotice.id, status: In([INVENTORY_STATUS.UNLOADED, INVENTORY_STATUS.CHECKED]) }
     })
 
+    const inventoryIds: string[] = inventories.map(iv => iv.id)
+
     putawayWorksheet = await putawayWSCtrl.generatePutawayWorksheet(arrivalNotice.name, inventories)
 
     if (putawayWorksheet.status === WORKSHEET_STATUS.DEACTIVATED) {
@@ -46,6 +50,16 @@ export const completeUnloadingResolver = {
     const bizplaceId: Bizplace = arrivalNotice.bizplace.id
     await generateGoodsReceivalNote({ refNo: arrivalNoticeNo, customer: bizplaceId }, domain, user, tx)
 
+    const customerDomain: Domain = arrivalNotice.bizplace.domain
+    const xilnex: Account = await tx
+      .getRepository(Account)
+      .findOne({ where: { domain: customerDomain, status: 'active', platform: 'xilnex' } })
+
+    if (xilnex) {
+      const xilnexCtrl: XilnexController = new XilnexController(tx, domain, user)
+      await xilnexCtrl.createInboundDocument(tx, xilnex, arrivalNotice.id, inventoryIds)
+    }
+
     const worksheetController: UnloadingWorksheetController = new UnloadingWorksheetController(tx, domain, user)
     worksheetController.notifyToOfficeAdmin({
       title: `Unloading Completed (${arrivalNotice.bizplace.name}, ${arrivalNotice.name})`,