@things-factory/worksheet-base 4.1.41 → 4.2.2

package/server/controllers/outbound/picking-worksheet-controller.ts

@@ -453,7 +453,7 @@ export class PickingWorksheetController extends VasWorksheetController {
         )
 
         pickedQty = await this.getChildQty(productDetails, productBarcode, roProductDetail)
-        if (pickedQty > releaseQty) {
+        if (pickedQty + targetInventory.pickedQty > releaseQty) {
           throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `over release`))
         }
       } else if (!foundProductDetail) {
@@ -555,8 +555,7 @@ export class PickingWorksheetController extends VasWorksheetController {
       //validation to prevent over release
       if (inventory.qty <= 0) throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `over release`))
 
-      if (inventory.palletId !== palletId /*&& !product?.isRequireSerialNumberScanningOutbound*/)
-        //to be changed
+      if (inventory.palletId !== palletId && !product?.isRequireSerialNumberScanningOutbound)
         throw new Error(this.ERROR_MSG.VALIDITY.UNEXPECTED_FIELD_VALUE('Pallet ID', palletId, inventory.palletId))
 
       if (product?.isRequireSerialNumberScanningOutbound) {
@@ -566,7 +565,8 @@ export class PickingWorksheetController extends VasWorksheetController {
 
         let totalInventoryItems = await this.trxMgr.getRepository(InventoryItem).count({
           where: {
-            inventory
+            inventory,
+            status: Not(In([INVENTORY_STATUS.TERMINATED, INVENTORY_STATUS.PICKED]))
           }
         })
 
@@ -580,13 +580,11 @@ export class PickingWorksheetController extends VasWorksheetController {
           .findOne({ where: { domain: this.domain, palletId }, relations: ['product'] })
 
         if (foundSerialNumber) {
-          if (
-            foundSerialNumber.status !== INVENTORY_STATUS.STORED ||
-            foundSerialNumber.outboundOrderId ||
-            foundSerialNumber.inventory !== inventory
-            /*to be changed for replacement && inventory.palletId == palletId*/
-          ) {
-            throw new Error('Inventory Item is not available')
+          if (foundSerialNumber.outboundOrderId) {
+            let releaseGood: ReleaseGood = await this.trxMgr
+              .getRepository(ReleaseGood)
+              .findOne({ where: { id: foundSerialNumber.outboundOrderId } })
+            throw new Error(`Inventory Item is already picked in ${releaseGood.name}`)
           }
 
           foundSerialNumber.status = INVENTORY_STATUS.PICKING
@@ -603,12 +601,13 @@ export class PickingWorksheetController extends VasWorksheetController {
           inventoryItem.name = InventoryNoGenerator.inventoryItemName()
           inventoryItem.serialNumber = serialNumber
           inventoryItem.status = INVENTORY_STATUS.PICKING
+          inventoryItem.source = INVENTORY_ITEM_SOURCE.OUTBOUND
           inventoryItem.outboundOrderId = releaseGood.id
           inventoryItem.product = product
           inventoryItem.inventory = scannedPalletIdInventory
           inventoryItem.domain = this.domain
 
-          await this.trxMgr.getRepository(InventoryItem).save(inventoryItem)
+          foundSerialNumber = await this.trxMgr.getRepository(InventoryItem).save(inventoryItem)
         }
 
         if (inventory.palletId !== palletId) {
@@ -648,10 +647,10 @@ export class PickingWorksheetController extends VasWorksheetController {
         }
       }
 
-      await this.updatePickingTransaction(releaseGood, targetInventory, worksheetDetail, inventory, pickedQty)
-
       targetInventory = await this.checkAndSetBinPicking(targetInventory, binLocation)
 
+      await this.updatePickingTransaction(releaseGood, targetInventory, worksheetDetail, inventory, pickedQty)
+
       const fromLocation: Location = targetInventory.inventory.location
       if (locationName) {
         const toLocation: Location = await this.trxMgr.getRepository(Location).findOne({
@@ -954,12 +953,12 @@ export class PickingWorksheetController extends VasWorksheetController {
     ])
     await this.checkRecordValidity(worksheet, { status: WORKSHEET_STATUS.EXECUTING })
 
-    let InventoryItems: InventoryItem = await this.trxMgr
+    let inventoryItems: InventoryItem = await this.trxMgr
       .getRepository(InventoryItem)
       .find({ where: { outboundOrderId: releaseGood.id } })
 
-    if (InventoryItems.length > 0) {
-      InventoryItems.forEach((itm: InventoryItem) => {
+    if (inventoryItems.length > 0) {
+      inventoryItems.forEach((itm: InventoryItem) => {
         itm.status = INVENTORY_STATUS.TERMINATED
         itm.updater = this.user
       })
@@ -973,7 +972,7 @@ export class PickingWorksheetController extends VasWorksheetController {
       //     this.transactionInventory(itm, releaseGood, 0, 0, INVENTORY_TRANSACTION_TYPE.TERMINATED)
       // })
 
-      await this.trxMgr.getRepository(InventoryItem).save(InventoryItems)
+      await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
     }
 
     let orderStatus: string
@@ -1126,17 +1125,17 @@ export class PickingWorksheetController extends VasWorksheetController {
       worksheetDetail.updater = this.user
       await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
 
-      let InventoryItems: InventoryItem = await this.trxMgr
+      let inventoryItems: InventoryItem = await this.trxMgr
         .getRepository(InventoryItem)
         .find({ where: { outboundOrderId: releaseGood.id } })
 
-      if (InventoryItems.length > 0) {
-        InventoryItems.forEach((itm: InventoryItem) => {
+      if (inventoryItems.length > 0) {
+        inventoryItems.forEach((itm: InventoryItem) => {
           itm.status = INVENTORY_STATUS.PICKED
           itm.updater = this.user
         })
 
-        await this.trxMgr.getRepository(InventoryItem).save(InventoryItems)
+        await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
       }
 
       if (leftQty === 0) {
@@ -1247,8 +1246,8 @@ export class PickingWorksheetController extends VasWorksheetController {
           }
         )
       } else {
-        await this.trxMgr.getRepository(OrderInventory).delete(targetInventory.id)
         await this.trxMgr.getRepository(WorksheetDetail).delete(worksheetDetail.ild)
+        await this.trxMgr.getRepository(OrderInventory).delete(targetInventory.id)
       }
     } catch (e) {}
   }
@@ -1362,8 +1361,8 @@ export class PickingWorksheetController extends VasWorksheetController {
           }
         )
       } else {
-        await this.trxMgr.getRepository(OrderInventory).delete(targetInventory.id)
         await this.trxMgr.getRepository(WorksheetDetail).delete(worksheetDetail.id)
+        await this.trxMgr.getRepository(OrderInventory).delete(targetInventory.id)
       }
     } catch (e) {}
   }

package/server/controllers/outbound/sorting-worksheet-controller.ts

@@ -1,6 +1,13 @@
 import { VasWorksheetController } from '../vas/vas-worksheet-controller'
 import { Product, ProductDetail } from '@things-factory/product-base'
-import { Inventory, INVENTORY_TRANSACTION_TYPE } from '@things-factory/warehouse-base'
+import {
+  Inventory,
+  INVENTORY_TRANSACTION_TYPE,
+  InventoryItem,
+  INVENTORY_STATUS,
+  InventoryNoGenerator,
+  INVENTORY_ITEM_SOURCE
+} from '@things-factory/warehouse-base'
 import { ReleaseGood, OrderInventory, ORDER_INVENTORY_STATUS, ORDER_STATUS } from '@things-factory/sales-base'
 import { Worksheet, WorksheetDetail } from '../../entities'
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../constants'
@@ -51,7 +58,12 @@ export class SortingWorksheetController extends VasWorksheetController {
     return await this.activateWorksheet(worksheet, worksheetDetails, sortingWorksheetDetails)
   }
 
-  async scanProductSorting(taskNo: string, releaseGoodNo: string, productBarcode: string): Promise<void> {
+  async scanProductSorting(
+    taskNo: string,
+    releaseGoodNo: string,
+    productBarcode: string,
+    serialNumber: string
+  ): Promise<void> {
     const worksheet: Worksheet = await this.trxMgr.getRepository(Worksheet).findOne({
       where: {
         domain: this.domain,
@@ -113,8 +125,53 @@ export class SortingWorksheetController extends VasWorksheetController {
             const releaseQty: number = matchingOI.releaseQty
             const inventory: Inventory = matchingOI.inventory
             const releaseGood: ReleaseGood = matchingOI.releaseGood
+            const product: Product = inventory.product
 
             if (releaseQty != matchingOI?.sortedQty && sortedQty == 1) {
+              // Serial Number scanning for batch picking
+              if (matchingOI?.refWorksheetId) {
+                if (product?.isRequireSerialNumberScanningOutbound) {
+                  if (!serialNumber || serialNumber == '') {
+                    throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('sorting', `require serial number`))
+                  }
+
+                  let foundSerialNumber: InventoryItem = await this.trxMgr
+                    .getRepository(InventoryItem)
+                    .findOne({ where: { domain: this.domain, serialNumber: serialNumber, product } })
+
+                  if (foundSerialNumber) {
+                    if (foundSerialNumber.inventoryId !== inventory.id) {
+                      throw new Error('Serial Number scanned is in another inventory')
+                    }
+
+                    if (foundSerialNumber.outboundOrderId) {
+                      let releaseGood: ReleaseGood = await this.trxMgr
+                        .getRepository(ReleaseGood)
+                        .findOne({ where: { id: foundSerialNumber.outboundOrderId } })
+                      throw new Error(`Inventory Item is already picked/sorted in ${releaseGood.name}`)
+                    }
+
+                    foundSerialNumber.status = INVENTORY_STATUS.SORTING
+                    foundSerialNumber.updater = this.user
+                    foundSerialNumber.outboundOrderId = releaseGood.id
+
+                    await this.trxMgr.getRepository(InventoryItem).save(foundSerialNumber)
+                  } else {
+                    let inventoryItem: InventoryItem = new InventoryItem()
+                    inventoryItem.name = InventoryNoGenerator.inventoryItemName()
+                    inventoryItem.serialNumber = serialNumber
+                    inventoryItem.status = INVENTORY_STATUS.SORTING
+                    inventoryItem.outboundOrderId = releaseGood.id
+                    inventoryItem.source = INVENTORY_ITEM_SOURCE.OUTBOUND
+                    inventoryItem.product = product
+                    inventoryItem.inventory = inventory
+                    inventoryItem.domain = this.domain
+
+                    await this.trxMgr.getRepository(InventoryItem).save(inventoryItem)
+                  }
+                }
+              }
+
               matchingOI.sortedQty = Boolean(matchingOI?.sortedQty) ? matchingOI.sortedQty + sortedQty : sortedQty
               sortedQty -= 1
               if (matchingOI.sortedQty == releaseQty) {
@@ -128,6 +185,19 @@ export class SortingWorksheetController extends VasWorksheetController {
                 worksheetDetail.status = WORKSHEET_STATUS.DONE
                 worksheetDetail.updater = this.user
                 await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
+
+                let inventoryItems: InventoryItem = await this.trxMgr
+                  .getRepository(InventoryItem)
+                  .find({ where: { outboundOrderId: releaseGood.id } })
+
+                if (inventoryItems.length > 0) {
+                  inventoryItems.forEach((itm: InventoryItem) => {
+                    itm.status = INVENTORY_STATUS.SORTED
+                    itm.updater = this.user
+                  })
+
+                  await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
+                }
               } else if (matchingOI?.sortedQty > releaseQty) {
                 const product: Product = matchingOI.inventory.product
                 throw new Error(this.ERROR_MSG.ORDER_ITEM.EXCESS_QTY(product.sku, packingType, packingSize))
@@ -141,7 +211,13 @@ export class SortingWorksheetController extends VasWorksheetController {
     }
   }
 
-  async sortingProduct(taskNo: string, releaseGoodNo: string, productId: string, sortingQty: number): Promise<void> {
+  async sortingProduct(
+    taskNo: string,
+    releaseGoodNo: string,
+    productId: string,
+    sortingQty: number,
+    serialNumber: string
+  ): Promise<void> {
     const worksheet: Worksheet = await this.trxMgr.getRepository(Worksheet).findOne({
       where: {
         domain: this.domain,
@@ -180,14 +256,70 @@ export class SortingWorksheetController extends VasWorksheetController {
           const packingType: string = matchingOI.packingType
           const packingSize: number = matchingOI.packingSize
 
+          if (product?.isRequireSerialNumberScanningOutbound) {
+            if (!serialNumber || serialNumber == '') {
+              throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('sorting', `require serial number`))
+            }
+
+            let foundSerialNumber: InventoryItem = await this.trxMgr.getRepository(InventoryItem).findOne({
+              where: { domain: this.domain, serialNumber: serialNumber, product },
+              relations: ['product', 'inventory']
+            })
+
+            if (foundSerialNumber) {
+              if (foundSerialNumber.outboundOrderId) {
+                let releaseGood: ReleaseGood = await this.trxMgr
+                  .getRepository(ReleaseGood)
+                  .findOne({ where: { id: foundSerialNumber.outboundOrderId } })
+                throw new Error(`Inventory Item is already picked/sorted in ${releaseGood.name}`)
+              }
+
+              foundSerialNumber.status = INVENTORY_STATUS.SORTING
+              foundSerialNumber.updater = this.user
+              foundSerialNumber.outboundOrderId = releaseGood.id
+
+              await this.trxMgr.getRepository(InventoryItem).save(foundSerialNumber)
+            } else {
+              let inventoryItem: InventoryItem = new InventoryItem()
+              inventoryItem.name = InventoryNoGenerator.inventoryItemName()
+              inventoryItem.serialNumber = serialNumber
+              inventoryItem.status = INVENTORY_STATUS.SORTING
+              inventoryItem.source = INVENTORY_ITEM_SOURCE.OUTBOUND
+              inventoryItem.outboundOrderId = releaseGood.id
+              inventoryItem.product = product
+              inventoryItem.inventory = inventory
+              inventoryItem.domain = this.domain
+
+              foundSerialNumber = await this.trxMgr.getRepository(InventoryItem).save(inventoryItem)
+            }
+          }
+
           if (releaseQty != matchingOI?.sortedQty && sortingQty != 0) {
-            matchingOI.sortedQty = releaseQty
+            if (product?.isRequireSerialNumberScanningOutbound) {
+              matchingOI.sortedQty += sortingQty
+            } else {
+              matchingOI.sortedQty = releaseQty
+            }
+
             sortingQty -= releaseQty
             if (matchingOI.sortedQty == releaseQty) {
               matchingOI.status = ORDER_INVENTORY_STATUS.SORTED
               await this.updateOrderTargets([matchingOI])
               await this.transactionInventory(inventory, releaseGood, 0, 0, INVENTORY_TRANSACTION_TYPE.SORTING)
 
+              let inventoryItems: InventoryItem = await this.trxMgr
+                .getRepository(InventoryItem)
+                .find({ where: { outboundOrderId: releaseGood.id } })
+
+              if (inventoryItems.length > 0) {
+                inventoryItems.forEach((itm: InventoryItem) => {
+                  itm.status = INVENTORY_STATUS.PACKED
+                  itm.updater = this.user
+                })
+
+                await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
+              }
+
               let worksheetDetail: WorksheetDetail = worksheetDetails.find(
                 wsd => wsd.targetInventory.id === matchingOI.id
               )
@@ -220,6 +352,19 @@ export class SortingWorksheetController extends VasWorksheetController {
     releaseGood.updater = this.user
     await this.trxMgr.getRepository(ReleaseGood).save(releaseGood)
 
+    let inventoryItems: InventoryItem = await this.trxMgr
+      .getRepository(InventoryItem)
+      .find({ where: { outboundOrderId: releaseGood.id } })
+
+    if (inventoryItems.length > 0) {
+      inventoryItems.forEach((itm: InventoryItem) => {
+        itm.status = INVENTORY_STATUS.TERMINATED
+        itm.updater = this.user
+      })
+
+      await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
+    }
+
     return releaseGood
   }
 

package/server/controllers/worksheet-controller.ts

@@ -950,7 +950,8 @@ export class WorksheetController {
     const duplicatedSerialNumberCnt: number = await this.trxMgr.getRepository(InventoryItem).count({
       domain: this.domain,
       product,
-      serialNumber
+      serialNumber,
+      status: Not(Equal(INVENTORY_STATUS.DELETED))
     })
 
     if (duplicatedSerialNumberCnt) throw new Error(this.ERROR_MSG.VALIDITY.DUPLICATED('Serial Number', serialNumber))

package/server/graphql/resolvers/worksheet/find-release-orders-by-task-no.ts

@@ -1,11 +1,12 @@
 import { EntityManager, SelectQueryBuilder } from 'typeorm'
 
 import {
-  ORDER_STATUS,
+  ORDER_STATUS, ORDER_INVENTORY_STATUS,
   OrderInventory as OrderInventoryEntity,
   ReleaseGood as ReleaseGoodEntity
 } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
+import { Location } from '@things-factory/warehouse-base'
 
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
 import { Worksheet as WorksheetEntity, WorksheetDetail as WorksheetDetailEntity } from '../../../entities'
@@ -16,6 +17,38 @@ export const findReleaseOrdersByTaskNoResolver = {
     let task = await tx.getRepository(WorksheetEntity).findOne({
       where: { taskNo, status: WORKSHEET_STATUS.EXECUTING, type: WORKSHEET_TYPE.SORTING }
     })
+
+    // Find Task based on Bin
+    if (!task) {
+      const binLocation: Location = await tx.getRepository(Location).findOne({
+        where: { domain, name: taskNo }
+      })
+
+      const qb: SelectQueryBuilder<OrderInventoryEntity> = tx.getRepository(OrderInventoryEntity).createQueryBuilder('orderInventory')
+
+      qb.innerJoinAndSelect('orderInventory.releaseGood', 'releaseGood')
+        .innerJoinAndSelect('worksheets', 'ws', `orderInventory.ref_worksheet_id = ws.id AND ws.type = 'BATCH_PICKING'`)
+        .innerJoinAndSelect('worksheets', 'ws2', `ws2.task_no = ws.task_no AND ws2.type = 'SORTING'`)
+        .innerJoinAndSelect('releaseGood.bizplace', 'bizplace')
+        .innerJoinAndSelect('bizplace.domain', 'domain')
+        .where('orderInventory.domain_id = :domainId', { domainId: domain.id })
+        .andWhere('orderInventory.status IN (:...orderInventoryStatus)', {
+          orderInventoryStatus: [ORDER_INVENTORY_STATUS.SORTING]
+        })
+        .andWhere('orderInventory.bin_location_id = :locationId', { locationId: binLocation.id })
+        .andWhere('releaseGood.status = :status', { status: ORDER_STATUS.SORTING })
+
+      const orderInventoryByBin = await qb.getRawOne()
+      if (orderInventoryByBin?.releaseGood_id) {
+        taskNo = orderInventoryByBin.ws_task_no
+        task = await tx.getRepository(WorksheetEntity).findOne({
+          where: { taskNo, status: WORKSHEET_STATUS.EXECUTING, type: WORKSHEET_TYPE.SORTING }
+        })
+      } else {
+        throw new Error(`Bin do not have any batch picking order.`)
+      }
+    }
+
     if (!task) throw new Error('Unable to find task no.')
 
     const qb: SelectQueryBuilder<WorksheetEntity> = tx
@@ -38,6 +71,6 @@ export const findReleaseOrdersByTaskNoResolver = {
       .addGroupBy('rg.status')
 
     const releaseGoods: ReleaseGoodEntity[] = await qb.getRawMany()
-    return releaseGoods
+    return { releaseGoods, taskNo }
   }
 }

package/server/graphql/resolvers/worksheet/inventories-by-pallet.ts

@@ -78,6 +78,8 @@ export const inventoriesByPalletResolver = {
       locationSortingRules.forEach((rule: { name: string; desc: boolean }) => {
         qb.addOrderBy(`location.${rule.name}`, rule.desc ? 'DESC' : 'ASC')
       })
+    } else {
+      qb.addOrderBy('location.name', 'DESC')
     }
 
     if (productFilters && productFilters.length > 0) {

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

@@ -2,10 +2,12 @@ import { activatePackingResolver } from './activate-packing'
 import { completePackingResolver } from './complete-packing'
 import { packingResolver } from './packing'
 import { scanProductPackingResolver } from './scan-product-packing'
+import { undoSerialNumberPackingResolver } from './undo-serial-number-packing'
 
 export const Mutations = {
   ...activatePackingResolver,
   ...completePackingResolver,
   ...packingResolver,
-  ...scanProductPackingResolver
+  ...scanProductPackingResolver,
+  ...undoSerialNumberPackingResolver
 }

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

@@ -9,9 +9,9 @@ import { PackingWorksheetController, SellercraftController } from '../../../../c
 import { Worksheet } from '../../../../entities'
 
 export const packingResolver = {
-  async packing(_: any, { worksheetDetailName, releaseQty }, context: any) {
+  async packing(_: any, { worksheetDetailName, releaseQty, serialNumber }, context: any) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    await packing(tx, domain, user, worksheetDetailName, releaseQty)
+    await packing(tx, domain, user, worksheetDetailName, releaseQty, serialNumber)
   }
 }
 
@@ -20,10 +20,11 @@ export async function packing(
   domain: Domain,
   user: User,
   worksheetDetailName: string,
-  releaseQty: number
+  releaseQty: number,
+  serialNumber: string
 ) {
   const worksheetController: PackingWorksheetController = new PackingWorksheetController(tx, domain, user)
-  const worksheetDetail = await worksheetController.packing(worksheetDetailName, releaseQty)
+  const worksheetDetail = await worksheetController.packing(worksheetDetailName, releaseQty, serialNumber)
 
   let releaseGood: ReleaseGood = worksheetDetail.targetInventory.releaseGood
   const worksheet: Worksheet = worksheetDetail.worksheet

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

@@ -9,9 +9,9 @@ import { PackingWorksheetController, SellercraftController } from '../../../../c
 import { Worksheet } from '../../../../entities'
 
 export const scanProductPackingResolver = {
-  async scanProductPacking(_: any, { worksheetDetailName, productBarcode }, context: any) {
+  async scanProductPacking(_: any, { worksheetDetailName, productBarcode, serialNumber }, context: any) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    await scanProductPacking(tx, domain, user, worksheetDetailName, productBarcode)
+    await scanProductPacking(tx, domain, user, worksheetDetailName, productBarcode, serialNumber)
   }
 }
 
@@ -20,10 +20,15 @@ export async function scanProductPacking(
   domain: Domain,
   user: User,
   worksheetDetailName: string,
-  productBarcode: string
+  productBarcode: string,
+  serialNumber?: string
 ) {
   const worksheetController: PackingWorksheetController = new PackingWorksheetController(tx, domain, user)
-  const worksheetDetail = await worksheetController.scanProductPacking(worksheetDetailName, productBarcode)
+  const worksheetDetail = await worksheetController.scanProductPacking(
+    worksheetDetailName,
+    productBarcode,
+    serialNumber
+  )
 
   let releaseGood: ReleaseGood = worksheetDetail.targetInventory.releaseGood
   const worksheet: Worksheet = worksheetDetail.worksheet

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

@@ -0,0 +1,24 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+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
+    await undoSerialNumberPacking(tx, domain, user, worksheetDetailName, inventoryItemId)
+  }
+}
+
+async function undoSerialNumberPacking(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetDetailName: string,
+  inventoryItemId: string
+): Promise<void> {
+  const worksheetController: PackingWorksheetController = new PackingWorksheetController(tx, domain, user)
+  await worksheetController.undoSerialNumberPacking(worksheetDetailName, inventoryItemId)
+}