@things-factory/worksheet-base 4.0.0-y.0 → 4.0.0

package/server/controllers/vas/vas-worksheet-controller.ts

@@ -1,28 +1,30 @@
+import { EntityManager, Equal, In, Not } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
+import { Product } from '@things-factory/product-base'
 import {
   ArrivalNotice,
-  OrderNoGenerator,
-  OrderVas,
   ORDER_STATUS,
   ORDER_TYPES,
   ORDER_VAS_STATUS,
+  OrderNoGenerator,
+  OrderVas,
   ReleaseGood,
-  VasOrder,
-  VAS
+  VAS,
+  VasOrder
 } from '@things-factory/sales-base'
-import { Product } from '@things-factory/product-base'
 import {
   Inventory,
-  InventoryHistory,
-  InventoryNoGenerator,
   INVENTORY_STATUS,
   INVENTORY_TRANSACTION_TYPE,
+  InventoryHistory,
+  InventoryNoGenerator,
   Location,
   LOCATION_TYPE,
   Warehouse
 } from '@things-factory/warehouse-base'
-import { EntityManager, Equal, Not, In } from 'typeorm'
+
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../constants'
 import { Worksheet, WorksheetDetail } from '../../entities'
 import {
@@ -30,10 +32,12 @@ import {
   completeRepackaging,
   completeRepalletizing,
   completeUnpacking,
+  FeaturedInventoryInterface,
   RefOrderType
 } from '../../graphql/resolvers/worksheet/vas-transactions'
-import { ReferenceOrderType, WorksheetController } from '.././worksheet-controller'
+import { PackingUnits } from '../../graphql/resolvers/worksheet/vas-transactions/interfaces/repackaging'
 import { generateInventoryHistory } from '../../utils'
+import { ReferenceOrderType, WorksheetController } from '../worksheet-controller'
 
 type CompleteTransactionType = (trxMgr: EntityManager, orderVas: OrderVas, user: User) => Promise<void>
 
@@ -41,6 +45,7 @@ export class VasWorksheetController extends WorksheetController {
   private readonly COMPLETE_TRX_MAP: Record<string, CompleteTransactionType> = {
     'vas-repalletizing': completeRepalletizing,
     'vas-repack': completeRepackaging,
+    'vas-repack-relabel': completeRepackaging,
     'vas-relabel': completeRelabeling,
     'vas-unpack': completeUnpacking
   }
@@ -102,20 +107,88 @@ export class VasWorksheetController extends WorksheetController {
         return acc + inv.qty
       }, 0)
 
+      let operationGuide = JSON.parse(targetVas.operationGuide)
+      let vasOperationGuide = targetVas.vas?.operationGuide
+
+      if (vasOperationGuide === 'vas-repack' || vasOperationGuide === 'vas-repack-relabel') {
+        const mainInventory: Inventory = inventories[0]
+        const featuredInvs: FeaturedInventoryInterface[] = []
+        const foundInvs: Inventory[] = await this.trxMgr
+          .getRepository(Inventory)
+          .findByIds(inventories.filter(inv => inv.id !== mainInventory.id).map(inv => inv.id))
+
+        /* Update lockedQty of featuredInvs */
+        for (let inventory of foundInvs) {
+          const transferQty: number = inventories.find(inv => inv.id === inventory.id).qty
+          const transferUomValue: number = Math.round((inventory.uomValue / inventory.qty) * transferQty * 100) / 100
+
+          inventory.lockedQty += transferQty
+          inventory.lockedUomValue += transferUomValue
+
+          await this.trxMgr.getRepository(Inventory).save(inventory)
+
+          let featuredInv: FeaturedInventoryInterface = {
+            palletId: inventory.palletId,
+            originalQty: transferQty,
+            originalUomValue: transferUomValue,
+            packingSize: inventory.packingSize,
+            uomValuePerQty: inventory.uomValue / (inventory.qty * inventory.packingSize)
+          }
+
+          switch (operationGuide.data?.packingUnit) {
+            case PackingUnits.QTY:
+              featuredInv.currentUnitQty = transferQty * inventory.packingSize
+              break
+
+            case PackingUnits.UOM:
+              featuredInv.currentUomValue = transferUomValue
+              break
+          }
+
+          featuredInvs.push(featuredInv)
+        }
+
+        /* assign featuredInvs inside operationGuide.data */
+        operationGuide.data = {
+          ...operationGuide.data,
+          featuredInvs
+        }
+
+        /* assign main inventory as the only inventories */
+        inventories = [mainInventory]
+      }
+
       for (let inventory of inventories) {
         let newTargetVas: OrderVas = new OrderVas()
 
         const foundInventory: Inventory = await this.trxMgr.getRepository(Inventory).findOne(inventory.id)
-        const unitUomValue: number = foundInventory.uomValue / foundInventory.qty
-        const assignedQty = inventory.qty // assigned inventory qty that was passed from client side
+        if (!foundInventory) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(inventory.id))
 
-        let operationGuide = JSON.parse(targetVas.operationGuide)
+        // assigned inventory qty that was passed from client side
+        const assignedQty = inventory.qty
+        const unitUomValue: number = foundInventory.uomValue / foundInventory.qty
 
         // update unpack qty for unpacking vas
-        if (targetVas.vas?.operationGuide === 'vas-unpack') {
+        if (vasOperationGuide === 'vas-unpack') {
           operationGuide.data.unpackQty = Math.round(operationGuide.data.unpackQty / accInventoriesQty) * assignedQty
         }
 
+        if (vasOperationGuide === 'vas-repack' || vasOperationGuide === 'vas-repack-relabel') {
+          switch (operationGuide.data?.packingUnit) {
+            case PackingUnits.UOM:
+              newTargetVas.qty = 1
+              newTargetVas.uomValue = targetVas.uomValue
+              break
+
+            default:
+              newTargetVas.qty = accInventoriesQty
+              newTargetVas.uomValue = accInventoriesQty * unitUomValue
+          }
+        } else {
+          newTargetVas.qty = assignedQty
+          newTargetVas.uomValue = assignedQty * unitUomValue
+        }
+
         newTargetVas.set = targetVas.set
         newTargetVas.targetType = targetVas.targetType
         newTargetVas.targetBatchId = targetVas.targetBatchId
@@ -129,8 +202,6 @@ export class VasWorksheetController extends WorksheetController {
         newTargetVas.vas = targetVas.vas
         newTargetVas.domain = this.domain
         newTargetVas.name = OrderNoGenerator.orderVas()
-        newTargetVas.qty = assignedQty
-        newTargetVas.uomValue = assignedQty * unitUomValue
         newTargetVas.inventory = foundInventory
         newTargetVas.bizplace = bizplace
         newTargetVas.creator = this.user
@@ -141,15 +212,13 @@ export class VasWorksheetController extends WorksheetController {
         seq++
 
         // update inventory locked qty & uom value
-        const currentLockedQty: any = inventory.lockedQty
-        const currentLockedUomValue: any = inventory.lockedUomValue
+        const currentLockedQty: number = foundInventory.lockedQty || 0
+        const currentLockedUomValue: number = foundInventory.lockedUomValue || 0
 
         await this.trxMgr.getRepository(Inventory).save({
           ...foundInventory,
-          lockedQty: !!currentLockedQty ? targetVas.qty + currentLockedQty : targetVas.qty,
-          lockedUomValue: !!currentLockedUomValue
-            ? targetVas.qty * unitUomValue + currentLockedUomValue
-            : targetVas.qty * unitUomValue,
+          lockedQty: inventory.qty + currentLockedQty,
+          lockedUomValue: inventory.qty * unitUomValue + currentLockedUomValue,
           updater: this.user
         })
       }
@@ -360,13 +429,19 @@ export class VasWorksheetController extends WorksheetController {
       }
     }
 
-    const targetVas: Inventory = foundWorksheetDetail.targetVas
+    const targetVas: VasOrder = foundWorksheetDetail.targetVas
     if (!targetVas) throw new Error(`VAS doesn't exists`)
 
     const inventory: Inventory = foundWorksheetDetail.targetVas.inventory
 
     // reset lockedQty if there's inventory found
-    if (inventory && inventory.lockedQty >= targetVas.qty) {
+    if (
+      inventory &&
+      inventory.lockedQty >= targetVas.qty &&
+      targetVas.vas.operationGuide &&
+      targetVas.vas.operationGuide !== 'vas-repack' &&
+      targetVas.vas.operationGuide !== 'vas-repack-relabel'
+    ) {
       await this.trxMgr.getRepository(Inventory).save({
         ...inventory,
         lockedQty: inventory.lockedQty - targetVas.qty,
@@ -664,6 +739,12 @@ export class VasWorksheetController extends WorksheetController {
         (wsd: WorksheetDetail) => wsd.targetVas.id === targetVas.id
       )
 
+      // if (targetVas.operationGuide && (!issue || (targetVas.vas.name.toUpperCase() == VAS.REPACKAGING && issue))) {
+      //   await this.doOperationTransaction(targetVas)
+      // } /*else if (targetVas.operationGuide && targetVas.vas.name.toUpperCase() === VAS.REPACKAGING && issue) {
+      //   await this.doOperationTransaction(targetVas)
+      // }*/
+
       if (targetVas.operationGuide && !issue) {
         await this.doOperationTransaction(targetVas)
       }

package/server/controllers/worksheet-controller.ts

@@ -1,24 +1,26 @@
+import { EntityManager, EntitySchema, Equal, FindOneOptions, In, Not } from 'typeorm'
+
 import { Role, User } from '@things-factory/auth-base'
 import { Bizplace, getDomainUsers } from '@things-factory/biz-base'
+import { sendNotification } from '@things-factory/notification'
+import { ProductDetail } from '@things-factory/product-base'
 import {
   ArrivalNotice,
   DeliveryOrder,
   InventoryCheck,
-  OrderInventory,
-  OrderProduct,
-  OrderVas,
   ORDER_INVENTORY_STATUS,
   ORDER_PRODUCT_STATUS,
   ORDER_VAS_STATUS,
+  OrderInventory,
+  OrderProduct,
+  OrderVas,
   ReleaseGood,
-  VasOrder,
-  ReturnOrder
+  ReturnOrder,
+  VasOrder
 } from '@things-factory/sales-base'
-import { ProductDetail } from '@things-factory/product-base'
 import { Domain } from '@things-factory/shell'
-import { sendNotification } from '@things-factory/notification'
-import { Inventory, Pallet, INVENTORY_STATUS } from '@things-factory/warehouse-base'
-import { EntityManager, EntitySchema, Equal, FindOneOptions, Not, In } from 'typeorm'
+import { Inventory, INVENTORY_STATUS, Pallet } from '@things-factory/warehouse-base'
+
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../constants'
 import { Worksheet, WorksheetDetail } from '../entities'
 import { generateInventoryHistory, WorksheetNoGenerator } from '../utils'
@@ -56,6 +58,7 @@ export class WorksheetController {
   public readonly ERROR_MSG = {
     FIND: {
       NO_RESULT: (condition: any) => `There's no results matched with condition ${condition}`,
+      NO_CHILD_RESULT: (condition: any) => `There's no child result matched with condition ${condition}`,
       NOT_MATCH: (source: any, target: any) => `Unable to find matching ${target} using ${source}`
     },
     ORDER_ITEM: {
@@ -637,10 +640,12 @@ export class WorksheetController {
 
     const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
 
-    worksheetDetails.forEach((wsd: WorksheetDetail) => {
-      wsd.status = WORKSHEET_STATUS.DONE
-      wsd.updater = this.user
-    })
+    worksheetDetails
+      .filter((wsd: WorksheetDetail) => wsd.status !== ORDER_INVENTORY_STATUS.REPLACED)
+      .forEach((wsd: WorksheetDetail) => {
+        wsd.status = WORKSHEET_STATUS.DONE
+        wsd.updater = this.user
+      })
     await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetails)
 
     if (worksheetType === WORKSHEET_TYPE.UNLOADING) {
@@ -668,12 +673,14 @@ export class WorksheetController {
       worksheetType === WORKSHEET_TYPE.WAREHOUSE_RETURN ||
       worksheetType === WORKSHEET_TYPE.UNLOADING_RETURN
     ) {
-      const targetInventories: OrderInventory[] = worksheet.worksheetDetails.map((wsd: WorksheetDetail) => {
-        let targetInventory: OrderInventory = wsd.targetInventory
-        targetInventory.status = ORDER_INVENTORY_STATUS.TERMINATED
-        targetInventory.updater = this.user
-        return targetInventory
-      })
+      const targetInventories: OrderInventory[] = worksheet.worksheetDetails
+        .filter((wsd: WorksheetDetail) => wsd.status !== ORDER_INVENTORY_STATUS.REPLACED)
+        .map((wsd: WorksheetDetail) => {
+          let targetInventory: OrderInventory = wsd.targetInventory
+          targetInventory.status = ORDER_INVENTORY_STATUS.TERMINATED
+          targetInventory.updater = this.user
+          return targetInventory
+        })
 
       await this.updateOrderTargets(targetInventories)
     }
@@ -951,6 +958,60 @@ export class WorksheetController {
     return childQty
   }
 
+  /**
+   * @summary Check for product child qty at any scanned level
+   * @description It will check every level of product detail by comparing scanned level and GAN registered level.
+   * By getting the level that has relation, child qty will be retrieved
+   * 1st level: PALLET -> 2 CARTONS (scan), 2nd level: CARTON -> 6 BAGS, 3rd level: BAG -> 10 UNITS, lowest: UNIT (order registered packing type)
+   */
+  async getChildPackingSize(
+    productDetails: ProductDetail[],
+    defaultProductDetail: ProductDetail,
+    unmatchingProductDetail: ProductDetail
+  ): Promise<number> {
+    let hasChildRelation: boolean = Boolean(unmatchingProductDetail?.childProductDetail)
+    let hasMatchingChild: boolean
+    let packingSize: number = 1
+    let currentChildProductDetail: ProductDetail
+
+    if (hasChildRelation) {
+      currentChildProductDetail = productDetails.find(
+        (productDetail: ProductDetail) => productDetail.id === unmatchingProductDetail.childProductDetail.id
+      )
+
+      if (!currentChildProductDetail) {
+        throw new Error(this.ERROR_MSG.FIND.NOT_MATCH('packing type', `GTIN (${unmatchingProductDetail.gtin})`))
+      }
+
+      hasMatchingChild = Boolean(defaultProductDetail.id === currentChildProductDetail.id)
+      if (hasMatchingChild) {
+        packingSize = unmatchingProductDetail.packingSize
+      } else {
+        packingSize = unmatchingProductDetail.packingSize * packingSize
+      }
+    } else {
+      throw new Error(this.ERROR_MSG.FIND.NO_CHILD_RESULT(`${unmatchingProductDetail.gtin}`))
+    }
+
+    while (hasChildRelation && !hasMatchingChild) {
+      if (hasMatchingChild) {
+        packingSize = currentChildProductDetail.packingSize * packingSize // 12 x 10
+      } else if (!hasMatchingChild && hasChildRelation) {
+        packingSize = currentChildProductDetail.packingSize * packingSize // 12 x 10
+        currentChildProductDetail = productDetails.find(
+          (productDetail: ProductDetail) => productDetail.id === currentChildProductDetail.childProductDetail.id
+        )
+
+        hasChildRelation = Boolean(currentChildProductDetail?.childProductDetail)
+        hasMatchingChild = Boolean(defaultProductDetail.id === currentChildProductDetail.id)
+      } else if (!hasChildRelation && !hasMatchingChild) {
+        throw new Error(this.ERROR_MSG.FIND.NO_RESULT(unmatchingProductDetail.gtin))
+      }
+    }
+
+    return packingSize
+  }
+
   async createInventory(inventory: Partial<Inventory> | Partial<Inventory>[]): Promise<Inventory | Inventory[]> {
     inventory = this.setStamp(inventory)
     return await this.trxMgr.getRepository(Inventory).save(inventory)
@@ -1037,9 +1098,13 @@ export class WorksheetController {
   }
 
   tidyConditions(record: Record<string, any>): Record<string, any> {
-    Object.keys(record).forEach((key: string) => {
-      if (record[key] === null || record[key] instanceof Date || Array.isArray(record[key])) delete record[key]
-    })
+    if ('id' in record) {
+      return { id: record.id }
+    } else {
+      Object.keys(record).forEach((key: string) => {
+        if (record[key] === null || record[key] instanceof Date || Array.isArray(record[key])) delete record[key]
+      })
+    }
 
     return record
   }

package/server/graphql/resolvers/pallet/pallet-outbound.ts

@@ -1,9 +1,10 @@
+import { EntityManager, In } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
 import { ReleaseGood } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 import { Pallet, PalletHistory } from '@things-factory/warehouse-base'
-import { EntityManager, getRepository, In } from 'typeorm'
 
 export const palletOutbound = {
   async palletOutbound(_: any, { refOrderNo, patches }, context: any) {

package/server/graphql/resolvers/worksheet/cycle-count-adjustment.ts

@@ -1,9 +1,13 @@
+import { EntityManager, In } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
-import { InventoryCheck, OrderInventory, ORDER_INVENTORY_STATUS, ORDER_STATUS } from '@things-factory/sales-base'
+import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
+import { InventoryCheck, ORDER_INVENTORY_STATUS, ORDER_STATUS, OrderInventory } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory, INVENTORY_STATUS, INVENTORY_TRANSACTION_TYPE, Location } from '@things-factory/warehouse-base'
-import { EntityManager, In } from 'typeorm'
+
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
+import { SellercraftController } from '../../../controllers'
 import { Worksheet, WorksheetDetail } from '../../../entities'
 import { generateInventoryHistory, switchLocationStatus } from '../../../utils'
 
@@ -48,6 +52,11 @@ export async function cycleCountAdjustment(
     relations: [
       'targetInventory',
       'targetInventory.inventory',
+      'targetInventory.inventory.product',
+      'targetInventory.inventory.product.productDetails',
+      'targetInventory.inventory.product.productDetails.childProductDetail',
+      'targetInventory.inventory.bizplace',
+      'targetInventory.inventory.bizplace.domain',
       'targetInventory.inventory.location',
       'targetInventory.inspectedLocation',
       'targetInventory.inspectedLocation.warehouse'
@@ -61,6 +70,10 @@ export async function cycleCountAdjustment(
     const transactQty: number = targetInventory.inspectedQty - inventory.qty
     const transactUomValue: number = targetInventory.inspectedUomValue - inventory.uomValue
 
+    const sellercraft: Sellercraft = await tx.getRepository(Sellercraft).findOne({
+      where: { domain: inventory.bizplace.domain, status: SellercraftStatus.ACTIVE }
+    })
+
     if (targetInventory.status === ORDER_INVENTORY_STATUS.MISSING) {
       // create STORED, CC_ADJUSTMENT history
       await generateInventoryHistory(
@@ -83,6 +96,11 @@ export async function cycleCountAdjustment(
 
       // create TERMINATED, TERMINATED history
       await generateInventoryHistory(inventory, cycleCount, INVENTORY_TRANSACTION_TYPE.TERMINATED, 0, 0, user, tx)
+
+      if (sellercraft) {
+        const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
+        await sellercraftCtrl.updateSellercraftStock(sellercraft, inventory)
+      }
     } else if (targetInventory.inspectedQty == 0) {
       // create STORED, CC_ADJUSTMENT history
       await generateInventoryHistory(
@@ -109,6 +127,11 @@ export async function cycleCountAdjustment(
 
       // create TERMINATED, TERMINATED history
       await generateInventoryHistory(inventory, cycleCount, INVENTORY_TRANSACTION_TYPE.TERMINATED, 0, 0, user, tx)
+
+      if (sellercraft) {
+        const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
+        await sellercraftCtrl.updateSellercraftStock(sellercraft, inventory)
+      }
     } else {
       const prevLocationId: string = inventory.location.id
 
@@ -153,6 +176,11 @@ export async function cycleCountAdjustment(
       )
     }
 
+    if (sellercraft) {
+      const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
+      await sellercraftCtrl.updateSellercraftStock(sellercraft, inventory)
+    }
+
     targetInventory.status = ORDER_INVENTORY_STATUS.TERMINATED
     targetInventory.updater = user
     await tx.getRepository(OrderInventory).save(targetInventory)

package/server/graphql/resolvers/worksheet/cycle-count-worksheet.ts

@@ -1,7 +1,9 @@
+import { createQueryBuilder, getRepository, In, SelectQueryBuilder } from 'typeorm'
+
+import { InventoryCheck, ORDER_STATUS, OrderInventory } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { getRepository, createQueryBuilder, SelectQueryBuilder, In } from 'typeorm'
 import { Inventory } from '@things-factory/warehouse-base'
-import { OrderInventory, ORDER_STATUS, InventoryCheck } from '@things-factory/sales-base'
+
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
 import { Worksheet, WorksheetDetail } from '../../../entities'
 
@@ -21,7 +23,7 @@ export const cycleCountWorksheetResolver = {
         type: In([WORKSHEET_TYPE.CYCLE_COUNT, WORKSHEET_TYPE.CYCLE_COUNT_RECHECK]),
         status: WORKSHEET_STATUS.EXECUTING
       },
-      relations: ['bizplace']
+      relations: ['bizplace', 'bizplace.domain']
     })
 
     const qb: SelectQueryBuilder<WorksheetDetail> = createQueryBuilder(WorksheetDetail, 'WSD')
@@ -46,7 +48,8 @@ export const cycleCountWorksheetResolver = {
     return {
       worksheetInfo: {
         startedAt: worksheet.startedAt,
-        bizplace: worksheet.bizplace
+        bizplace: worksheet.bizplace,
+        partnerDomainId: worksheet.bizplace?.domain.id
       },
       worksheetDetailInfos: worksheetDetails.map(async (cycleCountWSD: WorksheetDetail) => {
         const targetInventory: OrderInventory = cycleCountWSD.targetInventory

package/server/graphql/resolvers/worksheet/fetch-sellercraft-airway-bill.ts

@@ -0,0 +1,30 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
+import { ReleaseGood } from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+
+import { SellercraftController } from '../../../controllers'
+
+export const fetchSellercraftAirwayBillResolver = {
+  async fetchSellercraftAirwayBill(_: any, { releaseGoodNo }, context: any) {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    let releaseGood: ReleaseGood = await tx
+      .getRepository(ReleaseGood)
+      .findOne({ where: { domain, name: releaseGoodNo }, relations: ['bizplace', 'bizplace.domain'] })
+
+    const sellercraft: Sellercraft = await tx.getRepository(Sellercraft).findOne({
+      domain: releaseGood.bizplace.domain,
+      status: SellercraftStatus.ACTIVE
+    })
+
+    if (sellercraft && !releaseGood?.airwayBill) {
+      const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
+      await sellercraftCtrl.fetchOrderDocument(sellercraft, releaseGood)
+    }
+
+    const airwayBill: string = releaseGood?.airwayBill
+    return { airwayBill }
+  }
+}

package/server/graphql/resolvers/worksheet/generate-worksheet/generate-cycle-count-worksheet.ts

@@ -1,11 +1,18 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
+import { OrderInventory } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
+
 import { CycleCountWorksheetController } from '../../../../controllers'
 import { Worksheet } from '../../../../entities'
 
 export const generateCycleCountWorksheetResolver = {
-  async generateCycleCountWorksheet(_: any, { executionDate, customerId, orderInventoryIds, limit }, context: any) {
+  async generateCycleCountWorksheet(
+    _: any,
+    { executionDate, customerId, orderInventoryIds, orderInventories, limit },
+    context: any
+  ) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
 
     const cycleCountWorksheet: Worksheet = await generateCycleCountWorksheet(
@@ -15,6 +22,7 @@ export const generateCycleCountWorksheetResolver = {
       executionDate,
       customerId,
       orderInventoryIds,
+      orderInventories,
       limit
     )
 
@@ -29,8 +37,15 @@ export async function generateCycleCountWorksheet(
   executionDate: string,
   customerId: string,
   orderInventoryIds: string[] = [],
+  orderInventories: OrderInventory[],
   limit: number
 ): Promise<Worksheet> {
   const worksheetController: CycleCountWorksheetController = new CycleCountWorksheetController(tx, domain, user)
-  return await worksheetController.generateCycleCountWorksheet(executionDate, customerId, orderInventoryIds, limit)
+  return await worksheetController.generateCycleCountWorksheet(
+    executionDate,
+    customerId,
+    orderInventoryIds,
+    orderInventories,
+    limit
+  )
 }

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

@@ -8,6 +8,8 @@ import { cycleCountAdjustmentResolver } from './cycle-count-adjustment'
 import { cycleCountWorksheetResolver } from './cycle-count-worksheet'
 import { deleteWorksheet } from './delete-worksheet'
 import { deliveryOrderByWorksheetResolver } from './delivery-order-by-worksheet'
+import { fetchSellercraftAirwayBillResolver } from './fetch-sellercraft-airway-bill'
+import { findReleaseOrdersByTaskNoResolver } from './find-release-orders-by-task-no'
 import { Mutations as GenerateWorksheetMutations } from './generate-worksheet'
 import { havingVasResolver } from './having-vas'
 import { Mutations as InspectMutations } from './inspecting'
@@ -33,13 +35,13 @@ import { recommendPutawayLocationResolver } from './recommend-putway-location'
 import { rejectCancellationReleaseOrder } from './reject-cancellation-release-order'
 import { replacePickingPalletsResolver } from './replace-picking-pallets'
 import { returnWorksheetResolver } from './return-worksheet'
-import { sortingWorksheetResolver } from './sorting-worksheet'
 import { Mutations as ReturningMutations } from './returning'
+import { Mutations as SortingMutations } from './sorting'
+import { sortingWorksheetResolver } from './sorting-worksheet'
 import { transfer } from './transfer'
 import { unloadedInventories } from './unloaded-inventories'
 import { unloadedInventoriesByReusablePallet } from './unloaded-inventories-by-reusable-pallet'
 import { Mutations as UnloadingMutations } from './unloading'
-import { Mutations as SortingMutations } from './sorting'
 import { Mutations as UnloadingReturnMutations } from './unloading-return'
 import { unloadingReturnWorksheetResolver } from './unloading-return-worksheet'
 import { unloadingWorksheetResolver } from './unloading-worksheet'
@@ -62,7 +64,6 @@ import { worksheetResolver } from './worksheet'
 import { worksheetByOrderNoResolver } from './worksheet-by-order-no'
 import { worksheetWithPaginationResolver } from './worksheet-with-pagination'
 import { worksheetsResolver } from './worksheets'
-import { findReleaseOrdersByTaskNoResolver } from './find-release-orders-by-task-no'
 
 export const Query = {
   ...worksheetsResolver,
@@ -130,5 +131,6 @@ export const Mutation = {
   ...undoRelabelingResolver,
   ...crossDockPickingResolver,
   ...unpackingResolver,
-  ...palletizingPallets
+  ...palletizingPallets,
+  ...fetchSellercraftAirwayBillResolver
 }

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

@@ -1,6 +1,8 @@
+import { createQueryBuilder, getRepository, SelectQueryBuilder } from 'typeorm'
+
 import { InventoryCheck, ORDER_INVENTORY_STATUS } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { createQueryBuilder, getRepository, SelectQueryBuilder } from 'typeorm'
+
 import { Worksheet, WorksheetDetail } from '../../../entities'
 
 export const notTallyTargetInventoriesResolver = {
@@ -24,7 +26,7 @@ export const notTallyTargetInventoriesResolver = {
       .leftJoinAndSelect('INV.product', 'PROD')
       .where('WSD.domain = :domainId', { domainId: domain.id })
       .andWhere('WSD.worksheet = :worksheetId', { worksheetId: worksheet.id })
-      .andWhere('T_INV.status = :status', { status: ORDER_INVENTORY_STATUS.NOT_TALLY })
+      .andWhere('WSD.status = :status', { status: ORDER_INVENTORY_STATUS.NOT_TALLY })
       .getMany()
 
     return worksheetDetails.map((wsd: WorksheetDetail) => wsd.targetInventory)

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

@@ -1,7 +1,11 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
+import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
+import { ReleaseGood } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { PackingWorksheetController } from '../../../../controllers'
+
+import { PackingWorksheetController, SellercraftController } from '../../../../controllers'
 import { Worksheet } from '../../../../entities'
 
 export const activatePackingResolver = {
@@ -18,5 +22,18 @@ export async function activatePacking(
   worksheetNo: string
 ): Promise<Worksheet> {
   const worksheetController: PackingWorksheetController = new PackingWorksheetController(tx, domain, user)
-  return await worksheetController.activatePacking(worksheetNo)
+  const worksheet = await worksheetController.activatePacking(worksheetNo)
+  let releaseGood: ReleaseGood = worksheet.releaseGood
+
+  if (releaseGood.type == 'b2c') {
+    const sellercraft: Sellercraft = await tx
+      .getRepository(Sellercraft)
+      .findOne({ domain: releaseGood.bizplace.domain, status: SellercraftStatus.ACTIVE })
+
+    if (sellercraft) {
+      const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
+      await sellercraftCtrl.fetchOrderDocument(sellercraft, releaseGood)
+    }
+  }
+  return worksheet
 }