@things-factory/worksheet-base 4.3.75 → 4.3.78

package/server/graphql/resolvers/worksheet/generate-worksheet/generate-multiple-release-good-worksheet.ts

@@ -1,21 +1,17 @@
 import { EntityManager, getManager } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
-import { OrderInventory } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 
-import { PickingWorksheetController } from '../../../../controllers/'
-import { Worksheet, WorksheetDetail } from '../../../../entities'
-
 import { generatePickingWorksheet } from './generate-release-good-worksheet'
 
 export const generateMultipleReleaseGoodWorksheetResolver = {
-  async generateMultipleReleaseGoodWorksheet(_: any, { releaseGoodNos }, context: any) {
+  async generateMultipleReleaseGoodWorksheet(_: any, { releaseGoods }, context: any) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
 
-    for (let idx = 0; idx < releaseGoodNos.length; idx++) {
+    for (let idx = 0; idx < releaseGoods.length; idx++) {
       await getManager().transaction(async txMgr => {
-        await generatePickingWorksheet(txMgr, domain, user, releaseGoodNos[idx])
+        await generatePickingWorksheet(txMgr, domain, user, releaseGoods[idx].name, releaseGoods[idx].status)
       });
     }
 

package/server/graphql/resolvers/worksheet/generate-worksheet/generate-release-good-worksheet.ts

@@ -11,9 +11,9 @@ import { Worksheet, WorksheetDetail } from '../../../../entities'
 import { Inventory, InventoryUtil, INVENTORY_TRANSACTION_TYPE } from '@things-factory/warehouse-base'
 
 export const generateReleaseGoodWorksheetResolver = {
-  async generateReleaseGoodWorksheet(_: any, { releaseGoodNo }, context: any) {
+  async generateReleaseGoodWorksheet(_: any, { releaseGoodNo, currentStatus = null }, context: any) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    return await generatePickingWorksheet(tx, domain, user, releaseGoodNo)
+    return await generatePickingWorksheet(tx, domain, user, releaseGoodNo, currentStatus)
   }
 }
 
@@ -21,7 +21,8 @@ export async function generatePickingWorksheet(
   tx: EntityManager,
   domain: Domain,
   user: User,
-  releaseGoodNo: string
+  releaseGoodNo: string,
+  currentStatus: string = null
 ): Promise<Worksheet> {
   try {
     const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
@@ -78,7 +79,7 @@ export async function generatePickingWorksheet(
 
       await tx.getRepository(ReleaseGood).update({ id: releaseGood.id }, { status: ORDER_STATUS.DONE })
     } else {
-      worksheet = await worksheetController.generatePickingWorksheet(releaseGoodNo)
+      worksheet = await worksheetController.generatePickingWorksheet(releaseGoodNo, currentStatus)
     }
 
     return worksheet

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

@@ -14,9 +14,10 @@ import { Domain } from '@things-factory/shell'
 import { Inventory, Location } from '@things-factory/warehouse-base'
 
 import { WORKSHEET_TYPE } from '../../../constants'
-import { SellercraftController } from '../../../controllers'
+import { PackingWorksheetController, SellercraftController } from '../../../controllers'
 import { Worksheet, WorksheetDetail } from '../../../entities'
 import { fetchExecutingWorksheet } from '../../../utils'
+import { PartnerSetting, Setting } from '@things-factory/setting-base'
 
 export const packingWorksheetResolver = {
   async packingWorksheet(_: any, { releaseGoodNo }, context: any) {
@@ -47,7 +48,7 @@ export const packingWorksheetResolver = {
             .innerJoinAndSelect(
               'worksheets',
               'ws',
-              `orderInventory.release_good_id = ws.release_good_id AND ws.type = 'PACKING' AND ws.status = 'EXECUTING'`
+              `orderInventory.release_good_id = ws.release_good_id AND ws.type = 'PACKING' AND (ws.status = 'EXECUTING' OR ws.status = 'DEACTIVATED')`
             )
             .where('orderInventory.domain_id = :domainId', { domainId: domain.id })
             .andWhere('orderInventory.status IN (:...orderInventoryStatus)', {
@@ -61,11 +62,22 @@ export const packingWorksheetResolver = {
             .andWhere('releaseGood.status IN (:...status)', {
               status: [ORDER_STATUS.READY_TO_PACK, ORDER_STATUS.PACKING]
             })
+            .orderBy(`case when orderInventory.status = '${ORDER_INVENTORY_STATUS.PACKED}' then 1 end`)
+            .addOrderBy('ws.created_at', 'ASC')
 
-          const orderInventoryByBin = await qb.getOne()
-          if (orderInventoryByBin?.releaseGood) {
-            releaseGoodNo = orderInventoryByBin.releaseGood.name
-            releaseGood = orderInventoryByBin.releaseGood
+          const [orderInventoriesByBin, totalInventoriesByBin] = await qb.getManyAndCount()
+          // @oscarchuaweiwen-fsd @chrislim I suggest using getMany() instead since the total is redundant here
+
+          // remove duplicated count of release good
+          const filteredRO = orderInventoriesByBin.map(oiBin => {
+            return oiBin.releaseGood.name
+          })
+
+          if (orderInventoriesByBin.length > 0) {
+            releaseGoodNo = orderInventoriesByBin[0].releaseGood.name
+            releaseGood = orderInventoriesByBin[0].releaseGood
+            releaseGood.totalInventoriesByBin = [...new Set(filteredRO)].length
+            releaseGood.isOrderInventoryBin = true
           } else {
             throw new Error(`Bin do not have any existing order.`)
           }
@@ -95,7 +107,39 @@ export const packingWorksheetResolver = {
         releaseGood
       )
 
-      let marketplaceOrder: MarketplaceOrder
+      if (worksheet.status === 'DEACTIVATED') {
+        const packingWSCtrl: PackingWorksheetController = new PackingWorksheetController(tx, domain, user)
+
+        const directActivatePackingWorksheet: Setting = await tx.getRepository(Setting).findOne({
+          where: { domain: domain, category: 'id-rule', name: 'enable-direct-activate-packing-worksheet' }
+        })
+
+        const partnerDirectActivatePackingWorksheetSetting: PartnerSetting = await tx
+          .getRepository(PartnerSetting)
+          .findOne({
+            where: {
+              setting: directActivatePackingWorksheet,
+              domain: domain,
+              partnerDomain: releaseGood.bizplace?.domain
+            }
+          })
+
+        if (
+          directActivatePackingWorksheet != undefined &&
+          directActivatePackingWorksheet.value.toLowerCase() == 'true'
+        ) {
+          if (partnerDirectActivatePackingWorksheetSetting != undefined) {
+            if (partnerDirectActivatePackingWorksheetSetting.value.toLowerCase() == 'true')
+              await packingWSCtrl.activatePacking(worksheet.name)
+          } else {
+            await packingWSCtrl.activatePacking(worksheet.name)
+          }
+        } else {
+          throw new Error('Kindly go to packing worksheet page to activate the packing worksheet')
+        }
+      }
+
+      let marketplaceOrder: MarketplaceOrder = {}
       let marketplaceOrderItems: MarketplaceOrderItem[] = []
       let marketplaceStore
       let trackingNo: string
@@ -103,7 +147,6 @@ export const packingWorksheetResolver = {
       let marketplaceStatus: string
 
       if (releaseGood.type === 'b2c') {
-
         const sellercraft: Sellercraft = await tx.getRepository(Sellercraft).findOne({
           domain: worksheet.bizplace.domain,
           status: SellercraftStatus.ACTIVE
@@ -165,8 +208,8 @@ export const packingWorksheetResolver = {
           airwayBill: releaseGood?.airwayBill,
           checkedRemarkBy: releaseGood?.checkedRemarkBy,
           invoice: releaseGood?.invoice,
-          platform: marketplaceOrder ? marketplaceOrder.marketplaceStore.platform : 'operato',
-          marketplaceStoreId: marketplaceOrder ? marketplaceOrder.marketplaceStore.id : '',
+          platform: Object.keys(marketplaceOrder).length > 0 ? marketplaceOrder.marketplaceStore?.platform : 'operato',
+          marketplaceStoreId: Object.keys(marketplaceOrder).length > 0 ? marketplaceOrder.marketplaceStore?.id : '',
           marketplaceStatus: marketplaceStatus ? marketplaceStatus : '',
           marketplaceOrder: marketplaceOrder ? marketplaceOrder : ''
         },
@@ -265,7 +308,14 @@ async function getSellercraftDocument(sellercraft: Sellercraft, releaseGood: Rel
         }
       }
     } catch (error) {
-      logger.error(`packing-worksheet[getSellercraftDocument]:(data:${JSON.stringify({ sellercraft, releaseGood, domain, user })}) ${error} `)
+      logger.error(
+        `packing-worksheet[getSellercraftDocument]:(data:${JSON.stringify({
+          sellercraft,
+          releaseGood,
+          domain,
+          user
+        })}) ${error} `
+      )
     }
   })
-}
+}

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

@@ -24,6 +24,7 @@ export const pendingCancellationReleaseOrder = {
       relations: ['bizplace', 'orderInventories', 'orderVass']
     })
 
+    if (foundRO.status === "DONE") throw new Error('Release good has been completed!')
     if (!foundRO) throw new Error(`Release good order doesn't exists.`)
     let targetOIs: OrderInventory[] = foundRO.orderInventories
     let foundOVs: OrderVas[] = foundRO.orderVass
@@ -94,77 +95,81 @@ export const pendingCancellationReleaseOrder = {
       await tx.getRepository(OrderVas).save(foundOVs)
     }
 
-    if (pickedOIs && pickedOIs.length) {
-      let pickedWSD: WorksheetDetail[] = await tx.getRepository(WorksheetDetail).find({
-        where: {
-          domain,
-          targetInventory: In(pickedOIs.map(oi => oi.id)),
-          status: ORDER_INVENTORY_STATUS.DONE
-        }
-      })
+    // find worksheet and update status to PENDING_CANCEL
+    let foundWS: Worksheet = await tx.getRepository(Worksheet).findOne({
+      where: {
+        domain,
+        releaseGood: foundRO
+      },
+      order: { 'createdAt': 'DESC' }
+    })
 
-      pickedWSD = pickedWSD.map((wsd: WorksheetDetail) => {
-        return {
-          ...wsd,
-          status: ORDER_INVENTORY_STATUS.PENDING_CANCEL,
-          updater: user
-        }
-      })
-      await tx.getRepository(WorksheetDetail).save(pickedWSD)
-
-      let replacedWSD: WorksheetDetail[] = await tx.getRepository(WorksheetDetail).find({
-        where: {
-          domain,
-          targetInventory: In(pickedOIs.map(oi => oi.id)),
-          status: ORDER_INVENTORY_STATUS.REPLACED
-        },
-        relations: ['targetInventory']
+    if (foundWS) {
+      await tx.getRepository(Worksheet).update({ id: foundWS.id }, {
+        status: ORDER_INVENTORY_STATUS.PENDING_CANCEL,
+        updater: user
       })
 
-      if (replacedWSD && replacedWSD.length) {
-        let replacedOI: OrderInventory[] = replacedWSD.map((wsd: WorksheetDetail) => wsd.targetInventory)
-        replacedOI = replacedOI.map((oi: OrderInventory) => {
+      if (pickedOIs && pickedOIs.length) {
+        let pickedWSD: WorksheetDetail[] = await tx.getRepository(WorksheetDetail).find({
+          where: {
+            domain,
+            targetInventory: In(pickedOIs.map(oi => oi.id)),
+            status: ORDER_INVENTORY_STATUS.DONE,
+            worksheet: foundWS
+          }
+        })
+
+        pickedWSD = pickedWSD.map((wsd: WorksheetDetail) => {
           return {
-            ...oi,
-            status: ORDER_INVENTORY_STATUS.REPLACED,
+            ...wsd,
+            status: ORDER_INVENTORY_STATUS.PENDING_CANCEL,
             updater: user
           }
         })
-        await tx.getRepository(OrderInventory).save(replacedOI)
-      }
-    }
+        await tx.getRepository(WorksheetDetail).save(pickedWSD)
 
-    if (pickingOIs && pickingOIs.length) {
-      let pickingWSD: WorksheetDetail[] = await tx.getRepository(WorksheetDetail).find({
-        where: { domain, targetInventory: In(pickingOIs.map(oi => oi.id)) }
-      })
+        let replacedWSD: WorksheetDetail[] = await tx.getRepository(WorksheetDetail).find({
+          where: {
+            domain,
+            targetInventory: In(pickedOIs.map(oi => oi.id)),
+            status: ORDER_INVENTORY_STATUS.REPLACED,
+            worksheet: foundWS
+          },
+          relations: ['targetInventory']
+        })
 
-      pickingWSD = pickingWSD.map((wsd: WorksheetDetail) => {
-        return {
-          ...wsd,
-          status: ORDER_INVENTORY_STATUS.PENDING_CANCEL,
-          updater: user
+        if (replacedWSD && replacedWSD.length) {
+          let replacedOI: OrderInventory[] = replacedWSD.map((wsd: WorksheetDetail) => wsd.targetInventory)
+          replacedOI = replacedOI.map((oi: OrderInventory) => {
+            return {
+              ...oi,
+              status: ORDER_INVENTORY_STATUS.REPLACED,
+              updater: user
+            }
+          })
+          await tx.getRepository(OrderInventory).save(replacedOI)
         }
-      })
-      await tx.getRepository(WorksheetDetail).save(pickingWSD)
-    }
-
-    // find worksheet and update status to PENDING_CANCEL
-    let foundWS: Worksheet[] = await tx.getRepository(Worksheet).find({
-      where: {
-        domain,
-        releaseGood: foundRO
       }
-    })
 
-    foundWS = foundWS.map((ws: Worksheet) => {
-      return {
-        ...ws,
-        status: ORDER_INVENTORY_STATUS.PENDING_CANCEL,
-        updater: user
+      if (pickingOIs && pickingOIs.length) {
+        let pickingWSD: WorksheetDetail[] = await tx.getRepository(WorksheetDetail).find({
+          where: {
+            domain, targetInventory: In(pickingOIs.map(oi => oi.id)),
+            worksheet: foundWS
+          }
+        })
+
+        pickingWSD = pickingWSD.map((wsd: WorksheetDetail) => {
+          return {
+            ...wsd,
+            status: ORDER_INVENTORY_STATUS.PENDING_CANCEL,
+            updater: user
+          }
+        })
+        await tx.getRepository(WorksheetDetail).save(pickingWSD)
       }
-    })
-    await tx.getRepository(Worksheet).save(foundWS)
+    }
 
     // find DO and change status to pending cancel
     let foundDO: DeliveryOrder[] = await tx.getRepository(DeliveryOrder).find({
@@ -186,43 +191,43 @@ export const pendingCancellationReleaseOrder = {
       updater: user
     })
 
-    // notification logics
-    // get Office Admin Users
-    const users: any[] = await tx
-      .getRepository('users_roles')
-      .createQueryBuilder('ur')
-      .select('ur.users_id', 'id')
-      .where(qb => {
-        const subQuery = qb
-          .subQuery()
-          .select('role.id')
-          .from(Role, 'role')
-          .where("role.name = 'Office Admin'")
-          .andWhere('role.domain_id = :domain', { domain: domain.id })
-          .getQuery()
-        return 'ur.roles_id IN ' + subQuery
-      })
-      .getRawMany()
-
-    // send notification to Office Admin Users
-    if (users?.length && context.header?.referer) {
-      const receivers: any[] = users.map(user => user.id)
-      const msg = {
-        title: `${foundRO.name} cancellation`,
-        body: `${customerBizplace.name} is requesting to cancel order`,
-        url: context.header.referer,
-        data: { url: context.header.referer }
-      }
-
-      /**
-       * @notes Temporary off sendNotification due to suspect of causing wms down
-       */
 
-      // await sendNotification({
-      //   receivers,
-      //   message: { ...msg }
-      // })
-    }
+    /**
+     * @notes Temporary off sendNotification due to suspect of causing wms down
+     */
+    // // notification logics
+    // // get Office Admin Users
+    // const users: any[] = await tx
+    //   .getRepository('users_roles')
+    //   .createQueryBuilder('ur')
+    //   .select('ur.users_id', 'id')
+    //   .where(qb => {
+    //     const subQuery = qb
+    //       .subQuery()
+    //       .select('role.id')
+    //       .from(Role, 'role')
+    //       .where("role.name = 'Office Admin'")
+    //       .andWhere('role.domain_id = :domain', { domain: domain.id })
+    //       .getQuery()
+    //     return 'ur.roles_id IN ' + subQuery
+    //   })
+    //   .getRawMany()
+
+    // // send notification to Office Admin Users
+    // if (users?.length && context.header?.referer) {
+    //   const receivers: any[] = users.map(user => user.id)
+    //   const msg = {
+    //     title: `${foundRO.name} cancellation`,
+    //     body: `${customerBizplace.name} is requesting to cancel order`,
+    //     url: context.header.referer,
+    //     data: { url: context.header.referer }
+    //   }
+
+    //   await sendNotification({
+    //     receivers,
+    //     message: { ...msg }
+    //   })
+    // }
 
     return
   }

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

@@ -226,26 +226,7 @@ export async function completePicking(
 
   if (releaseGood.packingOption) {
     const packingWSCtrl: PackingWorksheetController = new PackingWorksheetController(tx, domain, user)
-
-    const directActivatePackingWorksheet: Setting = await tx.getRepository(Setting).findOne({
-      where: { domain: domain, category: 'id-rule', name: 'enable-direct-activate-packing-worksheet' }
-    })
-    const partnerDirectActivatePackingWorksheetSetting: PartnerSetting = await tx
-      .getRepository(PartnerSetting)
-      .findOne({
-        where: { setting: directActivatePackingWorksheet, domain: domain, partnerDomain: releaseGood.bizplace?.domain }
-      })
-
-    let packingWorksheet: Worksheet = await packingWSCtrl.generatePackingWorksheet(releaseGoodNo)
-
-    if (directActivatePackingWorksheet != undefined && directActivatePackingWorksheet.value.toLowerCase() == 'true') {
-      if (partnerDirectActivatePackingWorksheetSetting != undefined) {
-        if (partnerDirectActivatePackingWorksheetSetting.value.toLowerCase() == 'true')
-          await packingWSCtrl.activatePacking(packingWorksheet.name)
-      } else {
-        await packingWSCtrl.activatePacking(packingWorksheet.name)
-      }
-    }
+    await packingWSCtrl.generatePackingWorksheet(releaseGoodNo)
   } else {
     // Find Existing Loading Worksheet if any
     let existLoadingWorksheet: Worksheet = await tx.getRepository(Worksheet).findOne({