@things-factory/worksheet-base 4.3.156 → 4.3.159

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

@@ -1,4 +1,4 @@
-import { EntityManager, getManager, In } from 'typeorm'
+import { EntityManager, getManager } from 'typeorm'
 
 import { ApplicationType, User } from '@things-factory/auth-base'
 import { Bizplace, getMyBizplace } from '@things-factory/biz-base'
@@ -14,10 +14,9 @@ import {
   ReleaseGood,
   OrderProduct
 } from '@things-factory/sales-base'
-import { Inventory } from '@things-factory/warehouse-base'
 import { Setting } from '@things-factory/setting-base'
 import { Domain } from '@things-factory/shell'
-import { WORKSHEET_STATUS } from '../../../../constants'
+
 import {
   PackingWorksheetController,
   PickingWorksheetController,
@@ -26,7 +25,7 @@ import {
 } from '../../../../controllers/'
 import { EcommerceController } from '../../../../controllers/ecommerce'
 import { WorksheetController } from '../../../../controllers/worksheet-controller'
-import { Worksheet, WorksheetDetail } from '../../../../entities'
+import { WorksheetDetail } from '../../../../entities'
 
 export const completeBatchPickingResolver = {
   async completeBatchPicking(_: any, { taskNo }, context: any) {
@@ -50,7 +49,7 @@ export async function completeBatchPicking(
   domain: Domain,
   user: User,
   taskNo: string
-): Promise<any> {
+): Promise<void> {
   const pickingWSCtrl: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
   const worksheet = await pickingWSCtrl.completeBatchPicking(taskNo)
 
@@ -62,187 +61,151 @@ export async function completeBatchPicking(
   const releaseGoods: ReleaseGood[] = worksheetDetails.map(
     worksheetDetail => worksheetDetail.targetInventory && worksheetDetail.targetInventory.releaseGood
   )
-
-  if (worksheet?.type) {
-    const uniqueReleaseGoods: ReleaseGood[] = []
-    const map = new Map()
-    for (const releaseGood of releaseGoods) {
-      if (!map.has(releaseGood.id)) {
-        map.set(releaseGood.id, true)
-        uniqueReleaseGoods.push({ ...releaseGood })
-      }
+  const uniqueReleaseGoods: ReleaseGood[] = []
+  const map = new Map()
+  for (const releaseGood of releaseGoods) {
+    if (!map.has(releaseGood.id)) {
+      map.set(releaseGood.id, true)
+      uniqueReleaseGoods.push({ ...releaseGood })
     }
+  }
 
-    for (let i = 0; i < uniqueReleaseGoods.length; i++) {
-      let foundReleaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
-        where: { id: uniqueReleaseGoods[i].id },
-        relations: [
-          'domain',
-          'creator',
-          'updater',
-          'orderPackages',
-          'orderProducts',
-          'orderProducts.product',
-          'bizplace',
-          'bizplace.company',
-          'bizplace.company.domain'
-        ]
-      })
-      const orderSource: string = foundReleaseGood.source
-      switch (orderSource) {
-        case ApplicationType.SELLERCRAFT:
-          const sellercraft: Sellercraft = await tx
-            .getRepository(Sellercraft)
-            .findOne({ domain: worksheet.bizplace.domain, status: SellercraftStatus.ACTIVE })
-
-          if (sellercraft) {
-            const initSCOrderShipment = async (sellercraft: Sellercraft, foundReleaseGood: ReleaseGood) => {
-              await getManager().transaction(async txMgr => {
-                const sellercraftCtrl: SellercraftController = new SellercraftController(txMgr, domain, user)
-
-                if (!foundReleaseGood?.orderPackages?.length && !foundReleaseGood?.marketPackCallSuccess) {
-                  await sellercraftCtrl.packOrder(sellercraft, foundReleaseGood)
-                }
-
-                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, foundReleaseGood)
-                }
+  for (let i = 0; i < uniqueReleaseGoods.length; i++) {
+    let foundReleaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
+      where: { id: uniqueReleaseGoods[i].id },
+      relations: [
+        'domain',
+        'creator',
+        'updater',
+        'orderPackages',
+        'orderProducts',
+        'orderProducts.product',
+        'bizplace',
+        'bizplace.company',
+        'bizplace.company.domain'
+      ]
+    })
+    const orderSource: string = foundReleaseGood.source
+    switch (orderSource) {
+      case ApplicationType.SELLERCRAFT:
+        const sellercraft: Sellercraft = await tx
+          .getRepository(Sellercraft)
+          .findOne({ domain: worksheet.bizplace.domain, status: SellercraftStatus.ACTIVE })
+
+        if (sellercraft) {
+          const initSCOrderShipment = async (sellercraft: Sellercraft, foundReleaseGood: ReleaseGood) => {
+            await getManager().transaction(async txMgr => {
+              const sellercraftCtrl: SellercraftController = new SellercraftController(txMgr, domain, user)
+
+              if (!foundReleaseGood?.orderPackages?.length && !foundReleaseGood?.marketPackCallSuccess) {
+                await sellercraftCtrl.packOrder(sellercraft, foundReleaseGood)
+              }
+
+              const rtsTriggerLevel: Setting = await tx.getRepository(Setting).findOne({
+                where: { domain, category: 'id-rule', name: 'rts-trigger-level' }
               })
-            }
 
-            // asynchronouly call to initiate sellercraft order shipment/ RTS
-            initSCOrderShipment(sellercraft, foundReleaseGood)
-          }
-          break
-
-        case ApplicationType.MMS:
-          const companyDomain: Domain = foundReleaseGood.bizplace.company.domain
-          const marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
-            where: { orderNo: foundReleaseGood.refNo, domain: companyDomain },
-            relations: [
-              'marketplaceOrderItems',
-              'marketplaceOrderItems.marketplaceOrderShippingItems',
-              'marketplaceOrderItems.marketplaceOrderShippingItems.marketplaceOrderShipping',
-              'marketplaceStore',
-              'marketplaceStore.marketplaceDistributors'
-            ]
-          })
-          const marketplaceStore: MarketplaceStore = marketplaceOrder.marketplaceStore
-
-          const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
-          if (marketplaceStore?.isAutoUpdateShipment) {
-            await ecommerceCtrl.createOrderShip(foundReleaseGood, marketplaceStore, marketplaceOrder, companyDomain)
+              if (rtsTriggerLevel && parseInt(rtsTriggerLevel?.value || 0) == 1) {
+                await sellercraftCtrl.initiateOrderShipment(sellercraft, foundReleaseGood)
+              }
+            })
           }
-          await ecommerceCtrl.createOrderPackage(
-            tx,
-            marketplaceOrder,
-            companyDomain,
-            marketplaceStore,
-            foundReleaseGood
-          )
-          break
-
-        default:
-          const orderPackage: OrderPackage = {
-            name: OrderNoGenerator.orderPackage(),
-            packageId: null,
-            trackingNo: null,
-            transporter: null,
-            airwayBill: null,
+
+          // asynchronouly call to initiate sellercraft order shipment/ RTS
+          initSCOrderShipment(sellercraft, foundReleaseGood)
+        }
+        break
+
+      case ApplicationType.MMS:
+        const companyDomain: Domain = foundReleaseGood.bizplace.company.domain
+        const marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+          where: { orderNo: foundReleaseGood.refNo, domain: companyDomain },
+          relations: [
+            'marketplaceOrderItems',
+            'marketplaceOrderItems.marketplaceOrderShippingItems',
+            'marketplaceOrderItems.marketplaceOrderShippingItems.marketplaceOrderShipping',
+            'marketplaceStore',
+            'marketplaceStore.marketplaceDistributors'
+          ]
+        })
+        const marketplaceStore: MarketplaceStore = marketplaceOrder.marketplaceStore
+
+        const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
+        if (marketplaceStore?.isAutoUpdateShipment) {
+          await ecommerceCtrl.createOrderShip(foundReleaseGood, marketplaceStore, marketplaceOrder, companyDomain)
+        }
+        await ecommerceCtrl.createOrderPackage(tx, marketplaceOrder, companyDomain, marketplaceStore, foundReleaseGood)
+        break
+
+      default:
+        const orderPackage: OrderPackage = {
+          name: OrderNoGenerator.orderPackage(),
+          packageId: null,
+          trackingNo: null,
+          transporter: null,
+          airwayBill: null,
+          status: ORDER_STATUS.PROCESSING,
+          releaseGood: foundReleaseGood,
+          domain: foundReleaseGood.domain,
+          bizplace: foundReleaseGood.bizplace,
+          creator: foundReleaseGood.creator,
+          updater: foundReleaseGood.updater
+        }
+
+        let savedOrderPackage: OrderPackage = await tx.getRepository(OrderPackage).save(orderPackage)
+        const orderPackageItems: OrderPackageItem[] = foundReleaseGood.orderProducts.map(op => {
+          return {
+            name: OrderNoGenerator.orderPackageItem(),
+            orderProduct: op,
             status: ORDER_STATUS.PROCESSING,
-            releaseGood: foundReleaseGood,
+            releaseQty: op.releaseQty,
+            orderPackage: savedOrderPackage,
             domain: foundReleaseGood.domain,
             bizplace: foundReleaseGood.bizplace,
             creator: foundReleaseGood.creator,
             updater: foundReleaseGood.updater
           }
+        })
 
-          let savedOrderPackage: OrderPackage = await tx.getRepository(OrderPackage).save(orderPackage)
-          const orderPackageItems: OrderPackageItem[] = foundReleaseGood.orderProducts.map(op => {
-            return {
-              name: OrderNoGenerator.orderPackageItem(),
-              orderProduct: op,
-              status: ORDER_STATUS.PROCESSING,
-              releaseQty: op.releaseQty,
-              orderPackage: savedOrderPackage,
-              domain: foundReleaseGood.domain,
-              bizplace: foundReleaseGood.bizplace,
-              creator: foundReleaseGood.creator,
-              updater: foundReleaseGood.updater
-            }
-          })
-
-          await tx.getRepository(OrderPackageItem).save(orderPackageItems)
-          break
-      }
+        await tx.getRepository(OrderPackageItem).save(orderPackageItems)
+        break
     }
+  }
 
-    const pickPackTargetInventories: OrderInventory[] = targetInventories
-      .filter(targetInventory => targetInventory.releaseGood.packingOption)
-      .map((pickPackTargetInventory: OrderInventory) => {
-        return pickPackTargetInventory
-      })
-
-    const pickSortTargetInventories: OrderInventory[] = targetInventories
-      .filter(targetInventory => !targetInventory.releaseGood.packingOption)
-      .map((pickSortTargetInventory: OrderInventory) => {
-        return pickSortTargetInventory
-      })
-
-    if (pickPackTargetInventories?.length) {
-      // pull out all unique RO
-      const roNoList: string[] = pickPackTargetInventories.map((oi: OrderInventory) => oi.releaseGood.name)
-      let uniqueRoNo: string[] = []
-      roNoList.forEach(roNo => {
-        if (!uniqueRoNo.includes(roNo)) {
-          uniqueRoNo.push(roNo)
-        }
-      })
+  const pickPackTargetInventories: OrderInventory[] = targetInventories
+    .filter(targetInventory => targetInventory.releaseGood.packingOption)
+    .map((pickPackTargetInventory: OrderInventory) => {
+      return pickPackTargetInventory
+    })
 
-      // loop to generate packing worksheet
-      for (let i: number = 0; i < uniqueRoNo.length; i++) {
-        const releaseGoodNo: string = uniqueRoNo[i]
+  const pickSortTargetInventories: OrderInventory[] = targetInventories
+    .filter(targetInventory => !targetInventory.releaseGood.packingOption)
+    .map((pickSortTargetInventory: OrderInventory) => {
+      return pickSortTargetInventory
+    })
 
-        const packingWSCtrl: PackingWorksheetController = new PackingWorksheetController(tx, domain, user)
-        await packingWSCtrl.generatePackingWorksheet(releaseGoodNo)
+  if (pickPackTargetInventories?.length) {
+    // pull out all unique RO
+    const roNoList: string[] = pickPackTargetInventories.map((oi: OrderInventory) => oi.releaseGood.name)
+    let uniqueRoNo: string[] = []
+    roNoList.forEach(roNo => {
+      if (!uniqueRoNo.includes(roNo)) {
+        uniqueRoNo.push(roNo)
       }
-    }
+    })
+
+    // loop to generate packing worksheet
+    for (let i: number = 0; i < uniqueRoNo.length; i++) {
+      const releaseGoodNo: string = uniqueRoNo[i]
 
-    // loop to generate sorting worksheet
-    if (pickSortTargetInventories?.length) {
-      const sortingWSCtrl: SortingWorksheetController = new SortingWorksheetController(tx, domain, user)
-      await sortingWSCtrl.generateSortingWorksheet(worksheet, pickSortTargetInventories)
+      const packingWSCtrl: PackingWorksheetController = new PackingWorksheetController(tx, domain, user)
+      await packingWSCtrl.generatePackingWorksheet(releaseGoodNo)
     }
-  } else {
-    let foundObsoleteInventories: any = worksheet
-    await tx.getRepository(Inventory).update({ id: In(foundObsoleteInventories) }, { obsolete: true })
-
-    foundObsoleteInventories = foundObsoleteInventories
-      .map(inv => {
-        return "'" + inv.trim() + "'"
-      })
-      .join(',')
-
-    //update any orders that is assigned with obsolete inventories
-    await tx.getRepository(ReleaseGood).query(`
-    update release_goods rg set status = 'OBSOLETE' 
-    from order_inventories oi
-    where oi.release_good_id = rg.id
-    and oi.inventory_id in (${foundObsoleteInventories})
-    and rg.status in ('PICKING', 'PENDING_WORKSHEET', 'READY_TO_PICK')`)
-
-    await tx.getRepository(Worksheet).query(`
-    update worksheets w set status = 'DEACTIVATED', updater_id = '${user.id}', assignee_id = null
-    from worksheet_details wd
-    inner join order_inventories oi on oi.id = wd.target_inventory_id
-    where wd.worksheet_id = w.id
-    and oi.inventory_id in (${foundObsoleteInventories})
-    `)
-
-    return false
+  }
+
+  // loop to generate sorting worksheet
+  if (pickSortTargetInventories?.length) {
+    const sortingWSCtrl: SortingWorksheetController = new SortingWorksheetController(tx, domain, user)
+    await sortingWSCtrl.generateSortingWorksheet(worksheet, pickSortTargetInventories)
   }
 }