@things-factory/worksheet-base 8.0.0-beta.8 → 8.0.0

package/server/controllers/index.ts

@@ -0,0 +1,21 @@
+export * from './render-ro-do'
+export * from './render-grn'
+export * from './render-manual-do'
+export * from './render-elccl-grn'
+export * from './render-job-sheet'
+export * from './render-kimeda-grn'
+export * from './render-orientage-grn'
+export * from './render-orientage-do'
+export * from './render-seebuu-grn'
+export * from './render-fm-grn'
+export * from './render-manifest'
+export * from './render-po'
+
+
+/* Worksheet Controllers */
+export * from './worksheet-controller'
+export * from './ecommerce'
+export * from './inbound'
+export * from './inspect'
+export * from './outbound'
+export * from './vas'

package/server/controllers/inspect/cycle-count-worksheet-controller.ts

@@ -0,0 +1,537 @@
+import { Brackets, Equal, In, Not, SelectQueryBuilder } from 'typeorm'
+
+import { Bizplace } from '@things-factory/biz-base'
+import {
+  generateCycleCount,
+  InventoryCheck,
+  ORDER_INVENTORY_STATUS,
+  ORDER_STATUS,
+  OrderInventory,
+  OrderNoGenerator
+} from '@things-factory/sales-base'
+import { Inventory, INVENTORY_STATUS, Location } from '@things-factory/warehouse-base'
+
+import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../constants'
+import { Worksheet, WorksheetDetail } from '../../entities'
+import { WorksheetNoGenerator } from '../../utils'
+import { WorksheetController } from '../worksheet-controller'
+
+export class CycleCountWorksheetController extends WorksheetController {
+  async generateCycleCountWorksheet(
+    executionDate: string,
+    customerId: string,
+    orderInventoryIds: string[] = [],
+    orderInventory: OrderInventory[],
+    limit: number
+  ): Promise<Worksheet> {
+    // Find out warehouse and customer bizplace
+    const customerBizplace: Bizplace = await this.trxMgr.getRepository(Bizplace).findOneBy({ id: customerId })
+    let foundCycleCountWorksheet: Worksheet = await this.trxMgr.getRepository(Worksheet).findOne({
+      where: {
+        domain: { id: this.domain.id },
+        bizplace: { id: customerBizplace.id },
+        type: In([WORKSHEET_TYPE.CYCLE_COUNT, WORKSHEET_TYPE.CYCLE_COUNT_RECHECK]),
+        status: Not(WORKSHEET_STATUS.DONE)
+      },
+      relations: ['worksheetDetails', 'worksheetDetails.targetInventory', 'inventoryCheck']
+    })
+
+    // Create second round of cycle count with specified order inventories
+    if (orderInventoryIds.length) {
+      // Update status of target inventories (NOT_TALLY => INSPECTING)
+      let targetInventories: OrderInventory[] = await this.trxMgr
+        .getRepository(OrderInventory)
+        .findByIds(orderInventoryIds)
+      targetInventories.forEach((targetInventory: OrderInventory) => {
+        targetInventory.status = ORDER_INVENTORY_STATUS.INSPECTING
+        targetInventory.updater = this.user
+      })
+      await this.trxMgr.getRepository(OrderInventory).save(targetInventories)
+
+      // Update status of worksheet (NOT_TALLY => EXECUTING)
+      foundCycleCountWorksheet.type = WORKSHEET_TYPE.CYCLE_COUNT_RECHECK
+      foundCycleCountWorksheet.status = WORKSHEET_STATUS.EXECUTING
+      foundCycleCountWorksheet.endedAt = null
+      foundCycleCountWorksheet.updater = this.user
+      await this.trxMgr.getRepository(Worksheet).save(foundCycleCountWorksheet)
+
+      // Update status of worksheet details (NOT_TALLY => EXECUTING)
+      let worksheetDetails = foundCycleCountWorksheet.worksheetDetails.filter(
+        (wsd: WorksheetDetail) => orderInventoryIds.indexOf(wsd.targetInventory.id) >= 0
+      )
+      worksheetDetails.forEach((wsd: WorksheetDetail) => {
+        wsd.status = WORKSHEET_STATUS.EXECUTING
+        wsd.updater = this.user
+      })
+      await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetails)
+
+      // Update status of cycle count
+      const cycleCount: InventoryCheck = foundCycleCountWorksheet.inventoryCheck
+      cycleCount.status = ORDER_STATUS.INSPECTING
+      cycleCount.updater = this.user
+      await this.trxMgr.getRepository(InventoryCheck).save(cycleCount)
+
+      return foundCycleCountWorksheet
+    } else {
+      // Create first round of cycle count with whole pallets
+      if (foundCycleCountWorksheet) {
+        throw new Error(`Unfinished cycle count worksheet exists.`)
+      }
+
+      const cycleCount: InventoryCheck = await generateCycleCount(
+        this.trxMgr,
+        this.domain,
+        this.user,
+        executionDate,
+        customerId
+      )
+
+      // Find out inventories which is target for cycle counting
+      const qb: SelectQueryBuilder<Inventory> = this.trxMgr.getRepository(Inventory).createQueryBuilder('INV')
+      qb.leftJoinAndSelect('INV.location', 'LOC')
+        .where('INV.domain_id = :domainId', { domainId: this.domain.id })
+        .andWhere('INV.bizplace_id = :bizplaceId', { bizplaceId: customerBizplace.id })
+        .andWhere('INV.status = :status', { status: INVENTORY_STATUS.STORED })
+        .andWhere(
+          new Brackets(qb => {
+            qb.where('"INV"."locked_qty" ISNULL')
+            qb.orWhere('"INV"."locked_qty" = 0')
+          })
+        )
+
+      if (orderInventory && orderInventory.length > 0) {
+        let keyval = {
+          batchId: 'batch_id',
+          batchIdRef: 'batch_id_ref',
+          packingType: 'packing_type',
+          packingSize: 'packing_size',
+          productId: 'product_id'
+        }
+
+        qb.andWhere(
+          new Brackets(qb => {
+            orderInventory.forEach((itm, idx) => {
+              // sample itm value
+              // batchId: 'WO00019730', batchIdRef: null, packingType: 'CARBOY', packingSize: 1, productId: '1d679587-c713-42d6-bd0a-74e587e39cc7'
+              qb.orWhere(
+                new Brackets(qb2 => {
+                  let first = true
+                  for (var prop in itm) {
+                    if (first) {
+                      first = false
+                      qb2.where(`INV.${keyval[prop]} ${itm[prop] == null ? 'is null' : " = '" + itm[prop] + "'"}`)
+                    } else {
+                      qb2.andWhere(`INV.${keyval[prop]} ${itm[prop] == null ? 'is null' : " = '" + itm[prop] + "'"}`)
+                    }
+                  }
+                })
+              )
+            })
+          })
+        )
+      } else {
+        if (limit > 0) {
+          qb.orderBy('RANDOM()').limit(limit)
+        }
+      }
+
+      let inventories: Inventory[] = await qb.getMany()
+
+      if (!inventories.length) {
+        throw new Error(`Failed to find inventories`)
+      }
+
+      let cycleCountWorksheet: Worksheet = new Worksheet()
+      cycleCountWorksheet.domain = this.domain
+      cycleCountWorksheet.bizplace = customerBizplace
+      cycleCountWorksheet.name = WorksheetNoGenerator.cycleCount()
+      cycleCountWorksheet.inventoryCheck = cycleCount
+      cycleCountWorksheet.type = WORKSHEET_TYPE.CYCLE_COUNT
+      cycleCountWorksheet.status = WORKSHEET_STATUS.DEACTIVATED
+      cycleCountWorksheet.creator = this.user
+      cycleCountWorksheet.updater = this.user
+      cycleCountWorksheet = await this.trxMgr.getRepository(Worksheet).save(cycleCountWorksheet)
+
+      // generate order inventory mapping with inventory ID
+      let targetInventories: OrderInventory[] = []
+      for (let i: number = 0; i < inventories.length; i++) {
+        const inventory: Inventory = inventories[i]
+
+        let targetInventory: OrderInventory = new OrderInventory()
+        targetInventory.domain = this.domain
+        targetInventory.bizplace = customerBizplace
+        targetInventory.status = ORDER_INVENTORY_STATUS.PENDING
+        targetInventory.name = OrderNoGenerator.orderInventory()
+        targetInventory.inventoryCheck = cycleCount
+        targetInventory.originQty = inventory.qty
+        //@ts-ignore
+        targetInventory.originWeight = 0
+        targetInventory.originUomValue = inventory.uomValue
+        targetInventory.originBatchNo = inventory.batchId
+        targetInventory.originLocation = inventory.location
+        targetInventory.releaseQty = 0
+        //@ts-ignore
+        targetInventory.releaseWeight = 0
+        targetInventory.releaseUomValue = 0
+        targetInventory.inventory = inventory
+        targetInventory.creator = this.user
+        targetInventory.updater = this.user
+        targetInventories.push(targetInventory)
+
+        inventory.lockedQty = inventory.qty
+        //@ts-ignore
+        inventory.lockedWeight = 0
+        inventory.lockedUomValue = inventory.uomValue
+        inventory.updater = this.user
+      }
+
+      targetInventories = await this.trxMgr.getRepository(OrderInventory).save(targetInventories, { chunk: 500 })
+
+      inventories = await this.trxMgr.getRepository(Inventory).save(inventories, { chunk: 500 })
+
+      let cycleCountWorksheetDetails: WorksheetDetail[] = []
+      for (let i: number = 0; i < targetInventories.length; i++) {
+        let targetInventory: OrderInventory = targetInventories[i]
+
+        let cycleCountWorksheetDetail: WorksheetDetail = new WorksheetDetail()
+        cycleCountWorksheetDetail.domain = this.domain
+        cycleCountWorksheetDetail.bizplace = customerBizplace
+        cycleCountWorksheetDetail.worksheet = cycleCountWorksheet
+        cycleCountWorksheetDetail.name = WorksheetNoGenerator.cycleCountDetail()
+        cycleCountWorksheetDetail.targetInventory = targetInventory
+        cycleCountWorksheetDetail.type = WORKSHEET_TYPE.CYCLE_COUNT
+        cycleCountWorksheetDetail.status = WORKSHEET_STATUS.DEACTIVATED
+        cycleCountWorksheetDetail.creator = this.user
+        cycleCountWorksheetDetail.updater = this.user
+
+        cycleCountWorksheetDetails.push(cycleCountWorksheetDetail)
+      }
+
+      await this.trxMgr.getRepository(WorksheetDetail).save(cycleCountWorksheetDetails, { chunk: 500 })
+
+      return cycleCountWorksheet
+    }
+  }
+
+  async activateCycleCount(worksheetNo: string): Promise<Worksheet> {
+    let worksheet: Worksheet = await this.findActivatableWorksheet(worksheetNo, WORKSHEET_TYPE.CYCLE_COUNT, [
+      'inventoryCheck',
+      'worksheetDetails',
+      'worksheetDetails.targetInventory'
+    ])
+
+    let worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
+    let targetInventories: OrderInventory[] = worksheetDetails.map((wsd: WorksheetDetail) => wsd.targetInventory)
+
+    for (let i: number = 0; i < targetInventories.length; i++) {
+      let targetInventory: OrderInventory = targetInventories[i]
+      targetInventory.status = ORDER_INVENTORY_STATUS.INSPECTING
+      targetInventory.updater = this.user
+    }
+    await this.trxMgr.getRepository(OrderInventory).save(targetInventories, { chunk: 500 })
+
+    for (let i: number = 0; i < worksheetDetails.length; i++) {
+      let foundWSD: WorksheetDetail = worksheetDetails[i]
+      foundWSD.status = WORKSHEET_STATUS.EXECUTING
+      foundWSD.updater = this.user
+    }
+    await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetails, { chunk: 500 })
+
+    worksheet.status = WORKSHEET_STATUS.EXECUTING
+    worksheet.startedAt = new Date()
+    worksheet.updater = this.user
+    worksheet = await this.trxMgr.getRepository(Worksheet).save(worksheet)
+
+    let cycleCount: InventoryCheck = worksheet.inventoryCheck
+    cycleCount.status = ORDER_STATUS.INSPECTING
+    cycleCount.updater = this.user
+    await this.updateRefOrder(cycleCount)
+    return worksheet
+  }
+
+  async inspecting(
+    worksheetDetailName: string,
+    inspectedBatchNo: string,
+    inspectedQty: number,
+    inspectedUomValue: number
+  ): Promise<void> {
+    let worksheetDetail: WorksheetDetail = await this.findExecutableWorksheetDetailByName(
+      worksheetDetailName,
+      WORKSHEET_TYPE.CYCLE_COUNT,
+      ['targetInventory', 'targetInventory.inventory', 'targetInventory.inventory.location']
+    )
+
+    let targetInventory: OrderInventory = worksheetDetail.targetInventory
+    const inventory: Inventory = targetInventory.inventory
+    const { batchId, qty, uomValue }: { batchId: string; qty: number; uomValue: number } = inventory
+
+    const isChanged: boolean = batchId !== inspectedBatchNo || qty !== inspectedQty || uomValue !== inspectedUomValue
+    const worksheetDetailStatus: string = isChanged ? WORKSHEET_STATUS.NOT_TALLY : WORKSHEET_STATUS.DONE
+    const targetInventoryStatus: string = isChanged
+      ? ORDER_INVENTORY_STATUS.NOT_TALLY
+      : ORDER_INVENTORY_STATUS.INSPECTED
+
+    worksheetDetail.status = worksheetDetailStatus
+    worksheetDetail.updater = this.user
+    await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
+
+    targetInventory.inspectedBatchNo = inspectedBatchNo
+    targetInventory.inspectedQty = inspectedQty
+    targetInventory.inspectedUomValue = inspectedUomValue
+    targetInventory.inspectedLocation = targetInventory.inventory.location
+    targetInventory.status = targetInventoryStatus
+    targetInventory.updater = this.user
+    await this.updateOrderTargets([targetInventory])
+
+    //If all tally, remove lockedQty, lockedWeight, lockedUomValue
+    if (!isChanged) {
+      inventory.lockedQty = 0
+      //@ts-ignore
+      inventory.lockedWeight = 0
+      inventory.lockedUomValue = 0
+      inventory.updater = this.user
+      await this.trxMgr.getRepository(Inventory).save(inventory, { chunk: 500 })
+    }
+  }
+
+  async undoInspection(worksheetDetailName: string): Promise<void> {
+    let worksheetDetail: WorksheetDetail = await this.findWorksheetDetail(
+      { domain: { id: this.domain.id }, name: worksheetDetailName, status: Not(Equal(WORKSHEET_STATUS.EXECUTING)) },
+      ['targetInventory', 'targetInventory.inventory']
+    )
+
+    let targetInventory: OrderInventory = worksheetDetail.targetInventory
+    targetInventory.inspectedBatchNo = null
+    targetInventory.inspectedQty = null
+    //@ts-ignore
+    targetInventory.inspectedWeight = null
+    targetInventory.inspectedUomValue = null
+    targetInventory.inspectedLocation = null
+    targetInventory.status =
+      targetInventory.status === ORDER_INVENTORY_STATUS.RELOCATED
+        ? ORDER_INVENTORY_STATUS.MISSING
+        : ORDER_INVENTORY_STATUS.INSPECTING
+    targetInventory.updater = this.user
+    await this.updateOrderTargets([targetInventory])
+
+    worksheetDetail.status = WORKSHEET_STATUS.EXECUTING
+    worksheetDetail.updater = this.user
+    await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
+
+    const inventory: Inventory = targetInventory.inventory
+    inventory.lockedQty = inventory.qty
+    //@ts-ignore
+    inventory.lockedWeight = inventory.weight
+    inventory.lockedUomValue = inventory.uomValue
+    inventory.updater = this.user
+    await this.trxMgr.getRepository(Inventory).save(inventory, { chunk: 500 })
+  }
+
+  async checkMissingPallet(worksheetDetailName: string): Promise<void> {
+    let worksheetDetail: WorksheetDetail = await this.findExecutableWorksheetDetailByName(
+      worksheetDetailName,
+      WORKSHEET_TYPE.CYCLE_COUNT,
+      ['targetInventory']
+    )
+
+    let targetInventory: OrderInventory = worksheetDetail.targetInventory
+    worksheetDetail.status = WORKSHEET_STATUS.NOT_TALLY
+    worksheetDetail.updater = this.user
+    await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
+
+    targetInventory.status = ORDER_INVENTORY_STATUS.MISSING
+    targetInventory.updater = this.user
+    await this.updateOrderTargets([targetInventory])
+  }
+
+  async addExtraPallet(
+    cycleCountNo: string,
+    palletId: string,
+    inspectedBatchNo: string,
+    inspectedQty: number,
+    inspectedUomValue: number,
+    locationName: string
+  ): Promise<void> {
+    //@ts-ignore
+    const inventoryCheck: InventoryCheck = await this.findRefOrder(
+      //@ts-ignore
+      InventoryCheck,
+      {
+        name: cycleCountNo,
+        status: ORDER_STATUS.INSPECTING
+      },
+      ['bizplace']
+    )
+
+    const bizplace: Bizplace = inventoryCheck.bizplace
+    const qb: SelectQueryBuilder<Inventory> = this.trxMgr.getRepository(Inventory).createQueryBuilder('INV')
+    let inventory: Inventory = await qb
+      .where('INV.domain = :domainId', { domainId: this.domain.id })
+      .andWhere('INV.bizplace = :bizplaceId', { bizplaceId: bizplace.id })
+      .andWhere('INV.palletId = :palletId', { palletId })
+      .andWhere('INV.status = :status', { status: INVENTORY_STATUS.STORED })
+      .andWhere(
+        new Brackets(qb => {
+          qb.where('INV.lockedQty ISNULL')
+          qb.orWhere('INV.lockedQty = 0')
+        })
+      )
+      .getOne()
+    if (!inventory) throw new Error('Failed to find inventory')
+
+    const worksheet: Worksheet = await this.trxMgr.getRepository(Worksheet).findOne({
+      where: {
+        domain: { id: this.domain.id },
+        type: WORKSHEET_TYPE.CYCLE_COUNT,
+        status: WORKSHEET_STATUS.EXECUTING,
+        inventoryCheck: { id: inventoryCheck.id }
+      }
+    })
+    const location: Location = await this.trxMgr.getRepository(Location).findOne({
+      where: { domain: { id: this.domain.id }, name: locationName }
+    })
+
+    let targetInventory: OrderInventory = new OrderInventory()
+    targetInventory.domain = this.domain
+    targetInventory.bizplace = bizplace
+    targetInventory.status = ORDER_INVENTORY_STATUS.ADDED
+    targetInventory.name = OrderNoGenerator.orderInventory()
+    targetInventory.inventoryCheck = inventoryCheck
+    targetInventory.inventory = inventory
+    targetInventory.inspectedBatchNo = inspectedBatchNo
+    targetInventory.inspectedQty = inspectedQty
+    //@ts-ignore
+    targetInventory.inspectedWeight = 0
+    targetInventory.inspectedUomValue = inspectedUomValue
+    targetInventory.inspectedLocation = location
+    targetInventory.creator = this.user
+    targetInventory.updater = this.user
+    await this.updateOrderTargets([targetInventory])
+
+    let worksheetDetail: WorksheetDetail = new WorksheetDetail()
+    worksheetDetail.domain = this.domain
+    worksheetDetail.bizplace = bizplace
+    worksheetDetail.worksheet = worksheet
+    worksheetDetail.name = WorksheetNoGenerator.cycleCountDetail()
+    worksheetDetail.targetInventory = targetInventory
+    worksheetDetail.type = WORKSHEET_TYPE.CYCLE_COUNT
+    worksheetDetail.status = WORKSHEET_STATUS.NOT_TALLY
+    worksheetDetail.creator = this.user
+    worksheetDetail.updater = this.user
+    await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
+  }
+
+  async relocatePallet(
+    worksheetDetailName: string,
+    inspectedBatchNo: string,
+    inspectedQty: number,
+    inspectedUomValue: number,
+    inspectedLocationName: string
+  ): Promise<void> {
+    let worksheetDetail: WorksheetDetail = await this.trxMgr.getRepository(WorksheetDetail).findOne({
+      where: { domain: { id: this.domain.id }, name: worksheetDetailName, type: WORKSHEET_TYPE.CYCLE_COUNT },
+      relations: ['targetInventory', 'targetInventory.inventory', 'targetInventory.inventory.location']
+    })
+
+    if (!worksheetDetail) throw new Error('Failed to find worksheet detail')
+
+    let targetInventory: OrderInventory = worksheetDetail.targetInventory
+    const location: Location = targetInventory?.inventory?.location
+    if (location.name === inspectedLocationName) throw new Error(`You can't relocate at same location`)
+
+    const inspectedLocation: Location = await this.trxMgr.getRepository(Location).findOne({
+      where: { name: inspectedLocationName, domain: { id: this.domain.id } }
+    })
+
+    worksheetDetail.status = WORKSHEET_STATUS.NOT_TALLY
+    worksheetDetail.updater = this.user
+    await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
+
+    targetInventory.inspectedLocation = inspectedLocation
+    targetInventory.inspectedBatchNo = inspectedBatchNo
+    targetInventory.inspectedQty = inspectedQty
+    //@ts-ignore
+    targetInventory.inspectedWeight = 0
+    targetInventory.inspectedUomValue = inspectedUomValue
+    targetInventory.status = ORDER_INVENTORY_STATUS.RELOCATED
+    targetInventory.updater = this.user
+    await this.updateOrderTargets([targetInventory])
+  }
+
+  async completeCycleCount(inventoryCheckNo: string): Promise<Worksheet> {
+    //@ts-ignore
+    const inventoryCheck: InventoryCheck = await this.findRefOrder(InventoryCheck, {
+      name: inventoryCheckNo,
+      status: ORDER_STATUS.INSPECTING
+    })
+
+    let worksheet: Worksheet = await this.trxMgr.getRepository(Worksheet).findOne({
+      where: {
+        domain: { id: this.domain.id },
+        status: WORKSHEET_STATUS.EXECUTING,
+        type: In([WORKSHEET_TYPE.CYCLE_COUNT, WORKSHEET_TYPE.CYCLE_COUNT_RECHECK]),
+        inventoryCheck: { id: inventoryCheck.id }
+      },
+      relations: ['worksheetDetails', 'worksheetDetails.targetInventory', 'worksheetDetails.targetInventory.inventory']
+    })
+    this.checkRecordValidity(worksheet, { status: WORKSHEET_STATUS.EXECUTING })
+
+    const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
+    const targetInventories: OrderInventory[] = worksheetDetails.map((wsd: WorksheetDetail) => wsd.targetInventory)
+
+    const {
+      tallyTargetInventories,
+      notTallyTargetInventories
+    }: {
+      tallyTargetInventories: OrderInventory[]
+      notTallyTargetInventories: OrderInventory[]
+    } = targetInventories.reduce(
+      (result, targetInventory: OrderInventory) => {
+        if (targetInventory.status !== ORDER_INVENTORY_STATUS.INSPECTED) {
+          result.notTallyTargetInventories.push(targetInventory)
+        } else {
+          result.tallyTargetInventories.push(targetInventory)
+        }
+
+        return result
+      },
+      {
+        tallyTargetInventories: [],
+        notTallyTargetInventories: []
+      }
+    )
+
+    const tallyInventories: Inventory[] = tallyTargetInventories.map(targetInventory => targetInventory.inventory)
+    tallyTargetInventories.forEach((targetInventory: OrderInventory) => {
+      targetInventory.status = ORDER_INVENTORY_STATUS.TERMINATED
+      targetInventory.updater = this.user
+    })
+    await this.trxMgr.getRepository(OrderInventory).save(tallyTargetInventories, { chunk: 500 })
+
+    tallyInventories.forEach((inventory: Inventory) => {
+      inventory.lockedQty = 0
+      //@ts-ignore
+      inventory.lockedWeight = 0
+      inventory.lockedUomValue = 0
+      inventory.updater = this.user
+    })
+    await this.trxMgr.getRepository(Inventory).save(tallyInventories, { chunk: 500 })
+
+    if (notTallyTargetInventories.length) {
+      worksheet.status = WORKSHEET_STATUS.NOT_TALLY
+      inventoryCheck.status = ORDER_STATUS.PENDING_REVIEW
+    } else {
+      worksheet.status = WORKSHEET_STATUS.DONE
+      inventoryCheck.status = ORDER_STATUS.DONE
+    }
+
+    worksheet.endedAt = new Date()
+    worksheet.updater = this.user
+    await this.trxMgr.getRepository(Worksheet).save(worksheet)
+
+    inventoryCheck.updater = this.user
+    await this.trxMgr.getRepository(InventoryCheck).save(inventoryCheck)
+
+    return worksheet
+  }
+}

package/server/controllers/inspect/index.ts

@@ -0,0 +1 @@
+export * from './cycle-count-worksheet-controller'

package/server/controllers/outbound/index.ts

@@ -0,0 +1,5 @@
+export * from './loading-worksheet-controller'
+export * from './packing-worksheet-controller'
+export * from './picking-worksheet-controller'
+export * from './returning-worksheet-controller'
+export * from './sorting-worksheet-controller'