@things-factory/warehouse-base 8.0.2 → 8.0.5

package/server/service/inventory-change/inventory-change-mutation.ts

@@ -1,969 +0,0 @@
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { Equal, In, MoreThan, Not } from 'typeorm'
-
-import { Bizplace } from '@things-factory/biz-base'
-import { generateId } from '@things-factory/id-rule-base'
-import { MarketplaceStore } from '@things-factory/integration-marketplace'
-import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
-import { Product } from '@things-factory/product-base'
-import { PartnerSetting, Setting } from '@things-factory/setting-base'
-import { Domain } from '@things-factory/shell'
-
-import { INVENTORY_ITEM_CHANGE_TYPE, INVENTORY_ITEM_SOURCE, INVENTORY_STATUS, LOCATION_STATUS } from '../../constants'
-import { EcommerceController, SellercraftController } from '../../controllers'
-import { InventoryNoGenerator } from '../../utils'
-import { InventoryHistory } from '../inventory-history/inventory-history'
-import { InventoryItemChange } from '../inventory-item-change/inventory-item-change'
-import { InventoryItem } from '../inventory-item/inventory-item'
-import { checkExistingSerialNumber } from '../inventory-item/inventory-item-query'
-import { Inventory } from '../inventory/inventory'
-import { InventoryPatch } from '../inventory/inventory-types'
-import { Location } from '../location/location'
-import { InventoryChange } from './inventory-change'
-import { InventoryChangeList, InventoryChangePatch, NewInventoryChange } from './inventory-change-types'
-
-@Resolver(InventoryChange)
-export class InventoryChangeMutation {
-  @Directive('@transaction')
-  @Mutation(returns => InventoryChange)
-  async createInventoryChange(@Arg('inventoryChange') inventoryChange: NewInventoryChange, @Ctx() context: ResolverContext): Promise<InventoryChange> {
-    const { domain, user, tx } = context.state
-
-    return await tx.getRepository(InventoryChange).save({
-      ...inventoryChange,
-      domain: domain,
-      creator: user,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => InventoryChange)
-  async updateInventoryChange(@Arg('name') name: string, @Arg('patch') patch: InventoryChangePatch, @Ctx() context: ResolverContext): Promise<InventoryChange> {
-    const { domain, user, tx } = context.state
-
-    const repository = tx.getRepository(InventoryChange)
-    const inventoryChange = await repository.findOne({
-      where: { domain: { id: domain.id }, name }
-    })
-
-    return await repository.save({
-      ...inventoryChange,
-      ...patch,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [InventoryChange])
-  async updateMultipleInventoryChange(
-    @Arg('patches', type => [InventoryChangePatch]) patches: InventoryChangePatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<InventoryChange[]> {
-    const { domain, user, tx } = context.state
-    let results = []
-    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
-    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-    const inventoryChangeRepo = tx.getRepository(InventoryChange)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await inventoryChangeRepo.save({
-          ...newRecord,
-          domain: domain,
-          creator: user,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const newRecord = _updateRecords[i]
-        const inventoryChange = await inventoryChangeRepo.findOneBy({ id: newRecord.id })
-
-        const result = await inventoryChangeRepo.save({
-          ...inventoryChange,
-          ...newRecord,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean)
-  async deleteInventoryChange(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<Boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(InventoryChange).delete({ domain: { id: domain.id }, name })
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean)
-  async deleteInventoryChanges(@Arg('names', type => [String]) names: string[], @Ctx() context: ResolverContext): Promise<Boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(InventoryChange).delete({
-      domain: { id: domain.id },
-      name: In(names)
-    })
-    return true
-  }
-
-  @Directive('@privilege(category: "inventory", privilege: "mutation")')
-  @Directive('@transaction')
-  @Mutation(returns => Boolean)
-  async submitInventoryChanges(@Arg('patches', type => [InventoryPatch]) patches: InventoryPatch[], @Ctx() context: ResolverContext) {
-    const { domain, user, tx } = context.state
-    try {
-      const _createRecords = []
-      const _updateRecords = []
-
-      for (let i = 0; i < patches.length; i++) {
-        let foundExistingPallet = await tx
-          .getRepository(Inventory)
-          .createQueryBuilder('iv')
-          .where('iv.domain_id = :domain_id', { domain_id: domain.id })
-          .andWhere('(iv.pallet_id = :pallet_id or iv.id = :id)', {
-            pallet_id: patches[i]?.palletId,
-            id: patches[i]?.id
-          })
-          .getOne()
-
-        //remove any unchanged records
-        for (const [key, value] of Object.entries(patches[i])) {
-          if (foundExistingPallet && key != 'id' && key != 'cuFlag' && value == foundExistingPallet[key]) {
-            delete patches[i][key]
-          }
-        }
-
-        // skip process when no processable data found
-        if (Object.keys(patches[i]).filter(x => x != 'id' && x != 'cuFlag').length == 0) {
-          continue
-        }
-
-        const invLockedQty: number = foundExistingPallet?.lockedQty == null ? 0 : foundExistingPallet?.lockedQty
-
-        if (patches[i]?.qty < invLockedQty) {
-          throw new Error('Adjusted qty value should not be lower than released qty, kindly contact our support for assistance')
-        }
-
-        if (foundExistingPallet) {
-          delete patches[i].serialNumbers
-          _updateRecords.push(patches[i])
-        } else {
-          _createRecords.push(patches[i])
-        }
-      }
-
-      const inventoryChangeRepo = tx.getRepository(InventoryChange)
-      const inventoryItemChangeRepo = tx.getRepository(InventoryItemChange)
-      if (_createRecords.length > 0) {
-        for (let i = 0; i < _createRecords.length; i++) {
-          const newRecord = _createRecords[i]
-
-          var location = await tx.getRepository(Location).findOne({
-            where: { id: newRecord.location.id },
-            relations: ['warehouse']
-          })
-          newRecord.location = location
-          newRecord.zone = location.zone
-          newRecord.warehouse = location.warehouse
-
-          newRecord.bizplace = await tx.getRepository(Bizplace).findOneBy({ id: newRecord.bizplace.id })
-
-          var product: Product = await tx.getRepository(Product).findOne(newRecord.product.id)
-          newRecord.product = product
-
-          newRecord.status = 'PENDING'
-          newRecord.transactionType = 'NEW'
-
-          newRecord.expirationDate = ((newRecord?.expirationDate && new Date(newRecord.expirationDate).getFullYear()) || 0) < 2000 ? null : newRecord.expirationDate
-
-          const newInventoryChange: InventoryChange = await inventoryChangeRepo.save({
-            ...newRecord,
-            id: undefined,
-            name: InventoryNoGenerator.inventoryName(),
-            domain: domain,
-            creator: user,
-            updater: user
-          })
-
-          if (newRecord?.serialNumbers) {
-            let serialNumbers: string = newRecord.serialNumbers
-            let newSerialNumbers: any = serialNumbers.split(',')
-            let inventoryItemChanges: InventoryItemChange[] = []
-
-            for (let i = 0; i < newSerialNumbers.length; i++) {
-              let newSerialNumber: string = newSerialNumbers[i]
-              let inventoryItemChange: any = {
-                serialNumber: newSerialNumber,
-                type: INVENTORY_ITEM_CHANGE_TYPE.NEW
-              }
-
-              inventoryItemChanges.push(inventoryItemChange)
-            }
-
-            newRecord.inventoryItemChangesJson = JSON.stringify(inventoryItemChanges)
-          }
-
-          // create new inventory items
-          if (newRecord?.inventoryItemChangesJson) {
-            const inventoryItemChanges: InventoryItemChange[] = JSON.parse(newRecord.inventoryItemChangesJson)
-            if (product?.isRequireSerialNumberScanningInbound) {
-              if (inventoryItemChanges?.length != newRecord?.qty) {
-                throw new Error('Serial Numbers not tally with quantity')
-              }
-            }
-
-            let newInventoryItemChanges: InventoryItemChange[] = []
-
-            inventoryItemChanges.map(inventoryItemChange => {
-              let newInventoryItemChange: InventoryItemChange = new InventoryItemChange()
-              newInventoryItemChange.name = InventoryNoGenerator.inventoryName()
-              newInventoryItemChange.serialNumber = inventoryItemChange.serialNumber
-              newInventoryItemChange.type = inventoryItemChange.type
-              newInventoryItemChange.status = newInventoryChange.status
-              newInventoryItemChange.inventoryItem = newInventoryItemChange?.type == INVENTORY_ITEM_CHANGE_TYPE.NEW ? null : newInventoryItemChange.inventoryItem
-              newInventoryItemChange.inventoryChange = newInventoryChange
-              newInventoryItemChange.domain = domain
-              newInventoryItemChange.creator = user
-              newInventoryItemChange.updater = user
-
-              newInventoryItemChanges.push(newInventoryItemChange)
-            })
-
-            await inventoryItemChangeRepo.save(newInventoryItemChanges)
-          }
-        }
-      }
-
-      if (_updateRecords.length > 0) {
-        for (let i = 0; i < _updateRecords.length; i++) {
-          const updateRecord = _updateRecords[i]
-
-          let existingRecord = await tx.getRepository(Inventory).findOne({
-            where: { domain: { id: domain.id }, palletId: Equal(updateRecord?.palletId) },
-            relations: ['location', 'warehouse', 'product', 'bizplace']
-          })
-
-          if (!existingRecord) {
-            existingRecord = await tx.getRepository(Inventory).findOne({
-              where: { domain: { id: domain.id }, id: updateRecord?.id },
-              relations: ['location', 'warehouse', 'product', 'bizplace']
-            })
-          }
-
-          if (!!updateRecord?.location?.id) {
-            var location = await tx.getRepository(Location).findOne({
-              where: { id: updateRecord.location.id },
-              relations: ['warehouse']
-            })
-            updateRecord.location = location
-            updateRecord.zone = location.zone
-            updateRecord.warehouse = location.warehouse
-          }
-
-          if (!!updateRecord?.bizplace?.id) updateRecord.bizplace = await tx.getRepository(Bizplace).findOne(updateRecord.bizplace.id)
-
-          let product: Product
-
-          if (!!updateRecord?.product?.id) {
-            product = await tx.getRepository(Product).findOne(updateRecord.product.id)
-            updateRecord.product = product
-          } else {
-            product = existingRecord.product
-          }
-
-          if (!updateRecord.transactionType) {
-            updateRecord.transactionType = 'CHANGES'
-          }
-
-          updateRecord.status = 'PENDING'
-
-          updateRecord.expirationDate =
-            ((updateRecord?.expirationDate && new Date(updateRecord.expirationDate).getFullYear()) || 0) < 2000 ? null : updateRecord.expirationDate
-
-          const updatedInventoryChange: InventoryChange = await inventoryChangeRepo.save({
-            palletId: existingRecord.palletId,
-            ...updateRecord,
-            id: undefined,
-            name: InventoryNoGenerator.inventoryName(),
-            inventory: existingRecord,
-            domain: domain,
-            creator: user,
-            updater: user
-          })
-
-          // create new inventory items
-          if (updateRecord?.inventoryItemChangesJson) {
-            const originalInventoryItems: InventoryItem[] = await tx.getRepository(InventoryItem).find({
-              where: { domain: { id: domain.id }, inventory: { id: existingRecord.id }, status: Not('DELETED') }
-            })
-            const inventoryItemChanges: InventoryItemChange[] = JSON.parse(updateRecord.inventoryItemChangesJson)
-            if (product?.isRequireSerialNumberScanningInbound) {
-              // const combinedInventoryItems: any[] = [...originalInventoryItems, ...inventoryItemChanges]
-              let qty: number = updateRecord?.qty ? updateRecord.qty : existingRecord.qty
-
-              if (originalInventoryItems.length == 0) {
-                if (inventoryItemChanges.length !== qty) {
-                  throw new Error('Serial Numbers not tally with quantity')
-                }
-              } else {
-                if (originalInventoryItems?.length - inventoryItemChanges.length !== qty) {
-                  throw new Error('Serial Numbers not tally with quantity')
-                }
-              }
-            }
-
-            let newInventoryItemChanges: InventoryItemChange[] = []
-
-            inventoryItemChanges.map(inventoryItemChange => {
-              let newInventoryItemChange: InventoryItemChange = new InventoryItemChange()
-              newInventoryItemChange.name = InventoryNoGenerator.inventoryName()
-              newInventoryItemChange.serialNumber = inventoryItemChange.serialNumber
-              newInventoryItemChange.type = inventoryItemChange.type
-              newInventoryItemChange.status = updatedInventoryChange.status
-              newInventoryItemChange.inventory = updatedInventoryChange.inventory
-              newInventoryItemChange.inventoryItem = newInventoryItemChange?.type == INVENTORY_ITEM_CHANGE_TYPE.NEW ? null : inventoryItemChange.inventoryItem
-              newInventoryItemChange.inventoryChange = updatedInventoryChange
-              newInventoryItemChange.domain = domain
-              newInventoryItemChange.creator = user
-              newInventoryItemChange.updater = user
-
-              newInventoryItemChanges.push(newInventoryItemChange)
-            })
-
-            await inventoryItemChangeRepo.save(newInventoryItemChanges)
-          }
-        }
-      }
-
-      /**
-       * @notes Temporary off sendNotification due to suspect of causing wms down
-       */
-      // const notificationApprover: any = await tx
-      //   .getRepository(Privilege)
-      //   .createQueryBuilder('p')
-      //   .select('u.*')
-      //   .addSelect('r.*')
-      //   .innerJoin('p.roles', 'r')
-      //   .innerJoin('r.users', 'u')
-      //   .where('p.name = :name', { name: 'mutation' })
-      //   .andWhere('p.category = :category', { category: 'inventory' })
-      //   .andWhere('r.domain_id = :domainId', { domainId: domain.id })
-      //   .groupBy('u.id')
-      //   .addGroupBy('r.id')
-      //   .getRawMany()
-
-      // if (_updateRecords.some(res => res.transactionType == 'MISSING')) {
-      //   if (notificationApprover?.length && context.header?.referer) {
-      //     const receivers: any[] = notificationApprover.map(user => user.id)
-      //     const msg = {
-      //       title: `Missing stock identified. Review this transaction in Inventory Adjustment Approval.`,
-      //       body: ``,
-      //       url: context.header.referer,
-      //       data: { url: context.header.referer }
-      //     }
-      //     await sendNotification({
-      //       receivers,
-      //       message: { ...msg }
-      //     })
-      //   }
-      // } else {
-      //   if (notificationApprover?.length && context.header?.referer) {
-      //     const receivers: any[] = notificationApprover.map(user => user.id)
-      //     const msg = {
-      //       title: `There is an inventory adjustment pending for approval, kindly review within 1 hour to avoid any operation conflict.`,
-      //       body: ``,
-      //       url: context.header.referer,
-      //       data: { url: context.header.referer }
-      //     }
-      //     await sendNotification({
-      //       receivers,
-      //       message: { ...msg }
-      //     })
-      //   }
-      // }
-
-      return true
-    } catch (error) {
-      throw error
-    }
-  }
-
-  @Directive('@privilege(category: "inventory_adjustment_approval", privilege: "mutation")')
-  @Directive('@transaction')
-  @Mutation(returns => InventoryChangeList)
-  async approveInventoryChanges(
-    @Arg('patches', type => [InventoryChangePatch]) patches: InventoryChangePatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<InventoryChangeList> {
-    const inventoryChangeList = await approveInventoryChanges(patches, context)
-
-    return inventoryChangeList
-  }
-
-  @Directive('@privilege(category: "inventory_adjustment_approval", privilege: "mutation")')
-  @Directive('@transaction')
-  @Mutation(returns => Boolean)
-  async rejectInventoryChanges(@Arg('patches', type => [InventoryChangePatch]) patches: InventoryChangePatch[], @Ctx() context: ResolverContext): Promise<Boolean> {
-    const { domain, user, tx } = context.state
-
-    const _inventoryChanges = await tx.getRepository(InventoryChange).find({
-      where: { id: In(patches.map(item => item.id)) },
-      relations: ['inventory', 'inventory.bizplace', 'inventory.product', 'inventory.location', 'inventory.warehouse', 'bizplace', 'product', 'location']
-    })
-
-    if (_inventoryChanges.length > 0) {
-      for (let i = 0; i < _inventoryChanges.length; i++) {
-        if (_inventoryChanges[i].status.toLocaleLowerCase() != 'pending') return true
-        _inventoryChanges[i].status = 'REJECTED'
-
-        // Get last row of InventoryHistory
-        let latestEntry = await tx.getRepository(InventoryHistory).find({
-          where: { palletId: _inventoryChanges[i].palletId, domain: { id: domain.id } },
-          order: { seq: 'DESC' },
-          take: 1
-        })
-
-        if (latestEntry.length > 0) _inventoryChanges[i].lastInventoryHistory = latestEntry[0]
-
-        await upsertInventoryItems(context, _inventoryChanges[i], 'REJECTED', tx)
-      }
-
-      await tx.getRepository(InventoryChange).save(_inventoryChanges.filter(change => change.status == 'REJECTED'))
-    }
-    return true
-  }
-}
-
-function clean(obj) {
-  var propNames = Object.getOwnPropertyNames(obj)
-  for (var i = 0; i < propNames.length; i++) {
-    var propName = propNames[i]
-    if (obj[propName] === null || obj[propName] === undefined) {
-      delete obj[propName]
-    }
-  }
-}
-
-async function upsertInventoryItems(context, inventoryChange, approvalStatus, tx) {
-  const { domain, user } = context.state
-
-  let inventoryItemChanges: InventoryItemChange[] = await tx.getRepository(InventoryItemChange).find({
-    where: { domain: { id: domain.id }, inventoryChange: { id: inventoryChange.id }, status: 'PENDING' },
-    relations: ['domain', 'inventoryItem', 'inventory', 'inventory.product', 'inventoryChange']
-  })
-  await Promise.all(
-    inventoryItemChanges.map(async inventoryItemChange => {
-      let inventoryItem: InventoryItem = new InventoryItem()
-      if (approvalStatus == 'APPROVED') {
-        const changeType: string = inventoryItemChange.type
-        const existingInventoryItem: InventoryItem = inventoryItemChange.inventoryItem
-        if (changeType == INVENTORY_ITEM_CHANGE_TYPE.NEW) {
-          const foundSerialNumber: Boolean = await checkExistingSerialNumber(
-            inventoryItemChange.serialNumber,
-            inventoryChange.inventory.product,
-            context,
-            inventoryChange.inventory,
-            tx
-          )
-
-          if (foundSerialNumber) throw new Error(`Serial number ${inventoryItemChange.serialNumber} is duplicated`)
-
-          inventoryItem.name = InventoryNoGenerator.inventoryName()
-          inventoryItem.serialNumber = inventoryItemChange.serialNumber
-          inventoryItem.status = INVENTORY_STATUS.STORED
-          inventoryItem.product = inventoryChange.inventory.product
-          inventoryItem.domain = inventoryItemChange.domain
-          inventoryItem.inventory = inventoryChange.inventory
-          inventoryItem.source = INVENTORY_ITEM_SOURCE.ADJUSTMENT
-          inventoryItem.creator = user
-          inventoryItem.updater = user
-        } else if (changeType == INVENTORY_ITEM_CHANGE_TYPE.MODIFIED) {
-          const foundSerialNumber: Boolean = await checkExistingSerialNumber(
-            inventoryItemChange.serialNumber,
-            inventoryItemChange.inventory.product,
-            context,
-            inventoryItemChange.inventory,
-            tx
-          )
-
-          if (foundSerialNumber) throw new Error(`Serial number ${inventoryItemChange.serialNumber} is duplicated`)
-
-          inventoryItem = {
-            ...existingInventoryItem,
-            serialNumber: inventoryItemChange.serialNumber,
-            product: inventoryItemChange.inventory.product
-          }
-        } else if (changeType == INVENTORY_ITEM_CHANGE_TYPE.REMOVED) {
-          inventoryItem = {
-            ...existingInventoryItem,
-            status: INVENTORY_STATUS.DELETED
-          }
-        }
-
-        inventoryItem = await tx.getRepository(InventoryItem).save(inventoryItem)
-      }
-
-      await tx.getRepository(InventoryItemChange).update({ id: inventoryItemChange.id }, { status: approvalStatus, inventoryItem })
-    })
-  )
-}
-
-export async function approveInventoryChanges(patches: any, context: ResolverContext) {
-  const { domain, user, tx } = context.state
-
-  // Get Selected Inventory Change Data
-  const _inventoryChanges = await tx.getRepository(InventoryChange).find({
-    where: { id: In(patches.map(item => item.id)) },
-    relations: [
-      'inventory',
-      'inventory.bizplace',
-      'inventory.bizplace.domain',
-      'inventory.product',
-      'inventory.location',
-      'inventory.warehouse',
-      'bizplace',
-      'bizplace.domain',
-      'bizplace.company',
-      'bizplace.company.domain',
-      'product',
-      'product.productDetails',
-      'product.productDetails.childProductDetail',
-      'location',
-      'location.warehouse'
-    ],
-    order: {
-      createdAt: 'ASC'
-    }
-  })
-
-  let arrLockedInventory: InventoryChange[] = []
-
-  if (_inventoryChanges.length > 0) {
-    let today = new Date(),
-      year = today.getFullYear(),
-      month = today.getMonth(),
-      date = today.getDate()
-
-    for (let i = 0; i < _inventoryChanges.length; i++) {
-      if (_inventoryChanges[i].status.toLocaleLowerCase() != 'pending') continue
-
-      const newRecord: any = { ..._inventoryChanges[i] },
-        newHistoryRecord: any = { ..._inventoryChanges[i] }
-
-      // Adjustment of existing Inventory
-      if (_inventoryChanges[i].inventory != null) {
-        let inventoryId = _inventoryChanges[i].inventory.id
-        let inventory: Inventory = await tx.getRepository(Inventory).findOne({
-          where: { id: inventoryId },
-          relations: [
-            'domain',
-            'bizplace',
-            'bizplace.domain',
-            'bizplace.company',
-            'bizplace.company.domain',
-            'product',
-            'product.productDetails',
-            'product.productDetails.childProductDetail',
-            'warehouse',
-            'location',
-            'creator',
-            'updater'
-          ]
-        })
-
-        const customerDomain: Domain = inventory.bizplace.domain
-
-        // Check for locked inventory, and stop from udpating inventory
-        if (inventory.qty < inventory.lockedQty) {
-          arrLockedInventory.push(_inventoryChanges[i])
-          continue
-        }
-
-        // Check for Terminated inventory, then update InventoryChange entity, and stop from udpating inventory
-        if (inventory.status == INVENTORY_STATUS.TERMINATED) {
-          _inventoryChanges[i] = { ..._inventoryChanges[i], status: 'TERMINATED' }
-          continue
-        }
-
-        let lastSeq = inventory.lastSeq,
-          transactionType = ''
-
-        newHistoryRecord.openingQty = inventory.qty
-        newHistoryRecord.openingUomValue = inventory.uomValue
-
-        // Get last row of InventoryHistory
-        let latestEntry = await tx.getRepository(InventoryHistory).findOne({
-          where: { palletId: inventory.palletId, domain: { id: domain.id } },
-          order: { seq: 'DESC' }
-        })
-        _inventoryChanges[i].lastInventoryHistory = latestEntry
-
-        // Check Change of existing inventory location
-        if (newRecord.location && newRecord.location.id != inventory.location.id) {
-          newRecord.zone = newRecord.location.zone
-          newRecord.warehouse = { id: newRecord.location.warehouse.id }
-          transactionType = 'ADJUSTMENT'
-
-          // Check and set current location status
-          let currentLocationInventoryCount = await tx.getRepository(Inventory).count({
-            where: { location: { id: inventory.location.id }, status: 'STORED', id: Not(inventory.id) }
-          })
-
-          if (currentLocationInventoryCount == 0) {
-            let currentLocation = await tx.getRepository(Location).findOne({
-              where: { id: inventory.location.id }
-            })
-            await tx.getRepository(Location).save({
-              ...currentLocation,
-              status: LOCATION_STATUS.EMPTY
-            })
-          }
-        }
-
-        // Check Change of existing inventory quantity
-        if (newRecord.qty != null && newRecord.qty != inventory.qty) {
-          newHistoryRecord.qty = newRecord.qty - inventory.qty
-          if (newRecord.qty <= 0) {
-            newRecord.qty = 0
-            newRecord.uomValue = 0
-          }
-          transactionType = 'ADJUSTMENT'
-        } else {
-          newHistoryRecord.qty = 0
-        }
-
-        // Check Change of existing inventory uomValue
-        if (newRecord.uomValue != null && newRecord.uomValue != inventory.uomValue) {
-          newHistoryRecord.uomValue = newRecord.uomValue - inventory.uomValue
-          Math.round(newHistoryRecord.uomValue * 100) / 100
-          transactionType = 'ADJUSTMENT'
-        } else {
-          newHistoryRecord.uomValue = 0
-        }
-
-        // Terminate current inventory history if there is change of bizplace, product, batchId, packingType, or uom
-        if (
-          (newRecord.bizplace && inventory.bizplace.id !== newRecord.bizplace.id) ||
-          (newRecord.product && inventory.product.id !== newRecord.product.id) ||
-          (newRecord.batchId && inventory.batchId !== newRecord.batchId) ||
-          (newRecord.packingType && inventory.packingType !== newRecord.packingType) ||
-          (newRecord.uom && inventory.uom !== newRecord.uom)
-        ) {
-          transactionType = 'ADJUSTMENT'
-          lastSeq = lastSeq + 1
-          let inventoryHistory = {
-            ...inventory,
-            domain: domain,
-            bizplace: inventory.bizplace.id,
-            openingQty: inventory.qty,
-            openingUomValue: inventory.uomValue,
-            qty: -inventory.qty || 0,
-            uom: inventory.uom,
-            uomValue: -inventory.uomValue || 0,
-            name: InventoryNoGenerator.inventoryHistoryName(),
-            seq: lastSeq,
-            transactionType: transactionType,
-            status: INVENTORY_STATUS.TERMINATED,
-            productId: inventory.product.id,
-            warehouseId: inventory.warehouse.id,
-            locationId: inventory.location.id,
-            packingType: inventory.packingType,
-            creator: user,
-            updater: user
-          }
-          delete inventoryHistory.id
-          delete inventoryHistory.createdAt
-          delete inventoryHistory.updatedAt
-          await tx.getRepository(InventoryHistory).save(inventoryHistory as any)
-          newHistoryRecord.qty = newRecord.qty != null ? newRecord.qty : inventory.qty || 0
-          newHistoryRecord.uomValue = newRecord.uomValue != null ? newRecord.uomValue : inventory.uomValue || 0
-          newHistoryRecord.openingQty = 0
-          newHistoryRecord.openingUomValue = 0
-        }
-
-        // Set and update inventory and inventory history data
-        lastSeq = lastSeq + 1
-        clean(newHistoryRecord)
-        let inventoryHistory = {
-          ...inventory,
-          ...newHistoryRecord,
-          domain: domain,
-          creator: user,
-          updater: user,
-          name: InventoryNoGenerator.inventoryHistoryName(),
-          status: newHistoryRecord.transactionType == 'MISSING' ? 'MISSING' : 'STORED',
-          seq: lastSeq,
-          transactionType: transactionType == '' ? 'ADJUSTMENT' : transactionType,
-          productId: newRecord.product ? newRecord.product.id : inventory.product.id,
-          warehouseId: newRecord.warehouse ? newRecord.warehouse.id : inventory.warehouse.id,
-          locationId: newRecord.location && newRecord.location.id != inventory.location.id ? newRecord.location.id : inventory.location.id,
-          uom: newRecord.uom != null ? newRecord.uom : inventory.uom
-        }
-        delete inventoryHistory.id
-        delete inventoryHistory.createdAt
-        delete inventoryHistory.updatedAt
-        await tx.getRepository(InventoryHistory).save(inventoryHistory)
-
-        if (newRecord.qty != null && newRecord.qty == 0) {
-          ++lastSeq
-          delete inventoryHistory.id
-          inventoryHistory = {
-            ...inventoryHistory,
-            name: InventoryNoGenerator.inventoryHistoryName(),
-            qty: 0,
-            uomValue: 0,
-            openingQty: 0,
-            openingUomValue: 0,
-            seq: lastSeq,
-            transactionType: 'TERMINATED',
-            status: 'TERMINATED'
-          }
-
-          await tx.getRepository(InventoryHistory).save(inventoryHistory)
-        }
-
-        clean(newRecord)
-        let statusFilter = ''
-        if (newRecord.transactionType == 'MISSING') {
-          statusFilter = 'MISSING'
-        } else {
-          statusFilter = (newRecord.qty != null ? newRecord.qty : inventory.qty) > 0 ? 'STORED' : 'TERMINATED'
-        }
-
-        delete newRecord.createdAt
-        await tx.getRepository(Inventory).save({
-          ...inventory,
-          ...newRecord,
-          id: inventoryId,
-          status: statusFilter,
-          updater: user,
-          lastSeq: lastSeq
-        })
-
-        //Check and set latest location status
-        if (newRecord.qty != null ? newRecord.qty : inventory.qty > 0) {
-          var location = await tx.getRepository(Location).findOne({
-            where: { id: newRecord.location ? newRecord.location.id : inventory.location.id }
-          })
-          await tx.getRepository(Location).save({
-            ...location,
-            status: LOCATION_STATUS.OCCUPIED
-          })
-        } else {
-          let latestLocationInventoryCount = await tx.getRepository(Inventory).count({
-            where: {
-              location: { id: newRecord.location ? newRecord.location.id : inventory.location.id },
-              status: 'STORED',
-              id: Not(inventory.id)
-            }
-          })
-          if (latestLocationInventoryCount == 0) {
-            let latestLocation = await tx.getRepository(Location).findOne({
-              where: { id: newRecord.location ? newRecord.location.id : inventory.location.id }
-            })
-            await tx.getRepository(Location).save({
-              ...latestLocation,
-              status: LOCATION_STATUS.EMPTY
-            })
-          }
-        }
-
-        await upsertInventoryItems(context, _inventoryChanges[i], 'APPROVED', tx)
-
-        const companyDomain: Domain = inventory.bizplace?.company.domain
-
-        const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
-        if (newRecord?.bizplace?.id && inventory.bizplace.id != newRecord?.bizplace?.id) {
-          const prevBizSC: Sellercraft = await tx.getRepository(Sellercraft).findOne({
-            where: {
-              domain: { id: inventory.bizplace?.domain.id },
-              status: SellercraftStatus.ACTIVE
-            },
-            relations: ['domain']
-          })
-          if (prevBizSC) {
-            await sellercraftCtrl.updateSellercraftStock(prevBizSC, { ...inventory, bizplace: inventory.bizplace })
-          }
-        }
-
-        const currentBizSC: Sellercraft = await tx.getRepository(Sellercraft).findOne({
-          where: {
-            domain: { id: newRecord?.bizplace?.domain.id || inventory?.bizplace?.domain.id },
-            status: SellercraftStatus.ACTIVE
-          },
-          relations: ['domain']
-        })
-
-        if (currentBizSC) {
-          if (newRecord?.product?.id && newRecord?.product?.id != inventory?.product?.id)
-            await sellercraftCtrl.updateSellercraftStock(currentBizSC, {
-              ...inventory,
-              bizplace: newRecord?.bizplace || inventory?.bizplace,
-              product: inventory.product
-            })
-
-          await sellercraftCtrl.updateSellercraftStock(currentBizSC, {
-            ...inventory,
-            bizplace: newRecord?.bizplace || inventory?.bizplace,
-            product: newRecord?.product || inventory?.product
-          })
-        }
-
-        // check for any existing active marketplace connection, update marketplace selling qty
-        const marketplaceStores: MarketplaceStore[] = await tx.getRepository(MarketplaceStore).find({
-          where: { domain: { id: companyDomain.id }, 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, inventory.product.id, companyDomain)
-
-          if (newRecord?.product || newRecord?.bizplace) await ecommerceCtrl.updateProductVariationStock(marketplaceStores, newRecord.product.id, companyDomain)
-        }
-      }
-
-      // Adding Inventory
-      else {
-        const total = await tx.getRepository(Inventory).countBy({
-          createdAt: MoreThan(new Date(year, month, date))
-        })
-
-        const yy = String(year).substr(String(year).length - 2)
-        const mm = String(month + 1).padStart(2, '0')
-        const dd = String(date).padStart(2, '0')
-
-        const dateStr = yy + mm + dd
-
-        let palletId = newRecord.palletId
-
-        if (!newRecord.palletId?.trim()) {
-          palletId = await generateId({
-            domain: domain,
-            type: 'adjustment_pallet_id',
-            seed: {
-              batchId: newRecord.batchId,
-              date: dateStr
-            }
-          })
-          if (!palletId) throw new Error('No adjustment pallet id setting rule found')
-        }
-
-        var location = await tx.getRepository(Location).findOne({
-          where: { id: newRecord.location.id },
-          relations: ['warehouse']
-        })
-        newRecord.location = location
-        newRecord.zone = location.zone
-        newRecord.warehouse = location.warehouse
-
-        newRecord.status = INVENTORY_STATUS.STORED
-        newRecord.name = palletId
-        newRecord.palletId = palletId
-
-        const warehouseCartonSetting: Setting = await tx.getRepository(Setting).findOne({
-          where: { domain: { id: domain.id }, category: 'id-rule', name: 'enable-carton-label' }
-        })
-
-        const partnerCartonSetting: PartnerSetting = await tx.getRepository(PartnerSetting).findOne({
-          where: {
-            setting: { id: warehouseCartonSetting.id },
-            domain: { id: domain.id },
-            partnerDomain: { id: newRecord.bizplace?.domain.id }
-          }
-        })
-
-        if (partnerCartonSetting?.value) {
-          let cartonId = await generateId({
-            domain: domain,
-            type: 'adjustment_carton_id',
-            seed: { date: dateStr }
-          })
-          if (!cartonId) throw new Error('No adjustment carton id setting rule found')
-
-          newRecord.cartonId = cartonId
-        }
-
-        let expirationDate = ((newRecord?.expirationDate && new Date(newRecord.expirationDate).getFullYear()) || 0) < 2000 ? null : newRecord.expirationDate
-
-        let savedInventory = await tx.getRepository(Inventory).save({
-          ...newRecord,
-          expirationDate,
-          domain: domain,
-          creator: user,
-          updater: user,
-          lastSeq: 0
-        })
-
-        await tx.getRepository(InventoryHistory).save({
-          ...newRecord,
-          domain: domain,
-          creator: user,
-          updater: user,
-          name: InventoryNoGenerator.inventoryHistoryName(),
-          seq: 0,
-          transactionType: 'NEW',
-          productId: newRecord.product.id,
-          warehouseId: newRecord.warehouse.id,
-          locationId: newRecord.location.id,
-          inventory: savedInventory,
-          expirationDate: expirationDate
-        })
-
-        await tx.getRepository(Location).save({
-          ...location,
-          status: LOCATION_STATUS.OCCUPIED
-        })
-
-        _inventoryChanges[i].inventory = savedInventory
-        _inventoryChanges[i].palletId = savedInventory.palletId
-
-        await upsertInventoryItems(context, _inventoryChanges[i], 'APPROVED', tx)
-
-        const sellercraft: Sellercraft = await tx.getRepository(Sellercraft).findOne({
-          where: { domain: { id: newRecord.bizplace.domain.id }, status: SellercraftStatus.ACTIVE },
-          relations: ['domain']
-        })
-
-        const companyDomain: Domain = newRecord.bizplace?.company.domain
-
-        if (sellercraft) {
-          const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
-          await sellercraftCtrl.updateSellercraftStock(sellercraft, newRecord)
-        }
-
-        // update marketplace store qty
-        // check for any existing active marketplace connection, update marketplace selling qty
-        const marketplaceStores: MarketplaceStore[] = await tx.getRepository(MarketplaceStore).find({
-          where: { domain: { id: companyDomain.id }, 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, newRecord.product.id, companyDomain)
-        }
-      }
-
-      _inventoryChanges[i].status = 'APPROVED'
-    }
-
-    await tx.getRepository(InventoryChange).save(_inventoryChanges)
-  }
-
-  return { items: arrLockedInventory, total: arrLockedInventory.length }
-}