@things-factory/worksheet-base 4.3.159 → 4.3.161

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

@@ -1,4 +1,4 @@
-import { EntityManager, getManager } from 'typeorm'
+import { EntityManager, getManager, In } from 'typeorm'
 
 import { ApplicationType, User } from '@things-factory/auth-base'
 import { Bizplace, getMyBizplace } from '@things-factory/biz-base'
@@ -11,11 +11,11 @@ import {
   OrderNoGenerator,
   OrderPackage,
   OrderPackageItem,
-  ReleaseGood,
-  OrderProduct
+  ReleaseGood
 } from '@things-factory/sales-base'
 import { Setting } from '@things-factory/setting-base'
 import { Domain } from '@things-factory/shell'
+import { Inventory } from '@things-factory/warehouse-base'
 
 import {
   PackingWorksheetController,
@@ -25,14 +25,16 @@ import {
 } from '../../../../controllers/'
 import { EcommerceController } from '../../../../controllers/ecommerce'
 import { WorksheetController } from '../../../../controllers/worksheet-controller'
-import { WorksheetDetail } from '../../../../entities'
+import { Worksheet, WorksheetDetail } from '../../../../entities'
 
 export const completeBatchPickingResolver = {
   async completeBatchPicking(_: any, { taskNo }, context: any) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
 
-    await completeBatchPicking(tx, domain, user, taskNo)
-
+    let obsolete = await completeBatchPicking(tx, domain, user, taskNo)
+    if (obsolete) {
+      return { obsolete: true }
+    }
     const bizplace: Bizplace = await getMyBizplace(domain, user)
     const worksheetController: WorksheetController = new WorksheetController(tx, domain, user)
     await worksheetController.notifyToCustomer(bizplace, {
@@ -49,163 +51,199 @@ export async function completeBatchPicking(
   domain: Domain,
   user: User,
   taskNo: string
-): Promise<void> {
+): Promise<any> {
   const pickingWSCtrl: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
   const worksheet = await pickingWSCtrl.completeBatchPicking(taskNo)
 
-  const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
-  const targetInventories: OrderInventory[] = worksheetDetails
-    .filter(wsd => wsd.status != 'MISSING')
-    .map((wsd: WorksheetDetail) => wsd.targetInventory)
-
-  const releaseGoods: ReleaseGood[] = worksheetDetails.map(
-    worksheetDetail => worksheetDetail.targetInventory && worksheetDetail.targetInventory.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 })
+  if (worksheet?.type) {
+    const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
+    const targetInventories: OrderInventory[] = worksheetDetails
+      .filter(wsd => wsd.status != 'MISSING')
+      .map((wsd: WorksheetDetail) => wsd.targetInventory)
+
+    const releaseGoods: ReleaseGood[] = worksheetDetails.map(
+      worksheetDetail => worksheetDetail.targetInventory && worksheetDetail.targetInventory.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' }
+    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)
+                }
               })
+            }
 
-              if (rtsTriggerLevel && parseInt(rtsTriggerLevel?.value || 0) == 1) {
-                await sellercraftCtrl.initiateOrderShipment(sellercraft, foundReleaseGood)
-              }
-            })
+            // asynchronouly call to initiate sellercraft order shipment/ RTS
+            initSCOrderShipment(sellercraft, foundReleaseGood)
           }
-
-          // 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,
+          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,
-            releaseQty: op.releaseQty,
-            orderPackage: savedOrderPackage,
+            releaseGood: foundReleaseGood,
             domain: foundReleaseGood.domain,
             bizplace: foundReleaseGood.bizplace,
             creator: foundReleaseGood.creator,
             updater: foundReleaseGood.updater
           }
-        })
 
-        await tx.getRepository(OrderPackageItem).save(orderPackageItems)
-        break
+          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
+      }
     }
-  }
 
-  const pickPackTargetInventories: OrderInventory[] = targetInventories
-    .filter(targetInventory => targetInventory.releaseGood.packingOption)
-    .map((pickPackTargetInventory: OrderInventory) => {
-      return pickPackTargetInventory
-    })
+    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 pickSortTargetInventories: OrderInventory[] = targetInventories
-    .filter(targetInventory => !targetInventory.releaseGood.packingOption)
-    .map((pickSortTargetInventory: OrderInventory) => {
-      return pickSortTargetInventory
-    })
+      // loop to generate packing worksheet
+      for (let i: number = 0; i < uniqueRoNo.length; i++) {
+        const releaseGoodNo: string = uniqueRoNo[i]
 
-  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 packingWSCtrl: PackingWorksheetController = new PackingWorksheetController(tx, domain, user)
+        await packingWSCtrl.generatePackingWorksheet(releaseGoodNo)
       }
-    })
-
-    // loop to generate packing worksheet
-    for (let i: number = 0; i < uniqueRoNo.length; i++) {
-      const releaseGoodNo: string = uniqueRoNo[i]
-
-      const packingWSCtrl: PackingWorksheetController = new PackingWorksheetController(tx, domain, user)
-      await packingWSCtrl.generatePackingWorksheet(releaseGoodNo)
     }
-  }
 
-  // loop to generate sorting worksheet
-  if (pickSortTargetInventories?.length) {
-    const sortingWSCtrl: SortingWorksheetController = new SortingWorksheetController(tx, domain, user)
-    await sortingWSCtrl.generateSortingWorksheet(worksheet, pickSortTargetInventories)
+    // loop to generate sorting worksheet
+    if (pickSortTargetInventories?.length) {
+      const sortingWSCtrl: SortingWorksheetController = new SortingWorksheetController(tx, domain, user)
+      await sortingWSCtrl.generateSortingWorksheet(worksheet, pickSortTargetInventories)
+    }
+  } 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 true
   }
 }