@things-factory/worksheet-base 3.7.1 → 3.7.6

package/server/graphql/resolvers/worksheet/picking-worksheet.ts

@@ -1,8 +1,8 @@
-import { createQueryBuilder, getRepository, SelectQueryBuilder } from 'typeorm'
+import { EntityManager, In, SelectQueryBuilder } from 'typeorm'
 
 import { ORDER_INVENTORY_STATUS, OrderInventory, ReleaseGood } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { Inventory } from '@things-factory/warehouse-base'
+import { Inventory, Location } from '@things-factory/warehouse-base'
 
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
 import { WorksheetDetail } from '../../../entities'
@@ -10,71 +10,111 @@ import { fetchExecutingWorksheet } from '../../../utils'
 
 export const pickingWorksheetResolver = {
   async pickingWorksheet(_: any, { releaseGoodNo, locationSortingRules }, context: any) {
-    const { domain }: { domain: Domain } = context.state
-    const releaseGood: ReleaseGood = await getRepository(ReleaseGood).findOne({
-      where: { domain, name: releaseGoodNo /*status: ORDER_STATUS.PICKING*/ },
-      relations: ['bizplace', 'bizplace.domain']
-    })
-    if (!releaseGood) throw new Error(`Couldn't find picking worksheet by order no (${releaseGoodNo})`)
-
-    const worksheet = await fetchExecutingWorksheet(
-      domain,
-      releaseGood.bizplace,
-      ['bizplace'],
-      WORKSHEET_TYPE.PICKING,
-      releaseGood
-    )
+    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
 
-    const qb: SelectQueryBuilder<WorksheetDetail> = createQueryBuilder(WorksheetDetail, 'WSD')
-    qb.leftJoinAndSelect('WSD.targetInventory', 'T_INV')
-      .leftJoinAndSelect('T_INV.inventory', 'INV')
-      .leftJoinAndSelect('T_INV.product', 'PROD')
-      .leftJoinAndSelect('INV.location', 'LOC')
+    return await pickingWorksheet(domain, releaseGoodNo, locationSortingRules, tx)
+  }
+}
 
-    if (locationSortingRules?.length > 0) {
-      locationSortingRules.forEach((rule: { name: string; desc: boolean }) => {
-        qb.addOrderBy(`LOC.${rule.name}`, rule.desc ? 'DESC' : 'ASC')
-      })
-    }
+export async function pickingWorksheet(
+  domain: Domain,
+  releaseGoodNo: String,
+  locationSortingRules: any,
+  tx: EntityManager
+) {
+  let releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
+    where: { domain, name: releaseGoodNo /*status: ORDER_STATUS.PICKING*/ },
+    relations: ['bizplace', 'bizplace.domain']
+  })
 
-    const worksheetDetails: WorksheetDetail[] = await qb
-      .where('"WSD"."worksheet_id" = :worksheetId', { worksheetId: worksheet.id })
-      .andWhere('"WSD"."status" != :status', { status: WORKSHEET_STATUS.REPLACED })
-      .andWhere('"T_INV"."status" != :t_invstatus', { t_invstatus: ORDER_INVENTORY_STATUS.CANCELLED })
-      .getMany()
+  // Find Release Order based on Bin
+  if (!releaseGood) {
+    const binLocation: Location = await tx.getRepository(Location).findOne({
+      where: { domain, name: releaseGoodNo }
+    })
 
-    return {
-      worksheetInfo: {
-        bizplaceName: releaseGood.bizplace.name,
-        partnerDomainId: releaseGood.bizplace?.domain.id,
-        startedAt: worksheet.startedAt,
-        refNo: releaseGood.refNo,
-        refNo2: releaseGood.refNo2,
-        releaseGood
+    const orderInventoryByBin: OrderInventory = await tx.getRepository(OrderInventory).findOne({
+      where: {
+        domain,
+        binLocation,
+        status: In([ORDER_INVENTORY_STATUS.PICKING, ORDER_INVENTORY_STATUS.PICKED])
+      },
+      order: {
+        createdAt: 'ASC'
       },
-      worksheetDetailInfos: worksheetDetails.map(async (pickingWSD: WorksheetDetail) => {
-        const targetInventory: OrderInventory = pickingWSD.targetInventory
-        const inventory: Inventory = targetInventory.inventory
-        return {
-          name: pickingWSD.name,
-          palletId: inventory?.palletId,
-          cartonId: inventory?.cartonId,
-          batchId: inventory?.batchId,
-          batchIdRef: inventory?.batchIdRef,
-          product: inventory?.product,
-          qty: inventory?.qty,
-          releaseQty: targetInventory.releaseQty,
-          pickedQty: targetInventory.pickedQty,
-          status: pickingWSD.status,
-          description: pickingWSD.description,
-          targetName: targetInventory.name,
-          packingType: inventory?.packingType,
-          packingSize: inventory?.packingSize,
-          expirationDate: inventory?.expirationDate,
-          location: inventory?.location,
-          relatedOrderInv: targetInventory
-        }
-      })
+      relations: ['releaseGood', 'releaseGood.bizplace', 'releaseGood.bizplace.domain']
+    })
+
+    if (orderInventoryByBin?.releaseGood) {
+      releaseGoodNo = orderInventoryByBin.releaseGood.name
+      releaseGood = orderInventoryByBin.releaseGood
     }
   }
+
+  if (!releaseGood) throw new Error(`Couldn't find picking worksheet by order no (${releaseGoodNo})`)
+
+  const worksheet = await fetchExecutingWorksheet(
+    domain,
+    releaseGood.bizplace,
+    ['bizplace'],
+    WORKSHEET_TYPE.PICKING,
+    releaseGood,
+    tx
+  )
+
+  const qb: SelectQueryBuilder<WorksheetDetail> = tx.createQueryBuilder(WorksheetDetail, 'WSD')
+  qb.leftJoinAndSelect('WSD.targetInventory', 'T_INV')
+    .leftJoinAndSelect('T_INV.binLocation', 'BIN_LOC')
+    .leftJoinAndSelect('T_INV.inventory', 'INV')
+    .leftJoinAndSelect('T_INV.product', 'PROD')
+    .leftJoinAndSelect('INV.location', 'LOC')
+
+  if (locationSortingRules?.length > 0) {
+    locationSortingRules.forEach((rule: { name: string; desc: boolean }) => {
+      qb.addOrderBy(`LOC.${rule.name}`, rule.desc ? 'DESC' : 'ASC')
+    })
+  }
+
+  qb.addOrderBy(`PROD.name`, 'ASC')
+
+  const worksheetDetails: WorksheetDetail[] = await qb
+    .where('"WSD"."worksheet_id" = :worksheetId', { worksheetId: worksheet.id })
+    .andWhere('"WSD"."status" != :status', { status: WORKSHEET_STATUS.REPLACED })
+    .andWhere('"T_INV"."status" != :t_invstatus', { t_invstatus: ORDER_INVENTORY_STATUS.CANCELLED })
+    .getMany()
+
+  return {
+    worksheetInfo: {
+      bizplaceName: releaseGood.bizplace.name,
+      partnerDomainId: releaseGood.bizplace?.domain.id,
+      startedAt: worksheet.startedAt,
+      refNo: releaseGood.refNo,
+      refNo2: releaseGood.refNo2,
+      releaseGood
+    },
+    worksheetDetailInfos: worksheetDetails.map(async (pickingWSD: WorksheetDetail) => {
+      const targetInventory: OrderInventory = pickingWSD.targetInventory
+      const inventory: Inventory = targetInventory.inventory
+      return {
+        name: pickingWSD.name,
+        palletId: inventory?.palletId,
+        cartonId: inventory?.cartonId,
+        batchId: inventory?.batchId,
+        batchIdRef: inventory?.batchIdRef,
+        product: inventory?.product,
+        qty: inventory?.qty,
+        binLocation: targetInventory?.binLocation || '',
+        releaseQty: targetInventory.releaseQty,
+        pickedQty: targetInventory.pickedQty,
+        status: pickingWSD.status,
+        description: pickingWSD.description,
+        targetName: targetInventory.name,
+        packingType: inventory?.packingType,
+        packingSize: inventory?.packingSize,
+        expirationDate: inventory?.expirationDate,
+        location: inventory?.location,
+        relatedOrderInv: targetInventory
+      }
+    })
+  }
 }

package/server/graphql/resolvers/worksheet/unloading-return-worksheet.ts

@@ -1,10 +1,12 @@
+import { getRepository } from 'typeorm'
+
 import { Bizplace } from '@things-factory/biz-base'
+import { OrderInventory, ReturnOrder } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
-import { fetchExecutingWorksheet } from '../../../utils'
-import { ReturnOrder, OrderInventory } from '@things-factory/sales-base'
+
 import { WORKSHEET_TYPE } from '../../../constants'
 import { Worksheet, WorksheetDetail } from '../../../entities'
+import { fetchExecutingWorksheet } from '../../../utils'
 
 export const unloadingReturnWorksheetResolver = {
   async unloadingReturnWorksheet(_: any, { returnOrderNo }, context: any) {
@@ -59,7 +61,7 @@ export const unloadingReturnWorksheetResolver = {
           description: productWSD.description,
           targetName: targetInventory.name,
           packingType: targetInventory.packingType,
-          packingSize: targetInventory.packingSize,
+          packingSize: targetInventory.inventory.packingSize,
           palletQty: targetInventory.palletQty,
           actualPalletQty: targetInventory.actualPalletQty,
           packQty: targetInventory.returnQty,

package/server/graphql/types/worksheet/index.ts

@@ -290,6 +290,7 @@ export const Mutation = /* GraphQL */ `
     cartonId: String
     locationName: String!
     releaseQty: Int!
+    binLocation: String
   ): Boolean @privilege(category: "worksheet_execute", privilege: "mutation") @transaction
 
   scanProductPicking (
@@ -515,6 +516,9 @@ export const Mutation = /* GraphQL */ `
     worksheetId: String!
     userId: String!
   ): Boolean @privilege(category: "worksheet_control", privilege: "mutation") @transaction
+
+  fetchAndAssignPickingTask     
+  : ExecutingWorksheet @privilege(category: "worksheet_control", privilege: "mutation") @transaction
   
   palletizingPallets (
     refOrderNo: String!
@@ -588,7 +592,7 @@ export const Query = /* GraphQL */ `
 
   pickingWorksheet (
     releaseGoodNo: String!, locationSortingRules: [Sorting]
-  ): ExecutingWorksheet @privilege(category: "worksheet", privilege: "query")
+  ): ExecutingWorksheet @privilege(category: "worksheet", privilege: "query") @transaction
 
   sortingWorksheet (
     releaseGoodNo: String!

package/server/utils/inventory-util.ts

@@ -1,8 +1,4 @@
-import {
-  EntityManager,
-  getRepository,
-  Repository
-} from 'typeorm'
+import { EntityManager, getRepository, Repository } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
@@ -63,10 +59,36 @@ export async function generateInventoryHistory(
       palletId: inventory.palletId,
       seq: seq - 1
     })
+
     openingQty = lastInvHistory.openingQty + lastInvHistory.qty
     openingUomValue = lastInvHistory.openingUomValue + lastInvHistory.uomValue
   }
 
+  if (transactionType == 'PICKING' || transactionType == 'UNLOADING') {
+    const [findSameOrderHistory, total]: InventoryHistory = await invHistoryRepo.findAndCount({
+      domain: inventory.domain,
+      palletId: inventory.palletId,
+      refOrderId: refOrder.id
+    })
+
+    if (findSameOrderHistory) {
+      let prevTotalQty = 0
+      let prevTotalUomValue = 0
+      for (let oh of findSameOrderHistory) {
+        prevTotalQty += oh.qty
+        prevTotalUomValue += oh.uomValue
+      }
+      qty -= prevTotalQty
+      uomValue -= prevTotalUomValue
+    }
+  } else if (transactionType == 'UNDO_UNLOADING' || transactionType == 'RETURN') {
+    qty = qty
+    uomValue = uomValue
+  } else {
+    qty = 0
+    uomValue = 0
+  }
+
   let inventoryHistory: InventoryHistory = new InventoryHistory()
   inventoryHistory.name = InventoryNoGenerator.inventoryHistoryName()
   inventoryHistory.description = inventory.description
@@ -221,7 +243,7 @@ export async function checkPalletIdenticallity(
  * @param trxMgr
  */
 export async function inventoriesByStrategy(
-  { worksheetId, batchId, bizplaceId, productId, packingType, packingSize, pickingStrategy, locationSortingRules },
+  { worksheetId, batchId, bizplaceId, productId, packingType, packingSize, uom, pickingStrategy, locationSortingRules },
   domain: Domain,
   trxMgr: EntityManager
 ) {
@@ -248,12 +270,14 @@ export async function inventoriesByStrategy(
     .andWhere('"PROD"."id" = :productId')
     .andWhere('"INV"."packing_type" = :packingType')
     .andWhere('"INV"."packing_size" = :packingSize')
+    .andWhere('"INV"."uom" = :uom')
     .andWhere('"INV"."status" = :status', { status: 'STORED' })
     .setParameters({
       domainId: domain.id,
       productId,
       packingType,
-      packingSize
+      packingSize,
+      uom
     })
 
   if (batchId !== '') {