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

package/server/graphql/resolvers/worksheet-detail/generate-batch-picking-worksheet-details-by-bulk.ts

@@ -0,0 +1,206 @@
+import {
+  ORDER_INVENTORY_STATUS,
+  ORDER_PRODUCT_STATUS,
+  ORDER_TYPES,
+  OrderInventory,
+  OrderNoGenerator,
+  OrderProduct
+} from '@things-factory/sales-base'
+import { Setting } from '@things-factory/setting-base'
+import { getRepository } from '@things-factory/shell'
+import { Inventory } from '@things-factory/warehouse-base'
+
+import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
+import { Worksheet, WorksheetDetail } from '../../../entities'
+import { inventoriesByStrategy, WorksheetNoGenerator } from '../../../utils'
+
+export const generateBatchPickingWorksheetDetailsByBulkResolver = {
+  async generateBatchPickingWorksheetDetailsByBulk(
+    _: any,
+    { worksheetId, bizplaceId, selectedItems },
+    context: ResolverContext
+  ): Promise<Boolean> {
+    const { tx, user, domain } = context.state
+
+    try {
+      let worksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
+        where: { id: worksheetId },
+        relations: [
+          'releaseGood',
+          'worksheetDetails',
+          'worksheetDetails.targetInventory',
+          'worksheetDetails.targetInventory.inventory',
+          'worksheetDetails.targetInventory.product'
+        ]
+      })
+
+      // Only proceed if worksheet status IS "DEACTIVATED"
+      if (worksheet.status != WORKSHEET_STATUS.DEACTIVATED) {
+        return true
+      }
+
+      await getRepository(Worksheet).update(
+        { domain: { id: domain.id }, id: worksheetId },
+        {
+          status: WORKSHEET_STATUS.PROCESSING,
+          updater: user,
+          updatedAt: new Date()
+        }
+      )
+
+      const inventoryAssignmentSetting: Setting = await tx.getRepository(Setting).findOne({
+        where: { domain: { id: domain.id }, name: 'rule-for-inventory-assignment' }
+      })
+
+      await Promise.all(
+        selectedItems.map(async (oi: OrderInventory & { pickingStrategy: string }) => {
+          try {
+            let pOrderInventories = tx.getRepository(OrderInventory).find({
+              where: {
+                refWorksheetId: worksheet.id,
+                product: { id: oi.productId },
+                batchId: oi.batchId,
+                packingType: oi.packingType,
+                packingSize: oi.packingSize,
+                status: ORDER_INVENTORY_STATUS.PENDING_SPLIT
+              },
+              relations: ['product', 'releaseGood', 'bizplace', 'orderProduct'],
+              order: {
+                releaseQty: 'DESC'
+              }
+            })
+
+            let pInventoryList = inventoriesByStrategy(
+              {
+                ...oi,
+                worksheetId: worksheet.id,
+                bizplaceId,
+                locationSortingRules: inventoryAssignmentSetting ? JSON.parse(inventoryAssignmentSetting.value) : false
+              } as any,
+              domain,
+              tx
+            )
+
+            let idx = 0
+            let [orderInventories, inventoryList] = await Promise.all([pOrderInventories, pInventoryList])
+
+            for (let oiIdx = 0; oiIdx < orderInventories.length; oiIdx++) {
+              const orderInventory: OrderInventory = orderInventories[oiIdx]
+
+              let { releaseQty, releaseUomValue } = orderInventory
+
+              while (releaseQty > 0 && idx < inventoryList.items.length) {
+                let targetInventory: Inventory = await tx
+                  .getRepository(Inventory)
+                  .findOne({ where: { id: inventoryList.items[idx].id } })
+
+                let inventoryAvailableQty = targetInventory.qty - (targetInventory?.lockedQty || 0)
+                let inventoryAvailableUomValue = targetInventory.uomValue - (targetInventory?.lockedUomValue || 0)
+
+                if (inventoryAvailableQty > 0) {
+                  let allocatedQty = 0,
+                    allocatedUomValue = 0
+                  if (inventoryAvailableQty < releaseQty) {
+                    idx = idx + 1
+                    allocatedQty = inventoryAvailableQty
+                    allocatedUomValue = inventoryAvailableUomValue
+                  } else {
+                    allocatedQty = releaseQty
+                    allocatedUomValue = releaseUomValue
+                  }
+
+                  releaseQty = releaseQty - allocatedQty
+                  releaseUomValue = releaseUomValue - allocatedUomValue
+
+                  //// Update inventory locked quantity
+                  let qbInv = tx
+                    .getRepository(Inventory)
+                    .createQueryBuilder('inv')
+                    .update(Inventory)
+                    .set({
+                      lockedUomValue: () => `COALESCE(locked_uom_value,0) + ${allocatedUomValue}`,
+                      lockedQty: () => `COALESCE(locked_qty,0) + ${allocatedQty}`
+                    })
+                    .where('id = :id', { id: targetInventory.id })
+                  await qbInv.execute()
+
+                  // update order product status to ASSIGNED
+                  await tx.getRepository(OrderProduct).update({ id: orderInventory.orderProduct.id }, {
+                    status: ORDER_PRODUCT_STATUS.ASSIGNED as string,
+                    updater: user
+                  } as any)
+
+                  // Create new order inventory with status -> READY_TO_PICK, type -> RELEASE_OF_GOODS
+                  let newTargetInventory: OrderInventory = new OrderInventory()
+                  //@ts-ignore
+                  newTargetInventory = {
+                    domain: domain,
+                    bizplace: orderInventory.bizplace,
+                    name: OrderNoGenerator.orderInventory(),
+                    releaseGood: orderInventory.releaseGood,
+                    batchId: orderInventory.batchId,
+                    status: ORDER_INVENTORY_STATUS.READY_TO_PICK,
+                    type: ORDER_TYPES.RELEASE_OF_GOODS,
+                    refWorksheetId: orderInventory.refWorksheetId,
+                    product: orderInventory.product,
+                    packingType: orderInventory.packingType,
+                    //@ts-ignore
+                    packingSize: parseFloat(orderInventory.packingSize),
+                    creator: user,
+                    inventory: targetInventory,
+                    releaseQty: allocatedQty,
+                    releaseUomValue: allocatedUomValue,
+                    uom: orderInventory.uom,
+                    orderProduct: orderInventory.orderProduct
+                  }
+                  newTargetInventory = await tx.getRepository(OrderInventory).save(newTargetInventory)
+
+                  // Generate Worksheet Detail with status -> DEACTIVATED, type -> BATCH_PICKING
+                  let newWorksheetDetail: WorksheetDetail = new WorksheetDetail()
+                  newWorksheetDetail = {
+                    ...newWorksheetDetail,
+                    domain: domain,
+                    worksheet: worksheet,
+                    bizplace: orderInventory.bizplace,
+                    name: WorksheetNoGenerator.batchPickingDetail(),
+                    targetInventory: newTargetInventory,
+                    targetProduct: newTargetInventory.orderProduct,
+                    type: WORKSHEET_TYPE.BATCH_PICKING,
+                    status: WORKSHEET_STATUS.DEACTIVATED,
+                    creator: user
+                  }
+                  await tx.getRepository(WorksheetDetail).save(newWorksheetDetail)
+                } else {
+                  idx = idx + 1
+                }
+              }
+
+              //Update Current Order Inventory status -> COMPLETE_SPLIT
+              await tx.getRepository(OrderInventory).update({ id: orderInventory.id }, {
+                status: ORDER_INVENTORY_STATUS.COMPLETE_SPLIT,
+                updater: user,
+                updatedAt: new Date()
+              } as any)
+            }
+            return { orderInventory: oi, status: 'success', message: null }
+          } catch (error) {
+            return { orderInventory: oi, status: 'error', message: error }
+          }
+        })
+      )
+
+      return true
+    } catch (error) {
+      throw error
+    } finally {
+      await getRepository(Worksheet).update(
+        { domain: { id: domain.id }, id: worksheetId },
+        {
+          status: WORKSHEET_STATUS.DEACTIVATED,
+          updater: user,
+          updatedAt: new Date()
+        }
+      )
+    }
+  }
+}

package/server/graphql/resolvers/worksheet-detail/generate-batch-picking-worksheet-details.ts

@@ -0,0 +1,165 @@
+import { Product } from '@things-factory/product-base'
+import {
+  ORDER_INVENTORY_STATUS,
+  ORDER_PRODUCT_STATUS,
+  OrderInventory,
+  OrderNoGenerator,
+  OrderProduct
+} from '@things-factory/sales-base'
+import { Inventory } from '@things-factory/warehouse-base'
+
+import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
+import { Worksheet, WorksheetDetail } from '../../../entities'
+import { WorksheetNoGenerator } from '../../../utils'
+
+export const generateBatchPickingWorksheetDetailsResolver = {
+  async generateBatchPickingWorksheetDetails(
+    _: any,
+    { worksheetNo, batchId, productId, packingType, worksheetDetails },
+    context: ResolverContext
+  ): Promise<void> {
+    const { tx, user, domain } = context.state
+
+    // 1. Find Related Worksheet
+    const worksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
+      where: { name: worksheetNo, domain: { id: domain.id } },
+      relations: [
+        'worksheetDetails',
+        'worksheetDetails.targetInventory',
+        'worksheetDetails.targetInventory.inventory',
+        'worksheetDetails.targetInventory.product'
+      ]
+    })
+
+    // Only proceed if worksheet status IS "DEACTIVATED"
+    if (worksheet.status != WORKSHEET_STATUS.DEACTIVATED) {
+      return
+    }
+
+    // 2. Find all existing order inventory that is related to the product
+    let prevOrdInvs: OrderInventory[] = await tx.getRepository(OrderInventory).find({
+      where: {
+        domain: { id: domain.id },
+        refWorksheetId: worksheet.id,
+        product: { id: productId },
+        batchId,
+        packingType,
+        status: ORDER_INVENTORY_STATUS.PENDING_SPLIT
+      },
+      relations: ['releaseGood', 'bizplace', 'orderProduct']
+    })
+
+    // Sort all release qty from highest to lowest
+    prevOrdInvs = prevOrdInvs.sort(function (a, b) {
+      return b.releaseQty - a.releaseQty
+    })
+
+    const selectedOrdInvs: OrderInventory[] = worksheetDetails
+      .map((wsd: any) => wsd.targetInventory)
+      .sort(function (a, b) {
+        return b.releaseQty - a.releaseQty
+      })
+
+    let j = 0
+
+    for (var i: number = 0; i < prevOrdInvs.length; i++) {
+      let prevOrdInv: OrderInventory = prevOrdInvs[i] //PENDING_SPLIT
+      let requiredQty: number = prevOrdInv.releaseQty
+      let requiredUomValue: number = prevOrdInv.releaseUomValue
+
+      while (j < selectedOrdInvs.length && requiredQty > 0) {
+        let selectedOrdInv: any = selectedOrdInvs[j]
+        let remainingQty: number = selectedOrdInv.releaseQty
+        let remainingUomValue: number = selectedOrdInv.releaseUomValue
+
+        if (remainingQty == 0) {
+          j = j + 1
+          continue
+        }
+
+        // Create new order inventory with new status -> READY_TO_PICK
+        let newTargetInventory: OrderInventory = new OrderInventory()
+        newTargetInventory.domain = domain
+        newTargetInventory.bizplace = prevOrdInv.bizplace
+        newTargetInventory.name = OrderNoGenerator.orderInventory()
+        newTargetInventory.releaseGood = prevOrdInv.releaseGood
+        newTargetInventory.batchId = prevOrdInv.batchId
+        newTargetInventory.status = ORDER_INVENTORY_STATUS.READY_TO_PICK
+        newTargetInventory.type = selectedOrdInv.type
+        newTargetInventory.refWorksheetId = prevOrdInv.refWorksheetId
+        newTargetInventory.product = await tx.getRepository(Product).findOne(productId)
+        newTargetInventory.packingType = prevOrdInv.packingType
+        //@ts-ignore
+        newTargetInventory.packingSize = parseFloat(prevOrdInv.packingSize)
+        newTargetInventory.creator = user
+        newTargetInventory.uom = selectedOrdInv.uom
+        newTargetInventory.orderProduct = prevOrdInv.orderProduct
+
+        let inventory: Inventory = await tx.getRepository(Inventory).findOne(selectedOrdInv.inventory.id)
+
+        const currentLockedQty: number = inventory.lockedQty
+        const currentLockedUomValue: number = inventory.lockedUomValue
+
+        // Negative means fulfilled, positive mean current inventory is insufficient to fulfil all qty
+        const fulfiledQty: number = requiredQty - remainingQty // 2 - 5 || 2 - 2 || 2 - 1
+        const fulfiledUomValue: number = Math.round((requiredUomValue - remainingUomValue) * 100) / 100
+
+        newTargetInventory.inventory = inventory
+        newTargetInventory.releaseQty = fulfiledQty <= 0 ? requiredQty : remainingQty
+        newTargetInventory.releaseUomValue = fulfiledUomValue <= 0 ? requiredUomValue : remainingUomValue
+        newTargetInventory = await tx.getRepository(OrderInventory).save(newTargetInventory)
+
+        remainingQty = remainingQty - requiredQty
+        remainingUomValue = Math.round((remainingUomValue - requiredUomValue) * 100) / 100
+
+        requiredQty = fulfiledQty <= 0 ? 0 : fulfiledQty
+        requiredUomValue = fulfiledUomValue <= 0 ? 0 : fulfiledUomValue
+
+        await tx.getRepository(Inventory).update({ domain, id: inventory.id }, {
+          lockedQty: Boolean(currentLockedQty)
+            ? newTargetInventory.releaseQty + currentLockedQty
+            : newTargetInventory.releaseQty,
+          lockedUomValue: Boolean(currentLockedUomValue)
+            ? Math.round((newTargetInventory.releaseUomValue + currentLockedUomValue) * 100) / 100
+            : newTargetInventory.releaseUomValue,
+          updater: user,
+          updatedAt: new Date()
+        } as any)
+
+        // update order product status to ASSIGNED
+        await tx
+          .getRepository(OrderProduct)
+          .update(prevOrdInv.orderProduct, { status: ORDER_PRODUCT_STATUS.ASSIGNED, updater: user } as any)
+
+        // Generate Worksheet Detail
+        let newWorksheetDetail: WorksheetDetail = new WorksheetDetail()
+        newWorksheetDetail = {
+          ...newWorksheetDetail,
+          domain: domain,
+          worksheet: worksheet,
+          bizplace: prevOrdInv.bizplace,
+          name: WorksheetNoGenerator.batchPickingDetail(),
+          targetInventory: newTargetInventory,
+          targetProduct: prevOrdInv.orderProduct,
+          type: WORKSHEET_TYPE.BATCH_PICKING,
+          status: WORKSHEET_STATUS.DEACTIVATED,
+          creator: user
+        }
+        await tx.getRepository(WorksheetDetail).save(newWorksheetDetail)
+
+        selectedOrdInv.releaseQty = remainingQty <= 0 ? 0 : remainingQty
+        selectedOrdInv.releaseUomValue = remainingUomValue <= 0 ? 0 : remainingUomValue
+
+        // insufficient qty for current order inventory, use the next inventory qty
+        if (selectedOrdInv.releaseQty == 0) {
+          j = j + 1
+        }
+      }
+      await tx.getRepository(OrderInventory).update({ id: prevOrdInvs[i].id }, {
+        status: ORDER_INVENTORY_STATUS.COMPLETE_SPLIT,
+        updater: user,
+        updatedAt: new Date()
+      } as any)
+    }
+  }
+}

package/server/graphql/resolvers/worksheet-detail/generate-carton-id.ts

@@ -0,0 +1,26 @@
+import { generateId } from '@things-factory/id-rule-base'
+
+export const generateCartonIdResolver = {
+  async generateCartonId(_: any, { printQty, type }, context: ResolverContext) {
+    const { tx, domain } = context.state
+    // 1. get and set the date
+    const today = new Date()
+    const year = today.getFullYear()
+    const month = today.getMonth()
+    const day = today.getDate()
+
+    const yy = String(year).substr(String(year).length - 2)
+    const mm = String(month + 1).padStart(2, '0')
+    const dd = String(day).padStart(2, '0')
+
+    const date = yy + mm + dd
+    let results = []
+
+    for (let i = 0; i < printQty; i++) {
+      const generatedPalletId = await generateId({ domain, type, seed: { date: date } })
+      results.push({ cartonId: generatedPalletId })
+    }
+
+    return results
+  }
+}

package/server/graphql/resolvers/worksheet-detail/generate-pallet-id.ts

@@ -0,0 +1,94 @@
+import { In } from 'typeorm'
+
+import { generateId } from '@things-factory/id-rule-base'
+
+import { WorksheetDetail } from '../../../entities'
+
+export const generatePalletIdResolver = {
+  async generatePalletId(_: any, { targets, type }, context: ResolverContext) {
+    const { tx, domain } = context.state
+    // 1. get date in yymmdd format
+    const date = new Date().toJSON().slice(0, 10).replace(/-/g, '').slice(2, 8)
+    let results = []
+
+    // 2. get worksheet details
+    const foundWorksheetDetails: WorksheetDetail[] = await tx.getRepository(WorksheetDetail).find({
+      where: {
+        domain: { id: domain.id },
+        id: In(targets.map(target => target.id))
+      },
+      relations: [
+        'domain',
+        'bizplace',
+        'worksheet',
+        'worker',
+        'targetProduct',
+        'targetProduct.arrivalNotice',
+        'targetProduct.arrivalNotice.purchaseOrder',
+        'targetProduct.product',
+        'targetInventory',
+        'targetInventory.product',
+        'targetVas',
+        'targetVas.targetProduct'
+      ]
+    })
+
+    // 3. from worksheet detail get product name, product type, batchid, packing type, bizplace
+    if (!foundWorksheetDetails?.length) throw new Error('Unable to find worksheet details')
+    else {
+      for (let i = 0; i < foundWorksheetDetails.length; i++) {
+        let foundWSD = foundWorksheetDetails[i]
+        for (let idx = 0; idx < targets.length; idx++) {
+          if (foundWSD.id === targets[idx].id) {
+            // 4. generate pallet id based on print qty > call generateId resolver
+            for (let i = 0; i < targets[idx].printQty; i++) {
+              let result: any = {}
+              // 5. map all data to be returned
+              if (foundWSD.targetProduct) {
+                result = {
+                  ...foundWSD.targetProduct,
+                  bizplace: foundWSD.bizplace,
+                  orderProductRemark: foundWSD.targetProduct.remark,
+                  purchaseOrderNo: foundWSD.targetProduct.arrivalNotice?.purchaseOrder?.name || '',
+                  arrivalNoticeRefNo: foundWSD.targetProduct.arrivalNotice?.refNo || '',
+                  arrivalNoticeNo: foundWSD.targetProduct.arrivalNotice?.name || ''
+                }
+              } else if (foundWSD.targetInventory) {
+                result = {
+                  ...foundWSD.targetInventory,
+                  bizplace: foundWSD.bizplace,
+                  orderProductRemark: '',
+                  purchaseOrderNo: '',
+                  arrivalNoticeRefNo: ''
+                }
+              } else if (foundWSD.targetVas) {
+                result = {
+                  ...foundWSD.targetVas,
+                  bizplace: foundWSD.bizplace,
+                  batchId: foundWSD.targetVas.targetBatchId,
+                  orderProductRemark: '',
+                  purchaseOrderNo: '',
+                  arrivalNoticeRefNo: ''
+                }
+              }
+
+              results.push({
+                ...result,
+                palletId: await generateId({
+                  domain,
+                  type,
+                  seed: {
+                    batchId: result.batchId || '',
+                    date
+                  }
+                })
+              })
+            }
+          }
+        }
+      }
+    }
+
+    return results
+  }
+}