@things-factory/warehouse-base 3.7.13 → 3.8.1

package/server/graphql/resolvers/inventory-change/delete-inventory-changes.ts

@@ -1,15 +0,0 @@
-import { Domain } from '@things-factory/shell'
-import { EntityManager, In } from 'typeorm'
-import { InventoryChange } from '../../../entities'
-
-export const deleteInventoryChanges = {
-  async deleteInventoryChanges(_: any, { names }, context: any) {
-    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
-
-    await tx.getRepository(InventoryChange).delete({
-      domain: domain,
-      name: In(names)
-    })
-    return true
-  }
-}

package/server/graphql/resolvers/inventory-change/index.ts

@@ -1,27 +0,0 @@
-import { inventoryChangeResolver } from './inventory-change'
-import { inventoryChangesResolver } from './inventory-changes'
-
-import { updateInventoryChange } from './update-inventory-change'
-import { updateMultipleInventoryChange } from './update-multiple-inventory-change'
-import { createInventoryChange } from './create-inventory-change'
-import { deleteInventoryChange } from './delete-inventory-change'
-import { deleteInventoryChanges } from './delete-inventory-changes'
-import { submitInventoryChanges } from './submit-inventory-changes'
-import { approveInventoryChanges } from './approve-inventory-changes'
-import { rejectInventoryChanges } from './reject-inventory-changes'
-
-export const Query = {
-  ...inventoryChangesResolver,
-  ...inventoryChangeResolver
-}
-
-export const Mutation = {
-  ...updateInventoryChange,
-  ...updateMultipleInventoryChange,
-  ...createInventoryChange,
-  ...deleteInventoryChange,
-  ...deleteInventoryChanges,
-  ...submitInventoryChanges,
-  ...approveInventoryChanges,
-  ...rejectInventoryChanges
-}

package/server/graphql/resolvers/inventory-change/inventory-change.ts

@@ -1,14 +0,0 @@
-import { Domain } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
-import { InventoryChange } from '../../../entities'
-
-export const inventoryChangeResolver = {
-  async inventoryChange(_: any, { name }, context: any) {
-    const { domain }: { domain: Domain } = context.state
-
-    return await getRepository(InventoryChange).findOne({
-      where: { domain: domain, name },
-      relations: ['domain', 'creator', 'updater']
-    })
-  }
-}

package/server/graphql/resolvers/inventory-change/reject-inventory-changes.ts

@@ -1,42 +0,0 @@
-import { Domain } from '@things-factory/shell'
-import { EntityManager, In } from 'typeorm'
-import { InventoryChange, InventoryHistory } from '../../../entities'
-
-export const rejectInventoryChanges = {
-  async rejectInventoryChanges(_: any, { patches }, context: any) {
-    const { domain, tx }: { domain: Domain; tx: EntityManager } = 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: domain },
-          order: { seq: 'DESC' },
-          take: 1
-        })
-
-        if (latestEntry.length > 0) _inventoryChanges[i].lastInventoryHistory = latestEntry[0]
-      }
-
-      await tx.getRepository(InventoryChange).save(_inventoryChanges.filter(change => change.status == 'REJECTED'))
-    }
-    return true
-  }
-}

package/server/graphql/resolvers/inventory-change/submit-inventory-changes.ts

@@ -1,101 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { Bizplace } from '@things-factory/biz-base'
-import { Product } from '@things-factory/product-base'
-import { EntityManager } from 'typeorm'
-import { Inventory, InventoryChange, Location } from '../../../entities'
-import { InventoryNoGenerator } from '../../../utils'
-
-export const submitInventoryChanges = {
-  async submitInventoryChanges(_: any, { patches }, context: any) {
-    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
-
-    const _createRecords = patches.filter((patch: any) => !patch.id)
-    const _updateRecords = patches.filter((patch: any) => patch.id)
-
-    const inventoryChangeRepo = tx.getRepository(InventoryChange)
-    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).findOne(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
-
-        await inventoryChangeRepo.save({
-          ...newRecord,
-          id: undefined,
-          name: InventoryNoGenerator.inventoryName(),
-          domain: domain,
-          creator: user,
-          updater: user
-        })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const updateRecord = _updateRecords[i]
-
-        let existingRecord = await tx.getRepository(Inventory).findOne({
-          where: { 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)
-
-        if (!!updateRecord?.product?.id)
-          updateRecord.product = await tx.getRepository(Product).findOne(updateRecord.product.id)
-
-        updateRecord.status = 'PENDING'
-        updateRecord.transactionType = 'CHANGES'
-
-        updateRecord.expirationDate =
-          ((updateRecord?.expirationDate && new Date(updateRecord.expirationDate).getFullYear()) || 0) < 2000
-            ? null
-            : updateRecord.expirationDate
-
-        await inventoryChangeRepo.save({
-          palletId: existingRecord.palletId,
-          ...updateRecord,
-          id: undefined,
-          name: InventoryNoGenerator.inventoryName(),
-          inventory: existingRecord,
-          domain: domain,
-          creator: user,
-          updater: user
-        })
-      }
-    }
-
-    return true
-  }
-}

package/server/graphql/resolvers/inventory-change/update-inventory-change.ts

@@ -1,21 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { InventoryChange } from '../../../entities'
-
-export const updateInventoryChange = {
-  async updateInventoryChange(_: any, { name, patch }, context: any) {
-    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
-
-    const repository = tx.getRepository(InventoryChange)
-    const inventoryChange = await repository.findOne({
-      where: { domain: domain, name }
-    })
-
-    return await repository.save({
-      ...inventoryChange,
-      ...patch,
-      updater: user
-    })
-  }
-}

package/server/graphql/resolvers/inventory-change/update-multiple-inventory-change.ts

@@ -1,47 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { InventoryChange } from '../../../entities'
-
-export const updateMultipleInventoryChange = {
-  async updateMultipleInventoryChange(_: any, { patches }, context: any) {
-    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = 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.findOne(newRecord.id)
-
-        const result = await inventoryChangeRepo.save({
-          ...inventoryChange,
-          ...newRecord,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-}

package/server/graphql/resolvers/inventory-history/bizplace-inventory-histories.ts

@@ -1,82 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Bizplace, getMyBizplace } from '@things-factory/biz-base'
-import { Product } from '@things-factory/product-base'
-import { convertListParams, Domain } from '@things-factory/shell'
-import { getRepository, SelectQueryBuilder, Brackets, Between, EntityManager, In, Raw } from 'typeorm'
-import { InventoryHistory, Location, Warehouse } from '../../../entities'
-
-export const bizplaceInventoryHistories = {
-  async bizplaceInventoryHistories(_: any, { inventoryHistory, filters, pagination, sortings }, context: any) {
-    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
-
-    const ownerBizplace: Bizplace = await getMyBizplace(domain, user)
-    const customerBizplace: Bizplace = await tx.getRepository(Bizplace).findOne(inventoryHistory.bizplace.id)
-
-    const productFilters = filters.find(x => x.name == 'product_info')
-    filters = filters.filter(x => x.name != 'product_info')
-
-    const fromDate: Date = new Date(inventoryHistory.fromDate)
-    const toDate: Date = new Date(inventoryHistory.toDate)
-
-    const convertedParams = convertListParams({ filters, pagination, sortings })
-    let where = { domain: domain }
-
-    if (productFilters) {
-      let productFilterValue = `%${productFilters.value.toLowerCase()}%`
-      const productQb: SelectQueryBuilder<Product> = getRepository(Product).createQueryBuilder('prd')
-
-      productQb.where(
-        new Brackets(qb => {
-          qb.where('Lower(prd.sku) LIKE :productInfo', { productInfo: productFilterValue })
-            .orWhere('Lower(prd.name) LIKE :productInfo', { productInfo: productFilterValue })
-            .orWhere('Lower(prd.description) LIKE :productInfo', { productInfo: productFilterValue })
-            .orWhere('Lower(prd.brand) LIKE :productInfo', { productInfo: productFilterValue })
-        })
-      )
-
-      const _products = await productQb.getMany()
-
-      where['product'] = In(_products.map((product: Product) => product.id))
-    }
-
-    if (inventoryHistory && inventoryHistory.warehouseName) {
-      const _warehouses: Warehouse[] = await tx.getRepository(Warehouse).find({
-        domain: domain,
-        name: Raw(alias => `LOWER(${alias}) LIKE '${inventoryHistory.warehouseName.toLowerCase()}'`)
-      })
-      where['warehouse'] = In(_warehouses.map((warehouse: Warehouse) => warehouse.id))
-    }
-
-    if (inventoryHistory && inventoryHistory.locationName) {
-      const _locations = await tx.getRepository(Location).find({
-        where: {
-          domain: domain,
-          name: Raw(alias => `LOWER(${alias}) LIKE '${inventoryHistory.locationName.toLowerCase()}'`)
-        }
-      })
-      where['location'] = In(_locations.map((location: Location) => location.id))
-    }
-
-    where['createdAt'] = Between(fromDate, toDate)
-
-    convertedParams.where = {
-      ...convertedParams.where,
-      ...where,
-      bizplace: customerBizplace
-    }
-
-    const result = await tx.getRepository(InventoryHistory).findAndCount({
-      ...convertedParams,
-      relations: ['domain', 'product', 'warehouse', 'location', 'bizplace', 'updater'],
-      order: {
-        palletId: 'ASC',
-        seq: 'ASC'
-      }
-    })
-
-    let items = result[0] as any
-    let total = result[1]
-
-    return { items, total }
-  }
-}

package/server/graphql/resolvers/inventory-history/create-inventory-history.ts

@@ -1,17 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { InventoryHistory } from '../../../entities'
-
-export const createInventoryHistory = {
-  async createInventoryHistory(_: any, { inventoryHistory }, context: any) {
-    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
-
-    return await tx.getRepository(InventoryHistory).save({
-      ...inventoryHistory,
-      domain: domain,
-      creator: user,
-      updater: user
-    })
-  }
-}

package/server/graphql/resolvers/inventory-history/delete-inventory-histories.ts

@@ -1,15 +0,0 @@
-import { Domain } from '@things-factory/shell'
-import { EntityManager, In } from 'typeorm'
-import { InventoryHistory } from '../../../entities'
-
-export const deleteInventoryHistories = {
-  async deleteInventoryHistories(_: any, { names }, context: any) {
-    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
-
-    await tx.getRepository(InventoryHistory).delete({
-      domain: domain,
-      name: In(names)
-    })
-    return true
-  }
-}

package/server/graphql/resolvers/inventory-history/delete-inventory-history.ts

@@ -1,12 +0,0 @@
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { InventoryHistory } from '../../../entities'
-
-export const deleteInventoryHistory = {
-  async deleteInventoryHistory(_: any, { name }, context: any) {
-    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
-
-    await tx.getRepository(InventoryHistory).delete({ domain: domain, name })
-    return true
-  }
-}

package/server/graphql/resolvers/inventory-history/index.ts

@@ -1,37 +0,0 @@
-import { createInventoryHistory } from './create-inventory-history'
-import { deleteInventoryHistories } from './delete-inventory-histories'
-import { deleteInventoryHistory } from './delete-inventory-history'
-import { inventoryHistoriesResolver } from './inventory-histories'
-import { inventoryHistoryResolver } from './inventory-history'
-import { updateInventoryHistory } from './update-inventory-history'
-import { updateMultipleInventoryHistory } from './update-multiple-inventory-history'
-import { bizplaceInventoryHistories } from './bizplace-inventory-histories'
-import { inventoryHistoryReport } from './inventory-history-report'
-import { inventoryHistoryPalletReport } from './inventory-history-pallet-report'
-import { inventoryHistoryPalletDetailReport } from './inventory-history-pallet-detail-report'
-import { inventoryHistoryPalletStorageReport } from './inventory-history-pallet-storage-report'
-import { inventoryHistorySummaryReport } from './inventory-history-summary-report'
-import { onhandInventoriesResolver, onhandInventories } from './onhand-inventories'
-
-export const Query = {
-  ...inventoryHistoriesResolver,
-  ...inventoryHistoryResolver,
-  ...bizplaceInventoryHistories,
-  ...inventoryHistoryReport,
-  ...inventoryHistoryPalletReport,
-  ...inventoryHistoryPalletDetailReport,
-  ...inventoryHistoryPalletStorageReport,
-  ...inventoryHistorySummaryReport,
-  ...onhandInventoriesResolver
-}
-
-export const Mutation = {
-  ...updateInventoryHistory,
-  ...updateMultipleInventoryHistory,
-  ...createInventoryHistory,
-  ...deleteInventoryHistory,
-  ...deleteInventoryHistories
-}
-
-
-export { onhandInventories }

package/server/graphql/resolvers/inventory-history/inventory-histories.ts

@@ -1,62 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { convertListParams, Domain, ListParam } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
-import { InventoryHistory } from '../../../entities'
-
-export const inventoryHistoriesResolver = {
-  async inventoryHistories(_: any, params: ListParam, context: any) {
-    const { domain, user }: { domain: Domain; user: User } = context.state
-
-    if (!params.filters.find((filter: any) => filter.name === 'bizplace')) {
-      params.filters.push({
-        name: 'bizplace',
-        operator: 'in',
-        value: await getPermittedBizplaceIds(domain, user)
-      })
-    }
-
-    const convertedParams = convertListParams(params)
-    let [items, total] = await getRepository(InventoryHistory).findAndCount({
-      ...convertedParams,
-      relations: ['domain', 'bizplace', 'product', 'location', 'warehouse', 'creator', 'updater'],
-      order: {
-        palletId: 'DESC',
-        createdAt: 'ASC'
-      }
-    })
-
-    items = (await Promise.all(
-      items.map(async item => {
-        switch (item.transactionType) {
-          case 'UNLOADING':
-            item.description = 'Inbound'
-            break
-          case 'UNDO_UNLOADING':
-            item.description = 'Undo Unloading'
-            item.orderRefNo = ''
-            break
-          case 'LOADING':
-            item.description = 'Loading'
-            break
-          case 'UNDO_LOADING':
-            item.description = 'Undo Loading'
-            break
-          default:
-            item.description = String(item.transactionType)
-            break
-        }
-        item.description = item.description.toUpperCase()
-        return {
-          ...item,
-          orderRefNo: item.orderRefNo,
-          orderNo: item.orderNo,
-          qty: item.qty,
-          openingQty: item.openingQty
-        }
-      })
-    )) as any
-
-    return { items, total }
-  }
-}

package/server/graphql/resolvers/inventory-history/inventory-history-pallet-detail-report.ts

@@ -1,166 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { Bizplace } from '@things-factory/biz-base'
-import { ListParam } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { InventoryHistory } from '../../../entities'
-
-export const inventoryHistoryPalletDetailReport = {
-  async inventoryHistoryPalletDetailReport(_: any, params: ListParam, context: any) {
-    try {
-      const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
-      let userFilter = params.filters.find(data => data.name === 'user')
-
-      let bizplaceFilter = { name: '', operator: '', value: '' }
-
-      if (userFilter) {
-        const user: User = await tx.getRepository(User).findOne({
-          where: { id: userFilter.value },
-          relations: ['bizplaces']
-        })
-
-        const bizplace: Bizplace = user.bizplaces[0]
-
-        if (!bizplace) throw 'Invalid input'
-
-        bizplaceFilter = { name: 'bizplace', operator: 'eq', value: bizplace.id }
-      } else {
-        bizplaceFilter = params.filters.find(data => data.name === 'bizplace')
-      }
-
-      let fromDate = params.filters.find(data => data.name === 'fromDate')
-      let toDate = params.filters.find(data => data.name === 'toDate')
-      let product = params.filters.find(data => data.name === 'product')
-
-      if (!fromDate || !toDate) throw 'Invalid input'
-
-      let bizplaceQuery = ''
-      if (bizplaceFilter) {
-        const bizplace: Bizplace = await tx.getRepository(Bizplace).findOne({
-          id: bizplaceFilter.value
-        })
-
-        if (bizplace) {
-          bizplaceQuery = "AND i2.bizplace_id = '" + bizplace.id + "'"
-        } else {
-          throw 'Invalid input'
-        }
-      }
-
-      let productQuery = ''
-      if (product) {
-        productQuery =
-          'AND prd.name ILIKE ANY(ARRAY[' +
-          product.value
-            .split(',')
-            .map(prod => {
-              return "'%" + prod.trim().replace(/'/g, "''") + "%'"
-            })
-            .join(',') +
-          '])'
-      }
-
-      const result = await tx.getRepository(InventoryHistory).query(`
-        with invHistory as (
-          select case when ar.name is null then 'NEW' else ar.name end as arrival_notice_name, 
-          case when js.container_size is null then '' else js.container_size end as container_size,
-          i2.batch_id,
-          bzp.name as bizplace_name,
-          i2.pallet_id, ih.seq, ih.status, ih.transaction_type, i2.product_id, prd.name as product_name,
-          prd.description as product_description,	ih.id as inventory_history_id, ih.packing_type, ih.qty, ih.opening_qty,
-          ih.weight, ih.opening_weight, ih.created_at::date
-          from inventories i2 
-          inner join reduced_inventory_histories ih on ih.pallet_id = i2.pallet_id and ih.domain_id = i2.domain_id
-          inner join products prd on prd.id = i2.product_id
-          inner join bizplaces bzp on bzp.id = ih.bizplace_id
-          left join order_inventories oi on oi.inventory_id = i2.id and oi.arrival_notice_id is not null
-          left join arrival_notices ar on ar.id = oi.arrival_notice_id
-          left join job_sheets js on js.id = ar.job_sheet_id
-          where
-            i2.domain_id = '${domain.id}'
-            and (
-            (ih.status = 'STORED' and ih.transaction_type = 'NEW') 
-            or (ih.status = 'STORED' and ih.transaction_type = 'CANCEL_ORDER')
-            or (ih.status = 'STORED' and ih.transaction_type = 'RETURN')
-            or (ih.status = 'STORED' and ih.transaction_type = 'PUTAWAY') 
-            or (ih.status = 'TERMINATED' and ih.transaction_type = 'TERMINATED')
-            ) 
-            ${bizplaceQuery}
-            ${productQuery}
-          order by ih.pallet_id, ih.seq
-        ), inventoryHistoryMovement as (
-          select bizplace_name, container_size, pallet_id, seq, status, transaction_type, product_id, product_name, product_description, batch_id,
-            inventory_history_id, packing_type, qty, opening_qty, weight, opening_weight, created_at, arrival_notice_name from (
-              select row_number() over(partition by pallet_id order by created_at asc) as rn, *  from invHistory where status = 'STORED'
-            )as invIn where rn = 1
-            union all
-            select bizplace_name, container_size, pallet_id, seq, status, transaction_type, product_id, product_name, product_description, batch_id,
-            inventory_history_id, packing_type, qty, opening_qty, weight, opening_weight, created_at, arrival_notice_name from (
-              select row_number() over(partition by pallet_id order by created_at desc) as rn, *  from invHistory
-            )as invOut where rn = 1 and status = 'TERMINATED'
-        ), inventoryHistoriesByPallet as (
-          select invHistory.bizplace_name, invHistory.container_size, invHistory.product_name, invHistory.product_description, invHistory.arrival_notice_name, invHistory.batch_id,
-          SUM(case when invHistory.created_at <= '${new Date(fromDate.value).toLocaleDateString()} 00:00:00' then 
-              case when invHistory.status = 'STORED' then 1 else -1 end
-              else 0 end) as opening_balance,
-          SUM(case when invHistory.created_at >= '${new Date(fromDate.value).toLocaleDateString()} 00:00:00' 
-              and invHistory.created_at <= '${new Date(toDate.value).toLocaleDateString()} 23:59:59' then 
-              case when invHistory.status = 'STORED' then 1 else 0 end
-              else 0 end) as in_balance,
-          SUM(case when invHistory.created_at >= '${new Date(fromDate.value).toLocaleDateString()} 00:00:00' 
-              and invHistory.created_at <= '${new Date(toDate.value).toLocaleDateString()} 23:59:59' then 
-              case when invHistory.status = 'TERMINATED' then 1 else 0 end
-              else 0 end) as out_balance
-          from(
-            select * from inventoryHistoryMovement
-          ) as invHistory group by bizplace_name, container_size, product_name, product_description, arrival_notice_name, batch_id
-        )
-        select invh.*, invh.opening_balance + invh.in_balance - invh.out_balance as closing_balance 
-        , (
-          select json_agg(json_build_object('created_at', created_at, 'in_balance', in_balance, 'out_balance', out_balance)) as jsonData from 
-            (
-              select bizplace_name, product_name, batch_id, arrival_notice_name, created_at,
-              SUM(case when status = 'STORED' then 1 else 0 end) as in_balance,
-              SUM(case when status = 'TERMINATED' then 1 else 0 end) as out_balance
-              from inventoryHistoryMovement
-              where created_at >= '${new Date(fromDate.value).toLocaleDateString()} 00:00:00' and 
-              created_at <= '${new Date(toDate.value).toLocaleDateString()} 23:59:59' and 
-              bizplace_name = invh.bizplace_name and product_name = invh.product_name and
-              batch_id = invh.batch_id and arrival_notice_name = invh.arrival_notice_name
-              group by bizplace_name, product_name, batch_id, arrival_notice_name, created_at
-              order by created_at
-            ) 
-          as t
-        )::varchar as json_date_movement
-        from inventoryHistoriesByPallet invh
-        where invh.opening_balance >= 0
-        and invh.in_balance >= 0
-        and invh.out_balance >= 0
-        and (invh.opening_balance > 0 or invh.in_balance > 0)
-        order by invh.bizplace_name, invh.product_name, invh.batch_id;
-      `)
-
-      let items = result as any
-      items = items.map(item => {
-        return {
-          bizplace: { name: item.bizplace_name },
-          product: {
-            name: item.product_name.trim() + ' ( ' + (item.product_description || '-').trim() + ' )'
-          },
-          arrivalNoticeName: item.arrival_notice_name,
-          batchId: item.batch_id,
-          openingBalance: item.opening_balance,
-          inBalance: item.in_balance,
-          outBalance: item.out_balance,
-          closingBalance: item.closing_balance,
-          jsonDateMovement: item.json_date_movement,
-          containerSize: item.container_size
-        }
-      })
-
-      return items
-    } catch (error) {
-      throw error
-    }
-  }
-}