@things-factory/worksheet-base 4.3.0-alpha.1 → 4.3.0

package/server/controllers/render-fm-grn.ts

@@ -0,0 +1,266 @@
+import FormData from 'form-data'
+import _ from 'lodash'
+import fetch from 'node-fetch'
+import { getRepository, IsNull, Not } from 'typeorm'
+
+import { Attachment, STORAGE } from '@things-factory/attachment-base'
+import { Partner } from '@things-factory/auth-base'
+import { Bizplace, ContactPoint } from '@things-factory/biz-base'
+import { config } from '@things-factory/env'
+import { ArrivalNotice, GoodsReceivalNote, ORDER_STATUS, OrderProduct } from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+import { InventoryItem, ReducedInventoryHistory } from '@things-factory/warehouse-base'
+
+import { TEMPLATE_TYPE, WORKSHEET_TYPE } from '../constants'
+import { Worksheet } from '../entities'
+import { DateTimeConverter } from '../utils/datetime-util'
+
+const REPORT_API_URL = config.get('reportApiUrl', 'http://localhost:8888/rest/report/show_html')
+
+export async function renderFmGRN({ grnNo, timezoneOffSet }, context: any) {
+  // 1. find domain
+  const domain: Domain = await getRepository(Domain).findOne({
+    where: { id: context.state.domain.id }
+  })
+
+  // 2. find grn
+  const foundGRN: GoodsReceivalNote = await getRepository(GoodsReceivalNote).findOne({
+    where: { domain, name: grnNo },
+    relations: ['domain', 'bizplace', 'bizplace.domain', 'bizplace.company', 'arrivalNotice']
+  })
+
+  // 3. find GAN
+  const foundGAN: ArrivalNotice = foundGRN.arrivalNotice
+  const ownRefNo = foundGAN.refNo
+
+  const foundInventoryItem: InventoryItem[] = await getRepository(InventoryItem).query(
+    `select row_number() over (partition by p.sku) as "seq",p.sku,p.brand_sku, ii.serial_number from inventory_items ii left join products p on ii.product_id = p.id where inbound_order_id = '${foundGAN.id}' group by p.sku,ii.serial_number,p.brand_sku`
+  )
+
+  // 4. find customer bizplace
+  const partnerBiz: Bizplace = foundGRN.bizplace
+
+  const partnerDomain: Partner = await getRepository(Partner).findOne({
+    where: { partnerDomain: partnerBiz.domain, domain },
+    relations: ['domain']
+  })
+
+  const domainOwner: Domain = partnerDomain.domain
+  const domainBizplace: Bizplace = await getRepository(Bizplace).findOne({
+    where: { domain: domainOwner },
+    relations: ['company']
+  })
+
+  const qbReducedInventory = getRepository(ReducedInventoryHistory)
+    .createQueryBuilder('ivh')
+    .select('product_id', 'productId')
+    .addSelect('batch_id', 'batchId')
+    .addSelect('reusable_pallet_id', 'reusablePalletId')
+    .addSelect('packing_type', 'packingType')
+    .addSelect('sum(qty)', 'qty')
+    .addSelect('sum(uom_value)', 'uomValue')
+    .addSelect('uom', 'uom')
+    .addSelect('expiration_date', 'expiryDate')
+    .addSelect('count(distinct pallet_id)', 'pallet')
+    .addSelect(`string_agg(distinct pallet_id::varchar,', ' order by pallet_id::varchar)`, 'palletId')
+    .where('ivh.domain_id = :domainId', { domainId: domain.id })
+    .andWhere('ivh.ref_order_id = :refOrderId', { refOrderId: foundGAN.id })
+    .andWhere(`ivh.transaction_type = 'UNLOADING'`)
+    .groupBy('reusable_pallet_id')
+    .addGroupBy('product_id')
+    .addGroupBy('batch_id')
+    .addGroupBy('packing_type')
+    .addGroupBy('uom')
+    .addGroupBy('expiration_date')
+    .getRawMany()
+
+  // 5. find domain contact point
+  const foundCP: ContactPoint = await getRepository(ContactPoint).findOne({
+    where: { domain, bizplace: domainBizplace }
+  })
+
+  // 5. find domain contact point
+  const foundPartnerCP: ContactPoint = await getRepository(ContactPoint).findOne({
+    where: { domain, bizplace: partnerBiz }
+  })
+
+  // 6. find unloading worksheet
+  const foundWS: Worksheet = await getRepository(Worksheet).findOne({
+    where: { domain, arrivalNotice: foundGAN, type: WORKSHEET_TYPE.UNLOADING, status: ORDER_STATUS.DONE },
+    relations: ['worksheetDetails', 'updater']
+  })
+
+  // find putaway worksheet
+  const foundPutawayWS: Worksheet = await getRepository(Worksheet).findOne({
+    where: { domain, arrivalNotice: foundGAN, type: WORKSHEET_TYPE.PUTAWAY, status: ORDER_STATUS.DONE },
+    relations: ['worksheetDetails', 'updater']
+  })
+
+  const targetProducts: OrderProduct[] = await getRepository(OrderProduct).find({
+    where: { domain, arrivalNotice: foundGAN, actualPalletQty: Not(IsNull()), actualPackQty: Not(IsNull()) },
+    relations: ['product']
+  })
+
+  // 7. find grn template based on category
+  const foundTemplate: Attachment = await getRepository(Attachment).findOne({
+    where: { domain, category: TEMPLATE_TYPE.GRN_TEMPLATE }
+  })
+
+  // 8. find grn logo
+  const foundLogo: Attachment = await getRepository(Attachment).findOne({
+    where: {
+      domain,
+      category: TEMPLATE_TYPE.LOGO
+    }
+  })
+
+  // 9. find signature
+  const foundSignature: Attachment = await getRepository(Attachment).findOne({
+    where: {
+      domain,
+      category: TEMPLATE_TYPE.SIGNATURE
+    }
+  })
+
+  const foundCop: Attachment = await getRepository(Attachment).findOne({
+    where: {
+      domain,
+      category: TEMPLATE_TYPE.COP
+    }
+  })
+
+  const inboundInventories: any[] = await qbReducedInventory
+
+  const template = await STORAGE.readFile(foundTemplate.path, 'utf-8')
+
+  let logo = null
+  if (foundLogo?.path) {
+    logo = 'data:' + foundLogo.mimetype + ';base64,' + (await STORAGE.readFile(foundLogo.path, 'base64'))
+  }
+
+  let signature = null
+  if (foundSignature?.path) {
+    signature = 'data:' + foundSignature.mimetype + ';base64,' + (await STORAGE.readFile(foundSignature.path, 'base64'))
+  }
+
+  let cop = null
+  if (foundCop?.path) {
+    cop = 'data:' + foundSignature.mimetype + ';base64,' + (await STORAGE.readFile(foundCop.path, 'base64'))
+  }
+
+  const filterInventoryItem = _.groupBy(foundInventoryItem, i => i.sku)
+
+  const tempIndexArr = []
+
+  const tempTotalQuantity = []
+
+  Object.keys(filterInventoryItem).forEach(k => {
+    const tempIndex = foundInventoryItem.findIndex(i => {
+      return i.sku == k
+    })
+
+    tempIndexArr.push(tempIndex)
+  })
+
+  Object.values(filterInventoryItem).forEach(k => {
+    const tempQuantity = k.length
+
+    tempTotalQuantity.push(tempQuantity)
+  })
+
+  tempIndexArr.forEach((t, index) => {
+    if (t >= 0) foundInventoryItem[t].totalQuantity = tempTotalQuantity[index]
+  })
+
+  const data = {
+    logo_url: logo,
+    sign_url: signature,
+    cop_url: cop,
+    customer_biz: partnerBiz.name,
+    customer_address: partnerBiz.address,
+    company_domain: domainBizplace.company.name,
+    company_phone: foundCP.phone,
+    company_email: foundCP.email,
+    company_brn: domainBizplace.company.brn,
+    company_address: domainBizplace.company.address,
+    warehouse_address: foundCP.address,
+    warehouse_address2: foundCP.address2,
+    warehouse_postcode: foundCP.postCode,
+    warehouse_city: foundCP.city,
+    warehouse_state: foundCP.state,
+    warehouse_phone: foundCP.phone,
+    warehouse_fax: foundCP.fax,
+    warehouse_email: foundCP.email,
+    order_no: foundGRN.name,
+    gan_no: foundGAN.name,
+    gan_accepted_at: foundGAN.acceptedAt ? DateTimeConverter.datetime(foundGAN.acceptedAt, timezoneOffSet) : '',
+    unload_date: DateTimeConverter.date(foundWS.endedAt),
+    ref_no: ownRefNo ? `${foundGAN.name} / ${foundGAN.refNo}` : `${foundGAN.name}`,
+    ref_no_only: ownRefNo ? ` ${foundGAN.refNo}` : '',
+    ref_no1: foundGAN.refNo2 ? `${foundGAN.refNo2}` : '',
+    ref_no2: foundGAN.refNo3 ? `${foundGAN.refNo3}` : '',
+    received_date: DateTimeConverter.date(foundWS.endedAt),
+    truck_no: foundGAN.truckNo || '',
+    container_no: foundGAN.containerNo || '',
+    container_size: foundGAN.containerSize || '',
+    delivery_order_no: foundGAN.deliveryOrderNo ? foundGAN.deliveryOrderNo : '',
+    account_no: foundPartnerCP ? foundPartnerCP.accountNo : '',
+    unloaded_by: foundWS ? foundWS.updater.name : '',
+    putaway_by: foundPutawayWS ? foundPutawayWS.updater.name : '',
+    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_pack_qty: item.packQty,
+                descrepancy_qty: (unloadInvHistory.qty || item.actualPackQty) - item.packQty,
+                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
+  }
+
+  const formData = new FormData()
+  formData.append('template', template)
+  formData.append('jsonString', JSON.stringify(data))
+
+  const response = await fetch(REPORT_API_URL, {
+    method: 'POST',
+    body: formData
+  })
+
+  return await response.text()
+}

package/server/controllers/render-grn.ts

@@ -52,25 +52,25 @@ export async function renderGRN({ grnNo, timezoneOffSet }, context: any) {
   })
 
   const qbReducedInventory = getRepository(ReducedInventoryHistory)
-    .createQueryBuilder(`ivh`)
-    .select(`product_id`, `productId`)
-    .addSelect(`batch_id`, `batchId`)
-    .addSelect(`reusable_pallet_id`, `reusablePalletId`)
-    .addSelect(`packing_type`, `packingType`)
-    .addSelect(`sum(qty)`, `qty`)
-    .addSelect(`sum(uom_value)`, `uomValue`)
-    .addSelect(`uom`, `uom`)
-    .addSelect(`count(distinct pallet_id)`, `pallet`)
-    .addSelect(`string_agg(distinct expiration_date::varchar,', ' order by expiration_date::varchar)`, `expiryDate`)
-    .addSelect(`string_agg(distinct pallet_id::varchar,', ' order by pallet_id::varchar)`, `palletId`)
-    .where(`ivh.domain_id = :domainId`, { domainId: domain.id })
-    .andWhere(`ivh.ref_order_id = :refOrderId`, { refOrderId: foundGAN.id })
+    .createQueryBuilder('ivh')
+    .select('product_id', 'productId')
+    .addSelect('batch_id', 'batchId')
+    .addSelect('reusable_pallet_id', 'reusablePalletId')
+    .addSelect('packing_type', 'packingType')
+    .addSelect('sum(qty)', 'qty')
+    .addSelect('sum(uom_value)', 'uomValue')
+    .addSelect('uom', 'uom')
+    .addSelect('count(distinct pallet_id)', 'pallet')
+    .addSelect(`string_agg(distinct expiration_date::varchar,', ' order by expiration_date::varchar)`, 'expiryDate')
+    .addSelect(`string_agg(distinct pallet_id::varchar,', ' order by pallet_id::varchar)`, 'palletId')
+    .where('ivh.domain_id = :domainId', { domainId: domain.id })
+    .andWhere('ivh.ref_order_id = :refOrderId', { refOrderId: foundGAN.id })
     .andWhere(`ivh.transaction_type = 'UNLOADING'`)
-    .groupBy(`reusable_pallet_id`)
-    .addGroupBy(`product_id`)
-    .addGroupBy(`batch_id`)
-    .addGroupBy(`packing_type`)
-    .addGroupBy(`uom`)
+    .groupBy('reusable_pallet_id')
+    .addGroupBy('product_id')
+    .addGroupBy('batch_id')
+    .addGroupBy('packing_type')
+    .addGroupBy('uom')
     .getRawMany()
 
   // 5. find domain contact point

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,

package/server/graphql/resolvers/worksheet/loading/loading.ts

@@ -9,7 +9,7 @@ import { WorksheetDetail } from '../../../../entities'
 export const loadingResolver = {
   async loading(_: any, { loadedWorksheetDetails, releaseGoodNo, orderInfo }, context: any) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    await loading(tx, domain, user, loadedWorksheetDetails, releaseGoodNo)
+    const worksheetDetails = await loading(tx, domain, user, loadedWorksheetDetails, releaseGoodNo)
     const worksheetController: WorksheetController = new WorksheetController(tx, domain, user)
     const releaseGood: ReleaseGood = await worksheetController.findRefOrder(
       ReleaseGood,
@@ -18,14 +18,7 @@ export const loadingResolver = {
     )
 
     const loadingWorksheetController: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
-    let targetInventories: OrderInventory[] = []
-    for (let worksheetDetail of loadedWorksheetDetails) {
-      worksheetDetail = await loadingWorksheetController.findWorksheetDetailByName(worksheetDetail.name, [
-        'targetInventory'
-      ])
-      const targetInventory = worksheetDetail.targetInventory
-      targetInventories.push(targetInventory)
-    }
+    let targetInventories: OrderInventory[] = worksheetDetails.map(itm => itm.targetInventory)
 
     const bizplace: Bizplace = releaseGood.bizplace
     orderInfo = {
@@ -41,9 +34,9 @@ export async function loading(
   tx: EntityManager,
   domain: Domain,
   user: User,
-  worksheetDetails: Partial<WorksheetDetail & { loadedQty: number }>[],
+  worksheetDetails: Partial<WorksheetDetail & { loadedQty: number } & { toteName: string }>[],
   releaseGoodNo: string
-): Promise<void> {
+): Promise<any> {
   const worksheetController: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
-  await worksheetController.loading(releaseGoodNo, worksheetDetails)
+  return await worksheetController.loading(releaseGoodNo, worksheetDetails)
 }

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

@@ -1,6 +1,13 @@
 import { Equal, getRepository, In, Not, SelectQueryBuilder } from 'typeorm'
 
-import { ORDER_STATUS, ORDER_INVENTORY_STATUS, OrderInventory, ReleaseGood } from '@things-factory/sales-base'
+import {
+  ORDER_STATUS,
+  ORDER_INVENTORY_STATUS,
+  OrderInventory,
+  ReleaseGood,
+  OrderTote,
+  OrderToteItem
+} from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory, Location } from '@things-factory/warehouse-base'
 
@@ -27,7 +34,9 @@ export const loadingWorksheetResolver = {
         .innerJoinAndSelect('releaseGood.bizplace', 'bizplace')
         .innerJoinAndSelect('bizplace.domain', 'domain')
         .where('orderInventory.domain_id = :domainId', { domainId: domain.id })
-        .andWhere('orderInventory.status IN (:...orderInventoryStatus)', { orderInventoryStatus: [ORDER_INVENTORY_STATUS.LOADING, ORDER_INVENTORY_STATUS.LOADED] })
+        .andWhere('orderInventory.status IN (:...orderInventoryStatus)', {
+          orderInventoryStatus: [ORDER_INVENTORY_STATUS.LOADING, ORDER_INVENTORY_STATUS.LOADED]
+        })
         .andWhere('orderInventory.bin_location_id = :locationId', { locationId: binLocation.id })
         .andWhere('releaseGood.status = :status', { status: ORDER_STATUS.LOADING })
 
@@ -41,6 +50,10 @@ export const loadingWorksheetResolver = {
 
     if (!releaseGood) throw new Error(`Release good doesn't exists.`)
 
+    let [orderTotes, orderTotesTotal]: OrderTote = await getRepository(OrderTote).findAndCount({
+      where: { releaseGood: releaseGood.id }
+    })
+
     const foundWorksheet: Worksheet = await fetchExecutingWorksheet(
       domain,
       releaseGood.bizplace,
@@ -48,7 +61,7 @@ export const loadingWorksheetResolver = {
       WORKSHEET_TYPE.LOADING,
       releaseGood
     )
-    const foundWSD: WorksheetDetail[] = await getRepository(WorksheetDetail).find({
+    let foundWSD: any[] = await getRepository(WorksheetDetail).find({
       where: {
         domain,
         worksheet: foundWorksheet,
@@ -57,21 +70,50 @@ export const loadingWorksheetResolver = {
       },
       relations: [
         'targetInventory',
+        'targetInventory.orderProduct',
         'targetInventory.inventory',
         'targetInventory.inventory.location',
         'targetInventory.inventory.product'
       ]
     })
 
-    return {
-      worksheetInfo: {
-        releaseGood,
-        bizplaceName: releaseGood.bizplace.name,
-        startedAt: foundWorksheet.startedAt,
-        refNo: releaseGood.refNo,
-        ownCollection: releaseGood.ownTransport
-      },
-      worksheetDetailInfos: foundWSD.map(async (loadingWSD: WorksheetDetail) => {
+    if (orderTotesTotal > 0) {
+      let [toteItems, toteItemsTotal]: OrderToteItem = await getRepository(OrderToteItem).findAndCount({
+        where: { orderTote: In(orderTotes.map(itm => itm.id)) },
+        relations: ['orderTote', 'orderInventory']
+      })
+
+      let toteWsd = []
+
+      for (let i = 0; i < toteItemsTotal; i++) {
+        let wsdIndex = foundWSD.findIndex(
+          itm => !itm?.toteName && itm.targetInventory.id == toteItems[i].orderInventory.id
+        )
+
+        if (wsdIndex >= 0) {
+          let filterWSD: any = JSON.parse(JSON.stringify(foundWSD[wsdIndex]))
+          let uomValue =
+            Math.round((filterWSD.targetInventory.releaseUomValue / filterWSD.targetInventory.releaseQty) * 100) / 100
+
+          foundWSD[wsdIndex].targetInventory.releaseQty -= toteItems[i].qty
+          foundWSD[wsdIndex].targetInventory.pickedQty -= toteItems[i].qty
+          foundWSD[wsdIndex].targetInventory.releaseUomValue = foundWSD[wsdIndex].targetInventory.releaseQty * uomValue
+
+          filterWSD.targetInventory.releaseQty = toteItems[i].qty
+          filterWSD.targetInventory.pickedQty = toteItems[i].qty
+          filterWSD.targetInventory.releaseUomValue = toteItems[i].qty * uomValue
+          filterWSD.toteName = toteItems[i].orderTote.name
+          toteWsd.push(filterWSD)
+        }
+      }
+
+      foundWSD = foundWSD.concat(toteWsd)
+      foundWSD.sort((a, b) => (a.toteName > b.toteName ? 1 : -1))
+    }
+
+    let worksheetDetailInfos = foundWSD
+      .filter(itm => itm.targetInventory.releaseQty > 0)
+      .map((loadingWSD: any) => {
         const targetInventory: OrderInventory = loadingWSD.targetInventory
         const inventory: Inventory = targetInventory.inventory
         return {
@@ -87,9 +129,20 @@ export const loadingWorksheetResolver = {
           targetName: targetInventory.name,
           packingType: inventory.packingType,
           packingSize: inventory.packingSize,
-          inventory: targetInventory.inventory
+          inventory: targetInventory.inventory,
+          toteName: loadingWSD.toteName
         }
       })
+
+    return {
+      worksheetInfo: {
+        releaseGood,
+        bizplaceName: releaseGood.bizplace.name,
+        startedAt: foundWorksheet.startedAt,
+        refNo: releaseGood.refNo,
+        ownCollection: releaseGood.ownTransport
+      },
+      worksheetDetailInfos
     }
   }
 }

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

@@ -11,7 +11,6 @@ import {
 import { ORDER_INVENTORY_STATUS, ORDER_STATUS, OrderInventory, ReleaseGood } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory, Location } from '@things-factory/warehouse-base'
-import { ProductDetail } from '@things-factory/product-base'
 
 import { WORKSHEET_TYPE } from '../../../constants'
 import { SellercraftController } from '../../../controllers'
@@ -167,6 +166,7 @@ export const packingWorksheetResolver = {
           shippingProvider: shippingProvider ? shippingProvider : '',
           trackingNo: trackingNo ? trackingNo : '',
           airwayBill: releaseGood?.airwayBill,
+          checkedRemarkBy: releaseGood?.checkedRemarkBy,
           invoice: releaseGood?.invoice,
           platform: marketplaceOrder ? marketplaceOrder.marketplaceStore.platform : 'operato',
           marketplaceStoreId: marketplaceOrder ? marketplaceOrder.marketplaceStore.id : '',

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

@@ -42,7 +42,7 @@ export async function completeBatchPicking(
   const worksheet = await pickingWSCtrl.completeBatchPicking(taskNo)
 
   const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
-  const targetInventories: OrderInventory[] = worksheetDetails.map((wsd: WorksheetDetail) => wsd.targetInventory)
+  const targetInventories: OrderInventory[] = worksheetDetails.filter(wsd=>wsd.status != 'MISSING').map((wsd: WorksheetDetail) => wsd.targetInventory)
 
   const sellercraft: Sellercraft = await tx
     .getRepository(Sellercraft)

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

@@ -248,18 +248,20 @@ export async function completePicking(
     })
 
     if (!existLoadingWorksheet && !releaseGood.courierOption && !releaseGood.packingOption) {
-      const loadingWSCtrl: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
-      let loadingWorksheet: Worksheet = await loadingWSCtrl.generateLoadingWorksheet(
-        releaseGoodNo,
-        pickedTargetInventories
-      )
-
-      if (!loadingWorksheet.worksheetDetails?.length) {
-        loadingWorksheet = await pickingWSCtrl.findWorksheetById(loadingWorksheet.id)
+      if(pickedTargetInventories.length>0){
+        const loadingWSCtrl: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
+        let loadingWorksheet: Worksheet = await loadingWSCtrl.generateLoadingWorksheet(
+          releaseGoodNo,
+          pickedTargetInventories
+        )
+  
+        if (!loadingWorksheet.worksheetDetails?.length) {
+          loadingWorksheet = await pickingWSCtrl.findWorksheetById(loadingWorksheet.id)
+        }
+  
+        const loadingWorksheetDetails: WorksheetDetail[] = loadingWorksheet.worksheetDetails
+        await loadingWSCtrl.activateLoading(loadingWorksheet.name, loadingWorksheetDetails)
       }
-
-      const loadingWorksheetDetails: WorksheetDetail[] = loadingWorksheet.worksheetDetails
-      await loadingWSCtrl.activateLoading(loadingWorksheet.name, loadingWorksheetDetails)
     } else {
       const loadingWSCtrl: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
       let loadingWorksheet: Worksheet = await loadingWSCtrl.updateLoadingWorksheet(

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

@@ -11,6 +11,7 @@ import { scanProductPickingResolver } from './scan-product-picking'
 import { scanProductBatchPickingResolver } from './scan-product-batch-picking'
 import { undoPickingAssigmentResolver } from './undo-picking-assignment'
 import { undoSerialNumberPickingResolver } from './undo-serial-number-picking'
+import { sealToteResolver } from './seal-tote'
 
 export const Mutations = {
   ...assignPickingInventoriesResolver,
@@ -25,5 +26,6 @@ export const Mutations = {
   ...completeBatchPickingResolver,
   ...assignPickingWorkerResolver,
   ...fetchAndAssignPickingTaskResolver,
-  ...undoSerialNumberPickingResolver
+  ...undoSerialNumberPickingResolver,
+  ...sealToteResolver
 }

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

@@ -4,9 +4,25 @@ import { EntityManager } from 'typeorm'
 import { PickingWorksheetController } from '../../../../controllers'
 
 export const pickingResolver = {
-  async picking(_: any, { worksheetDetailName, worksheetType, palletId, locationName, releaseQty, binLocation, serialNumber }, context: any) {
+  async picking(
+    _: any,
+    { worksheetDetailName, worksheetType, palletId, locationName, releaseQty, binLocation, serialNumber, toteNo },
+    context: any
+  ) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    await picking(tx, domain, user, worksheetDetailName, worksheetType, palletId, locationName, releaseQty, binLocation, serialNumber)
+    await picking(
+      tx,
+      domain,
+      user,
+      worksheetDetailName,
+      worksheetType,
+      palletId,
+      locationName,
+      releaseQty,
+      binLocation,
+      serialNumber,
+      toteNo
+    )
   }
 }
 
@@ -20,8 +36,18 @@ export async function picking(
   locationName: string,
   releaseQty: number,
   binLocation?: string,
-  serialNumber?: string
+  serialNumber?: string,
+  toteNo?: string
 ) {
   const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
-  await worksheetController.picking(worksheetDetailName, worksheetType, palletId, locationName, releaseQty, binLocation, serialNumber)
+  await worksheetController.picking(
+    worksheetDetailName,
+    worksheetType,
+    palletId,
+    locationName,
+    releaseQty,
+    binLocation,
+    serialNumber,
+    toteNo
+  )
 }