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

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

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