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

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

@@ -1,206 +0,0 @@
-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

@@ -1,165 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

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