@things-factory/worksheet-base 4.3.367 → 4.3.369

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

@@ -7,7 +7,7 @@ import { ORDER_STATUS, ReleaseGood } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 
 import { EcommerceController, PickingWorksheetController } from '../../../../controllers'
-import { Worksheet } from '../../../../entities'
+import { ActiveWorksheetPickingView, Worksheet } from '../../../../entities'
 
 export const activatePickingResolver = {
   async activatePicking(_: any, { worksheetNo }, context: any) {
@@ -22,77 +22,83 @@ export async function activatePicking(
   user: User,
   worksheetNo: string
 ): Promise<Worksheet> {
-  const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
-  const worksheet = await worksheetController.activatePicking(worksheetNo)
-  const companyDomain: Domain = worksheet?.bizplace.company.domain
-
-  let releaseGood: ReleaseGood = worksheet.releaseGood
-
-  const orderSource: string = releaseGood.source
-  switch (orderSource) {
-    case ApplicationType.MMS:
-      // find for any existing marketplace store connections
-      const marketplaceStores: MarketplaceStore[] = await tx.getRepository(MarketplaceStore).find({
-        where: { domain: companyDomain, status: 'ACTIVE', isAutoUpdateStockQty: true },
-        relations: ['marketplaceDistributors']
-      })
-
-      if (marketplaceStores?.length) {
-        if (marketplaceStores.some(store => store.isAutoUpdateStockQty)) {
-          const worksheetDetails = worksheet.worksheetDetails
-          let orderInventories: any[] = worksheetDetails.map(wsd => wsd.targetInventory)
-          const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
-          await ecommerceCtrl.updateProductVariationStock(marketplaceStores, orderInventories, companyDomain)
-        }
-
-        const marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
-          where: { orderNo: releaseGood.refNo, domain: companyDomain },
-          relations: ['marketplaceStore']
+  try {
+    const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
+    const worksheet = await worksheetController.activatePicking(worksheetNo)
+    const companyDomain: Domain = worksheet?.bizplace.company.domain
+
+    let releaseGood: ReleaseGood = worksheet.releaseGood
+
+    const orderSource: string = releaseGood.source
+    switch (orderSource) {
+      case ApplicationType.MMS:
+        // find for any existing marketplace store connections
+        const marketplaceStores: MarketplaceStore[] = await tx.getRepository(MarketplaceStore).find({
+          where: { domain: companyDomain, status: 'ACTIVE', isAutoUpdateStockQty: true },
+          relations: ['marketplaceDistributors']
         })
 
-        if (marketplaceOrder) {
-          const marketplaceStore: MarketplaceStore = marketplaceOrder.marketplaceStore
-
-          if (marketplaceStore.isAutoUpdateShipment) {
+        if (marketplaceStores?.length) {
+          if (marketplaceStores.some(store => store.isAutoUpdateStockQty)) {
+            const worksheetDetails = worksheet.worksheetDetails
+            let orderInventories: any[] = worksheetDetails.map(wsd => wsd.targetInventory)
             const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
-            await ecommerceCtrl.createOrderComment(marketplaceStore, marketplaceOrder, ORDER_STATUS.PICKING)
+            await ecommerceCtrl.updateProductVariationStock(marketplaceStores, orderInventories, companyDomain)
           }
-        }
-      }
-      break
 
-    default:
-      break
+          const marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+            where: { orderNo: releaseGood.refNo, domain: companyDomain },
+            relations: ['marketplaceStore']
+          })
+
+          if (marketplaceOrder) {
+            const marketplaceStore: MarketplaceStore = marketplaceOrder.marketplaceStore
+
+            if (marketplaceStore.isAutoUpdateShipment) {
+              const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
+              await ecommerceCtrl.createOrderComment(marketplaceStore, marketplaceOrder, ORDER_STATUS.PICKING)
+            }
+          }
+        }
+        break
+
+      default:
+        break
+    }
+
+    // if (releaseGood.type === 'b2c') {
+    //   const sellercraft: Sellercraft = await tx
+    //     .getRepository(Sellercraft)
+    //     .findOne({ domain: worksheet.bizplace.domain, status: SellercraftStatus.ACTIVE })
+
+    //   if (marketplaceStores?.length && !sellercraft) {
+    //     if (marketplaceStores.some(store => store.isAutoUpdateStockQty)) {
+    //       const worksheetDetails = worksheet.worksheetDetails
+    //       let orderInventories: any[] = worksheetDetails.map(wsd => wsd.targetInventory)
+    //       const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
+    //       await ecommerceCtrl.updateProductVariationStock(marketplaceStores, orderInventories, companyDomain)
+    //     }
+
+    //     const marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+    //       where: { orderNo: releaseGood.refNo, domain: companyDomain },
+    //       relations: ['marketplaceStore']
+    //     })
+
+    //     if (marketplaceOrder) {
+    //       const marketplaceStore: MarketplaceStore = marketplaceOrder.marketplaceStore
+
+    //       if (marketplaceStore.isAutoUpdateShipment) {
+    //         const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
+    //         await ecommerceCtrl.createOrderComment(marketplaceStore, marketplaceOrder, ORDER_STATUS.PICKING)
+    //       }
+    //     }
+    //   }
+    // }
+    return worksheet
+  } catch (error) {
+    throw error
+  } finally {
+    ActiveWorksheetPickingView.refreshView()
   }
 
-  // if (releaseGood.type === 'b2c') {
-  //   const sellercraft: Sellercraft = await tx
-  //     .getRepository(Sellercraft)
-  //     .findOne({ domain: worksheet.bizplace.domain, status: SellercraftStatus.ACTIVE })
-
-  //   if (marketplaceStores?.length && !sellercraft) {
-  //     if (marketplaceStores.some(store => store.isAutoUpdateStockQty)) {
-  //       const worksheetDetails = worksheet.worksheetDetails
-  //       let orderInventories: any[] = worksheetDetails.map(wsd => wsd.targetInventory)
-  //       const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
-  //       await ecommerceCtrl.updateProductVariationStock(marketplaceStores, orderInventories, companyDomain)
-  //     }
-
-  //     const marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
-  //       where: { orderNo: releaseGood.refNo, domain: companyDomain },
-  //       relations: ['marketplaceStore']
-  //     })
-
-  //     if (marketplaceOrder) {
-  //       const marketplaceStore: MarketplaceStore = marketplaceOrder.marketplaceStore
-
-  //       if (marketplaceStore.isAutoUpdateShipment) {
-  //         const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
-  //         await ecommerceCtrl.createOrderComment(marketplaceStore, marketplaceOrder, ORDER_STATUS.PICKING)
-  //       }
-  //     }
-  //   }
-  // }
-
-  return worksheet
 }

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

@@ -67,7 +67,8 @@ import { EcommerceController } from '../../../../controllers/ecommerce'
 import { WorksheetController } from '../../../../controllers/worksheet-controller'
 import {
   Worksheet,
-  WorksheetDetail
+  WorksheetDetail,
+  ActiveWorksheetPickingView
 } from '../../../../entities'
 import { createLmdParcel } from '../../../../utils'
 import { activateVas } from '../vas/activate-vas'
@@ -577,5 +578,7 @@ export async function completePicking(
     }
   } catch (error) {
     throw error
+  } finally {
+    ActiveWorksheetPickingView.refreshView()
   }
 }

package/server/graphql/resolvers/worksheet/picking/fetch-and-assign-picking-task.ts

@@ -11,7 +11,7 @@ import { pickingWorksheet } from '../picking-worksheet'
 import { activatePicking } from './activate-picking'
 
 export const fetchAndAssignPickingTaskResolver = {
-  async fetchAndAssignPickingTask(_: any, {}, context: any) {
+  async fetchAndAssignPickingTask(_: any, { }, context: any) {
     try {
       const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
       const assignee: User = await tx.getRepository(User).findOne(user.id, { relations: ['domains'] })
@@ -108,7 +108,8 @@ export const fetchAndAssignPickingTaskResolver = {
 
       const releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne(worksheet.releaseGood.id)
 
-      return await pickingWorksheet(domain, releaseGood.name, locationSortingRule, tx)
+      let data = await pickingWorksheet(domain, releaseGood.name, locationSortingRule, tx)
+      return data
     } catch (error) {
       throw error
     }

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

@@ -36,26 +36,28 @@ export async function pickingWorksheet(domain: Domain, orderNo: String, location
       where: { domain, name: orderNo }
     })
 
-    const orderInventoryByBin: OrderInventory = await tx.getRepository(OrderInventory).findOne({
-      where: {
-        domain,
-        binLocation,
-        status: In([ORDER_INVENTORY_STATUS.PICKING, ORDER_INVENTORY_STATUS.PICKED])
-      },
-      order: {
-        createdAt: 'ASC'
-      },
-      relations: ['releaseGood', 'releaseGood.bizplace', 'releaseGood.bizplace.domain']
-    })
+    if (binLocation) {
+      const orderInventoryByBin: OrderInventory = await tx.getRepository(OrderInventory).findOne({
+        where: {
+          domain,
+          binLocation,
+          status: In([ORDER_INVENTORY_STATUS.PICKING, ORDER_INVENTORY_STATUS.PICKED])
+        },
+        order: {
+          createdAt: 'ASC'
+        },
+        relations: ['releaseGood', 'releaseGood.bizplace', 'releaseGood.bizplace.domain']
+      })
 
-    if (orderInventoryByBin?.releaseGood) {
-      orderNo = orderInventoryByBin.releaseGood.name
-      releaseGood = orderInventoryByBin.releaseGood
+      if (orderInventoryByBin?.releaseGood) {
+        orderNo = orderInventoryByBin.releaseGood.name
+        releaseGood = orderInventoryByBin.releaseGood
+      }
     }
   }
 
   if (!releaseGood) {
-    const replenishment = await replenishmentWorksheet(orderNo)
+    const replenishment = await replenishmentWorksheet(orderNo, tx, domain, locationSortingRules)
 
     if (!replenishment) {
       throw new Error(`Couldn't find picking worksheet by order no (${orderNo})`)
@@ -157,76 +159,76 @@ export async function pickingWorksheet(domain: Domain, orderNo: String, location
       })
     }
   }
+}
 
-  async function replenishmentWorksheet(orderNo: String) {
-    let replenishment: Replenishment = await tx.getRepository(Replenishment).findOne({
-      where: { domain, name: orderNo }
-    })
+async function replenishmentWorksheet(orderNo: String, tx, domain, locationSortingRules) {
+  let replenishment: Replenishment = await tx.getRepository(Replenishment).findOne({
+    where: { domain, name: orderNo }
+  })
 
-    if (replenishment) {
-      const worksheet = await fetchExecutingWorksheet(
-        domain,
-        null,
-        [],
-        WORKSHEET_TYPE.PICKING_REPLENISHMENT,
-        replenishment,
-        tx
-      )
-
-      const qb: SelectQueryBuilder<WorksheetDetail> = tx.createQueryBuilder(WorksheetDetail, 'WSD')
-      qb.leftJoinAndSelect('WSD.targetInventory', 'T_INV')
-        .leftJoinAndSelect('T_INV.binLocation', 'BIN_LOC')
-        .leftJoinAndSelect('T_INV.inventory', 'INV')
-        .leftJoinAndSelect('T_INV.product', 'PROD')
-        .leftJoinAndSelect('T_INV.productDetail', 'PROD_DET')
-        .leftJoinAndSelect('INV.location', 'LOC')
-
-      if (locationSortingRules?.length > 0) {
-        locationSortingRules.forEach((rule: { name: string; desc: boolean }) => {
-          qb.addOrderBy(`LOC.${rule.name}`, rule.desc ? 'DESC' : 'ASC')
-        })
-      }
+  if (replenishment) {
+    const worksheet = await fetchExecutingWorksheet(
+      domain,
+      null,
+      [],
+      WORKSHEET_TYPE.PICKING_REPLENISHMENT,
+      replenishment,
+      tx
+    )
+
+    const qb: SelectQueryBuilder<WorksheetDetail> = tx.createQueryBuilder(WorksheetDetail, 'WSD')
+    qb.leftJoinAndSelect('WSD.targetInventory', 'T_INV')
+      .leftJoinAndSelect('T_INV.binLocation', 'BIN_LOC')
+      .leftJoinAndSelect('T_INV.inventory', 'INV')
+      .leftJoinAndSelect('T_INV.product', 'PROD')
+      .leftJoinAndSelect('T_INV.productDetail', 'PROD_DET')
+      .leftJoinAndSelect('INV.location', 'LOC')
 
-      qb.addOrderBy(`PROD.name`, 'ASC')
+    if (locationSortingRules?.length > 0) {
+      locationSortingRules.forEach((rule: { name: string; desc: boolean }) => {
+        qb.addOrderBy(`LOC.${rule.name}`, rule.desc ? 'DESC' : 'ASC')
+      })
+    }
 
-      const worksheetDetails: WorksheetDetail[] = await qb
-        .where('"WSD"."worksheet_id" = :worksheetId', { worksheetId: worksheet.id })
-        .andWhere('"WSD"."status" != :status', { status: WORKSHEET_STATUS.REPLACED })
-        .andWhere('"T_INV"."status" != :t_invstatus', { t_invstatus: ORDER_INVENTORY_STATUS.CANCELLED })
-        .getMany()
+    qb.addOrderBy(`PROD.name`, 'ASC')
 
-      return {
-        worksheetInfo: {
-          startedAt: worksheet.startedAt,
-          replenishment
-        },
-        worksheetDetailInfos: worksheetDetails.map(async (pickingWSD: WorksheetDetail) => {
-          const targetInventory: OrderInventory = pickingWSD.targetInventory
-          const inventory: Inventory = targetInventory.inventory
-
-          return {
-            name: pickingWSD.name,
-            palletId: inventory?.palletId,
-            cartonId: inventory?.cartonId,
-            batchId: inventory?.batchId,
-            batchIdRef: inventory?.batchIdRef,
-            product: inventory?.product,
-            qty: inventory?.qty,
-            binLocation: targetInventory?.binLocation || '',
-            releaseQty: targetInventory.releaseQty,
-            pickedQty: targetInventory.pickedQty,
-            status: pickingWSD.status,
-            description: pickingWSD.description,
-            targetName: targetInventory.name,
-            packingType: inventory?.packingType,
-            packingSize: inventory?.packingSize,
-            expirationDate: inventory?.expirationDate,
-            location: inventory?.location,
-            relatedOrderInv: targetInventory
-          }
-        })
-      }
+    const worksheetDetails: WorksheetDetail[] = await qb
+      .where('"WSD"."worksheet_id" = :worksheetId', { worksheetId: worksheet.id })
+      .andWhere('"WSD"."status" != :status', { status: WORKSHEET_STATUS.REPLACED })
+      .andWhere('"T_INV"."status" != :t_invstatus', { t_invstatus: ORDER_INVENTORY_STATUS.CANCELLED })
+      .getMany()
+
+    return {
+      worksheetInfo: {
+        startedAt: worksheet.startedAt,
+        replenishment
+      },
+      worksheetDetailInfos: worksheetDetails.map(async (pickingWSD: WorksheetDetail) => {
+        const targetInventory: OrderInventory = pickingWSD.targetInventory
+        const inventory: Inventory = targetInventory.inventory
+
+        return {
+          name: pickingWSD.name,
+          palletId: inventory?.palletId,
+          cartonId: inventory?.cartonId,
+          batchId: inventory?.batchId,
+          batchIdRef: inventory?.batchIdRef,
+          product: inventory?.product,
+          qty: inventory?.qty,
+          binLocation: targetInventory?.binLocation || '',
+          releaseQty: targetInventory.releaseQty,
+          pickedQty: targetInventory.pickedQty,
+          status: pickingWSD.status,
+          description: pickingWSD.description,
+          targetName: targetInventory.name,
+          packingType: inventory?.packingType,
+          packingSize: inventory?.packingSize,
+          expirationDate: inventory?.expirationDate,
+          location: inventory?.location,
+          relatedOrderInv: targetInventory
+        }
+      })
     }
-    return replenishment
   }
+  return replenishment
 }

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

@@ -18,7 +18,6 @@ interface WorksheetInterface extends Worksheet {
 
 export const worksheetResolver = {
   async worksheet(_: any, { name }, context: any) {
-    console.time('query for worksheet')
     const { domain }: { domain: Domain } = context.state
 
     let worksheet: WorksheetInterface
@@ -377,7 +376,6 @@ export const worksheetResolver = {
         relations: ['targetProduct']
       })
     }
-    console.timeEnd('query for worksheet')
     return worksheet
   },
 
@@ -449,7 +447,6 @@ export const worksheetResolver = {
       }
     })
 
-    // console.time('map')
     let worksheet: WorksheetInterface = {
       ...foundWorksheet,
       worksheetDetails: worksheetDetails,