@things-factory/worksheet-base 5.0.12 → 6.0.0-alpha.0

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

@@ -1,14 +1,14 @@
-import { Equal, getRepository, In, Not, SelectQueryBuilder } from 'typeorm'
+import { Equal, In, Not, SelectQueryBuilder } from 'typeorm'
 
 import {
-  ORDER_STATUS,
   ORDER_INVENTORY_STATUS,
+  ORDER_STATUS,
   OrderInventory,
-  ReleaseGood,
   OrderTote,
-  OrderToteItem
+  OrderToteItem,
+  ReleaseGood
 } from '@things-factory/sales-base'
-import { Domain } from '@things-factory/shell'
+import { getRepository } from '@things-factory/shell'
 import { Inventory, Location } from '@things-factory/warehouse-base'
 
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
@@ -16,17 +16,17 @@ import { Worksheet, WorksheetDetail } from '../../../entities'
 import { fetchExecutingWorksheet } from '../../../utils'
 
 export const loadingWorksheetResolver = {
-  async loadingWorksheet(_: any, { releaseGoodNo }, context: any) {
-    const { domain }: { domain: Domain } = context.state
+  async loadingWorksheet(_: any, { releaseGoodNo }, context: ResolverContext) {
+    const { domain } = context.state
     let releaseGood: ReleaseGood = await getRepository(ReleaseGood).findOne({
-      where: { domain, name: releaseGoodNo /*status: ORDER_STATUS.LOADING*/ },
+      where: { domain: { id: domain.id }, name: releaseGoodNo /*status: ORDER_STATUS.LOADING*/ },
       relations: ['bizplace', 'deliverTo', 'deliverTo.bizplace']
     })
 
     // Find Release Order based on Bin
     if (!releaseGood) {
       const binLocation: Location = await getRepository(Location).findOne({
-        where: { domain, name: releaseGoodNo }
+        where: { domain: { id: domain.id }, name: releaseGoodNo }
       })
 
       const qb: SelectQueryBuilder<OrderInventory> = getRepository(OrderInventory).createQueryBuilder('orderInventory')
@@ -63,8 +63,8 @@ export const loadingWorksheetResolver = {
     )
     let foundWSD: any[] = await getRepository(WorksheetDetail).find({
       where: {
-        domain,
-        worksheet: foundWorksheet,
+        domain: { id: domain.id },
+        worksheet: { id: foundWorksheet.id },
         type: WORKSHEET_TYPE.LOADING,
         status: Not(Equal(WORKSHEET_STATUS.DONE))
       },

package/server/graphql/resolvers/worksheet/not-tally-target-inventories.ts

@@ -1,20 +1,20 @@
-import { createQueryBuilder, getRepository, SelectQueryBuilder } from 'typeorm'
+import { createQueryBuilder, SelectQueryBuilder } from 'typeorm'
 
 import { InventoryCheck, ORDER_INVENTORY_STATUS } from '@things-factory/sales-base'
-import { Domain } from '@things-factory/shell'
+import { getRepository } from '@things-factory/shell'
 
 import { Worksheet, WorksheetDetail } from '../../../entities'
 
 export const notTallyTargetInventoriesResolver = {
-  async notTallyTargetInventories(_: any, { cycleCountNo }, context: any) {
-    const { domain }: { domain: Domain } = context.state
+  async notTallyTargetInventories(_: any, { cycleCountNo }, context: ResolverContext) {
+    const { domain } = context.state
 
     const cycleCount: InventoryCheck = await getRepository(InventoryCheck).findOne({
-      where: { domain, name: cycleCountNo }
+      where: { domain: { id: domain.id }, name: cycleCountNo }
     })
 
     const worksheet: Worksheet = await getRepository(Worksheet).findOne({
-      where: { domain, inventoryCheck: cycleCount }
+      where: { domain: { id: domain.id }, inventoryCheck: cycleCount }
     })
 
     const qb: SelectQueryBuilder<WorksheetDetail> = createQueryBuilder(WorksheetDetail, 'WSD')

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

@@ -9,20 +9,21 @@ import { PackingWorksheetController, SellercraftController } from '../../../../c
 import { Worksheet } from '../../../../entities'
 
 export const activatePackingResolver = {
-  async activatePacking(_: any, { worksheetNo }, context: any) {
-    const { domain, user }: { domain: Domain; user: User } = context.state
+  async activatePacking(_: any, { worksheetNo }, context: ResolverContext) {
+    const { domain, user } = context.state
 
     let activatedPackingWs = []
 
-    await Promise.all(worksheetNo.map(async item => {
-      try {
-        await getManager().transaction(async txMgr => {
-          let result = await activatePacking(txMgr, domain, user, item)
-          activatedPackingWs.push(result)
-        })
-      } catch (error) {
-      }
-    }))
+    await Promise.all(
+      worksheetNo.map(async item => {
+        try {
+          await getManager().transaction(async txMgr => {
+            let result = await activatePacking(txMgr, domain, user, item)
+            activatedPackingWs.push(result)
+          })
+        } catch (error) {}
+      })
+    )
     return activatedPackingWs
   }
 }
@@ -40,11 +41,11 @@ export async function activatePacking(
   if (releaseGood.type == 'b2c') {
     const sellercraft: Sellercraft = await tx
       .getRepository(Sellercraft)
-      .findOne({ domain: releaseGood.bizplace.domain, status: SellercraftStatus.ACTIVE })
+      .findOneBy({ domain: releaseGood.bizplace.domain, status: SellercraftStatus.ACTIVE })
 
     if (sellercraft) {
       const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
-      await sellercraftCtrl.fetchOrderDocument(sellercraft, releaseGood)
+      sellercraftCtrl.initiateOrderDocument(sellercraft, releaseGood)
     }
   }
   return worksheet

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

@@ -13,12 +13,12 @@ import { EcommerceController } from '../../../../controllers/ecommerce'
 import { WorksheetController } from '../../../../controllers/worksheet-controller'
 
 export const completePackingResolver = {
-  async completePacking(_: any, { releaseGoodNo }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async completePacking(_: any, { releaseGoodNo }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
     await completePacking(tx, domain, user, releaseGoodNo)
 
     const releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
-      where: { domain, name: releaseGoodNo },
+      where: { domain: { id: domain.id }, name: releaseGoodNo },
       relations: [
         'bizplace',
         'bizplace.domain',
@@ -32,7 +32,7 @@ export const completePackingResolver = {
     if (releaseGood.type === 'b2c') {
       const sellercraft: Sellercraft = await tx
         .getRepository(Sellercraft)
-        .findOne({ domain: releaseGood.bizplace.domain, status: SellercraftStatus.ACTIVE })
+        .findOneBy({ domain: releaseGood.bizplace.domain, status: SellercraftStatus.ACTIVE })
 
       if (!sellercraft) {
         const companyDomain: Domain = releaseGood.bizplace.company.domain

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

@@ -9,8 +9,8 @@ import { PackingWorksheetController, SellercraftController } from '../../../../c
 import { Worksheet } from '../../../../entities'
 
 export const packingResolver = {
-  async packing(_: any, { worksheetDetailName, releaseQty, serialNumber }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async packing(_: any, { worksheetDetailName, releaseQty, serialNumber }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
     await packing(tx, domain, user, worksheetDetailName, releaseQty, serialNumber)
   }
 }
@@ -32,7 +32,7 @@ export async function packing(
   if (releaseGood.type === 'b2c' && !releaseGood?.airwayBill) {
     const sellercraft: Sellercraft = await tx
       .getRepository(Sellercraft)
-      .findOne({ domain: worksheet.bizplace.domain, status: SellercraftStatus.ACTIVE })
+      .findOneBy({ domain: worksheet.bizplace.domain, status: SellercraftStatus.ACTIVE })
 
     if (sellercraft) {
       const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)

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

@@ -9,8 +9,8 @@ import { PackingWorksheetController, SellercraftController } from '../../../../c
 import { Worksheet } from '../../../../entities'
 
 export const scanProductPackingResolver = {
-  async scanProductPacking(_: any, { worksheetDetailName, productBarcode, serialNumber }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async scanProductPacking(_: any, { worksheetDetailName, productBarcode, serialNumber }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
     await scanProductPacking(tx, domain, user, worksheetDetailName, productBarcode, serialNumber)
   }
 }
@@ -23,24 +23,28 @@ export async function scanProductPacking(
   productBarcode: string,
   serialNumber?: string
 ) {
-  const worksheetController: PackingWorksheetController = new PackingWorksheetController(tx, domain, user)
-  const worksheetDetail = await worksheetController.scanProductPacking(
-    worksheetDetailName,
-    productBarcode,
-    serialNumber
-  )
+  try {
+    const worksheetController: PackingWorksheetController = new PackingWorksheetController(tx, domain, user)
+    const worksheetDetail = await worksheetController.scanProductPacking(
+      worksheetDetailName,
+      productBarcode,
+      serialNumber
+    )
 
-  let releaseGood: ReleaseGood = worksheetDetail.targetInventory.releaseGood
-  const worksheet: Worksheet = worksheetDetail.worksheet
+    let releaseGood: ReleaseGood = worksheetDetail.targetInventory.releaseGood
+    const worksheet: Worksheet = worksheetDetail.worksheet
 
-  if (releaseGood.type === 'b2c' && !releaseGood?.airwayBill) {
-    const sellercraft: Sellercraft = await tx
-      .getRepository(Sellercraft)
-      .findOne({ domain: worksheet.bizplace.domain, status: SellercraftStatus.ACTIVE })
+    if (releaseGood.type === 'b2c' && !releaseGood?.airwayBill) {
+      const sellercraft: Sellercraft = await tx
+        .getRepository(Sellercraft)
+        .findOneBy({ domain: worksheet.bizplace.domain, status: SellercraftStatus.ACTIVE })
 
-    if (sellercraft) {
-      const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
-      await sellercraftCtrl.fetchOrderDocument(sellercraft, releaseGood)
+      if (sellercraft) {
+        const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
+        sellercraftCtrl.fetchOrderDocument(sellercraft, releaseGood)
+      }
     }
+  } catch (error) {
+    throw error
   }
 }

package/server/graphql/resolvers/worksheet/packing/undo-serial-number-packing.ts

@@ -6,8 +6,8 @@ import { Domain } from '@things-factory/shell'
 import { PackingWorksheetController } from '../../../../controllers'
 
 export const undoSerialNumberPackingResolver = {
-  async undoSerialNumberPacking(_: any, { worksheetDetailName, inventoryItemId }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async undoSerialNumberPacking(_: any, { worksheetDetailName, inventoryItemId }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
     await undoSerialNumberPacking(tx, domain, user, worksheetDetailName, inventoryItemId)
   }
 }

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

@@ -1,6 +1,7 @@
-import { EntityManager, SelectQueryBuilder } from 'typeorm'
+import { getManager, SelectQueryBuilder } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
+import { logger } from '@things-factory/env'
 import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
 import {
   MarketplaceOrder,
@@ -13,17 +14,18 @@ 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) {
+  async packingWorksheet(_: any, { releaseGoodNo }, context: ResolverContext) {
     try {
-      const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+      const { tx, domain, user } = context.state
       let releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
         where: {
-          domain,
+          domain: { id: domain.id },
           name: releaseGoodNo
         },
         relations: ['bizplace', 'bizplace.domain']
@@ -32,7 +34,7 @@ export const packingWorksheetResolver = {
       // Find Release Order based on Bin
       if (!releaseGood) {
         const binLocation: Location = await tx.getRepository(Location).findOne({
-          where: { domain, name: releaseGoodNo }
+          where: { domain: { id: domain.id }, name: releaseGoodNo }
         })
 
         if (binLocation) {
@@ -46,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)', {
@@ -60,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 [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
+          })
 
-          const orderInventoryByBin = await qb.getOne()
-          if (orderInventoryByBin?.releaseGood) {
-            releaseGoodNo = orderInventoryByBin.releaseGood.name
-            releaseGood = orderInventoryByBin.releaseGood
+          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.`)
           }
@@ -94,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
@@ -102,19 +147,14 @@ export const packingWorksheetResolver = {
       let marketplaceStatus: string
 
       if (releaseGood.type === 'b2c') {
-        const sellercraft: Sellercraft = await tx.getRepository(Sellercraft).findOne({
-          domain: worksheet.bizplace.domain,
+        const sellercraft: Sellercraft = await tx.getRepository(Sellercraft).findOneBy({
+          domain: { id: worksheet.bizplace.domain.id },
           status: SellercraftStatus.ACTIVE
         })
 
         if (sellercraft) {
-          if (!releaseGood?.airwayBill) {
-            const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
-            releaseGood = await sellercraftCtrl.fetchOrderDocument(sellercraft, releaseGood)
-          }
-          trackingNo = releaseGood?.trackingNo
-          shippingProvider = releaseGood?.transporter
-          marketplaceStatus = releaseGood?.marketplaceOrderStatus
+          // asynchronously get document from sellercraft
+          getSellercraftDocument(sellercraft, releaseGood, domain, user)
         } else {
           marketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
             where: { orderNo: releaseGood.refNo },
@@ -168,12 +208,12 @@ 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 : ''
         },
-        worksheetDetailInfos: worksheet.worksheetDetails.map(async (packingWSD: WorksheetDetail) => {
+        worksheetDetailInfos: worksheet.worksheetDetails.map((packingWSD: WorksheetDetail) => {
           const targetInventory: OrderInventory = packingWSD.targetInventory
           const inventory: Inventory = targetInventory.inventory
           return {
@@ -241,3 +281,41 @@ export async function getTrackingNo(marketplaceStore, marketplaceOrderItems): Pr
 
   return trackingNo
 }
+
+//trigger RTS, init document, and fetch sellercraft document in separated transaction
+async function getSellercraftDocument(sellercraft: Sellercraft, releaseGood: ReleaseGood, domain: Domain, user: User) {
+  await getManager().transaction(async txMgr => {
+    const sellercraftCtrl: SellercraftController = new SellercraftController(txMgr, domain, user)
+    try {
+      if (!releaseGood?.airwayBill) {
+        try {
+          // try fetch order document / AWB
+          releaseGood = await sellercraftCtrl.fetchOrderDocument(sellercraft, releaseGood)
+        } catch (error) {
+          try {
+            // retry initiate order document
+            await sellercraftCtrl.initiateOrderDocument(sellercraft, releaseGood)
+          } catch (error) {
+            try {
+              // retry initiate order shipment / RTS
+              await sellercraftCtrl.initiateOrderShipment(sellercraft, releaseGood)
+            } catch (error) {
+              throw new Error(`initiateOrderShipment: ${error}`)
+            }
+            throw new Error(`initiateOrderDocument: ${error}`)
+          }
+          throw new Error(`fetchOrderDocument: ${error}`)
+        }
+      }
+    } catch (error) {
+      logger.error(
+        `packing-worksheet[getSellercraftDocument]:(data:${JSON.stringify({
+          sellercraft,
+          releaseGood,
+          domain,
+          user
+        })}) ${error} `
+      )
+    }
+  })
+}

package/server/graphql/resolvers/worksheet/palletizing-pallets.ts

@@ -1,17 +1,19 @@
+import { EntityManager, Equal, Not } from 'typeorm'
+import { v4 as uuidv4 } from 'uuid'
+
 import { User } from '@things-factory/auth-base'
+import { ArrivalNotice, ORDER_STATUS, ORDER_TYPES, OrderVas, Vas } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { ArrivalNotice, OrderVas, Vas, ORDER_STATUS, ORDER_VAS_STATUS, ORDER_TYPES } from '@things-factory/sales-base'
-import { v4 as uuidv4 } from 'uuid'
-import { Equal, Not, EntityManager } from 'typeorm'
+
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
-import { Worksheet, WorksheetDetail } from '../../../entities'
 import { VasWorksheetController, WorksheetController } from '../../../controllers'
+import { Worksheet, WorksheetDetail } from '../../../entities'
 
 export const palletizingPallets = {
-  async palletizingPallets(_: any, { refOrderNo, patches }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async palletizingPallets(_: any, { refOrderNo, patches }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
     let arrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
-      where: { domain: context.state.domain, name: refOrderNo, status: Not(Equal(ORDER_STATUS.DONE)) },
+      where: { domain: { id: context.state.domain.id }, name: refOrderNo, status: Not(Equal(ORDER_STATUS.DONE)) },
       relations: ['bizplace']
     })
 
@@ -30,7 +32,7 @@ export const palletizingPallets = {
       })
 
       const palletizingVAS: Vas = await tx.getRepository(Vas).findOne({
-        where: { domain, id: patch.vas.id }
+        where: { domain: { id: domain.id }, id: patch.vas.id }
       })
 
       if (foundOV) {