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

package/server/controllers/inbound/unloading-returning-worksheet-controller.ts

@@ -0,0 +1,291 @@
+import { In } from 'typeorm'
+
+import { Bizplace } from '@things-factory/biz-base'
+import {
+  ORDER_PRODUCT_STATUS,
+  ORDER_STATUS,
+  ORDER_TYPES,
+  ORDER_VAS_STATUS,
+  OrderInventory,
+  OrderNoGenerator,
+  OrderProduct,
+  OrderVas,
+  ReturnOrder,
+  Vas,
+  VAS_TARGET_TYPES
+} 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 { VasWorksheetController } from '../vas/vas-worksheet-controller'
+
+export type UnloadingReturningWorksheetDetail = Partial<WorksheetDetail> & {
+  palletizingVasId: string
+  palletQty: number
+  palletizingDescription: string
+}
+
+export class UnloadingReturningWorksheetController extends VasWorksheetController {
+  async generateUnloadingReturnWorksheet(returnOrderNo: string, bufferLocationId: string): Promise<Worksheet> {
+    //@ts-ignore
+    let returnOrder: ReturnOrder = await this.findRefOrder(
+      //@ts-ignore
+      ReturnOrder,
+      {
+        domain: this.domain,
+        name: returnOrderNo,
+        status: ORDER_STATUS.ARRIVED
+      },
+      ['bizplace', 'orderInventories', 'orderVass']
+    )
+    const orderInventories: OrderInventory[] = returnOrder.orderInventories
+    const orderVASs: OrderVas[] = returnOrder.orderVass
+    const bufferLocation: Location = await this.trxMgr.getRepository(Location).findOneBy({ id: bufferLocationId })
+
+    const worksheet: Worksheet = await this.generateWorksheet(
+      WORKSHEET_TYPE.UNLOADING_RETURN,
+      returnOrder,
+      orderInventories,
+      ORDER_STATUS.READY_TO_UNLOAD,
+      ORDER_PRODUCT_STATUS.READY_TO_UNLOAD,
+      { bufferLocation }
+    )
+
+    if (orderVASs?.length > 0) {
+      await this.generateVasWorksheet(returnOrder)
+    }
+
+    return worksheet
+  }
+
+  async activateUnloadingReturn(
+    worksheetNo: string,
+    unloadingReturnWorksheetDetails: UnloadingReturningWorksheetDetail[]
+  ): Promise<Worksheet> {
+    let worksheet: Worksheet = await this.findActivatableWorksheet(worksheetNo, WORKSHEET_TYPE.UNLOADING_RETURN, [
+      'bizplace',
+      'returnOrder',
+      'worksheetDetails',
+      'worksheetDetails.targetInventory',
+      'worksheetDetails.targetInventory.product'
+    ])
+
+    const bizplace: Bizplace = worksheet.bizplace
+    let worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
+
+    const targetInventories: OrderInventory[] = worksheetDetails.map((wsd: WorksheetDetail) => {
+      let targetInventory: OrderInventory = wsd.targetInventory
+      targetInventory.status = ORDER_PRODUCT_STATUS.UNLOADING
+      targetInventory.updater = this.user
+      return targetInventory
+    })
+    await this.updateOrderTargets(targetInventories)
+
+    let returnOrder: ReturnOrder = worksheet.returnOrder
+    returnOrder.status = ORDER_STATUS.PROCESSING
+    returnOrder.updater = this.user
+    this.updateRefOrder(returnOrder)
+
+    worksheet = await this.activateWorksheet(worksheet, worksheetDetails, unloadingReturnWorksheetDetails)
+
+    try {
+      const vasWorksheet: Worksheet = await this.findWorksheetByRefOrder(returnOrder, WORKSHEET_TYPE.VAS)
+      if (vasWorksheet) {
+        await this.activateVAS(vasWorksheet.name, vasWorksheet.worksheetDetails)
+      }
+    } catch (e) {
+      // Do nothing
+    }
+
+    return worksheet
+  }
+
+  async completeUnloadReturning(
+    returnOrderNo: string,
+    unloadingReturnWorksheetDetails: Partial<WorksheetDetail>[]
+  ): Promise<void> {
+    //@ts-ignore
+    let returnOrder: ReturnOrder = await this.findRefOrder(
+      //@ts-ignore
+      ReturnOrder,
+      {
+        domain: { id: this.domain.id },
+        name: returnOrderNo,
+        status: In([ORDER_STATUS.PROCESSING, ORDER_STATUS.PUTTING_AWAY])
+      },
+      ['orderInventories']
+    )
+
+    // if (returnOrder.crossDocking) {
+    //   // Picking worksheet for cross docking should be completed before complete it
+    //   // Find picking worksheet
+    //   const releaseGood: ReleaseGood = arrivalNotice.releaseGood
+    //   const executingPickingWS: Worksheet = await this.trxMgr.getRepository(Worksheet).findOne({
+    //     where: {
+    //       domain: { id: this.domain.id },
+    //       releaseGood: { id: releaseGood.id },
+    //       type: WORKSHEET_TYPE.PICKING,
+    //       status: Not(Equal(WORKSHEET_STATUS.DONE))
+    //     }
+    //   })
+
+    //   if (executingPickingWS)
+    //     throw new Error(`Picking should be completed before complete unloading for cross docking.`)
+    // }
+
+    if (
+      returnOrder.orderInventories.some((oi: OrderInventory) => oi.status === ORDER_PRODUCT_STATUS.READY_TO_APPROVED)
+    ) {
+      throw new Error(`There's non-approved order products`)
+    }
+
+    let worksheet: Worksheet = await this.findWorksheetByRefOrder(returnOrder, WORKSHEET_TYPE.UNLOADING_RETURN, [
+      'worksheetDetails',
+      'worksheetDetails.targetInventory'
+    ])
+    this.checkRecordValidity(worksheet, { status: WORKSHEET_STATUS.EXECUTING })
+
+    const partiallyUnloadedCnt: number = await this.trxMgr.getRepository(Inventory).count({
+      where: { domain: { id: this.domain.id }, refOrderId: returnOrder.id, status: INVENTORY_STATUS.PARTIALLY_UNLOADED }
+    })
+    if (partiallyUnloadedCnt) {
+      throw new Error('There is partially unloaded pallet, generate putaway worksheet before complete unloading.')
+    }
+
+    if (unloadingReturnWorksheetDetails.some((wsd: Partial<WorksheetDetail>) => wsd.issue)) {
+      const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
+      unloadingReturnWorksheetDetails = this.renewWorksheetDetails(
+        worksheetDetails,
+        unloadingReturnWorksheetDetails,
+        'name',
+        {
+          updater: this.user
+        }
+      )
+      const worksheetDetailsWithIssue: WorksheetDetail[] = unloadingReturnWorksheetDetails.filter(
+        (wsd: WorksheetDetail) => wsd.issue
+      ) as WorksheetDetail[]
+      if (worksheetDetailsWithIssue.length) {
+        await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetailsWithIssue)
+      }
+
+      const targetInventoriesWithIssue: OrderProduct[] = worksheetDetailsWithIssue.map((wsd: WorksheetDetail) => {
+        //@ts-ignore
+        let targetInventory: OrderProduct = wsd.targetInventory
+        targetInventory.remark = wsd.issue
+        return targetInventory
+      })
+      await this.updateOrderTargets(targetInventoriesWithIssue)
+    }
+
+    if (returnOrder.status !== ORDER_STATUS.PUTTING_AWAY) {
+      await this.completeWorksheet(worksheet, ORDER_STATUS.READY_TO_PUTAWAY)
+    } else {
+      await this.completeWorksheet(worksheet)
+    }
+  }
+
+  async completeUnloadReturnPartially(
+    returnOrderNo: string,
+    unloadingReturnWorksheetDetails: Partial<WorksheetDetail>[]
+  ): Promise<Worksheet> {
+    //@ts-ignore
+    const returnOrder: ReturnOrder = await this.findRefOrder(ReturnOrder, {
+      name: returnOrderNo,
+      status: ORDER_STATUS.PROCESSING
+    })
+
+    const worksheet: Worksheet = await this.findWorksheetByRefOrder(returnOrder, WORKSHEET_TYPE.UNLOADING_RETURN, [
+      'worksheetDetails',
+      'worksheetDetails.targetInventory'
+    ])
+    this.checkRecordValidity(worksheet, { status: WORKSHEET_STATUS.EXECUTING })
+
+    let worksheetDetails = worksheet.worksheetDetails.filter(({ name: itm1 }) =>
+      unloadingReturnWorksheetDetails.some(({ name: itm2 }) => itm2 === itm1)
+    )
+
+    worksheetDetails.forEach((wsds: WorksheetDetail) => {
+      wsds.status = WORKSHEET_STATUS.PARTIALLY_UNLOADED
+      wsds.updater = this.user
+    })
+
+    worksheetDetails = await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetails)
+
+    for (let i = 0; i < worksheetDetails.length; i++) {
+      worksheetDetails[i].targetInventory.status = ORDER_PRODUCT_STATUS.PARTIALLY_UNLOADED
+      worksheetDetails[i].targetInventory.remark =
+        worksheetDetails[i].issue || worksheetDetails[i].targetInventory.remark
+      await this.updateOrderTargets([worksheetDetails[i].targetInventory])
+    }
+
+    let inventories: Inventory[] = await this.trxMgr.getRepository(Inventory).find({
+      where: {
+        domain: { id: this.domain.id },
+        refOrderId: returnOrder.id,
+        status: In([INVENTORY_STATUS.UNLOADED, INVENTORY_STATUS.CHECKED])
+      }
+    })
+
+    inventories.forEach((inventory: Inventory) => {
+      inventory.status = INVENTORY_STATUS.PARTIALLY_UNLOADED
+      inventory.updater = this.user
+    })
+    await this.trxMgr.getRepository(Inventory).save(inventories)
+
+    return worksheet
+  }
+
+  async createPalletizingWSDs(
+    bizplace: Bizplace,
+    returnOrder: ReturnOrder,
+    worksheetDetails: WorksheetDetail[],
+    palletizingWSDs: UnloadingReturningWorksheetDetail[]
+  ): Promise<void> {
+    let palletizingOrderVASs: Partial<OrderVas>[] = []
+
+    for (let palletizingWSD of palletizingWSDs) {
+      const palletizingVAS: Vas = await this.trxMgr.getRepository(Vas).findOne({
+        where: { domain: { id: this.domain.id }, id: palletizingWSD.palletizingVasId }
+      })
+
+      //@ts-ignore
+      const targetInventory: OrderInventory = worksheetDetails.find(
+        (wsd: WorksheetDetail) => wsd.name === palletizingWSD.name
+      )
+
+      palletizingOrderVASs.push({
+        domain: this.domain,
+        bizplace,
+        name: OrderNoGenerator.orderVas(),
+        returnOrder,
+        vas: palletizingVAS,
+        targetType: VAS_TARGET_TYPES.BATCH_AND_PRODUCT_TYPE,
+        targetBatchId: targetInventory.batchId,
+        targetProduct: targetInventory.product,
+        packingType: targetInventory.packingType,
+        description: palletizingWSD.palletizingDescription,
+        //@ts-ignore
+        type: ORDER_TYPES.RETURN_ORDER,
+        status: ORDER_VAS_STATUS.COMPLETED,
+        creator: this.user,
+        updater: this.user
+      })
+    }
+
+    this.trxMgr.getRepository(OrderVas).save(palletizingOrderVASs)
+
+    let vasWorksheet: Worksheet = await this.findWorksheetByRefOrder(returnOrder, WORKSHEET_TYPE.VAS)
+    if (!vasWorksheet) {
+      this.generateVasWorksheet(returnOrder)
+    } else {
+      //@ts-ignore
+      await this.createWorksheetDetails(vasWorksheet, WORKSHEET_TYPE.VAS, palletizingOrderVASs)
+    }
+  }
+
+  filterPalletizingWSDs(unloadingWSDs: UnloadingReturningWorksheetDetail[]): UnloadingReturningWorksheetDetail[] {
+    return unloadingWSDs.filter((wsd: UnloadingReturningWorksheetDetail) => wsd.palletQty && wsd.palletizingDescription)
+  }
+}