@things-factory/worksheet-base 8.0.0-beta.0 → 8.0.0-beta.2

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

@@ -1,291 +0,0 @@
-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)
-  }
-}