@things-factory/worksheet-base 4.3.108 → 4.3.109

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

@@ -32,7 +32,6 @@ export const batchPickingWorksheetResolver = {
       .addSelect('"PROD".name', 'productName')
       .addSelect('"PROD".sku', 'productSku')
       .addSelect('"PROD".description', 'productDescription')
-      .addSelect('"PROD_DET".id', 'productDetailId')
       .addSelect('"INV".qty', 'qty')
       .addSelect('"INV".packing_type', 'packingType')
       .addSelect('"INV".packing_size', 'packingSize')
@@ -48,7 +47,6 @@ export const batchPickingWorksheetResolver = {
       .leftJoin('WSD.targetInventory', 'T_INV')
       .leftJoin('T_INV.inventory', 'INV')
       .leftJoin('T_INV.product', 'PROD')
-      .leftJoin('T_INV.productDetail', 'PROD_DET')
       .leftJoin('T_INV.binLocation', 'BIN_LOC')
       .leftJoin('INV.location', 'LOC')
       .where('"WSD"."worksheet_id" = :worksheetId', { worksheetId: worksheet.id })
@@ -66,7 +64,6 @@ export const batchPickingWorksheetResolver = {
       .addGroupBy('"PROD".name')
       .addGroupBy('"PROD".sku')
       .addGroupBy('"PROD".description')
-      .addGroupBy('"PROD_DET".id')
       .addGroupBy('"T_INV".batch_id')
       .addGroupBy('"T_INV".packing_type')
       .addGroupBy('BIN_LOC.name')
@@ -129,9 +126,6 @@ export const batchPickingWorksheetResolver = {
               name: item?.productName,
               description: item?.productDescription,
               sku: item?.productSku
-            },
-            productDetail: {
-              id: item?.productDetailId
             }
           }
         }

package/server/graphql/resolvers/worksheet/check-stock-take-current-location.ts

@@ -6,58 +6,56 @@ import { WorksheetDetail } from '../../../entities'
 
 export const checkStockTakeCurrentLocationResolver = {
   async checkStockTakeCurrentLocation(_: any, { palletId, cycleCountNo }, context: any) {
-    try {
-      const { domain }: { domain: Domain } = context.state
-      const invRepo: Repository<Inventory> = getRepository(Inventory)
-      const worksheetDetailRepo: Repository<WorksheetDetail> = getRepository(WorksheetDetail)
-      const inventoryCheckRepo: Repository<InventoryCheck> = getRepository(InventoryCheck)
-
-      const inventory: Inventory = await invRepo.findOne({
-        where: { domain, palletId },
-        relations: ['bizplace']
-      })
-
-      const cycleCount: InventoryCheck = await inventoryCheckRepo.findOne({
-        where: { domain, name: cycleCountNo },
-        relations: [
-          'orderInventories',
-          'orderInventories.inventory',
-          'orderInventories.inventory.location',
-          'orderInventories.inventory.product'
-        ]
-      })
-
-      const orderInventories: OrderInventory[] = cycleCount.orderInventories
-
-      const foundInventory: Inventory = orderInventories.find(
-        (oi: OrderInventory) => oi.inventory.palletId === inventory.palletId
-      )?.inventory
-
-      const foundWSD: any[] = await Promise.all(
-        orderInventories
-          .filter((oi: OrderInventory) => oi.inventory.palletId === inventory.palletId)
-          .map(async (oi: OrderInventory) => {
-            const matchingWSD = await worksheetDetailRepo.findOne({
-              where: { domain, targetInventory: oi }
-            })
-
-            return matchingWSD
+    const { domain }: { domain: Domain } = context.state
+    const invRepo: Repository<Inventory> = getRepository(Inventory)
+    const worksheetDetailRepo: Repository<WorksheetDetail> = getRepository(WorksheetDetail)
+    const inventoryCheckRepo: Repository<InventoryCheck> = getRepository(InventoryCheck)
+
+    const inventory: Inventory = await invRepo.findOne({
+      where: { domain, palletId },
+      relations: ['bizplace']
+    })
+
+    const cycleCount: InventoryCheck = await inventoryCheckRepo.findOne({
+      where: { domain, name: cycleCountNo },
+      relations: [
+        'orderInventories',
+        'orderInventories.inventory',
+        'orderInventories.inventory.location',
+        'orderInventories.inventory.product'
+      ]
+    })
+
+    const orderInventories: OrderInventory[] = cycleCount.orderInventories
+
+    const foundInventory: Inventory = orderInventories.find(
+      (oi: OrderInventory) => oi.inventory.palletId === inventory.palletId
+    ).inventory
+
+    const foundWSD: any[] = await Promise.all(
+      orderInventories
+        .filter((oi: OrderInventory) => oi.inventory.palletId === inventory.palletId)
+        .map(async (oi: OrderInventory) => {
+          const matchingWSD = await worksheetDetailRepo.findOne({
+            where: { domain, targetInventory: oi }
           })
-      )
-
-      if (!foundInventory) throw new Error(`${inventory.palletId} is not in cycle count worksheet`)
-
-      return {
-        worksheetDetailName: foundWSD[0].name,
-        currentLocation: foundInventory.location.name,
-        palletId: foundInventory.palletId,
-        batchId: foundInventory.batchId,
-        qty: foundInventory.qty,
-        uomValue: foundInventory.uomValue,
-        uom: foundInventory.uom,
-        productName: foundInventory.product.name,
-        productDescription: foundInventory.product.description
-      }
-    } catch (e) {}
+
+          return matchingWSD
+        })
+    )
+
+    if (!foundInventory) throw new Error(`${inventory.palletId} is not in cycle count worksheet`)
+
+    return {
+      worksheetDetailName: foundWSD[0].name,
+      currentLocation: foundInventory.location.name,
+      palletId: foundInventory.palletId,
+      batchId: foundInventory.batchId,
+      qty: foundInventory.qty,
+      uomValue: foundInventory.uomValue,
+      uom: foundInventory.uom,
+      productName: foundInventory.product.name,
+      productDescription: foundInventory.product.description
+    }
   }
 }

package/server/graphql/resolvers/worksheet/confirm-cancellation-release-order.ts

@@ -11,9 +11,10 @@ import {
   ReleaseGood
 } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { Inventory, INVENTORY_STATUS, INVENTORY_TRANSACTION_TYPE, Location, generateInventoryHistory } from '@things-factory/warehouse-base'
+import { Inventory, INVENTORY_STATUS, INVENTORY_TRANSACTION_TYPE, Location } from '@things-factory/warehouse-base'
 
 import { Worksheet, WorksheetDetail } from '../../../entities'
+import { generateInventoryHistory } from '../../../utils'
 
 export const confirmCancellationReleaseOrder = {
   async confirmCancellationReleaseOrder(_: any, { name }, context: any) {

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

@@ -4,12 +4,12 @@ import { User } from '@things-factory/auth-base'
 import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
 import { InventoryCheck, ORDER_INVENTORY_STATUS, ORDER_STATUS, OrderInventory } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { Inventory, INVENTORY_STATUS, INVENTORY_TRANSACTION_TYPE, Location, generateInventoryHistory } from '@things-factory/warehouse-base'
+import { Inventory, INVENTORY_STATUS, INVENTORY_TRANSACTION_TYPE, Location } from '@things-factory/warehouse-base'
 
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
 import { SellercraftController } from '../../../controllers'
 import { Worksheet, WorksheetDetail } from '../../../entities'
-import { switchLocationStatus } from '../../../utils'
+import { generateInventoryHistory, switchLocationStatus } from '../../../utils'
 
 export const cycleCountAdjustmentResolver = {
   async cycleCountAdjustment(_: any, { cycleCountNo }, context: any) {

package/server/graphql/resolvers/worksheet/inventories-by-pallet.ts

@@ -40,7 +40,6 @@ export const inventoriesByPalletResolver = {
     qb.leftJoinAndSelect('iv.domain', 'domain')
       .leftJoinAndSelect('iv.bizplace', 'bizplace')
       .leftJoinAndSelect('iv.product', 'product')
-      .leftJoinAndSelect('iv.productDetail', 'productDetail')
       .leftJoinAndSelect('iv.warehouse', 'warehouse')
       .leftJoinAndSelect('iv.location', 'location')
       .leftJoinAndSelect('iv.creator', 'creator')
@@ -135,8 +134,7 @@ export const inventoriesByPalletResolver = {
           productName: item.product.name,
           productSKU: item.product.sku,
           productBrand: item.product.brand,
-          productId: item.product.id,
-          productDetailId: item.productDetail.id
+          productId: item.product.id
         }
       })
     )

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

@@ -14,7 +14,7 @@ import { PartnerSetting, Setting } from '@things-factory/setting-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory, Location } from '@things-factory/warehouse-base'
 
-import { WORKSHEET_TYPE, WORKSHEET_STATUS } from '../../../constants'
+import { WORKSHEET_TYPE } from '../../../constants'
 import { PackingWorksheetController, SellercraftController } from '../../../controllers'
 import { Worksheet, WorksheetDetail } from '../../../entities'
 
@@ -104,9 +104,7 @@ export const packingWorksheetResolver = {
 
       if (!worksheet) throw new Error('Worksheet does not exist')
 
-      if (worksheet.status === WORKSHEET_STATUS.DONE) {
-        throw new Error(`Worksheet is completed already`)
-      } else if (worksheet.status === WORKSHEET_STATUS.DEACTIVATED) {
+      if (worksheet.status === 'DEACTIVATED') {
         const packingWSCtrl: PackingWorksheetController = new PackingWorksheetController(tx, domain, user)
 
         const directActivatePackingWorksheet: Setting = await tx.getRepository(Setting).findOne({

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

@@ -93,9 +93,9 @@ export async function completeBatchPicking(
           break
 
         case ApplicationType.MMS:
-          const companyDomain: Domain = releaseGood.bizplace.company.domain
+          const companyDomain: Domain = foundReleaseGood.bizplace.company.domain
           const marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
-            where: { orderNo: releaseGood.refNo, domain: companyDomain },
+            where: { orderNo: foundReleaseGood.refNo, domain: companyDomain },
             relations: [
               'marketplaceOrderItems',
               'marketplaceOrderItems.marketplaceOrderShippingItems',
@@ -108,7 +108,7 @@ export async function completeBatchPicking(
 
           if (marketplaceStore?.isAutoUpdateShipment) {
             const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
-            await ecommerceCtrl.createOrderShip(releaseGood, marketplaceStore, marketplaceOrder, companyDomain)
+            await ecommerceCtrl.createOrderShip(foundReleaseGood, marketplaceStore, marketplaceOrder, companyDomain)
           }
           break
 

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/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/unloaded-inventories.ts

@@ -44,7 +44,7 @@ export const unloadedInventories = {
           orderProductId: In(foundWorksheetDetails.map(wsd => wsd.targetProduct.id)),
           status: In([INVENTORY_STATUS.UNLOADED, INVENTORY_STATUS.CHECKED])
         },
-        relations: ['reusablePallet', 'product', 'bizplace', 'inventoryItems']
+        relations: ['reusablePallet', 'product', 'bizplace']
       })
       const items = foundInv.map((inv: Inventory) => {
         const expirationDate: Date = inv.expirationDate ? new Date(inv.expirationDate) : null

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/worksheets.ts

@@ -242,7 +242,7 @@ export const worksheetsResolver = {
             params.filters.findIndex(item => item.name == 'executionDate'),
             1
           )
-          arrFilters.push({ ...executionDateParam, name: 'executionDate' })
+          arrFilters.push({ ...releaseGoodRefNoParam, name: 'refNo' })
         }
         const foundInventoryCheck: InventoryCheck[] = await getRepository(InventoryCheck).find({
           ...convertListParams({ filters: arrFilters })

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