@things-factory/worksheet-base 4.3.82 → 4.3.87

package/server/graphql/resolvers/worksheet/picking/fetch-and-assign-picking-task.ts

@@ -1,7 +1,7 @@
-import { EntityManager, getRepository } from 'typeorm'
+import { EntityManager, getConnection } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
-import { ReleaseGood, OrderInventory } from '@things-factory/sales-base'
+import { OrderInventory, ReleaseGood } from '@things-factory/sales-base'
 import { Setting } from '@things-factory/setting-base'
 import { Domain } from '@things-factory/shell'
 
@@ -20,15 +20,14 @@ export const fetchAndAssignPickingTaskResolver = {
 
       if (!assignee) throw new Error('failed to find target user')
 
-      let worksheet: any
+      let worksheet: Worksheet
       let worksheetQb = await tx
         .getRepository(Worksheet)
         .createQueryBuilder('ws')
         .select('ws.id')
         .addSelect('ws.name')
         .addSelect('ws.status')
-        .addSelect('ws.release_good_id')
-        .innerJoin('ws.releaseGood', 'rg')
+        .innerJoinAndSelect('ws.releaseGood', 'rg')
         .where(
           '(ws.domain_id = :domain_id AND ws.type = :type AND ws.assignee_id =:assignee AND (ws.status = :status1 OR ws.status = :status2))',
           {
@@ -53,48 +52,50 @@ export const fetchAndAssignPickingTaskResolver = {
         })
         .orderBy('"rg"."created_at"', 'ASC')
 
-      worksheet = await worksheetQb.getRawOne()
+      worksheet = await worksheetQb.getOne()
 
       if (!worksheet) {
-        let worksheetQb = await tx
-          .getRepository(Worksheet)
-          .createQueryBuilder('ws')
-          .select('ws.id')
-          .addSelect('ws.name')
-          .addSelect('ws.status')
-          .addSelect('ws.release_good_id')
-          .innerJoin('ws.releaseGood', 'rg')
-          .where(
-            '(ws.domain_id = :domain_id AND ws.type = :type AND ws.assignee_id IS NULL AND (ws.status = :status1 OR ws.status = :status2))',
-            {
-              domain_id: domain.id,
-              type: WORKSHEET_TYPE.PICKING,
-              status1: WORKSHEET_STATUS.EXECUTING,
-              status2: WORKSHEET_STATUS.DEACTIVATED
-            }
+        // update and return updated worksheet id
+        let updatedWorksheets = await getConnection().transaction(async (tx2: EntityManager) => {
+          let x = await tx2.getRepository(Worksheet).query(
+            `
+            UPDATE worksheets ws SET assignee_id = $2,
+            updated_at = NOW(),
+            updater_id = $2
+            FROM (
+              SELECT ws.id, ws.name, ws.status, ws.release_good_id FROM worksheets ws
+              INNER JOIN release_goods rg ON rg.id = ws.release_good_id
+              WHERE 
+              ws.domain_id = $1 AND 
+              ws.type = 'PICKING' AND 
+              ws.assignee_id IS NULL AND 
+              (ws.status = 'EXECUTING' OR ws.status = 'DEACTIVATED') AND
+              NOT EXISTS (
+                SELECT count(id) AS "totalPS"
+                FROM order_inventories oi 
+                WHERE oi.release_good_id = ws.release_good_id AND
+                oi.status = 'PENDING_SPLIT'
+                GROUP BY oi.release_good_id 
+                HAVING count(id) > 0
+              )
+              ORDER BY rg.release_date, rg.created_at LIMIT 1
+            ) src where src.id = ws.id
+            RETURNING ws.id;
+          `,
+            [domain.id, assignee.id]
           )
-          .andWhere(qb => {
-            const subQuery = qb
-              .subQuery()
-              .select('COUNT(*) AS totalPS')
-              .from(OrderInventory, 'OrderInventory')
-              .where('OrderInventory.release_good_id = ws.release_good_id')
-              .andWhere(`OrderInventory.status = 'PENDING_SPLIT'`)
-              .groupBy('OrderInventory.release_good_id')
-              .having('COUNT(*) > 0')
-              .getQuery()
-            return 'NOT EXISTS ' + subQuery
-          })
-          .orderBy('"rg"."created_at"', 'ASC')
+          return x[0]
+        })
 
-        worksheet = await worksheetQb.getRawOne()
+        if (updatedWorksheets.length == 0) throw new Error('no suitable worksheet found')
 
-        if (!worksheet) throw new Error('no suitable worksheet found')
-        await getRepository(Worksheet).update({ id: worksheet.ws_id }, { assignee: assignee })
+        // relace worksheet with newly assigned worksheet
+        worksheet = await tx
+          .getRepository(Worksheet)
+          .findOne({ where: { id: updatedWorksheets[0].id }, relations: ['releaseGood'] })
       }
 
-      if (worksheet.ws_status == WORKSHEET_STATUS.DEACTIVATED)
-        await activatePicking(tx, domain, user, worksheet.ws_name)
+      if (worksheet.status == WORKSHEET_STATUS.DEACTIVATED) await activatePicking(tx, domain, user, worksheet.name)
 
       const locationSortingRules: Setting = await tx.getRepository(Setting).findOne({
         where: { domain, name: 'rule-for-picking-product' }
@@ -105,7 +106,7 @@ export const fetchAndAssignPickingTaskResolver = {
         return { name: field, desc: sortingRule[field] === 'DESC' }
       })
 
-      const releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne(worksheet.release_good_id)
+      const releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne(worksheet.releaseGood.id)
 
       return await pickingWorksheet(domain, releaseGood.name, locationSortingRule, tx)
     } catch (error) {

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

@@ -3,6 +3,9 @@ import { Domain } from '@things-factory/shell'
 import { EntityManager } from 'typeorm'
 import { PickingWorksheetController } from '../../../../controllers'
 
+import { pickingWorksheet } from '../picking-worksheet'
+
+
 export const scanProductPickingResolver = {
   async scanProductPicking(
     _: any,
@@ -10,10 +13,9 @@ export const scanProductPickingResolver = {
     context: any
   ) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    await scanProductPicking(
-      tx,
-      domain,
-      user,
+
+    const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
+    let ws = await worksheetController.scanProductPicking(
       worksheetDetailName,
       worksheetType,
       productBarcode,
@@ -23,31 +25,9 @@ export const scanProductPickingResolver = {
       toteNo,
       pickingQty
     )
-  }
-}
 
-export async function scanProductPicking(
-  tx: EntityManager,
-  domain: Domain,
-  user: User,
-  worksheetDetailName: string,
-  worksheetType: string,
-  productBarcode: string,
-  cartonId: string,
-  binLocation?: string,
-  serialNumber?: string,
-  toteNo?: string,
-  pickingQty?: number
-) {
-  const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
-  await worksheetController.scanProductPicking(
-    worksheetDetailName,
-    worksheetType,
-    productBarcode,
-    cartonId,
-    binLocation,
-    serialNumber,
-    toteNo,
-    pickingQty
-  )
+
+    // return await pickingWorksheet(domain, releaseGoodNo, locationSortingRule, tx)
+
+  }
 }

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

@@ -76,7 +76,6 @@ export async function pickingWorksheet(
     .leftJoinAndSelect('T_INV.binLocation', 'BIN_LOC')
     .leftJoinAndSelect('T_INV.inventory', 'INV')
     .leftJoinAndSelect('T_INV.product', 'PROD')
-    .leftJoinAndSelect('T_INV.productDetail', 'PROD_DET')
     .leftJoinAndSelect('INV.location', 'LOC')
 
   if (locationSortingRules?.length > 0) {
@@ -115,8 +114,8 @@ export async function pickingWorksheet(
       const inventoryChangesCount: number = await tx.getRepository(InventoryChange).count({
         where: {
           inventory: inventory.id,
-          status: 'PENDING',
-          transactionType: 'MISSING'
+          status: "PENDING",
+          transactionType: "MISSING"
         },
         relations: ['inventory', 'product']
       })

package/server/graphql/resolvers/worksheet/proceed-extra-products.ts

@@ -73,7 +73,7 @@ export const proceedExtraProductsResolver = {
       if (editedApprovedProducts?.length > 0) {
         editedApprovedProducts.map((editedApprovedProd: OrderProduct) => {
           const selectedOrderProduct: OrderProduct = storedOrderProducts.find(
-            (op: OrderProduct) => op.productDetail.id === editedApprovedProd.productDetailId
+            (op: OrderProduct) => op.id === editedApprovedProd.id
           )
 
           updatedOrderProducts.push({
@@ -115,7 +115,7 @@ export const proceedExtraProductsResolver = {
       if (addedApprovedProducts?.length > 0) {
         addedApprovedProducts.map((addedApprovedProd: OrderProduct) => {
           const selectedOrderProduct: OrderProduct = storedOrderProducts.find(
-            (op: OrderProduct) => op.productDetailId === addedApprovedProd.productDetailId
+            (op: OrderProduct) => op.id === addedApprovedProd.id
           )
           updatedOrderProducts.push({
             ...selectedOrderProduct,
@@ -173,7 +173,7 @@ export const proceedExtraProductsResolver = {
       if (editedRejectedProducts?.length > 0) {
         editedRejectedProducts = editedRejectedProducts.map((editedRejectProduct: OrderProduct) => {
           const selectedOrderProduct: OrderProduct = storedOrderProducts.find(
-            (op: OrderProduct) => op.productDetail.id === editedRejectProduct.productDetailId
+            (op: OrderProduct) => op.id === editedRejectProduct.id
           )
 
           return {
@@ -194,8 +194,7 @@ export const proceedExtraProductsResolver = {
         let deleteOrderProducts: OrderProduct[] = []
         addedRejectedProducts.map(rejectedOp => {
           const selectedOrderProduct: OrderProduct[] = storedOrderProducts.find(
-            //(op: OrderProduct) => op.id === rejectedOp.id
-            (op: OrderProduct) => op.productDetailId === rejectedOp.productDetailId
+            (op: OrderProduct) => op.id === rejectedOp.id
           )
           deleteOrderProducts.push(selectedOrderProduct)
         })

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

@@ -1,6 +1,6 @@
 import { EntityManager } from 'typeorm'
 
-import { ApplicationType, User } from '@things-factory/auth-base'
+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'
@@ -33,54 +33,24 @@ export const completePutawayResolver = {
     // 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 orderSource: string = arrivalNotice.source
-    switch (orderSource) {
-      case ApplicationType.SELLERCRAFT:
-        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)
-        }
-        break
-
-      case ApplicationType.MMS:
-        const marketplaceStores: MarketplaceStore[] = await tx.getRepository(MarketplaceStore).find({
-          where: { domain: companyDomain, status: 'ACTIVE', isAutoUpdateStockQty: true },
-          relations: ['marketplaceDistributors']
-        })
-
-        if (marketplaceStores?.length && marketplaceStores.some(store => store.isAutoUpdateStockQty)) {
-          const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
-          await ecommerceCtrl.updateProductVariationStock(marketplaceStores, arrivalNotice.orderProducts, companyDomain)
-        }
-        break
+    const sellercraft: Sellercraft = await tx
+      .getRepository(Sellercraft)
+      .findOne({ domain: customerDomain, status: SellercraftStatus.ACTIVE })
 
-      default:
-        break
+    if (sellercraft) {
+      const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
+      await sellercraftCtrl.registerProductInbound(sellercraft, arrivalNotice)
     }
 
-    // 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)
-    // }
+    if (marketplaceStores?.length && marketplaceStores.some(store => store.isAutoUpdateStockQty)) {
+      const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
+      await ecommerceCtrl.updateProductVariationStock(marketplaceStores, arrivalNotice.orderProducts, companyDomain)
+    }
   }
 }
 

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

@@ -1,36 +1,38 @@
-import { EntityManager } from 'typeorm'
-
 import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
-import { ORDER_PRODUCT_STATUS, OrderInventory } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
+import { OrderInventory, ORDER_PRODUCT_STATUS } from '@things-factory/sales-base'
 import {
   Inventory,
-  INVENTORY_STATUS,
-  INVENTORY_TRANSACTION_TYPE,
   InventoryHistory,
-  InventoryNoGenerator
+  InventoryNoGenerator,
+  INVENTORY_STATUS,
+  INVENTORY_TRANSACTION_TYPE
 } from '@things-factory/warehouse-base'
-
+import { EntityManager } from 'typeorm'
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
 import { Worksheet, WorksheetDetail } from '../../../entities'
 
 export const transfer = {
   async transfer(_: any, { palletId, toPalletId, qty }, context: any) {
-    const { tx, domain, bizplace, user }: { tx: EntityManager; domain: Domain; bizplace: Bizplace; user: User } =
-      context.state
+    const {
+      tx,
+      domain,
+      bizplace,
+      user
+    }: { tx: EntityManager; domain: Domain; bizplace: Bizplace; user: User } = context.state
 
     // 1. get to inventory
     let toInventory: Inventory = await tx.getRepository(Inventory).findOne({
       where: { domain: domain, palletId: toPalletId },
-      relations: ['bizplace', 'product', 'productDetail', 'warehouse', 'location']
+      relations: ['bizplace', 'product', 'warehouse', 'location']
     })
     if (!toInventory) throw new Error(`to pallet doesn't exists`)
 
     // 2. get from inventory
     let fromInventory: Inventory = await tx.getRepository(Inventory).findOne({
       where: { domain: domain, palletId },
-      relations: ['bizplace', 'product', 'productDetail', 'warehouse', 'location']
+      relations: ['bizplace', 'product', 'warehouse', 'location']
     })
     if (!fromInventory) throw new Error(`from pallet doesn't exists`)
     if (toInventory.batchId !== fromInventory.batchId) throw new Error(`Can't transfer to different batch`)
@@ -72,7 +74,6 @@ export const transfer = {
         domain: domain,
         name: InventoryNoGenerator.inventoryHistoryName(),
         product: toInventory.product,
-        productDetail: toInventory.productDetail,
         warehouse: toInventory.warehouse,
         location: toInventory.location,
         seq: toInventory.lastSeq,
@@ -96,7 +97,7 @@ export const transfer = {
 
       fromInventory = await tx.getRepository(Inventory).findOne({
         where: { id: fromInventory.id },
-        relations: ['bizplace', 'product', 'productDetail', 'warehouse', 'location']
+        relations: ['bizplace', 'product', 'warehouse', 'location']
       })
 
       //    - add inventory history
@@ -104,7 +105,6 @@ export const transfer = {
         ...fromInventory,
         name: InventoryNoGenerator.inventoryHistoryName(),
         product: fromInventory.product,
-        productDetail: fromInventory.productDetail,
         warehouse: fromInventory.warehouse,
         location: fromInventory.location,
         seq: fromInventory.lastSeq,
@@ -131,7 +131,7 @@ export const transfer = {
 
       toInventory = await tx.getRepository(Inventory).findOne({
         where: { id: toInventory.id },
-        relations: ['bizplace', 'product', 'productDetail', 'warehouse', 'location']
+        relations: ['bizplace', 'product', 'warehouse', 'location']
       })
       //    - add inventory history
       delete toInventory.id
@@ -140,7 +140,6 @@ export const transfer = {
         domain,
         name: InventoryNoGenerator.inventoryHistoryName(),
         product: toInventory.product,
-        productDetail: toInventory.productDetail,
         warehouse: toInventory.warehouse,
         location: toInventory.location,
         seq: toInventory.lastSeq,
@@ -158,7 +157,7 @@ export const transfer = {
 
       fromInventory = await tx.getRepository(Inventory).findOne({
         where: { id: fromInventory.id },
-        relations: ['bizplace', 'product', 'productDetail', 'warehouse', 'location']
+        relations: ['bizplace', 'product', 'warehouse', 'location']
       })
 
       //    - add inventory history
@@ -166,7 +165,6 @@ export const transfer = {
         ...fromInventory,
         name: InventoryNoGenerator.inventoryHistoryName(),
         product: fromInventory.product,
-        productDetail: fromInventory.productDetail,
         warehouse: fromInventory.warehouse,
         location: fromInventory.location,
         seq: fromInventory.lastSeq,

package/server/graphql/resolvers/worksheet/vas-transactions/common-utils.ts

@@ -19,13 +19,12 @@ import {
   InventoryNoGenerator,
   Location,
   Pallet,
-  Warehouse,
-  generateInventoryHistory
+  Warehouse
 } from '@things-factory/warehouse-base'
 
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../../constants'
 import { Worksheet, WorksheetDetail } from '../../../../entities'
-import { WorksheetNoGenerator } from '../../../../utils'
+import { generateInventoryHistory, WorksheetNoGenerator } from '../../../../utils'
 import {
   OperationGuideInterface,
   PackingUnits,

package/server/graphql/resolvers/worksheet-detail/regenerate-release-good-worksheet-details.ts

@@ -19,7 +19,7 @@ import { WorksheetNoGenerator } from '../../../utils'
 export const regenerateReleaseGoodWorksheetDetailsResolver = {
   async regenerateReleaseGoodWorksheetDetails(
     _: any,
-    { worksheetNo, batchId, productId, productDetailId, packingType, packingSize, orderProductId, worksheetDetails },
+    { worksheetNo, batchId, productId, packingType, packingSize, orderProductId, worksheetDetails },
     context: any
   ): Promise<void> {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
@@ -30,7 +30,6 @@ export const regenerateReleaseGoodWorksheetDetailsResolver = {
       worksheetNo,
       batchId,
       productId,
-      productDetailId,
       packingType,
       packingSize,
       orderProductId,
@@ -46,7 +45,6 @@ export async function regenerateReleaseGoodWorksheetDetails(
   worksheetNo: string,
   batchId: string,
   productId: string,
-  productDetailId: string,
   packingType: string,
   packingSize: number,
   orderProductId: string,
@@ -117,7 +115,6 @@ export async function regenerateReleaseGoodWorksheetDetails(
         batchIdRef: inventory.batchIdRef,
         status: ORDER_INVENTORY_STATUS.READY_TO_PICK,
         product: await tx.getRepository(Product).findOne(productId),
-        productDetail: productDetailId,
         packingType,
         packingSize,
         orderProduct: targetProduct,

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

@@ -32,7 +32,6 @@ export const Mutation = /* GraphQL */ `
     worksheetNo: String!
     batchId: String!
     productId: String!
-    productDetailId: String!
     packingType: String!
     packingSize: Float!
     orderProductId: String!

package/server/utils/inventory-util.ts

@@ -4,9 +4,134 @@ import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
 import { Product } from '@things-factory/product-base'
 import { Domain } from '@things-factory/shell'
-import { Inventory, INVENTORY_STATUS, Location, LOCATION_STATUS, LOCATION_TYPE } from '@things-factory/warehouse-base'
+import {
+  Inventory,
+  INVENTORY_STATUS,
+  InventoryHistory,
+  InventoryNoGenerator,
+  Location,
+  LOCATION_STATUS,
+  LOCATION_TYPE
+} from '@things-factory/warehouse-base'
 
 /**
+ * @description It will insert new record into inventory histories table.
+ * seq will be calculated based on number of records for one specific pallet id (provided by inventory object)
+ */
+export async function generateInventoryHistory(
+  inventory: Inventory,
+  refOrder: any,
+  transactionType: string,
+  qty: number = 0,
+  uomValue: number = 0,
+  user: User,
+  trxMgr?: EntityManager,
+  targetInventory: Inventory = {}
+): Promise<InventoryHistory> {
+  const invHistoryRepo: Repository<InventoryHistory> =
+    trxMgr?.getRepository(InventoryHistory) || getRepository(InventoryHistory)
+  const invRepo: Repository<Inventory> = trxMgr?.getRepository(Inventory) || getRepository(Inventory)
+
+  if (!inventory?.id) throw new Error(`Can't find out ID of inventory.`)
+  if (!refOrder?.id || !refOrder.name) throw new Error(`Can't find out ID or Name of Reference Order`)
+  if (
+    !inventory?.domain ||
+    !inventory?.bizplace ||
+    !inventory?.product?.id ||
+    !inventory?.warehouse?.id ||
+    !inventory?.location?.id
+  ) {
+    inventory = await invRepo.findOne({
+      where: { id: inventory.id },
+      relations: ['domain', 'bizplace', 'product', 'warehouse', 'location']
+    })
+  }
+
+  const domain: Domain = inventory.domain
+  const location: Location = inventory.location
+
+  const seq: number = await invHistoryRepo.count({ domain: inventory.domain, palletId: inventory.palletId })
+  let openingQty: number = 0
+  let openingUomValue: number = 0
+
+  if (seq) {
+    const lastInvHistory: InventoryHistory = await invHistoryRepo.findOne({
+      domain: inventory.domain,
+      palletId: inventory.palletId,
+      seq: seq - 1
+    })
+
+    openingQty = lastInvHistory.openingQty + lastInvHistory.qty
+    openingUomValue = lastInvHistory.openingUomValue + lastInvHistory.uomValue
+  }
+
+  if (transactionType == 'PICKING' || transactionType == 'UNLOADING') {
+    const [findSameOrderHistory, total]: InventoryHistory = await invHistoryRepo.findAndCount({
+      domain: inventory.domain,
+      palletId: inventory.palletId,
+      refOrderId: refOrder.id
+    })
+
+    if (findSameOrderHistory) {
+      let prevTotalQty = 0
+      let prevTotalUomValue = 0
+      for (let oh of findSameOrderHistory) {
+        prevTotalQty += oh.qty
+        prevTotalUomValue += oh.uomValue
+      }
+      qty -= prevTotalQty
+      uomValue -= prevTotalUomValue
+    }
+  }
+
+  let inventoryHistory: InventoryHistory = new InventoryHistory()
+  inventoryHistory.name = InventoryNoGenerator.inventoryHistoryName()
+  inventoryHistory.description = inventory.description
+  inventoryHistory.seq = seq
+  inventoryHistory.palletId = inventory.palletId
+  inventoryHistory.cartonId = inventory.cartonId
+  inventoryHistory.batchId = inventory.batchId
+  inventoryHistory.batchIdRef = inventory.batchIdRef
+  inventoryHistory.status = inventory.status
+  inventoryHistory.transactionType = transactionType
+  inventoryHistory.refOrderId = refOrder?.id || null
+  inventoryHistory.orderNo = refOrder?.name || null
+  inventoryHistory.orderRefNo = refOrder?.refNo || null
+  inventoryHistory.inventory = inventory
+  inventoryHistory.targetInventory = targetInventory
+  inventoryHistory.product = inventory.product
+  inventoryHistory.reusablePallet = inventory.reusablePallet
+  inventoryHistory.zone = inventory.zone
+  inventoryHistory.warehouse = inventory.warehouse
+  inventoryHistory.location = inventory.location
+  inventoryHistory.expirationDate = inventory.expirationDate
+  inventoryHistory.packingType = inventory.packingType
+  inventoryHistory.packingSize = inventory.packingSize
+  inventoryHistory.uom = inventory.uom
+  inventoryHistory.qty = qty
+  inventoryHistory.openingQty = openingQty
+  inventoryHistory.uomValue = uomValue
+  inventoryHistory.openingUomValue = openingUomValue
+  inventoryHistory.unitCost = inventory.unitCost
+  inventoryHistory.domain = inventory.domain
+  inventoryHistory.bizplace = inventory.bizplace
+  inventoryHistory.creator = user
+  inventoryHistory.updater = user
+
+  inventoryHistory = await invHistoryRepo.save(inventoryHistory)
+
+  if (inventory.lastSeq !== seq) {
+    await invRepo.save({
+      id: inventory.id,
+      lastSeq: inventoryHistory.seq,
+      updater: user
+    })
+  }
+
+  await switchLocationStatus(domain, location, user, trxMgr)
+  return inventoryHistory
+}
+
 /**
  * @description: Check location emptiness and update status of location
  * @param domain