@things-factory/worksheet-base 4.0.0-alpha.8 → 4.0.0-beta.2

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

@@ -1,8 +1,13 @@
+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 { MarketplaceOrder } from '@things-factory/marketplace-base'
+import { ORDER_STATUS, ReleaseGood } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { EcommerceController, PickingWorksheetController } from '../../../../controllers'
+
+import { EcommerceController, PickingWorksheetController, SellercraftController } from '../../../../controllers'
 import { Worksheet } from '../../../../entities'
 
 export const activatePickingResolver = {
@@ -24,14 +29,42 @@ export async function activatePicking(
 
   // find for any existing marketplace store connections
   const marketplaceStores: MarketplaceStore[] = await tx.getRepository(MarketplaceStore).find({
-    where: { domain: companyDomain, status: 'ACTIVE', isAutoUpdateStockQty: true }
+    where: { domain: companyDomain, status: 'ACTIVE', isAutoUpdateStockQty: true },
+    relations: ['marketplaceDistributors']
   })
 
-  if (marketplaceStores?.length && marketplaceStores.some(store => store.isAutoUpdateStockQty)) {
-    const worksheetDetails = worksheet.worksheetDetails
-    let orderInventories: any[] = worksheetDetails.map(wsd => wsd.targetInventory)
-    const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
-    await ecommerceCtrl.updateProductVariationStock(marketplaceStores, orderInventories, companyDomain)
+  let releaseGood: ReleaseGood = worksheet.releaseGood
+
+  if (releaseGood.type === 'b2c') {
+    const sellercraft: Sellercraft = await tx
+      .getRepository(Sellercraft)
+      .findOne({ domain: worksheet.bizplace.domain, status: SellercraftStatus.ACTIVE })
+
+    if (sellercraft) {
+      const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
+      await sellercraftCtrl.initiateOrderShipment(sellercraft, releaseGood)
+    }
+
+    if (marketplaceStores?.length && !sellercraft) {
+      if (marketplaceStores.some(store => store.isAutoUpdateStockQty)) {
+        const worksheetDetails = worksheet.worksheetDetails
+        let orderInventories: any[] = worksheetDetails.map(wsd => wsd.targetInventory)
+        const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
+        await ecommerceCtrl.updateProductVariationStock(marketplaceStores, orderInventories, companyDomain)
+      }
+
+      const marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+        where: { orderNo: releaseGood.refNo, domain: companyDomain },
+        relations: ['marketplaceStore']
+      })
+      const marketplaceStore: MarketplaceStore = marketplaceOrder.marketplaceStore
+
+      if (marketplaceStore.isAutoUpdateShipment) {
+        const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
+        await ecommerceCtrl.createOrderComment(marketplaceStore, marketplaceOrder, ORDER_STATUS.PICKING)
+      }
+    }
   }
+
   return worksheet
 }

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

@@ -7,11 +7,11 @@ import { WorksheetDetail } from '../../../../entities'
 export const assignPickingInventoriesResolver = {
   async assignPickingInventories(
     _: any,
-    { worksheetNo, batchId, productId, packingType, worksheetDetails },
+    { worksheetNo, batchId, productId, packingType, packingSize, worksheetDetails },
     context: any
   ): Promise<void> {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    await assignPickingInventories(tx, domain, user, worksheetNo, batchId, productId, packingType, worksheetDetails)
+    await assignPickingInventories(tx, domain, user, worksheetNo, batchId, productId, packingType, packingSize, worksheetDetails)
   }
 }
 
@@ -23,8 +23,9 @@ export async function assignPickingInventories(
   batchId: string,
   productId: string,
   packingType: string,
+  packingSize: number,
   worksheetDetails: Partial<WorksheetDetail>[]
 ): Promise<void> {
   const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
-  await worksheetController.assignPickingInventories(worksheetNo, batchId, productId, packingType, worksheetDetails)
+  await worksheetController.assignPickingInventories(worksheetNo, batchId, productId, packingType, packingSize, worksheetDetails)
 }

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

@@ -1,12 +1,15 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Bizplace, getMyBizplace } from '@things-factory/biz-base'
-import { ReleaseGood, OrderInventory } from '@things-factory/sales-base'
+import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
+import { OrderInventory, ReleaseGood } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { WORKSHEET_TYPE } from '../../../../constants'
+
 import {
   PackingWorksheetController,
   PickingWorksheetController,
+  SellercraftController,
   SortingWorksheetController
 } from '../../../../controllers/'
 import { WorksheetController } from '../../../../controllers/worksheet-controller'
@@ -41,6 +44,31 @@ export async function completeBatchPicking(
   const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
   const targetInventories: OrderInventory[] = worksheetDetails.map((wsd: WorksheetDetail) => wsd.targetInventory)
 
+  const sellercraft: Sellercraft = await tx
+    .getRepository(Sellercraft)
+    .findOne({ domain: worksheet.bizplace.domain, status: SellercraftStatus.ACTIVE })
+
+  if (sellercraft) {
+    const releaseGoods: ReleaseGood[] = worksheetDetails.map(
+      worksheetDetail => worksheetDetail.targetInventory && worksheetDetail.targetInventory.releaseGood
+    )
+    const uniqueReleaseGoods: ReleaseGood[] = []
+    const map = new Map()
+    for (const releaseGood of releaseGoods) {
+      if (!map.has(releaseGood.id)) {
+        map.set(releaseGood.id, true)
+        uniqueReleaseGoods.push({ ...releaseGood })
+      }
+    }
+
+    await Promise.all(
+      uniqueReleaseGoods.map(async releaseGood => {
+        const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
+        await sellercraftCtrl.initiateOrderDocument(sellercraft, releaseGood)
+      })
+    )
+  }
+
   const pickPackTargetInventories: OrderInventory[] = targetInventories
     .filter(targetInventory => targetInventory.releaseGood.packingOption)
     .map((pickPackTargetInventory: OrderInventory) => {

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

@@ -1,21 +1,24 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
-import { Bizplace, getMyBizplace, ContactPoint } from '@things-factory/biz-base'
-import { OrderInventory, ORDER_INVENTORY_STATUS, ReleaseGood } from '@things-factory/sales-base'
+import { Bizplace, ContactPoint, getMyBizplace } from '@things-factory/biz-base'
+import { LastMileAPI, LastMileDelivery } from '@things-factory/integration-lmd'
+import { MarketplaceStore, MarketplaceTransporter } from '@things-factory/integration-marketplace'
+import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
+import { MarketplaceOrder, MarketplaceOrderItem, MarketplaceOrderShipping } from '@things-factory/marketplace-base'
+import { ORDER_INVENTORY_STATUS, ORDER_STATUS, OrderInventory, ReleaseGood } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { WORKSHEET_TYPE, WORKSHEET_STATUS } from '../../../../constants'
+
+import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../../constants'
 import {
-  PackingWorksheetController,
   LoadingWorksheetController,
-  PickingWorksheetController
+  PackingWorksheetController,
+  PickingWorksheetController,
+  SellercraftController
 } from '../../../../controllers/'
-import { MarketplaceOrder, MarketplaceOrderItem, MarketplaceOrderShipping } from '@things-factory/marketplace-base'
-import { MarketplaceTransporter } from '@things-factory/integration-marketplace'
+import { EcommerceController } from '../../../../controllers/ecommerce'
 import { WorksheetController } from '../../../../controllers/worksheet-controller'
 import { Worksheet, WorksheetDetail } from '../../../../entities'
-import { WorksheetNoGenerator } from '../../../../utils'
-
-import { LastMileDelivery, LastMileAPI } from '@things-factory/integration-lmd'
 
 export const completePickingResolver = {
   async completePicking(_: any, { releaseGoodNo }, context: any) {
@@ -41,9 +44,16 @@ export async function completePicking(
   releaseGoodNo: string
 ): Promise<void> {
   const pickingWSCtrl: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
-  const releaseGood: ReleaseGood = await pickingWSCtrl.findRefOrder(ReleaseGood, {
-    domain,
-    name: releaseGoodNo
+  const releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
+    where: { domain, name: releaseGoodNo },
+    relations: [
+      'bizplace',
+      'bizplace.domain',
+      'bizplace.company',
+      'bizplace.company.domain',
+      'orderInventories',
+      'orderInventories.product'
+    ]
   })
 
   const worksheet: Worksheet = await pickingWSCtrl.findWorksheetByRefOrder(releaseGood, WORKSHEET_TYPE.PICKING, [
@@ -60,160 +70,151 @@ export async function completePicking(
 
   const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
   const targetInventories: OrderInventory[] = worksheetDetails.map((wsd: WorksheetDetail) => wsd.targetInventory)
-  const pickedTargetInventories: OrderInventory[] = targetInventories
-    .filter(targetInventory => targetInventory.status === ORDER_INVENTORY_STATUS.PICKED)
-    .map((pickedTargetInventory: OrderInventory) => {
-      return pickedTargetInventory
-    })
+  const pickedTargetInventories: OrderInventory[] = targetInventories.filter(
+    targetInventory => targetInventory.status === ORDER_INVENTORY_STATUS.PICKED
+  )
 
   await pickingWSCtrl.completePicking(releaseGoodNo)
 
-  // Find Existing Loading Worksheet if any
-  let existLoadingWorksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
-    where: {
-      releaseGood,
-      type: WORKSHEET_TYPE.LOADING,
-      status: WORKSHEET_STATUS.DEACTIVATED
-    }
-  })
-
-  // find marketplace store to check if there is any eTrax true config
-  // access marketplaceOrderShipping from marketplaceOrderItems
-  const marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
-    where: { releaseOrderId: releaseGood.id },
-    relations: ['marketplaceStore', 'marketplaceOrderItems', 'marketplaceOrderItems.marketplaceOrderShipping']
-  })
-
-  const eTraxOption: Boolean = marketplaceOrder?.marketplaceStore.eTrax
-
-  if (releaseGood.packingOption) {
-    // if eTrax option is true
-    if (eTraxOption) {
-      const marketplaceOrderItems: MarketplaceOrderItem[] = marketplaceOrder.marketplaceOrderItems
-
-      // access every marketplaceOrderItems for shipping information you need
-      // trigger the controller from integration-lmd that trigger the API, build the parameters needed
-      // for etrax didn't support multi awb per order
-      const marketplaceOrderShipping: MarketplaceOrderShipping = marketplaceOrderItems[0].marketplaceOrderShipping
-      const lmd: LastMileDelivery = await tx.getRepository(LastMileDelivery).findOne({
-        where: {
-          domain,
-          platform: 'eTrax'
-        }
+  if (releaseGood.type == 'b2c') {
+    const sellercraft: Sellercraft = await tx
+      .getRepository(Sellercraft)
+      .findOne({ domain: releaseGood.bizplace.domain, status: SellercraftStatus.ACTIVE })
+
+    if (sellercraft) {
+      const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
+      await sellercraftCtrl.initiateOrderDocument(sellercraft, releaseGood)
+    } else {
+      const companyDomain: Domain = releaseGood.bizplace.company.domain
+      let marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+        where: { orderNo: releaseGood.refNo, domain: companyDomain },
+        relations: ['marketplaceStore']
       })
+      const marketplaceStore: MarketplaceStore = marketplaceOrder.marketplaceStore
+      let eTraxOption: boolean
 
-      //Get which transporter to use
-      const marketplaceTransporter: MarketplaceTransporter = await tx.getRepository(MarketplaceTransporter).findOne({
-        where: { marketplaceStore: marketplaceOrder.marketplaceStore },
-        relations: ['pickupTransporter', 'deliveryTransporter']
-      })
+      if (marketplaceStore.isAutoUpdateShipment) {
+        const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
+        await ecommerceCtrl.createOrderComment(marketplaceStore, marketplaceOrder, ORDER_STATUS.PACKING)
+      }
 
-      const resp = await LastMileAPI.createShipmentRequest(lmd, {
-        orderNo: marketplaceOrder.orderNo,
-        clientId: lmd.clientId,
-        clientType: lmd.clientType,
-        clientName: lmd.clientName,
-        transporterId: marketplaceTransporter.pickupTransporter.transporterId,
-        pickupName: warehouseContactPoint.name,
-        pickupAddress1: warehouseContactPoint.address,
-        pickupAddress2: warehouseContactPoint.address2,
-        pickupPostcode: warehouseContactPoint.postCode,
-        pickupState: warehouseContactPoint.state,
-        pickupCity: warehouseContactPoint.city,
-        pickupPhone: warehouseContactPoint.phone,
-        pickupEmail: warehouseContactPoint.email,
-        name: marketplaceOrderShipping.attentionTo.trim(),
-        address1: marketplaceOrderShipping.address1.trim(),
-        address2: marketplaceOrderShipping.address2.trim(),
-        postCode: marketplaceOrderShipping.postCode.trim(),
-        city: marketplaceOrderShipping.city.trim(),
-        state: marketplaceOrderShipping.state.trim(),
-        phone: marketplaceOrderShipping.phone1 || '',
-        email: marketplaceOrderShipping.email || '',
-        attentionTo: marketplaceOrderShipping.attentionTo,
-        quantity: marketplaceOrderItems.length
+      marketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+        where: { orderNo: releaseGood.refNo },
+        relations: ['marketplaceStore', 'marketplaceOrderItems', 'marketplaceOrderItems.marketplaceOrderShipping']
       })
 
-      const delay = (ms: number) => {
-        return new Promise(resolve => setTimeout(resolve, ms))
-      }
+      if (!marketplaceOrder)
+        throw new Error('Failed to find ecommerce order, kindly contact our support team regarding this issue')
+      eTraxOption = marketplaceOrder?.marketplaceStore.eTrax
 
-      if (resp.Status === 'SUCCESS') {
-        //Success
-        let awbObtained = false
-        let retry = 0
-        while (!awbObtained) {
-          const marketplaceOrder2: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
-            where: { releaseOrderId: releaseGood.id },
-            relations: ['marketplaceStore', 'marketplaceOrderItems', 'marketplaceOrderItems.marketplaceOrderShipping']
-          })
-          const orderShipping = marketplaceOrder2.marketplaceOrderItems[0].marketplaceOrderShipping
-          if (orderShipping.airwayBill) {
-            awbObtained = true
+      // if eTrax option is true
+      if (eTraxOption) {
+        const marketplaceOrderItems: MarketplaceOrderItem[] = marketplaceOrder.marketplaceOrderItems
+
+        // access every marketplaceOrderItems for shipping information you need
+        // trigger the controller from integration-lmd that trigger the API, build the parameters needed
+        // for etrax didn't support multi awb per order
+        const marketplaceOrderShipping: MarketplaceOrderShipping = marketplaceOrderItems[0].marketplaceOrderShipping
+        const lmd: LastMileDelivery = await tx.getRepository(LastMileDelivery).findOne({
+          where: {
+            domain,
+            platform: 'eTrax'
           }
-          await delay(5000)
-          //Timeout after 15sec
-          if (++retry > 3) {
-            break
+        })
+
+        //Get which transporter to use
+        const marketplaceTransporter: MarketplaceTransporter = await tx.getRepository(MarketplaceTransporter).findOne({
+          where: { marketplaceStore: marketplaceOrder.marketplaceStore },
+          relations: ['pickupTransporter', 'deliveryTransporter']
+        })
+
+        const resp = await LastMileAPI.createShipmentRequest(lmd, {
+          orderNo: marketplaceOrder.orderNo,
+          clientId: lmd.clientId,
+          clientType: lmd.clientType,
+          clientName: lmd.clientName,
+          transporterId: marketplaceTransporter.pickupTransporter.transporterId,
+          pickupName: warehouseContactPoint.name,
+          pickupAddress1: warehouseContactPoint.address,
+          pickupAddress2: warehouseContactPoint.address2,
+          pickupPostcode: warehouseContactPoint.postCode,
+          pickupState: warehouseContactPoint.state,
+          pickupCity: warehouseContactPoint.city,
+          pickupPhone: warehouseContactPoint.phone,
+          pickupEmail: warehouseContactPoint.email,
+          name: marketplaceOrderShipping?.attentionTo ? marketplaceOrderShipping.attentionTo.trim() : '',
+          address1: marketplaceOrderShipping?.address1 ? marketplaceOrderShipping?.address1.trim() : '-',
+          address2: marketplaceOrderShipping?.address2 ? marketplaceOrderShipping?.address2.trim() : '-',
+          postCode: marketplaceOrderShipping?.postCode ? marketplaceOrderShipping?.postCode.trim() : '',
+          city: marketplaceOrderShipping?.city ? marketplaceOrderShipping?.city.trim() : '',
+          state: marketplaceOrderShipping?.state ? marketplaceOrderShipping?.state.trim() : '',
+          phone: marketplaceOrderShipping.phone1 || '',
+          email: marketplaceOrderShipping.email || '',
+          attentionTo: marketplaceOrderShipping.attentionTo,
+          quantity: marketplaceOrderItems.length
+        })
+
+        const delay = (ms: number) => {
+          return new Promise(resolve => setTimeout(resolve, ms))
+        }
+
+        if (resp.Status === 'SUCCESS') {
+          //Success
+          let awbObtained = false
+          let retry = 0
+          while (!awbObtained) {
+            const marketplaceOrder2: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+              where: { releaseOrderId: releaseGood.id },
+              relations: ['marketplaceStore', 'marketplaceOrderItems', 'marketplaceOrderItems.marketplaceOrderShipping']
+            })
+            const orderShipping = marketplaceOrder2.marketplaceOrderItems[0].marketplaceOrderShipping
+            if (orderShipping?.airwayBill) {
+              awbObtained = true
+            }
+            await delay(5000)
+            //Timeout after 15sec
+            if (++retry > 3) {
+              break
+            }
           }
+        } else {
+          throw resp
+          //Failed
         }
-      } else {
-        throw resp
-        //Failed
       }
     }
+  }
 
+  if (releaseGood.packingOption) {
     const packingWSCtrl: PackingWorksheetController = new PackingWorksheetController(tx, domain, user)
     await packingWSCtrl.generatePackingWorksheet(releaseGoodNo)
-  }
+  } else {
+    // Find Existing Loading Worksheet if any
+    const existLoadingWorksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
+      where: {
+        releaseGood,
+        type: WORKSHEET_TYPE.LOADING,
+        status: WORKSHEET_STATUS.DEACTIVATED
+      }
+    })
 
-  if (existLoadingWorksheet && !releaseGood.packingOption) {
-    const bizplace: Bizplace = await getMyBizplace(domain, user)
+    if (!existLoadingWorksheet && !releaseGood.courierOption && !releaseGood.packingOption) {
+      const loadingWSCtrl: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
+      let loadingWorksheet: Worksheet = await loadingWSCtrl.generateLoadingWorksheet(
+        releaseGoodNo,
+        pickedTargetInventories
+      )
 
-    // 2) Create loading worksheet details
-    let loadingWorksheetDetails = await Promise.all(
-      pickedTargetInventories.map(async (targetInventory: OrderInventory) => {
-        let existingLoadingWorksheetDetail: WorksheetDetail = await tx.getRepository(WorksheetDetail).findOne({
-          where: {
-            domain,
-            worksheet: existLoadingWorksheet,
-            targetInventory,
-            type: WORKSHEET_TYPE.LOADING
-          }
-        })
+      if (!loadingWorksheet.worksheetDetails?.length) {
+        loadingWorksheet = await pickingWSCtrl.findWorksheetById(loadingWorksheet.id)
+      }
 
-        return existingLoadingWorksheetDetail
-          ? {
-              ...existingLoadingWorksheetDetail,
-              status: WORKSHEET_STATUS.DEACTIVATED
-            }
-          : {
-              domain,
-              bizplace: bizplace,
-              worksheet: existLoadingWorksheet,
-              name: WorksheetNoGenerator.generateDetail(WORKSHEET_TYPE.LOADING),
-              targetInventory,
-              type: WORKSHEET_TYPE.LOADING,
-              status: WORKSHEET_STATUS.DEACTIVATED,
-              creator: user,
-              updater: user
-            }
-      })
-    )
-
-    loadingWorksheetDetails = await tx.getRepository(WorksheetDetail).save(loadingWorksheetDetails)
-  } else 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)
+      const loadingWorksheetDetails: WorksheetDetail[] = loadingWorksheet.worksheetDetails
+      await loadingWSCtrl.activateLoading(loadingWorksheet.name, loadingWorksheetDetails)
+    } else {
+      throw new Error(
+        'Picking completion has been triggered twice, loading worksheet has been generated. Kindly proceed to loading.'
+      )
     }
-
-    const loadingWorksheetDetails: WorksheetDetail[] = loadingWorksheet.worksheetDetails
-    await loadingWSCtrl.activateLoading(loadingWorksheet.name, loadingWorksheetDetails)
   }
 }

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

@@ -4,9 +4,9 @@ import { EntityManager } from 'typeorm'
 import { PickingWorksheetController } from '../../../../controllers'
 
 export const undoPickingAssigmentResolver = {
-  async undoPickingAssigment(_: any, { worksheetNo, batchId, productId, packingType }, context: any): Promise<void> {
+  async undoPickingAssigment(_: any, { worksheetNo, batchId, productId, packingType, packingSize }, context: any): Promise<void> {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    await undoPickingAssigment(tx, domain, user, worksheetNo, batchId, productId, packingType)
+    await undoPickingAssigment(tx, domain, user, worksheetNo, batchId, productId, packingType, packingSize)
   }
 }
 
@@ -17,8 +17,9 @@ export async function undoPickingAssigment(
   worksheetNo: string,
   batchId: string,
   productId: string,
-  packingType: string
+  packingType: string,
+  packingSize: number
 ): Promise<void> {
   const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
-  await worksheetController.undoPickingAssigment(worksheetNo, batchId, productId, packingType)
+  await worksheetController.undoPickingAssigment(worksheetNo, batchId, productId, packingType, packingSize)
 }

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

@@ -1,10 +1,12 @@
 import { createQueryBuilder, getRepository, SelectQueryBuilder } from 'typeorm'
+
+import { ORDER_INVENTORY_STATUS, OrderInventory, ReleaseGood } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { fetchExecutingWorksheet } from '../../../utils'
 import { Inventory } from '@things-factory/warehouse-base'
-import { OrderInventory, ReleaseGood, ORDER_INVENTORY_STATUS } from '@things-factory/sales-base'
+
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
 import { WorksheetDetail } from '../../../entities'
+import { fetchExecutingWorksheet } from '../../../utils'
 
 export const pickingWorksheetResolver = {
   async pickingWorksheet(_: any, { releaseGoodNo, locationSortingRules }, context: any) {
@@ -47,6 +49,7 @@ export const pickingWorksheetResolver = {
         partnerDomainId: releaseGood.bizplace?.domain.id,
         startedAt: worksheet.startedAt,
         refNo: releaseGood.refNo,
+        refNo2: releaseGood.refNo2,
         releaseGood
       },
       worksheetDetailInfos: worksheetDetails.map(async (pickingWSD: WorksheetDetail) => {

package/server/graphql/resolvers/worksheet/recommend-putway-location.ts

@@ -2,7 +2,7 @@ import { ArrivalNotice, ReturnOrder } from '@things-factory/sales-base'
 import { Setting } from '@things-factory/setting-base'
 import { Domain } from '@things-factory/shell'
 import { Location, LOCATION_STATUS, LOCATION_TYPE, Warehouse } from '@things-factory/warehouse-base'
-import { Equal, getRepository, Not } from 'typeorm'
+import { In, getRepository, Not } from 'typeorm'
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
 import { Worksheet, WorksheetDetail } from '../../../entities'
 
@@ -65,7 +65,12 @@ export async function recommendLocationLevel1(
   if (orderSetting?.value) order = JSON.parse(orderSetting.value)
 
   return await getRepository(Location).find({
-    where: { domain, warehouse, status: LOCATION_STATUS.EMPTY, type: Not(Equal(LOCATION_TYPE.BUFFER)) },
+    where: {
+      domain,
+      warehouse,
+      status: LOCATION_STATUS.EMPTY,
+      type: Not(In([LOCATION_TYPE.BUFFER, LOCATION_TYPE.BIN]))
+    },
     order,
     take: optCnt
   })

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

@@ -1,15 +1,18 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
+import { Product } from '@things-factory/product-base'
 import {
-  OrderInventory,
-  OrderNoGenerator,
   ORDER_INVENTORY_STATUS,
   ORDER_TYPES,
+  OrderInventory,
+  OrderNoGenerator,
   ReleaseGood
 } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory } from '@things-factory/warehouse-base'
-import { EntityManager } from 'typeorm'
+
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
 import { Worksheet, WorksheetDetail } from '../../../entities'
 import { WorksheetNoGenerator } from '../../../utils'
@@ -29,11 +32,13 @@ export const replacePickingPalletsResolver = {
         'worksheet',
         'targetInventory',
         'targetInventory.releaseGood',
-        'targetInventory.inventory'
+        'targetInventory.inventory',
+        'targetInventory.inventory.product'
       ]
     })
     const prevOrderInv: OrderInventory = prevWSD.targetInventory
     const prevInv: Inventory = prevOrderInv.inventory
+    const product: Product = prevInv.product
     const batchId: string = prevOrderInv.batchId
     const productName: string = prevOrderInv.productName
     const packingType: string = prevOrderInv.packingType
@@ -45,9 +50,8 @@ export const replacePickingPalletsResolver = {
     // remove locked qty and locked uomValue
     await tx.getRepository(Inventory).save({
       ...prevInv,
-      lockedQty: 0,
-      lockedWeight: 0,
-      lockedUomValue: 0,
+      lockedQty: prevInv.lockedQty - prevOrderInv.releaseQty,
+      lockedUomValue: prevInv.lockedUomValue - prevOrderInv.releaseUomValue,
       updater: user
     })
 
@@ -67,7 +71,7 @@ export const replacePickingPalletsResolver = {
 
     await Promise.all(
       inventories.map(async (inventory: Inventory) => {
-        const foundInv: Inventory = await tx.getRepository(Inventory).findOne({
+        let foundInv: Inventory = await tx.getRepository(Inventory).findOne({
           where: {
             domain,
             palletId: inventory.palletId
@@ -85,11 +89,13 @@ export const replacePickingPalletsResolver = {
           releaseQty: inventory.qty,
           releaseUomValue: unitUomValue * inventory.qty,
           inventory: foundInv,
+          product,
           batchId,
           type: ORDER_TYPES.RELEASE_OF_GOODS,
           status: ORDER_INVENTORY_STATUS.PICKING,
           productName,
           packingType,
+          packingSize: inventory.packingSize,
           creator: user,
           updater: user
         })
@@ -110,8 +116,15 @@ export const replacePickingPalletsResolver = {
           updater: user
         })
 
+        foundInv.lockedQty = foundInv.lockedQty ? foundInv.lockedQty + inventory.qty : inventory.qty
+        foundInv.lockedUomValue = foundInv.lockedUomValue
+          ? foundInv.lockedUomValue + unitUomValue * inventory.qty
+          : unitUomValue * inventory.qty
+
+        foundInv = await tx.getRepository(Inventory).save(foundInv)
+
         // 6. execute picking transaction
-        await picking(tx, domain, user, wsd.name, worksheetType, inventory.palletId, returnLocation, inventory.qty)
+        await picking(tx, domain, user, wsd.name, worksheetType, foundInv.palletId, returnLocation, inventory.qty)
       })
     )
   }