@things-factory/worksheet-base 5.0.0-alpha.50 → 5.0.0-alpha.53

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

@@ -1,3 +1,5 @@
+import { IsNull, In } from 'typeorm'
+
 import { VasWorksheetController } from '../vas/vas-worksheet-controller'
 import { Product, ProductDetail } from '@things-factory/product-base'
 import {
@@ -6,11 +8,22 @@ import {
   InventoryItem,
   INVENTORY_STATUS,
   InventoryNoGenerator,
-  INVENTORY_ITEM_SOURCE
+  INVENTORY_ITEM_SOURCE,
+  Tote,
+  TOTE_STATUS
 } from '@things-factory/warehouse-base'
-import { ReleaseGood, OrderInventory, ORDER_INVENTORY_STATUS, ORDER_STATUS } from '@things-factory/sales-base'
+import {
+  ReleaseGood,
+  OrderInventory,
+  ORDER_INVENTORY_STATUS,
+  ORDER_STATUS,
+  OrderTote,
+  OrderToteItem,
+  OrderNoGenerator
+} from '@things-factory/sales-base'
 import { Worksheet, WorksheetDetail } from '../../entities'
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../constants'
+import { temporaryGetRemainInventoryAmount } from 'server/graphql/resolvers/worksheet/vas-transactions/common-utils'
 
 export class SortingWorksheetController extends VasWorksheetController {
   async generateSortingWorksheet(
@@ -62,7 +75,8 @@ export class SortingWorksheetController extends VasWorksheetController {
     taskNo: string,
     releaseGoodNo: string,
     productBarcode: string,
-    serialNumber: string
+    serialNumber: string,
+    toteNo: string
   ): Promise<void> {
     const worksheet: Worksheet = await this.trxMgr.getRepository(Worksheet).findOne({
       where: {
@@ -75,6 +89,8 @@ export class SortingWorksheetController extends VasWorksheetController {
         'worksheetDetails',
         'worksheetDetails.targetInventory',
         'worksheetDetails.targetInventory.product',
+        'worksheetDetails.targetInventory.orderProduct',
+        'worksheetDetails.targetInventory.bizplace',
         'worksheetDetails.targetInventory.inventory',
         'worksheetDetails.targetInventory.inventory.product',
         'worksheetDetails.targetInventory.inventory.product.productDetails',
@@ -204,6 +220,17 @@ export class SortingWorksheetController extends VasWorksheetController {
               } else {
                 await this.updateOrderTargets([matchingOI])
               }
+
+              if (toteNo) {
+                await this.toteScanning(
+                  toteNo,
+                  matchingOI.orderProduct,
+                  matchingOI,
+                  1,
+                  releaseGood,
+                  matchingOI.bizplace
+                )
+              }
             }
           })
         )
@@ -216,7 +243,8 @@ export class SortingWorksheetController extends VasWorksheetController {
     releaseGoodNo: string,
     productId: string,
     sortingQty: number,
-    serialNumber: string
+    serialNumber: string,
+    toteNo: string
   ): Promise<void> {
     const worksheet: Worksheet = await this.trxMgr.getRepository(Worksheet).findOne({
       where: {
@@ -229,6 +257,8 @@ export class SortingWorksheetController extends VasWorksheetController {
         'worksheetDetails',
         'worksheetDetails.targetInventory',
         'worksheetDetails.targetInventory.product',
+        'worksheetDetails.targetInventory.orderProduct',
+        'worksheetDetails.targetInventory.bizplace',
         'worksheetDetails.targetInventory.inventory',
         'worksheetDetails.targetInventory.inventory.product',
         'worksheetDetails.targetInventory.inventory.product.productDetails',
@@ -294,6 +324,17 @@ export class SortingWorksheetController extends VasWorksheetController {
             }
           }
 
+          if (toteNo) {
+            await this.toteScanning(
+              toteNo,
+              matchingOI.orderProduct,
+              matchingOI,
+              sortingQty,
+              releaseGood,
+              matchingOI.bizplace
+            )
+          }
+
           if (releaseQty != matchingOI?.sortedQty && sortingQty != 0) {
             if (product?.isRequireSerialNumberScanningOutbound) {
               matchingOI.sortedQty += sortingQty
@@ -338,34 +379,50 @@ export class SortingWorksheetController extends VasWorksheetController {
   }
 
   async completeOrderSorting(releaseGoodNo: string): Promise<ReleaseGood> {
-    let releaseGood: ReleaseGood = await this.findRefOrder(
-      ReleaseGood,
-      {
-        domain: this.domain,
-        name: releaseGoodNo,
-        status: ORDER_STATUS.SORTING
-      },
-      ['bizplace', 'orderInventories']
-    )
+    try {
+      let releaseGood: ReleaseGood = await this.findRefOrder(
+        ReleaseGood,
+        {
+          domain: this.domain,
+          name: releaseGoodNo,
+          status: ORDER_STATUS.SORTING
+        },
+        ['bizplace', 'orderInventories']
+      )
 
-    releaseGood.status = ORDER_STATUS.READY_TO_LOAD
-    releaseGood.updater = this.user
-    await this.trxMgr.getRepository(ReleaseGood).save(releaseGood)
+      if (!releaseGood) {
+        throw new Error('Order is already sorted')
+      }
 
-    let inventoryItems: InventoryItem = await this.trxMgr
-      .getRepository(InventoryItem)
-      .find({ where: { outboundOrderId: releaseGood.id } })
+      const foundNotSealedOrderTote = await this.trxMgr
+        .getRepository(OrderTote)
+        .findOne({ where: { releaseGood, closedDate: IsNull() } })
 
-    if (inventoryItems.length > 0) {
-      inventoryItems.forEach((itm: InventoryItem) => {
-        itm.status = INVENTORY_STATUS.TERMINATED
-        itm.updater = this.user
-      })
+      if (foundNotSealedOrderTote) {
+        throw new Error('Please seal the tote(s) before proceeding')
+      }
 
-      await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
-    }
+      releaseGood.status = ORDER_STATUS.READY_TO_LOAD
+      releaseGood.updater = this.user
+      await this.trxMgr.getRepository(ReleaseGood).save(releaseGood)
+
+      let inventoryItems: InventoryItem = await this.trxMgr
+        .getRepository(InventoryItem)
+        .find({ where: { outboundOrderId: releaseGood.id } })
+
+      if (inventoryItems.length > 0) {
+        inventoryItems.forEach((itm: InventoryItem) => {
+          itm.status = INVENTORY_STATUS.TERMINATED
+          itm.updater = this.user
+        })
+
+        await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
+      }
 
-    return releaseGood
+      return releaseGood
+    } catch (e) {
+      throw e
+    }
   }
 
   async completeWorksheetSorting(taskNo: string): Promise<Worksheet> {
@@ -383,6 +440,16 @@ export class SortingWorksheetController extends VasWorksheetController {
       ]
     })
 
+    let releaseGoodIds = worksheet.worksheetDetails.map(itm => itm.targetInventory.releaseGood.id)
+
+    const foundNotSealedOrderTote = await this.trxMgr
+      .getRepository(OrderTote)
+      .findOne({ where: { releaseGood: In(releaseGoodIds), closedDate: IsNull() } })
+
+    if (foundNotSealedOrderTote) {
+      throw new Error('Please seal the tote(s) before proceeding')
+    }
+
     this.checkRecordValidity(worksheet, { status: WORKSHEET_STATUS.EXECUTING })
 
     const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
@@ -398,4 +465,77 @@ export class SortingWorksheetController extends VasWorksheetController {
 
     return worksheet
   }
+
+  private async toteScanning(toteNo, targetProduct, targetInventory, pickedQty, releaseGood, bizplace) {
+    //1. find tote
+    let foundTote: Tote = await this.trxMgr
+      .getRepository(Tote)
+      .findOne({ where: { bizplace, name: toteNo, deletedAt: IsNull() } })
+
+    if (foundTote?.status == TOTE_STATUS.DAMAGED) {
+      throw new Error('Tote is damaged')
+    }
+
+    if (foundTote?.status == TOTE_STATUS.DISPATCHED) {
+      throw new Error('Tote is dispatched')
+    }
+
+    //2. find order tote
+    let foundOrderTote: OrderTote = await this.trxMgr
+      .getRepository(OrderTote)
+      .findOne({ where: { domain: this.domain, name: toteNo, releaseGood } })
+
+    //if order tote not found the create one, if tote not found means it's tote box
+    //create order tote item
+    if (!foundOrderTote) {
+      const orderTote = await this.trxMgr.getRepository(OrderTote).save({
+        name: toteNo,
+        domain: this.domain,
+        releaseGood,
+        tote: foundTote ? foundTote : null,
+        updater: this.user
+      })
+
+      const orderToteItem = await this.trxMgr.getRepository(OrderToteItem).save({
+        domain: this.domain,
+        name: OrderNoGenerator.orderToteItem(),
+        orderProduct: targetProduct,
+        orderInventory: targetInventory,
+        orderTote,
+        qty: pickedQty,
+        updater: this.user
+      })
+    } else {
+      if (foundOrderTote.closedDate) {
+        throw new Error('Tote has been sealed, please try another tote!')
+      }
+
+      //if found order tote then check if order tote item exist
+      const foundOrderToteItem: OrderToteItem = await this.trxMgr.getRepository(OrderToteItem).findOne({
+        domain: this.domain,
+        orderProduct: targetProduct,
+        orderInventory: targetInventory,
+        orderTote: foundOrderTote
+      })
+
+      //if not order tote item doesnt exist then create one
+      if (!foundOrderToteItem) {
+        const orderToteItem = await this.trxMgr.getRepository(OrderToteItem).save({
+          domain: this.domain,
+          name: OrderNoGenerator.orderToteItem(),
+          orderProduct: targetProduct,
+          orderInventory: targetInventory,
+          orderTote: foundOrderTote,
+          qty: pickedQty,
+          updater: this.user
+        })
+      } else {
+        //if found order tote item found then add the quantity
+        const orderToteItem = await this.trxMgr.getRepository(OrderToteItem).save({
+          ...foundOrderToteItem,
+          qty: foundOrderToteItem.qty + pickedQty
+        })
+      }
+    }
+  }
 }

package/server/controllers/render-grn.ts

@@ -71,6 +71,7 @@ export async function renderGRN({ grnNo, timezoneOffSet }, context: any) {
     .addGroupBy('batch_id')
     .addGroupBy('packing_type')
     .addGroupBy('uom')
+    .addGroupBy('expiration_date')
     .getRawMany()
 
   // 5. find domain contact point
@@ -168,11 +169,9 @@ export async function renderGRN({ grnNo, timezoneOffSet }, context: any) {
   })
 
   tempIndexArr.forEach((t, index) => {
-    if (t >= 0)
-      foundInventoryItem[t].totalQuantity = tempTotalQuantity[index]
+    if (t >= 0) foundInventoryItem[t].totalQuantity = tempTotalQuantity[index]
   })
 
-
   const data = {
     logo_url: logo,
     sign_url: signature,
@@ -208,40 +207,50 @@ export async function renderGRN({ grnNo, timezoneOffSet }, context: any) {
     account_no: foundPartnerCP ? foundPartnerCP.accountNo : '',
     unloaded_by: foundWS ? foundWS.updater.name : '',
     putaway_by: foundPutawayWS ? foundPutawayWS.updater.name : '',
-    product_list: targetProducts.map((item, idx) => {
-      let unloadInvHistory = inboundInventories.find(
-        ih =>
-          ih.productId == item.product.id &&
-          ih.batchId == item.batchId &&
-          ih.packingType == item.packingType &&
-          ih.uom == item.uom
-      )
-
-      return {
-        list_no: idx + 1,
-        product_sku: `${item.product.sku}`,
-        product_brand_sku: `${item.product.brandSku}`,
-        product_name: `${item.product.name}(${item.product.description})`,
-        product_desc: item.product.description,
-        product_nameOnly: item.product.name,
-        product_type: item.packingType,
-        product_size: item.packingSize,
-        product_batch: item.batchId,
-        batch_id_ref: item?.batchIdRef ? item.batchIdRef : '',
-        pallet_qty: item.actualPalletQty,
-        product_qty: unloadInvHistory.qty || item.actualPackQty,
-        product_unit_uom_value: `${Math.round(item.uomValue * 100) / 100}`,
-        product_total_uom_value: `${Math.round((unloadInvHistory.uomValue || item.uomValue * item.actualPackQty) * 100) / 100
-          }`,
-        product_uom: `${unloadInvHistory.uom || item.uom}`,
-        product_gross_weight: item.product.grossWeight || null,
-        unit_price: item.unitPrice || null,
-        expiry_date: unloadInvHistory.expiryDate || '',
-        manufacture_date: item.manufactureDate,
-        reusable_pallet_id: unloadInvHistory.reusablePalletId || '',
-        remark: (item.remark ? item.remark : '') + (item.issue ? ' [Issue]: ' + item.issue : '')
-      }
-    }),
+    product_list: targetProducts
+      .reduce((acc, item) => {
+        acc.push(
+          ...inboundInventories
+            .filter(
+              ih =>
+                ih.productId == item.product.id &&
+                ih.batchId == item.batchId &&
+                ih.packingType == item.packingType &&
+                ih.uom == item.uom
+            )
+            .map(unloadInvHistory => {
+              return {
+                product_sku: `${item.product.sku}`,
+                product_brand_sku: `${item.product.brandSku}`,
+                product_name: `${item.product.name}(${item.product.description})`,
+                product_desc: item.product.description,
+                product_nameOnly: item.product.name,
+                product_type: item.packingType,
+                product_size: item.packingSize,
+                product_batch: item.batchId,
+                batch_id_ref: item?.batchIdRef ? item.batchIdRef : '',
+                pallet_qty: item.actualPalletQty,
+                product_qty: unloadInvHistory.qty || item.actualPackQty,
+                product_unit_uom_value: `${Math.round(item.uomValue * 100) / 100}`,
+                product_total_uom_value: `${
+                  Math.round((unloadInvHistory.uomValue || item.uomValue * item.actualPackQty) * 100) / 100
+                }`,
+                product_uom: `${unloadInvHistory.uom || item.uom}`,
+                product_gross_weight: item.product.grossWeight || null,
+                unit_price: item.unitPrice || null,
+                expiry_date:
+                  unloadInvHistory.expiryDate && unloadInvHistory.expiryDate != ''
+                    ? new Date(unloadInvHistory.expiryDate).toISOString().split('T')[0]
+                    : '',
+                manufacture_date: item.manufactureDate,
+                reusable_pallet_id: unloadInvHistory.reusablePalletId || '',
+                remark: (item.remark ? item.remark : '') + (item.issue ? ' [Issue]: ' + item.issue : '')
+              }
+            })
+        )
+        return acc
+      }, [])
+      .map((item, idx) => ({ list_no: idx + 1, ...item })),
     serialNumber: foundInventoryItem
   }
 

package/server/controllers/render-manifest.ts

@@ -6,6 +6,7 @@ import { Attachment, STORAGE } from '@things-factory/attachment-base'
 import { config } from '@things-factory/env'
 import { Manifest, ReleaseGood } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
+import { Bizplace, getCompanyBizplace } from '@things-factory/biz-base'
 
 import { TEMPLATE_TYPE } from '../constants'
 import { DateTimeConverter } from '../utils/datetime-util'
@@ -25,8 +26,9 @@ export async function renderManifest({ manifestNo }, context: any) {
   })
 
   // find release good
-  const releaseGoods: ReleaseGood[] = await getRepository(ReleaseGood).find({
-    where: { domain, manifest }
+  let releaseGoods: ReleaseGood[] = await getRepository(ReleaseGood).find({
+    where: { domain, manifest },
+    relations: ['bizplace']
   })
 
   // 7. find grn template based on category
@@ -41,7 +43,9 @@ export async function renderManifest({ manifestNo }, context: any) {
     manifest_no: manifest?.name,
     manifest_date: DateTimeConverter.date(manifest?.createdAt).toString(),
     total_list: releaseGoods?.length || 0,
-    product_list: releaseGoods.map((item, idx) => {
+    product_list: await Promise.all (releaseGoods.map(async(item, idx) => {
+      const customerBizplaceId: string = item.bizplace.id
+      const custCompanyBizplace: Bizplace = await getCompanyBizplace(null, null, customerBizplaceId)
       return {
         list_no: idx + 1,
         order_no: item?.refNo,
@@ -50,9 +54,12 @@ export async function renderManifest({ manifestNo }, context: any) {
         delivery_date: DateTimeConverter.date(manifest?.dispatchedAt).toString(),
         attention_to: item?.attentionTo,
         delivery_address: item?.deliveryAddress1,
-        postal_code_city: `${item?.postalCode}, ${item?.city}`
+        postal_code_city: `${item?.postalCode}, ${item?.city}`,
+        remark: item?.remark,
+        status: item?.status,
+        company_domain_name: custCompanyBizplace.domain.name
       }
-    })
+    }))
   }
 
   const formData = new FormData()

package/server/controllers/worksheet-controller.ts

@@ -300,7 +300,7 @@ export class WorksheetController {
 
   /**
    * @summary find worksheet detail by passed condition
-   * @description find worksheey based on passed condition
+   * @description find worksheet detail based on passed condition
    * If you want to get additional relations you need to define reltaions
    * ex) findWorksheetDetail(condition, ['worksheet'])
    */
@@ -390,6 +390,19 @@ export class WorksheetController {
     let refOrderType: string = await this.getRefOrderField(refOrder)
     const bizplace: Bizplace = await this.extractBizplaceFromRefOrder(refOrder)
 
+    let existingWorksheet: Worksheet
+    try {
+      existingWorksheet = await this.findWorksheetByRefOrder(refOrder, type)
+    } catch (e) {}
+
+    if (existingWorksheet)
+      throw new Error(
+        this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY(
+          `create ${type.toLocaleLowerCase()} worksheet`,
+          'existing worksheet is found'
+        )
+      )
+
     const worksheet: Partial<Worksheet> = {
       domain: this.domain,
       bizplace,

package/server/entities/index.ts

@@ -1,7 +1,8 @@
 import { Worksheet } from './worksheet'
 import { WorksheetDetail } from './worksheet-detail'
 import { WorksheetMovement } from './worksheet-movement'
+import { WarehouseBizplaceOnhandInventory } from './warehouse-bizplace-onhand-inventory'
 
-export const entities = [Worksheet, WorksheetDetail, WorksheetMovement]
+export const entities = [Worksheet, WorksheetDetail, WorksheetMovement, WarehouseBizplaceOnhandInventory]
 
 export { Worksheet, WorksheetDetail, WorksheetMovement }

package/server/entities/warehouse-bizplace-onhand-inventory.ts

@@ -0,0 +1,147 @@
+import { ViewColumn, ViewEntity } from 'typeorm'
+
+@ViewEntity({
+  expression: `  
+  select d.name as "domainName", b.name as "bizplaceName", src.* from (
+    WITH oi as (
+      select
+        oi.domain_id,
+        oi.bizplace_id,
+        SUM(oi.release_qty) AS release_qty,
+        SUM(oi.release_uom_value) AS release_uom_value,
+        oi.batch_id,
+        oi.batch_id_ref,
+        oi.product_id,
+        oi.packing_type,
+        oi.packing_size,
+        oi.uom
+      FROM
+        order_inventories oi
+      WHERE
+        (oi.status = 'PENDING' or oi.status = 'PENDING_RECEIVE' or oi.status = 'PENDING_WORKSHEET' or oi.status = 'PENDING_SPLIT')
+        AND oi.batch_id NOTNULL
+        AND oi.product_id NOTNULL
+        AND oi.packing_type NOTNULL
+        AND oi.packing_size NOTNULL
+        AND oi.inventory_id IS NULL
+      GROUP BY
+        oi.domain_id,
+        oi.bizplace_id,
+        oi.batch_id,
+        oi.batch_id_ref,
+        oi.product_id,
+        oi.packing_type,
+        oi.packing_size,
+        oi.uom
+    ) 
+    -- SINGLE ITEM INVENTORY QUERY
+    select
+    i.domain_id as "domainId",
+    i.bizplace_id as "bizplaceId",
+    i.packing_type as "packingType",
+    i.packing_size as "packingSize",
+    i.uom,
+    i.product_id as "productId",
+    null as "productBundleId",
+    COALESCE(SUM(COALESCE(i.qty, 0)) - SUM(COALESCE(i.locked_qty, 0)) - MAX(COALESCE(oi.release_qty, 0))) AS "remainQty",
+    COALESCE(SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0)), 0) AS "remainUomValue",
+    COALESCE(sum(COALESCE(i.qty, 0::double precision))) AS "qty",
+    COALESCE(sum(COALESCE(i.uom_value, 0::double precision))) AS "uomValue",
+    'SINGLE' AS "groupType"
+    FROM inventories i
+    INNER JOIN locations l2 ON i.location_id = l2.id AND i.domain_id = l2.domain_id AND l2.type NOT IN ('QUARANTINE', 'RESERVE')
+    LEFT JOIN oi ON i.batch_id = oi.batch_id AND i.product_id = oi.product_id AND i.packing_type = oi.packing_type AND i.packing_size = oi.packing_size AND i.uom = oi.uom
+    WHERE i.status = 'STORED'
+    GROUP by
+      i.domain_id,
+      i.bizplace_id,
+      i.product_id,
+      i.packing_type,
+      i.packing_size,
+      i.uom
+    union all
+    -- BUNDLE ITEM INVENTORY QUERY
+    SELECT 
+    pbs.domain_id as "domainId",
+    pbs.bizplace_id as "bizplaceId",
+    pb.packing_type as "packingType", 
+    pb.packing_size as "packingSize",
+    'UNIT' AS "uom", 
+    null as "productId",
+    pb.id AS "productBundleId",
+    COALESCE(MIN(FLOOR(pbs."availableQty")),0) AS "remainQty", 
+    COALESCE(MIN(FLOOR(pbs."availableUomValue")),0) AS "remainUomValue",
+    COALESCE(MIN(FLOOR(pbs."qty")), 0::double precision) AS "qty",
+    COALESCE(MIN(FLOOR(pbs."uomValue")), 0::double precision) AS "uomValue",
+    'BUNDLE' AS "groupType"
+    FROM product_bundles pb
+    INNER JOIN (
+      SELECT i.domain_id, i.bizplace_id, pbs.product_id, pbs.product_bundle_id, min(pbs.bundle_qty),
+      (SUM(COALESCE(i.qty, 0)) - SUM(COALESCE(i.locked_qty, 0)) - MAX(COALESCE(oi.release_qty, 0))) / min(pbs.bundle_qty) AS "availableQty",
+      (SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0))) / min(pbs.bundle_qty)  AS "availableUomValue",
+      (sum(COALESCE(i.qty, 0::double precision))) / min(pbs.bundle_qty)::double precision AS "qty",
+      (sum(COALESCE(i.uom_value, 0::double precision))) / min(pbs.bundle_qty)::double precision AS "uomValue"
+      FROM product_bundle_settings pbs 
+      LEFT JOIN inventories i ON i.product_id = pbs.product_id AND i.status = 'STORED'
+      INNER JOIN locations l ON i.location_id = l.id AND i.domain_id = l.domain_id AND l.type NOT IN ('QUARANTINE', 'RESERVE')    
+      LEFT JOIN oi ON oi.product_id = i.product_id
+      GROUP by
+        i.domain_id, 
+        i.bizplace_id,
+        pbs.product_id, 
+        pbs.product_bundle_id
+    ) pbs ON pbs.product_bundle_id = pb.id
+    GROUP BY 
+    pbs.domain_id,
+    pbs.bizplace_id,
+    pb.packing_type, 
+    pb.packing_size, 
+    pb.name, 
+    pb.sku, 
+    pb.id
+  )
+  AS src 
+  inner join domains d on d.id = src."domainId"
+  inner join bizplaces b on b.id = src."bizplaceId"
+  where src."remainQty" > 0
+  order by src."domainId"
+  `
+})
+
+export class WarehouseBizplaceOnhandInventory {
+  @ViewColumn()
+  domainName: string
+
+  @ViewColumn()
+  bizplaceName: string
+
+  @ViewColumn()
+  domainId: string
+
+  @ViewColumn()
+  bizplaceId: string
+
+  @ViewColumn()
+  packingType: string
+
+  @ViewColumn()
+  packingSize: number
+
+  @ViewColumn()
+  uom: string
+
+  @ViewColumn()
+  productId: string
+
+  @ViewColumn()
+  productBundleId: string
+
+  @ViewColumn()
+  remainQty: number
+
+  @ViewColumn()
+  remainUomValue: number
+
+  @ViewColumn()
+  groupType: string
+}

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

@@ -3,6 +3,7 @@ import { getRepository, SelectQueryBuilder } from 'typeorm'
 import { ORDER_INVENTORY_STATUS } from '@things-factory/sales-base'
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
 import { Worksheet, WorksheetDetail } from '../../../entities'
+import { InventoryChange } from '@things-factory/warehouse-base'
 
 export const batchPickingWorksheetResolver = {
   async batchPickingWorksheet(_: any, { taskNo, locationSortingRules }, context: any) {
@@ -42,6 +43,7 @@ export const batchPickingWorksheetResolver = {
       .addSelect('LOC.column', 'column')
       .addSelect('LOC.shelf', 'shelf')
       .addSelect('BIN_LOC.name', 'binLocationName')
+      .addSelect('WSD.status', 'status')
       .leftJoin('WSD.targetInventory', 'T_INV')
       .leftJoin('T_INV.inventory', 'INV')
       .leftJoin('T_INV.product', 'PROD')
@@ -70,6 +72,7 @@ export const batchPickingWorksheetResolver = {
       .addGroupBy('LOC.column')
       .addGroupBy('LOC.row')
       .addGroupBy('LOC.shelf')
+      .addGroupBy('WSD.status')
 
     if (locationSortingRules?.length > 0) {
       locationSortingRules.forEach((rule: { name: string; desc: boolean }) => {
@@ -86,6 +89,15 @@ export const batchPickingWorksheetResolver = {
         partnerDomainId: worksheet.bizplace?.domain.id
       },
       worksheetDetailInfos: items.map(async (item: any) => {
+        const inventoryChangesCount: number = await getRepository(InventoryChange).count({
+          where: {
+            inventory: item.inventoryId,
+            status: 'PENDING',
+            transactionType: 'MISSING'
+          },
+          relations: ['inventory', 'product']
+        })
+
         return {
           palletId: item?.palletId,
           cartonId: item?.cartonId,
@@ -98,6 +110,8 @@ export const batchPickingWorksheetResolver = {
           },
           qty: item?.qty,
           releaseQty: item.releaseQty,
+          hasMissingInventoryChanges: inventoryChangesCount > 0 ? true : false,
+          status: item.status,
           pickedQty: item.pickedQty,
           packingType: item?.packingType,
           packingSize: item?.packingSize,