@things-factory/worksheet-base 4.3.185 → 4.3.187

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

@@ -12,6 +12,7 @@ import { scanProductBatchPickingResolver } from './scan-product-batch-picking'
 import { undoPickingAssigmentResolver } from './undo-picking-assignment'
 import { undoSerialNumberPickingResolver } from './undo-serial-number-picking'
 import { sealToteResolver } from './seal-tote'
+import { replenishmentPickingResolver } from './replenishment-picking'
 
 export const Mutations = {
   ...assignPickingInventoriesResolver,
@@ -27,5 +28,6 @@ export const Mutations = {
   ...assignPickingWorkerResolver,
   ...fetchAndAssignPickingTaskResolver,
   ...undoSerialNumberPickingResolver,
-  ...sealToteResolver
+  ...sealToteResolver,
+  ...replenishmentPickingResolver
 }

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

@@ -0,0 +1,27 @@
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+import { EntityManager } from 'typeorm'
+import { ReplenishmentWorksheetController } from '../../../../controllers'
+
+import { pickingWorksheet } from '../picking-worksheet'
+
+export const replenishmentPickingResolver = {
+  async replenishmentPicking(
+    _: any,
+    { worksheetDetailName, worksheetType, productBarcode, cartonId, binLocation, serialNumber, pickingQty },
+    context: any
+  ) {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+
+    const worksheetController: ReplenishmentWorksheetController = new ReplenishmentWorksheetController(tx, domain, user)
+    let ws = await worksheetController.replenishmentPicking(
+      worksheetDetailName,
+      worksheetType,
+      productBarcode,
+      cartonId,
+      binLocation,
+      serialNumber,
+      pickingQty
+    )
+  }
+}

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

@@ -1,6 +1,12 @@
 import { EntityManager, In, SelectQueryBuilder } from 'typeorm'
 
-import { ORDER_INVENTORY_STATUS, OrderInventory, ReleaseGood, ShippingOrder } from '@things-factory/sales-base'
+import {
+  ORDER_INVENTORY_STATUS,
+  OrderInventory,
+  ReleaseGood,
+  ShippingOrder,
+  Replenishment
+} from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory, Location, InventoryChange } from '@things-factory/warehouse-base'
 
@@ -8,30 +14,26 @@ import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
 import { WorksheetDetail } from '../../../entities'
 import { fetchExecutingWorksheet } from '../../../utils'
 import { VasOrderWorksheet } from 'server/graphql/types/worksheet/vas-order-worksheet'
+import { ReplenishmentWorksheetController } from 'server/controllers'
 
 export const pickingWorksheetResolver = {
-  async pickingWorksheet(_: any, { releaseGoodNo, locationSortingRules }, context: any) {
+  async pickingWorksheet(_: any, { orderNo, locationSortingRules }, context: any) {
     const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
 
-    return await pickingWorksheet(domain, releaseGoodNo, locationSortingRules, tx)
+    return await pickingWorksheet(domain, orderNo, locationSortingRules, tx)
   }
 }
 
-export async function pickingWorksheet(
-  domain: Domain,
-  releaseGoodNo: String,
-  locationSortingRules: any,
-  tx: EntityManager
-) {
+export async function pickingWorksheet(domain: Domain, orderNo: String, locationSortingRules: any, tx: EntityManager) {
   let releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
-    where: { domain, name: releaseGoodNo /*status: ORDER_STATUS.PICKING*/ },
+    where: { domain, name: orderNo /*status: ORDER_STATUS.PICKING*/ },
     relations: ['bizplace', 'bizplace.domain']
   })
 
   // Find Release Order based on Bin
   if (!releaseGood) {
     const binLocation: Location = await tx.getRepository(Location).findOne({
-      where: { domain, name: releaseGoodNo }
+      where: { domain, name: orderNo }
     })
 
     const orderInventoryByBin: OrderInventory = await tx.getRepository(OrderInventory).findOne({
@@ -47,101 +49,181 @@ export async function pickingWorksheet(
     })
 
     if (orderInventoryByBin?.releaseGood) {
-      releaseGoodNo = orderInventoryByBin.releaseGood.name
+      orderNo = orderInventoryByBin.releaseGood.name
       releaseGood = orderInventoryByBin.releaseGood
     }
   }
 
-  if (!releaseGood) throw new Error(`Couldn't find picking worksheet by order no (${releaseGoodNo})`)
+  if (!releaseGood) {
+    const replenishment = await replenishmentWorksheet(orderNo)
 
-  if (releaseGood.exportOption) {
-    var shippingOrder: ShippingOrder = await tx.getRepository(ShippingOrder).findOne({
-      where: {
-        id: releaseGood?.shippingOrderId
-      }
-    })
+    if (!replenishment) {
+      throw new Error(`Couldn't find picking worksheet by order no (${orderNo})`)
+    }
+
+    return replenishment
+  } else {
+    if (releaseGood.exportOption) {
+      var shippingOrder: ShippingOrder = await tx.getRepository(ShippingOrder).findOne({
+        where: {
+          id: releaseGood?.shippingOrderId
+        }
+      })
+    }
+
+    const worksheet = await fetchExecutingWorksheet(
+      domain,
+      releaseGood.bizplace,
+      ['bizplace'],
+      WORKSHEET_TYPE.PICKING,
+      releaseGood,
+      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')
+      })
+    }
+
+    qb.addOrderBy(`PROD.name`, '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()
+
+    return {
+      worksheetInfo: {
+        bizplaceName: releaseGood.bizplace.name,
+        partnerDomainId: releaseGood.bizplace?.domain.id,
+        startedAt: worksheet.startedAt,
+        refNo: releaseGood.refNo,
+        refNo2: releaseGood.refNo2,
+        refNo3: releaseGood.refNo3,
+        type: releaseGood.type,
+        containerNo: shippingOrder?.containerNo,
+        marketplaceStatus: releaseGood.marketplaceOrderStatus,
+        shippingProvider: releaseGood.transporter,
+        trackingNo: releaseGood.trackingNo,
+        releaseGood
+      },
+      worksheetDetailInfos: worksheetDetails.map(async (pickingWSD: WorksheetDetail) => {
+        const targetInventory: OrderInventory = pickingWSD.targetInventory
+        const inventory: Inventory = targetInventory.inventory
+
+        const inventoryChangesCount: number = await tx.getRepository(InventoryChange).count({
+          where: {
+            inventory: inventory.id,
+            status: 'PENDING',
+            transactionType: 'MISSING'
+          },
+          relations: ['inventory', 'product']
+        })
+
+        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,
+          hasMissingInventoryChanges: inventoryChangesCount > 0 ? true : false
+        }
+      })
+    }
   }
 
-  const worksheet = await fetchExecutingWorksheet(
-    domain,
-    releaseGood.bizplace,
-    ['bizplace'],
-    WORKSHEET_TYPE.PICKING,
-    releaseGood,
-    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')
+  async function replenishmentWorksheet(orderNo: String) {
+    let replenishment: Replenishment = await tx.getRepository(Replenishment).findOne({
+      where: { domain, name: orderNo }
     })
-  }
 
-  qb.addOrderBy(`PROD.name`, '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()
-
-  return {
-    worksheetInfo: {
-      bizplaceName: releaseGood.bizplace.name,
-      partnerDomainId: releaseGood.bizplace?.domain.id,
-      startedAt: worksheet.startedAt,
-      refNo: releaseGood.refNo,
-      refNo2: releaseGood.refNo2,
-      refNo3: releaseGood.refNo3,
-      type: releaseGood.type,
-      containerNo: shippingOrder?.containerNo,
-      marketplaceStatus: releaseGood.marketplaceOrderStatus,
-      shippingProvider: releaseGood.transporter,
-      trackingNo: releaseGood.trackingNo,
-      releaseGood
-    },
-    worksheetDetailInfos: worksheetDetails.map(async (pickingWSD: WorksheetDetail) => {
-      const targetInventory: OrderInventory = pickingWSD.targetInventory
-      const inventory: Inventory = targetInventory.inventory
-
-      const inventoryChangesCount: number = await tx.getRepository(InventoryChange).count({
-        where: {
-          inventory: inventory.id,
-          status: 'PENDING',
-          transactionType: 'MISSING'
-        },
-        relations: ['inventory', 'product']
-      })
+    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')
+        })
+      }
+
+      qb.addOrderBy(`PROD.name`, '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()
 
       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,
-        hasMissingInventoryChanges: inventoryChangesCount > 0 ? true : false
+        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
   }
 }

package/server/graphql/resolvers/worksheet/putaway/complete-replenishment-putaway.ts

@@ -0,0 +1,25 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Replenishment } from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+
+import { ReplenishmentWorksheetController } from '../../../../controllers'
+import { Worksheet } from '../../../../entities'
+
+export const completeReplenishmentPutawayResolver = {
+  async completeReplenishmentPutaway(_: any, { replenishmentNo }, context: any) {
+    const { tx, user, domain }: { tx: EntityManager; user: User; domain: Domain } = context.state
+    await completeReplenishmentPutaway(tx, domain, user, replenishmentNo)
+  }
+}
+
+export async function completeReplenishmentPutaway(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  replenishmentNo: string
+): Promise<void> {
+  const worksheetController: ReplenishmentWorksheetController = new ReplenishmentWorksheetController(tx, domain, user)
+  let worksheet: Worksheet = await worksheetController.completeReplenishmentPutaway(replenishmentNo)
+}

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

@@ -2,10 +2,16 @@ import { activatePutawayResolver } from './activate-putaway'
 import { completePutawayResolver } from './complete-putaway'
 import { putawayResolver } from './putaway'
 import { undoPutawayResolver } from './undo-putaway'
+import { replenishmentPutawayResolver } from './replenishment-putaway'
+import { completeReplenishmentPutawayResolver } from './complete-replenishment-putaway'
+import { undoReplenishmentPutawayResolver } from './undo-replenishment-putaway'
 
 export const Mutations = {
   ...activatePutawayResolver,
   ...putawayResolver,
   ...undoPutawayResolver,
-  ...completePutawayResolver
+  ...completePutawayResolver,
+  ...replenishmentPutawayResolver,
+  ...completeReplenishmentPutawayResolver,
+  ...undoReplenishmentPutawayResolver
 }

package/server/graphql/resolvers/worksheet/putaway/replenishment-putaway.ts

@@ -0,0 +1,23 @@
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+import { EntityManager } from 'typeorm'
+import { ReplenishmentWorksheetController } from '../../../../controllers'
+
+export const replenishmentPutawayResolver = {
+  async replenishmentPutaway(_: any, { worksheetDetailName, cartonId, toLocation }, context: any) {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    await replenishmentPutaway(tx, domain, user, worksheetDetailName, cartonId, toLocation)
+  }
+}
+
+async function replenishmentPutaway(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetDetailName: [string],
+  cartonId: string,
+  locationName: string
+) {
+  const worksheetController: ReplenishmentWorksheetController = new ReplenishmentWorksheetController(tx, domain, user)
+  await worksheetController.replenishmentPutaway(worksheetDetailName, cartonId, locationName)
+}

package/server/graphql/resolvers/worksheet/putaway/undo-replenishment-putaway.ts

@@ -0,0 +1,22 @@
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+import { EntityManager } from 'typeorm'
+import { ReplenishmentWorksheetController } from '../../../../controllers'
+
+export const undoReplenishmentPutawayResolver = {
+  async undoReplenishmentPutaway(_: any, { worksheetDetailName, cartonId }, context: any) {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    await undoReplenishmentPutaway(tx, domain, user, worksheetDetailName, cartonId)
+  }
+}
+
+export async function undoReplenishmentPutaway(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetDetailName: [string],
+  cartonId: string
+): Promise<void> {
+  const worksheetController: ReplenishmentWorksheetController = new ReplenishmentWorksheetController(tx, domain, user)
+  await worksheetController.undoReplenishmentPutaway(worksheetDetailName, cartonId)
+}

package/server/graphql/resolvers/worksheet/putaway-replenishment-worksheet.ts

@@ -0,0 +1,95 @@
+import { getRepository, SelectQueryBuilder } from 'typeorm'
+
+import { Bizplace } from '@things-factory/biz-base'
+import { Replenishment, OrderInventory, ORDER_INVENTORY_STATUS, ORDER_STATUS } from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+import { Inventory, Location } from '@things-factory/warehouse-base'
+
+import { WORKSHEET_TYPE } from '../../../constants'
+import { Worksheet, WorksheetDetail } from '../../../entities'
+import { fetchExecutingWorksheet } from '../../../utils'
+
+export const putawayReplenishmentWorksheetResolver = {
+  async putawayReplenishmentWorksheet(_: any, { replenishmentNo }, context: any) {
+    const { domain }: { domain: Domain } = context.state
+    let replenishment: Replenishment = await getRepository(Replenishment).findOne({
+      where: {
+        domain,
+        name: replenishmentNo
+      }
+    })
+
+    if (!replenishment) {
+      const binLocation: Location = await getRepository(Location).findOne({
+        where: { domain, name: replenishmentNo }
+      })
+
+      if (!binLocation) throw new Error(`Replenishment dosen't exist.`)
+
+      const qb: SelectQueryBuilder<OrderInventory> = getRepository(OrderInventory).createQueryBuilder('orderInventory')
+      qb.innerJoinAndSelect('orderInventory.replenishment', 'replenishment')
+        .where('orderInventory.domain_id = :domainId', { domainId: domain.id })
+        .andWhere('orderInventory.status IN (:...orderInventoryStatus)', {
+          orderInventoryStatus: [ORDER_INVENTORY_STATUS.PUTTING_AWAY]
+        })
+        .andWhere('orderInventory.bin_location_id = :locationId', { locationId: binLocation.id })
+        .andWhere('replenishment.status = :status', { status: ORDER_STATUS.PUTTING_AWAY })
+
+      const orderInventoryByBin = await qb.getOne()
+
+      if (orderInventoryByBin?.replenishment) {
+        replenishmentNo = orderInventoryByBin.replenishment.name
+        replenishment = orderInventoryByBin.replenishment
+      }
+    }
+
+    if (!replenishment) throw new Error(`Replenishment dosen't exist.`)
+
+    const worksheet: Worksheet = await fetchExecutingWorksheet(
+      domain,
+      null,
+      [
+        'bizplace',
+        'replenishment',
+        'worksheetDetails',
+        'worksheetDetails.targetInventory',
+        'worksheetDetails.targetInventory.inventory',
+        'worksheetDetails.targetInventory.inventory.location',
+        'worksheetDetails.targetInventory.inventory.product',
+        'worksheetDetails.toLocation'
+      ],
+      WORKSHEET_TYPE.PUTAWAY_REPLENISHMENT,
+      replenishment
+    )
+
+    return {
+      worksheetInfo: {
+        status: worksheet.status,
+        replenishment: {
+          name: replenishment.name
+        }
+      },
+      worksheetDetailInfos: worksheet.worksheetDetails.map(async (putawayWSD: WorksheetDetail) => {
+        const targetInventory: OrderInventory = putawayWSD.targetInventory
+        const inventory: Inventory = targetInventory.inventory
+        return {
+          name: putawayWSD.name,
+          palletId: inventory.palletId,
+          cartonId: inventory.cartonId,
+          batchId: inventory.batchId,
+          expirationDate: inventory.expirationDate,
+          batchIdRef: inventory.batchIdRef,
+          product: inventory.product,
+          qty: targetInventory.releaseQty,
+          status: putawayWSD.status,
+          description: putawayWSD.description,
+          targetName: targetInventory.name,
+          packingType: inventory.packingType,
+          packingSize: inventory.packingSize,
+          location: inventory.location,
+          reusablePallet: inventory.reusablePallet
+        }
+      })
+    }
+  }
+}

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

@@ -0,0 +1,26 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { ReplenishmentWorksheetController } from '../../../../controllers'
+import { Worksheet } from '../../../../entities'
+
+export const activatePickingReplenishmentResolver = {
+  async activatePickingReplenishment(_: any, { worksheetNo }, context: any) {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    return await activatePickingReplenishment(tx, domain, user, worksheetNo)
+  }
+}
+
+export async function activatePickingReplenishment(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetNo: string
+): Promise<Worksheet> {
+  const worksheetController: ReplenishmentWorksheetController = new ReplenishmentWorksheetController(tx, domain, user)
+  const worksheet = await worksheetController.activatePickingReplenishment(worksheetNo)
+
+  return worksheet
+}

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

@@ -0,0 +1,5 @@
+import { activatePickingReplenishmentResolver } from './activate-picking-replenishment'
+
+export const Mutations = {
+  ...activatePickingReplenishmentResolver
+}

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

@@ -37,6 +37,7 @@ export const worksheetResolver = {
         'releaseGood.arrivalNotice',
         'releaseGood.shippingOrder',
         'releaseGood.orderPackages',
+        'replenishment',
         'returnOrder',
         'inventoryCheck',
         'vasOrder',