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

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

@@ -1,377 +0,0 @@
-import { Equal, Not, In } from 'typeorm'
-
-import { Bizplace } from '@things-factory/biz-base'
-import {
-  DeliveryOrder,
-  ORDER_INVENTORY_STATUS,
-  ORDER_STATUS,
-  ORDER_TYPES,
-  OrderInventory,
-  OrderNoGenerator,
-  ReleaseGood,
-  OrderToteItem,
-  OrderTote
-} from '@things-factory/sales-base'
-import { Inventory, INVENTORY_TRANSACTION_TYPE, Tote, TOTE_STATUS } from '@things-factory/warehouse-base'
-
-import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../constants'
-import { Worksheet, WorksheetDetail } from '../../entities'
-import { generateInventoryHistory } from '../../utils'
-import { VasWorksheetController } from '../vas/vas-worksheet-controller'
-
-export class LoadingWorksheetController extends VasWorksheetController {
-  async generateLoadingWorksheet(
-    releaseGoodNo: string,
-    targetInventories: Partial<OrderInventory>[]
-  ): Promise<Worksheet> {
-    //@ts-ignore
-    const releaseGood: ReleaseGood = await this.findRefOrder(
-      //@ts-ignore
-      ReleaseGood,
-      { domain: { id: this.domain.id }, name: releaseGoodNo },
-      ['bizplace']
-    )
-    return await this.generateWorksheet(
-      WORKSHEET_TYPE.LOADING,
-      releaseGood,
-      //@ts-ignore
-      targetInventories,
-      ORDER_STATUS.LOADING,
-      ORDER_INVENTORY_STATUS.LOADING
-    )
-  }
-
-  async updateLoadingWorksheet(
-    releaseGoodNo: string,
-    targetInventories: Partial<OrderInventory>[],
-    worksheet: Worksheet
-  ): Promise<Worksheet> {
-    //@ts-ignore
-    const releaseGood: ReleaseGood = await this.findRefOrder(
-      //@ts-ignore
-      ReleaseGood,
-      { domain: { id: this.domain.id }, name: releaseGoodNo },
-      ['bizplace']
-    )
-    return await this.updateWorksheet(
-      WORKSHEET_TYPE.LOADING,
-      releaseGood,
-      worksheet,
-      //@ts-ignore
-      targetInventories,
-      ORDER_STATUS.LOADING,
-      ORDER_INVENTORY_STATUS.LOADING
-    )
-  }
-
-  async activateLoading(worksheetNo: string, loadingWorksheetDetails: Partial<WorksheetDetail>[]): Promise<Worksheet> {
-    const worksheet: Worksheet = await this.findActivatableWorksheet(worksheetNo, WORKSHEET_TYPE.LOADING, [
-      'releaseGood',
-      'worksheetDetails',
-      'worksheetDetails.targetInventory'
-    ])
-
-    let releaseGood: ReleaseGood = worksheet.releaseGood
-    const nonFinishedVasCnt: number = await this.trxMgr.getRepository(Worksheet).count({
-      where: {
-        domain: { id: this.domain.id },
-        releaseGood: { id: releaseGood.id },
-        type: WORKSHEET_TYPE.VAS,
-        status: Not(Equal(WORKSHEET_STATUS.DONE))
-      }
-    })
-    if (nonFinishedVasCnt) return
-
-    const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
-    let targetInventories: OrderInventory[] = worksheetDetails.map((wsd: WorksheetDetail) => wsd.targetInventory)
-
-    targetInventories = targetInventories
-      .filter(targetInventory => targetInventory.status == ORDER_INVENTORY_STATUS.PICKED)
-      .map((targetInventory: OrderInventory) => {
-        targetInventory.status = ORDER_INVENTORY_STATUS.LOADING
-        targetInventory.updater = this.user
-        return targetInventory
-      })
-
-    releaseGood.status = ORDER_STATUS.LOADING
-    releaseGood.updater = this.user
-    await this.updateRefOrder(releaseGood)
-
-    if (targetInventories.length > 0) await this.updateOrderTargets(targetInventories)
-    return await this.activateWorksheet(worksheet, worksheetDetails, loadingWorksheetDetails)
-  }
-
-  async loading(
-    releaseGoodNo: string,
-    worksheetDetails: Partial<WorksheetDetail & { loadedQty: number } & { toteName: string }>[]
-  ): Promise<any> {
-    //@ts-ignore
-    const releaseGood: ReleaseGood = await this.findRefOrder(
-      //@ts-ignore
-      ReleaseGood,
-      { domain: { id: this.domain.id }, name: releaseGoodNo },
-      ['bizplace']
-    )
-    const bizplace: Bizplace = releaseGood.bizplace
-
-    for (let i = 0; i < worksheetDetails.length; i++) {
-      const loadedQty: number = worksheetDetails[i].loadedQty
-      const toteName: string = worksheetDetails[i].toteName
-      let worksheetDetail = await this.findExecutableWorksheetDetailByName(
-        worksheetDetails[i].name,
-        WORKSHEET_TYPE.LOADING,
-        ['worksheet', 'targetInventory', 'targetInventory.inventory', 'targetInventory.product']
-      )
-
-      const worksheet: Worksheet = worksheetDetail.worksheet
-      let targetInventory: OrderInventory = worksheetDetail.targetInventory
-      const pickedQty: number = targetInventory.releaseQty
-      let inventory: Inventory = targetInventory.inventory
-
-      targetInventory.loadedAt = new Date()
-      targetInventory.loadedByUser = this.user
-
-      let loadedBy: string[] = targetInventory.loadedBy ? targetInventory.loadedBy.split(',') : []
-      if (!loadedBy.find(x => x == this.user.name)) {
-        loadedBy.push(this.user.name)
-        targetInventory.loadedBy = loadedBy.join(',')
-      }
-
-      if (loadedQty > pickedQty) {
-        throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('load', `loaded quantity can't exceed picked qty`))
-      } else if (loadedQty == pickedQty) {
-        // Change status of current worksheet detail
-        worksheetDetail.status = WORKSHEET_STATUS.DONE
-        worksheetDetail.updater = this.user
-        await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
-
-        // Change status of order inventory
-        targetInventory.status = ORDER_INVENTORY_STATUS.LOADED
-        targetInventory.updater = this.user
-        await this.updateOrderTargets([targetInventory])
-      } else if (loadedQty < pickedQty) {
-        const remainQty: number = pickedQty - loadedQty
-        const loadedUomValue: number = parseFloat(
-          ((targetInventory.releaseUomValue / pickedQty) * loadedQty).toFixed(2)
-        )
-        const remainUomValue: number = parseFloat((targetInventory.releaseUomValue - loadedUomValue).toFixed(2))
-
-        targetInventory.status = ORDER_INVENTORY_STATUS.LOADED
-        targetInventory.releaseQty = loadedQty
-        targetInventory.releaseUomValue = loadedUomValue
-        targetInventory.updater = this.user
-        await this.updateOrderTargets([targetInventory])
-
-        worksheetDetail.status = WORKSHEET_STATUS.DONE
-        worksheetDetail.updater = this.user
-        worksheetDetail = await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
-
-        // Create order inventory for remaining item
-        let newTargetInventory: OrderInventory = new OrderInventory()
-        newTargetInventory.domain = this.domain
-        newTargetInventory.bizplace = bizplace
-        newTargetInventory.name = OrderNoGenerator.orderInventory()
-        newTargetInventory.releaseGood = releaseGood
-        newTargetInventory.inventory = inventory
-        newTargetInventory.type = ORDER_TYPES.RELEASE_OF_GOODS
-        newTargetInventory.status = ORDER_INVENTORY_STATUS.LOADING
-        newTargetInventory.releaseQty = remainQty
-        newTargetInventory.releaseUomValue = remainUomValue
-        newTargetInventory.product = targetInventory.product
-        newTargetInventory.packingType = targetInventory.packingType
-        newTargetInventory.batchId = targetInventory.batchId
-        newTargetInventory.creator = this.user
-        newTargetInventory.updater = this.user
-        newTargetInventory = await this.trxMgr.getRepository(OrderInventory).save(newTargetInventory)
-
-        if (toteName) {
-          let foundOrderTote = await this.trxMgr
-            .getRepository(OrderTote)
-            .findOne({ where: { name: toteName, releaseGood: { id: releaseGood.id } } })
-
-          let foundOrderToteItems = await this.trxMgr
-            .getRepository(OrderToteItem)
-            .find({ where: { orderInventory: { id: targetInventory.id } } })
-
-          let foundOrderToteItemIds = foundOrderToteItems.map((itm: OrderToteItem) => itm.id)
-
-          await this.trxMgr
-            .getRepository(OrderToteItem)
-            .update({ id: In(foundOrderToteItemIds) }, { orderInventory: newTargetInventory })
-
-          let foundOrderToteItem: OrderToteItem = await this.trxMgr.getRepository(OrderToteItem).findOne({
-            //@ts-ignore
-            where: { orderInventory: newTargetInventory.id, orderTote: { id: foundOrderTote.id }, qty: loadedQty }
-          })
-
-          await this.trxMgr
-            .getRepository(OrderToteItem)
-            //@ts-ignore
-            .update({ id: foundOrderToteItem.id }, { orderInventory: targetInventory.id })
-        }
-
-        let newWorksheetDetail: any = await this.createWorksheetDetails(
-          worksheet,
-          WORKSHEET_TYPE.LOADING,
-          [newTargetInventory],
-          {
-            status: WORKSHEET_STATUS.EXECUTING
-          }
-        )
-
-        let worksheetDetailName = worksheetDetails[i].name
-        worksheetDetails = worksheetDetails.map(record => {
-          if (record.name == worksheetDetailName && !record?.targetInventory) {
-            return {
-              ...record,
-              name: newWorksheetDetail[0].name
-            }
-          } else {
-            return record
-          }
-        })
-
-        worksheetDetails[i].name = worksheetDetailName
-      }
-
-      worksheetDetails[i].targetInventory = targetInventory
-
-      await generateInventoryHistory(
-        inventory,
-        releaseGood,
-        INVENTORY_TRANSACTION_TYPE.LOADING,
-        0,
-        0,
-        this.user,
-        this.trxMgr
-      )
-    }
-
-    return worksheetDetails
-  }
-
-  async undoLoading(deliveryOrder: Partial<DeliveryOrder>, palletIds: string[]): Promise<void> {
-    //@ts-ignore
-    deliveryOrder = await this.findRefOrder(DeliveryOrder, { id: deliveryOrder.id, domain: this.domain }, [
-      'releaseGood'
-    ])
-
-    const releaseGood: ReleaseGood = deliveryOrder.releaseGood
-
-    const targetInventories: OrderInventory[] = await this.trxMgr.getRepository(OrderInventory).find({
-      where: {
-        domain: { id: this.domain.id },
-        deliveryOrder: { id: deliveryOrder.id },
-        status: ORDER_INVENTORY_STATUS.LOADED
-      },
-      relations: ['inventory']
-    })
-    // Filter out inventories which is included palletIds list.
-    let undoTargetOrderInventories: OrderInventory[] = targetInventories.filter(
-      (targetInventory: OrderInventory) =>
-        targetInventory.status === ORDER_INVENTORY_STATUS.LOADED &&
-        palletIds.includes(targetInventory.inventory.palletId)
-    )
-
-    // If there was remained items => Merge into previous order inventories
-    for (let undoTargetOrderInventory of undoTargetOrderInventories) {
-      undoTargetOrderInventory.deliveryOrder = null
-      undoTargetOrderInventory.updater = this.user
-
-      undoTargetOrderInventory.loadedAt = null
-      undoTargetOrderInventory.loadedByUser = null
-      undoTargetOrderInventory.loadedBy = null
-
-      let prevTargetInventory: OrderInventory = await this.trxMgr.getRepository(OrderInventory).findOne({
-        where: {
-          domain: { id: this.domain.id },
-          id: Not(Equal(undoTargetOrderInventory.id)),
-          releaseGood: { id: releaseGood.id },
-          status: ORDER_INVENTORY_STATUS.LOADING,
-          inventory: { id: undoTargetOrderInventory.inventory.id }
-        }
-      })
-
-      let undoOrderToteItem: OrderToteItem = await this.trxMgr
-        .getRepository(OrderToteItem)
-        .findOne({ where: { orderInventory: { id: undoTargetOrderInventory.id } } })
-
-      if (prevTargetInventory) {
-        // If there's prev target inventory
-        // Merge qty and uomValue into prev target inventory
-        prevTargetInventory.releaseQty += undoTargetOrderInventory.releaseQty
-        prevTargetInventory.releaseUomValue += undoTargetOrderInventory.releaseUomValue
-        prevTargetInventory.updater = this.user
-        await this.updateOrderTargets([prevTargetInventory])
-
-        //Update order tote item if any
-        if (undoOrderToteItem) {
-          undoOrderToteItem.orderInventoryId = prevTargetInventory.id
-          undoOrderToteItem.orderInventory = prevTargetInventory
-          await this.trxMgr.getRepository(OrderToteItem).save(undoOrderToteItem)
-        }
-
-        // Terminate undo target order inventory
-        undoTargetOrderInventory.status = ORDER_INVENTORY_STATUS.TERMINATED
-        await this.updateOrderTargets([undoTargetOrderInventory])
-
-        // Delete worksheet detail
-        await this.trxMgr.getRepository(WorksheetDetail).delete({
-          targetInventory: undoTargetOrderInventory,
-          type: WORKSHEET_TYPE.LOADING,
-          status: WORKSHEET_STATUS.DONE
-        })
-      } else {
-        // Update undo target inventory
-        undoTargetOrderInventory.status = ORDER_INVENTORY_STATUS.LOADING
-        await this.updateOrderTargets([undoTargetOrderInventory])
-
-        // Update worksheet detail to be able to load
-        let undoTargetWorksheetDetail: WorksheetDetail = await this.findWorksheetDetail({
-          targetInventory: undoTargetOrderInventory,
-          type: WORKSHEET_TYPE.LOADING,
-          status: WORKSHEET_STATUS.DONE
-        })
-        undoTargetWorksheetDetail.status = WORKSHEET_STATUS.EXECUTING
-        undoTargetWorksheetDetail.updater = this.user
-        await this.trxMgr.getRepository(WorksheetDetail).save(undoTargetWorksheetDetail)
-      }
-
-      // Create inventory history
-      let inventory: Inventory = undoTargetOrderInventory.inventory
-      await generateInventoryHistory(inventory, releaseGood, INVENTORY_TRANSACTION_TYPE.UNDO_LOADING, 0, 0, this.user)
-    }
-
-    // Compare total inventories length and undo target inventories length
-    // to check whether there's more order inventories
-    // If thres' no more remove delivery order
-    if (targetInventories.length === undoTargetOrderInventories.length) {
-      await this.trxMgr.getRepository(DeliveryOrder).delete(deliveryOrder.id)
-    }
-  }
-
-  async completeLoading(releaseGoodNo: string): Promise<Worksheet> {
-    //@ts-ignore
-    const releaseGood: ReleaseGood = await this.findRefOrder(ReleaseGood, {
-      domain: { id: this.domain.id },
-      name: releaseGoodNo,
-      status: ORDER_STATUS.LOADING
-    })
-
-    const orderToteIds = await (
-      await this.trxMgr
-        .getRepository(OrderTote)
-        .find({ where: { releaseGood: { id: releaseGood.id } }, relations: ['tote'] })
-    ).map((record: OrderTote) => record?.toteId)
-
-    await this.trxMgr.getRepository(Tote).update({ id: In(orderToteIds) }, { status: TOTE_STATUS.DISPATCHED })
-
-    const worksheet: Worksheet = await this.findWorksheetByRefOrder(releaseGood, WORKSHEET_TYPE.LOADING, [
-      'worksheetDetails',
-      'worksheetDetails.targetInventory'
-    ])
-    this.checkRecordValidity(worksheet, { status: WORKSHEET_STATUS.EXECUTING })
-
-    return await this.completeWorksheet(worksheet, ORDER_STATUS.DONE)
-  }
-}