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

package/server/graphql/resolvers/worksheet/cancel-draft-release-order.ts

@@ -0,0 +1,27 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import {
+  ORDER_STATUS,
+  DraftReleaseGood
+} from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+
+export const cancelDraftReleaseOrder = {
+  async cancelDraftReleaseOrder(_: any, { name }, context: any) {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+
+    const foundDRO: DraftReleaseGood = await tx.getRepository(DraftReleaseGood).findOne({
+      where: { domain, name }
+    })
+
+    if (foundDRO) {
+      await tx.getRepository(DraftReleaseGood).save({
+        ...foundDRO,
+        status: ORDER_STATUS.CANCELLED,
+        updater: user
+      })
+    }
+    return
+  }
+}

package/server/graphql/resolvers/worksheet/cycle-count-adjustment.ts

@@ -73,7 +73,8 @@ export async function cycleCountAdjustment(
     let transactUomValue: number = targetInventory.inspectedUomValue - inventory.uomValue
 
     const sellercraft: Sellercraft = await tx.getRepository(Sellercraft).findOne({
-      where: { domain: inventory.bizplace.domain, status: SellercraftStatus.ACTIVE }
+      where: { domain: inventory.bizplace.domain, status: SellercraftStatus.ACTIVE },
+      relations: ['domain']
     })
 
     if (targetInventory.status === ORDER_INVENTORY_STATUS.MISSING) {

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

@@ -22,6 +22,7 @@ import { Mutations as PackingMutations } from './packing'
 import { packingWorksheetResolver } from './packing-worksheet'
 import { palletizingPallets } from './palletizing-pallets'
 import { pendingCancellationReleaseOrder } from './pending-cancellation-release-order'
+import { cancelDraftReleaseOrder } from './cancel-draft-release-order'
 import { Mutations as PickingMutations } from './picking'
 import { pickingWorksheetResolver } from './picking-worksheet'
 import { myPickingAssignmentStatusResolver } from './picking/my-picking-assignment-status'
@@ -132,5 +133,6 @@ export const Mutation = {
   ...crossDockPickingResolver,
   ...unpackingResolver,
   ...palletizingPallets,
-  ...fetchSellercraftAirwayBillResolver
+  ...fetchSellercraftAirwayBillResolver,
+  ...cancelDraftReleaseOrder
 }

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

@@ -1,6 +1,8 @@
 import { EntityManager } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
+import { Bizplace, Company } from '@things-factory/biz-base'
+import { FulfillmentCenter } from '@things-factory/integration-fulfillment'
 import { Sftp, SftpAPI } from '@things-factory/integration-sftp'
 import { ORDER_INVENTORY_STATUS, ORDER_STATUS, OrderInventory, ReleaseGood } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
@@ -44,28 +46,52 @@ export async function completeLoading(
     (targetInventory: OrderInventory) => targetInventory.status === ORDER_INVENTORY_STATUS.LOADING
   )
 
+  // Search Warehouse Company Domain
+  const warehouseCompanyBizplace: Bizplace = await tx
+    .getRepository(Bizplace)
+    .findOne({ where: { domain }, relations: ['company'] })
+
+  const warehouseCompany: Company = warehouseCompanyBizplace.company
+  const warehouseBizplaces: Bizplace[] = await tx
+    .getRepository(Bizplace)
+    .find({ where: { company: warehouseCompany }, relations: ['domain'] })
+  const warehouseCompanyBizplaces: Bizplace[] = warehouseBizplaces.filter(biz => biz.domain.extType == 'company')
+  const warehouseCompanyDomain: Domain = warehouseCompanyBizplaces[0].domain
+
   const customerDomain: Domain = releaseGood.bizplace.domain
-  let customerAvailableSftp: Sftp = await tx.getRepository(Sftp).findOne({
-    where: { domain: customerDomain }
-  })
-  if (customerAvailableSftp) {
-    let inventoryItems: InventoryItem[] = await tx.getRepository(InventoryItem).find({
-      where: { domain, outboundOrderId: releaseGood.id }
-    })
+  const fulfillmentCenter: FulfillmentCenter = await tx
+    .getRepository(FulfillmentCenter)
+    .findOne({ domain: warehouseCompanyDomain, centerId: domain.subdomain, status: 'active' })
 
-    let shipmentResult: Sftp = await SftpAPI.createShipment(customerAvailableSftp, {
-      releaseGood,
-      orderInventories: targetInventories,
-      sftp: customerAvailableSftp
+  if (fulfillmentCenter) {
+    let customerAvailableSftp: Sftp = await tx.getRepository(Sftp).findOne({
+      where: { domain: customerDomain, status: 'ACTIVE', fulfillmentCenter }
     })
-    customerAvailableSftp = await tx.getRepository(Sftp).save(shipmentResult)
+    if (customerAvailableSftp) {
+      const responseFileTypes: any = JSON.parse(customerAvailableSftp.responseFileTypes)
 
-    let snResult: Sftp = await SftpAPI.createSerialNumber(customerAvailableSftp, {
-      releaseGood,
-      inventoryItems,
-      sftp: customerAvailableSftp
-    })
-    customerAvailableSftp = await tx.getRepository(Sftp).save(snResult)
+      let inventoryItems: InventoryItem[] = await tx.getRepository(InventoryItem).find({
+        where: { domain, outboundOrderId: releaseGood.id }
+      })
+
+      if (responseFileTypes.enableShipment) {
+        let shipmentResult: Sftp = await SftpAPI.createShipment(customerAvailableSftp, {
+          releaseGood,
+          orderInventories: targetInventories,
+          sftp: customerAvailableSftp
+        })
+        customerAvailableSftp = await tx.getRepository(Sftp).save(shipmentResult)
+      }
+
+      if (responseFileTypes.enableSerialNumber) {
+        let snResult: Sftp = await SftpAPI.createSerialNumber(customerAvailableSftp, {
+          releaseGood,
+          inventoryItems,
+          sftp: customerAvailableSftp
+        })
+        customerAvailableSftp = await tx.getRepository(Sftp).save(snResult)
+      }
+    }
   }
 
   await worksheetController.completeLoading(releaseGoodNo)

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/palletizing-pallets.ts

@@ -1,7 +1,7 @@
 import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
 import { ArrivalNotice, OrderVas, Vas, ORDER_STATUS, ORDER_VAS_STATUS, ORDER_TYPES } from '@things-factory/sales-base'
-import uuid from 'uuid/v4'
+import { v4 as uuidv4 } from 'uuid'
 import { Equal, Not, EntityManager } from 'typeorm'
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
 import { Worksheet, WorksheetDetail } from '../../../entities'
@@ -74,7 +74,7 @@ export const palletizingPallets = {
         }
       } else {
         orderVass = {
-          name: uuid(),
+          name: uuidv4(),
           set: patch.set,
           vas: palletizingVAS,
           qty: patch.qty,

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
+  )
 }

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

@@ -6,7 +6,7 @@ import { PickingWorksheetController } from '../../../../controllers'
 export const scanProductPickingResolver = {
   async scanProductPicking(
     _: any,
-    { worksheetDetailName, worksheetType, productBarcode, cartonId, binLocation, serialNumber },
+    { worksheetDetailName, worksheetType, productBarcode, cartonId, binLocation, serialNumber, toteNo },
     context: any
   ) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
@@ -19,7 +19,8 @@ export const scanProductPickingResolver = {
       productBarcode,
       cartonId,
       binLocation,
-      serialNumber
+      serialNumber,
+      toteNo
     )
   }
 }
@@ -33,7 +34,8 @@ export async function scanProductPicking(
   productBarcode: string,
   cartonId: string,
   binLocation?: string,
-  serialNumber?: string
+  serialNumber?: string,
+  toteNo?: string
 ) {
   const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
   await worksheetController.scanProductPicking(
@@ -42,6 +44,7 @@ export async function scanProductPicking(
     productBarcode,
     cartonId,
     binLocation,
-    serialNumber
+    serialNumber,
+    toteNo
   )
 }

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

@@ -0,0 +1,25 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { PickingWorksheetController } from '../../../../controllers'
+
+export const sealToteResolver = {
+  async sealTote(_: any, { sealNo, toteNo, orderNo }, context: any) {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    await sealTote(tx, domain, user, sealNo, toteNo, orderNo)
+  }
+}
+
+async function sealTote(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  sealNo: string,
+  toteNo: string,
+  orderNo: string
+): Promise<void> {
+  const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
+  await worksheetController.sealTote(sealNo, toteNo, orderNo)
+}

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

@@ -2,7 +2,7 @@ import { EntityManager, In, SelectQueryBuilder } from 'typeorm'
 
 import { ORDER_INVENTORY_STATUS, OrderInventory, ReleaseGood, ShippingOrder } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { Inventory, Location } from '@things-factory/warehouse-base'
+import { Inventory, Location, InventoryChange } from '@things-factory/warehouse-base'
 
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
 import { WorksheetDetail } from '../../../entities'
@@ -109,6 +109,16 @@ export async function pickingWorksheet(
     worksheetDetailInfos: worksheetDetails.map(async (pickingWSD: WorksheetDetail) => {
       const targetInventory: OrderInventory = pickingWSD.targetInventory
       const inventory: Inventory = targetInventory.inventory
+
+      const inventoryChangesCount: number = await tx.getRepository(InventoryChange).count({
+        where: {
+          inventory: inventory.id,
+          status:"PENDING",
+          transactionType:"MISSING"
+        },
+        relations:['inventory','product']
+      })
+
       return {
         name: pickingWSD.name,
         palletId: inventory?.palletId,
@@ -127,7 +137,8 @@ export async function pickingWorksheet(
         packingSize: inventory?.packingSize,
         expirationDate: inventory?.expirationDate,
         location: inventory?.location,
-        relatedOrderInv: targetInventory
+        relatedOrderInv: targetInventory,
+        hasMissingInventoryChanges:inventoryChangesCount > 0 ? true:false
       }
     })
   }

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

@@ -1,13 +1,56 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
+import { MarketplaceStore } from '@things-factory/integration-marketplace'
+import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
+import { ArrivalNotice } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
+
 import { PutawayWorksheetController } from '../../../../controllers'
+import { EcommerceController, SellercraftController } from '../../../../controllers/ecommerce'
 import { Worksheet } from '../../../../entities'
 
 export const completePutawayResolver = {
   async completePutaway(_: any, { arrivalNoticeNo }, context: any) {
     const { tx, user, domain }: { tx: EntityManager; user: User; domain: Domain } = context.state
     await completePutaway(tx, domain, user, arrivalNoticeNo)
+
+    const arrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
+      where: { domain, name: arrivalNoticeNo },
+      relations: [
+        'purchaseOrder',
+        'bizplace',
+        'bizplace.domain',
+        'bizplace.company',
+        'bizplace.company.domain',
+        'orderProducts',
+        'orderProducts.product',
+        'orderProducts.product.productDetails',
+        'orderProducts.product.productDetails.childProductDetail'
+      ]
+    })
+
+    // search for any active marketplace connection
+    const companyDomain: Domain = arrivalNotice.bizplace.company.domain
+    const customerDomain: Domain = arrivalNotice.bizplace.domain
+    const marketplaceStores: MarketplaceStore[] = await tx.getRepository(MarketplaceStore).find({
+      where: { domain: companyDomain, status: 'ACTIVE', isAutoUpdateStockQty: true },
+      relations: ['marketplaceDistributors']
+    })
+
+    const sellercraft: Sellercraft = await tx
+      .getRepository(Sellercraft)
+      .findOne({ domain: customerDomain, status: SellercraftStatus.ACTIVE })
+
+    if (sellercraft) {
+      const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
+      await sellercraftCtrl.registerProductInbound(sellercraft, arrivalNotice)
+    }
+
+    if (marketplaceStores?.length && marketplaceStores.some(store => store.isAutoUpdateStockQty)) {
+      const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
+      await ecommerceCtrl.updateProductVariationStock(marketplaceStores, arrivalNotice.orderProducts, companyDomain)
+    }
   }
 }
 
@@ -28,4 +71,4 @@ export async function completePutaway(
       relations: ['bizplace', 'arrivalNotice']
     })
   }
-} 
+}

package/server/graphql/resolvers/worksheet/sorting/complete-order-sorting.ts

@@ -19,16 +19,20 @@ export async function completeOrderSorting(
   user: User,
   releaseGoodNo: string
 ): Promise<void> {
-  const sortingWSCtrl: SortingWorksheetController = new SortingWorksheetController(tx, domain, user)
-  const releaseGood = await sortingWSCtrl.completeOrderSorting(releaseGoodNo)
+  try {
+    const sortingWSCtrl: SortingWorksheetController = new SortingWorksheetController(tx, domain, user)
+    const releaseGood = await sortingWSCtrl.completeOrderSorting(releaseGoodNo)
 
-  const loadingWSCtrl: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
-  let loadingWorksheet: Worksheet = await loadingWSCtrl.generateLoadingWorksheet(
-    releaseGood.name,
-    releaseGood.orderInventories.filter(itm => itm.status != ORDER_INVENTORY_STATUS.COMPLETE_SPLIT)
-  )
+    const loadingWSCtrl: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
+    let loadingWorksheet: Worksheet = await loadingWSCtrl.generateLoadingWorksheet(
+      releaseGood.name,
+      releaseGood.orderInventories.filter(itm => itm.status != ORDER_INVENTORY_STATUS.COMPLETE_SPLIT)
+    )
 
-  if (loadingWorksheet.status === WORKSHEET_STATUS.DEACTIVATED) {
-    await loadingWSCtrl.activateLoading(loadingWorksheet.name, loadingWorksheet.worksheetDetails)
+    if (loadingWorksheet.status === WORKSHEET_STATUS.DEACTIVATED) {
+      await loadingWSCtrl.activateLoading(loadingWorksheet.name, loadingWorksheet.worksheetDetails)
+    }
+  } catch (e) {
+    throw e
   }
 }