@things-factory/warehouse-base 8.0.2 → 8.0.5

package/server/service/inventory-history/inventory-history-query.ts

@@ -1,1845 +0,0 @@
-import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { Between, Brackets, EntityManager, In, IsNull, Raw, SelectQueryBuilder } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Bizplace, getMyBizplace, getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { Product, ProductDetail } from '@things-factory/product-base'
-import {
-  buildQuery,
-  convertListParams,
-  Domain,
-  Filter,
-  getRepository,
-  ListParam,
-  Pagination,
-  Sorting
-} from '@things-factory/shell'
-
-import { RawInventoryHistoryList } from '../'
-import { InventoryList } from '../inventory/inventory-types'
-import { Location } from '../location/location'
-import { Warehouse } from '../warehouse/warehouse'
-import { InventoryHistory } from './inventory-history'
-import {
-  InventoryHistoryList,
-  InventoryHistoryPalletReportList,
-  InventoryHistoryPatch,
-  InventoryHistorySummaryList,
-  InventoryHistoryVolumeSummaryReportList
-} from './inventory-history-types'
-
-@Resolver(InventoryHistory)
-export class InventoryHistoryQuery {
-  @Query(returns => InventoryHistoryList)
-  async inventoryHistories(
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<InventoryHistoryList> {
-    const { domain, 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: {
-        ...convertedParams.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 }
-  }
-
-  @Query(returns => InventoryHistoryList)
-  async renewInventoryHistories(
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<InventoryHistoryList> {
-    const { domain, 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', 'inventory', 'warehouse', 'creator', 'updater'],
-      order: {
-        ...convertedParams.order,
-        palletId: 'DESC',
-        createdAt: 'ASC'
-      }
-    })
-
-    return { items, total }
-  }
-
-  @Query(returns => InventoryHistory)
-  async inventoryHistory(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<InventoryHistory> {
-    const { domain } = context.state
-
-    return await getRepository(InventoryHistory).findOne({
-      where: { domain: { id: domain.id }, name },
-      relations: ['domain', 'creator', 'updater']
-    })
-  }
-
-  @Directive('@transaction')
-  @Query(returns => InventoryHistoryList)
-  async bizplaceInventoryHistories(
-    @Ctx() context: ResolverContext,
-    @Arg('inventoryHistory', type => InventoryHistoryPatch, { nullable: true })
-    inventoryHistory?: InventoryHistoryPatch,
-    @Arg('filters', type => [Filter], { nullable: true }) filters?: Filter[],
-    @Arg('pagination', type => Pagination, { nullable: true }) pagination?: Pagination,
-    @Arg('sortings', type => [Sorting], { nullable: true }) sortings?: Sorting[]
-  ): Promise<InventoryHistoryList> {
-    const { domain, user, tx } = context.state
-
-    const ownerBizplace: Bizplace = await getMyBizplace(domain, user)
-    const customerBizplace: Bizplace = await tx.getRepository(Bizplace).findOneBy({ id: 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).findBy({
-        domain: { id: domain.id },
-        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: { id: domain.id },
-          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
-    } as any
-
-    const [items, total] = await tx.getRepository(InventoryHistory).findAndCount({
-      ...convertedParams,
-      relations: ['domain', 'product', 'warehouse', 'location', 'bizplace', 'updater'],
-      order: {
-        palletId: 'ASC',
-        seq: 'ASC'
-      }
-    })
-
-    return { items, total }
-  }
-
-  @Directive('@transaction')
-  @Query(returns => [InventoryHistory])
-  async inventoryHistoryReport(
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<InventoryHistory[]> {
-    try {
-      const { domain, tx } = context.state
-
-      let bizplaceFilter: Filter = { name: '', operator: '', value: '' }
-      let userFilter = params.filters.find(data => data.name === 'user')
-      let fromDate = params.filters.find(data => data.name === 'fromDate')
-      let toDate = params.filters.find(data => data.name === 'toDate')
-      let batchNo = params.filters.find(data => data.name === 'batchNo')
-      let product = params.filters.find(data => data.name === 'product')
-      let productDesc = params.filters.find(data => data.name === 'productDescription')
-      let hasTransactionOrBalanceFilter = params.filters.find(data => data.name === 'hasTransactionOrBalance')
-      let tzoffset = params.filters.find(data => data.name === 'tzoffset').value + ' seconds'
-
-      if (userFilter) {
-        const user = (await tx.getRepository(User).findOne({
-          where: { id: userFilter.value },
-          relations: ['bizplaces']
-        })) as User & { bizplaces: Bizplace[] }
-
-        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')
-      }
-
-      if (!bizplaceFilter || !fromDate || !toDate) throw 'Invalid input'
-
-      const bizplace: Bizplace = await tx.getRepository(Bizplace).findOneBy({
-        id: bizplaceFilter.value
-      })
-
-      let batchNoQuery = ''
-      if (batchNo) {
-        batchNoQuery =
-          'AND Lower(invh.batch_id) LIKE ANY(ARRAY[' +
-          batchNo.value
-            .toLowerCase()
-            .split(',')
-            .map(prod => {
-              return "'%" + prod.trim().replace(/'/g, "''") + "%'"
-            })
-            .join(',') +
-          '])'
-      }
-
-      let productQuery = ''
-      if (product) {
-        let productValue = product.value
-          .toLowerCase()
-          .split(',')
-          .map(prod => {
-            return "'%" + prod.trim().replace(/'/g, "''") + "%'"
-          })
-          .join(',')
-        productQuery = `AND (
-          Lower(prd.name) LIKE ANY(ARRAY[${productValue}])
-          OR Lower(prd.sku) LIKE ANY(ARRAY[${productValue}])
-          OR Lower(prd.description) LIKE ANY(ARRAY[${productValue}])
-        )`
-      }
-
-      let productDescQuery = ''
-      if (productDesc) {
-        productDescQuery = "AND Lower(description) LIKE '%" + productDesc.value.toLowerCase() + "%'"
-      }
-
-      let hasTransactionOrBalanceQuery = ''
-      if (hasTransactionOrBalanceFilter && hasTransactionOrBalanceFilter.value) {
-        hasTransactionOrBalanceQuery = 'and (src.totalRow > 1 or src.totalQty <> 0)'
-      }
-
-      await tx.query(
-        `
-      create temp table temp_products AS 
-      (
-        select prd.*, prd.id::varchar as product_id from products prd
-        inner join bizplaces b on b.id = prd.bizplace_id 
-        inner join companies c on c.domain_id = b.domain_id 
-        inner join bizplaces b2 on b2.company_id = c.id
-        where b2.id = $1
-        ${productQuery}
-      )`,
-        [bizplace.id]
-      )
-
-      await tx.query(
-        `
-      create temp table temp_data_src AS
-      (
-        SELECT prd.sku as sku, prd.name AS product_name, prd.description AS product_description, prd.type as product_type, prd.aux_value_1 AS product_aux_value_1, trim(invh.batch_id) as batch_id, invh.product_id,
-        invh.packing_type, invh.bizplace_id, invh.domain_id,
-        invh.ref_order_id, invh.order_no, invh.order_ref_no, invh.transaction_type, invh.status, invh.created_at,
-        invh.qty, invh.opening_qty, 
-        invh.uom, COALESCE(invh.uom_value, 0) as uom_value, COALESCE(invh.opening_uom_value, 0) as opening_uom_value
-        FROM reduced_inventory_histories invh
-        INNER JOIN temp_products prd ON prd.id = invh.product_id::uuid
-        WHERE
-        invh.domain_id = $1
-        AND invh.bizplace_id = $2
-        AND invh.created_at <= $3::timestamp
-        ${batchNoQuery}
-      ) 
-    `,
-        [domain.id, bizplace.id, toDate.value]
-      )
-
-      await tx.query(
-        `
-        create temp table temp_inv_history as (
-          SELECT src.sku, src.product_name, src.product_description, src.product_type, src.product_aux_value_1, src.batch_id, src.product_id, src.packing_type, src.uom,
-          src.bizplace_id, src.domain_id,
-          SUM(COALESCE(src.qty,0)) AS qty,
-          SUM(COALESCE(src.opening_qty,0)) AS opening_qty,
-          SUM(COALESCE(src.uom_value,0)) AS uom_value,
-          SUM(COALESCE(src.opening_uom_value,0)) AS opening_uom_value,
-          'Opening Balance' AS order_name,
-          '-' AS ref_no,
-          0 AS rn,
-          $1::timestamp AS created_at,
-          $1::date AS created_date  
-          FROM temp_data_src src
-          WHERE src.created_at < $1::timestamp
-          GROUP BY src.sku, src.product_name, src.product_description, src.product_type, src.product_aux_value_1, src.batch_id, src.product_id, src.packing_type, src.uom,
-          src.bizplace_id, src.domain_id
-          UNION ALL
-          SELECT sku, product_name, product_description, product_type, product_aux_value_1, batch_id, product_id, packing_type, uom, bizplace_id, 
-          domain_id, sum(qty) as qty, sum(opening_qty) as opening_qty, sum(uom_value) as uom_value, sum(opening_uom_value) as opening_uom_value, 
-          order_name, ref_no, 1 AS rn, MIN(created_at) - $2::interval as created_at, (MIN(created_at) - $2::interval)::DATE as created_date
-          FROM (
-            SELECT invh.sku, invh.product_name, invh.product_description, invh.product_type, invh.product_aux_value_1, invh.batch_id, invh.product_id, invh.packing_type, invh.bizplace_id, 
-            invh.domain_id,
-            invh.qty, invh.opening_qty,	invh.uom_value, invh.uom, invh.opening_uom_value,
-            COALESCE(order_no, '-') AS order_name,
-            COALESCE(order_ref_no, '-') AS ref_no,
-            invh.created_at,
-            invh.created_at::date as created_date
-            FROM temp_data_src invh
-            WHERE (invh.qty <> 0 OR invh.uom_value <> 0) AND 
-            invh.transaction_type <> 'ADJUSTMENT' AND 
-            invh.transaction_type <>'NEW'
-            AND invh.created_at >= $1::timestamp
-          ) AS inv_movement 
-          GROUP BY sku, product_name, product_description, product_type, product_aux_value_1, batch_id, product_id, packing_type, uom, bizplace_id, 
-          domain_id, order_name, ref_no, rn
-          UNION ALL
-          SELECT sku, product_name, product_description, product_type, product_aux_value_1, batch_id, product_id, packing_type, uom, bizplace_id, 
-          domain_id, sum(qty) as qty, sum(opening_qty) as opening_qty, sum(uom_value) as uom_value, sum(opening_uom_value) as opening_uom_value,
-          order_name, ref_no, 1 AS rn, created_at - $2::interval as created_at, created_at::date as created_date
-          FROM (
-            SELECT invh.sku, invh.product_name, invh.product_description, invh.product_type, invh.product_aux_value_1, invh.batch_id, invh.product_id, invh.packing_type, invh.uom, invh.bizplace_id, 
-            invh.domain_id,
-            invh.qty, invh.opening_qty,	invh.uom_value, invh.opening_uom_value,
-            invh.transaction_type AS order_name,
-            invh.transaction_type AS ref_no,
-            invh.created_at,
-            invh.created_at:: date as created_date
-            FROM temp_data_src invh
-            WHERE (invh.qty <> 0 OR invh.uom_value <> 0) AND 
-            (invh.transaction_type = 'ADJUSTMENT' OR 
-            invh.transaction_type = 'NEW')
-            AND invh.created_at >= $1::timestamp
-          ) AS inv_movement 
-          GROUP BY sku, product_name, product_description, product_type, product_aux_value_1, batch_id, product_id, packing_type, uom, bizplace_id, 
-          domain_id, order_name, ref_no, rn, created_at
-          UNION ALL
-          SELECT sku, product_name, product_description, product_type, product_aux_value_1, batch_id, product_id, packing_type, uom, bizplace_id, 
-          domain_id, sum(-opening_qty) as qty, sum(opening_qty) as opening_qty, sum(-opening_uom_value) as uom_value, sum(opening_uom_value) as opening_uom_value,
-          order_name, ref_no, 1 AS rn, created_at - $2::interval as created_at, created_at::date as created_date
-          FROM (
-            SELECT invh.sku, invh.product_name, invh.product_description, invh.product_type, invh.product_aux_value_1, invh.batch_id, invh.product_id, invh.packing_type, invh.uom, invh.bizplace_id, 
-            invh.domain_id,
-            invh.qty, invh.opening_qty,	invh.uom_value, invh.opening_uom_value,
-            invh.transaction_type AS order_name,
-            invh.transaction_type AS ref_no,
-            invh.created_at,
-            invh.created_at:: date as created_date
-            FROM temp_data_src invh
-            WHERE 
-            invh.transaction_type = 'ADJUSTMENT' AND
-            invh.status = 'MISSING'
-            AND invh.created_at >= $1::timestamp
-          ) AS inv_movement 
-          GROUP BY sku, product_name, product_description, product_type, product_aux_value_1, batch_id, product_id, packing_type, uom, bizplace_id, 
-          domain_id, order_name, ref_no, rn, created_at
-          
-        )`,
-        [fromDate.value, tzoffset]
-      )
-
-      const result: any = await tx.query(
-        ` 
-        select sku, product_name, product_description, product_type, product_aux_value_1, batch_id, product_id, packing_type, uom, bizplace_id, 
-        domain_id, qty, opening_qty, round(uom_value::decimal,2) as uom_value, opening_uom_value, order_name, ref_no, created_at::date
-        from temp_inv_history invh where
-        exists (
-          select * from (
-            select sku, batch_id, product_name, packing_type, sum(qty) as totalQty, count(*) as totalRow from temp_inv_history ih2 
-            group by sku, batch_id, product_name, packing_type
-          ) src 
-          where src.sku = invh.sku and src.batch_id = invh.batch_id and src.product_name = invh.product_name and src.packing_type = invh.packing_type
-          ${hasTransactionOrBalanceQuery}
-        )
-        ORDER BY invh.sku asc, invh.product_name asc, invh.product_description asc, invh.packing_type asc, invh.batch_id asc, invh.uom asc, invh.rn asc, invh.created_at asc
-      `
-      )
-
-      tx.query(
-        `
-        drop table temp_products, temp_data_src, temp_inv_history
-      `
-      )
-
-      let items = result as any
-      items = items.map(item => {
-        return {
-          batchId: item.batch_id,
-          bizplace: bizplace,
-          packingType: item.packing_type,
-          product: {
-            id: item.product_id,
-            sku: item.sku,
-            name:
-              item.product_name +
-              ' ( ' +
-              item.product_description +
-              ' ) ' +
-              (item.product_aux_value_1 === null ? '' : ' [ ' + item.product_aux_value_1 + ' ] '),
-            type: item.product_type
-          },
-          qty: item.qty,
-          uom: item.uom,
-          uomValue: item.uom_value,
-          openingQty: item.opening_qty,
-          openingUomValue: item.opening_uom_value,
-          orderNo: item.order_name,
-          orderRefNo: item.ref_no,
-          createdAt: item.created_at,
-          palletId: ''
-        }
-      })
-
-      return items
-    } catch (error) {
-      throw error
-    }
-  }
-
-  @Directive('@transaction')
-  @Query(returns => [InventoryHistory])
-  async inventoryHistoryPalletReport(
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<InventoryHistory[]> {
-    try {
-      const { domain, tx } = context.state
-      let userFilter = params.filters.find(data => data.name === 'user')
-
-      let bizplaceFilter: Filter = { name: '', operator: '', value: '' }
-
-      if (userFilter) {
-        const user = (await tx.getRepository(User).findOne({
-          where: { id: userFilter.value },
-          relations: ['bizplaces']
-        })) as User & { bizplaces: Bizplace[] }
-
-        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).findOneBy({
-          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.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, 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, 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
-    }
-  }
-
-  @Directive('@transaction')
-  @Query(returns => [InventoryHistory])
-  async inventoryHistoryPalletDetailReport(
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<InventoryHistory[]> {
-    try {
-      const { domain, tx } = context.state
-      let userFilter = params.filters.find(data => data.name === 'user')
-
-      let bizplaceFilter: Filter = { name: '', operator: '', value: '' }
-
-      if (userFilter) {
-        const user = (await tx.getRepository(User).findOne({
-          where: { id: userFilter.value },
-          relations: ['bizplaces']
-        })) as User & { bizplaces: Bizplace[] }
-
-        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).findOneBy({
-          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.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, 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, 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
-    }
-  }
-
-  @Directive('@transaction')
-  @Query(returns => InventoryHistoryPalletReportList)
-  async inventoryHistoryPalletStorageReport(
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<InventoryHistoryPalletReportList> {
-    try {
-      const { domain, tx } = context.state
-
-      let userFilter = params.filters.find(data => data.name === 'user')
-
-      let bizplaceFilter: Filter = { name: '', operator: '', value: '' }
-
-      if (userFilter) {
-        const user = (await tx.getRepository(User).findOne({
-          where: { id: userFilter.value },
-          relations: ['bizplaces']
-        })) as User & { bizplaces: Bizplace[] }
-
-        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')
-
-      if (!bizplaceFilter || !fromDate || !toDate) throw 'Invalid input'
-
-      const bizplace: Bizplace = await tx.getRepository(Bizplace).findOneBy({
-        id: bizplaceFilter.value
-      })
-
-      let queryFilter = ``
-      let queryParams = [fromDate.value, toDate.value]
-      let locationType = params.filters.find(data => data.name === 'locationType')
-      if (locationType) {
-        queryFilter = queryFilter + `AND location_type = $` + (queryParams.length + 1)
-        queryParams.push(locationType.value)
-      }
-
-      let zone = params.filters.find(data => data.name === 'zone')
-      if (zone) {
-        queryFilter = queryFilter + `AND LOWER(location_zone) like $` + (queryParams.length + 1)
-        queryParams.push(zone.value.toLowerCase())
-      }
-
-      await tx.query(
-        `
-        create temp table temp_history as (
-          select distinct on (ih.pallet_id) 
-          ih.pallet_id, ih.created_at as in_at, loc.name as location_name, loc."type" as location_type, loc."zone"  as location_zone,
-          bz.name as bizplace_name
-          from reduced_inventory_histories ih 
-          inner join inventories inv on inv.pallet_id = ih.pallet_id and inv.domain_id = ih.domain_id 
-          inner join locations loc on loc.id = inv.location_id
-          inner join bizplaces bz on bz.id = inv.bizplace_id 
-          where ih.domain_id = $1
-          and inv.bizplace_id = $2
-          and not exists(
-            SELECT domain_id, pallet_id 
-            FROM reduced_inventory_histories ih2
-            where ih2.domain_id = $1
-            and ih2.created_at < $3
-            and ih2.transaction_type = 'TERMINATED' and ih2.status ='TERMINATED'
-            and ih2.pallet_id = ih.pallet_id
-            group by ih2.domain_id , ih2.pallet_id
-          )
-          and ih.created_at <= $4
-          order by ih.pallet_id , ih.seq
-        )      
-      `,
-        [domain.id, bizplace.id, fromDate.value, toDate.value]
-      )
-
-      await tx.query(
-        `          
-        create temp table temp_pallet_storage_history as (
-          select * from (
-            select bizplace_name, location_type, location_zone, location_name, 
-            COUNT(pallet_id) filter (where in_at between $1 and $2) as inbound_qty,
-            COUNT(*) as total_qty,
-            string_agg(case when in_at between $1 and $2 then pallet_id end, ', ')  as inbound_pallet_id,
-            string_agg(case when in_at not between $1 and $2 then pallet_id end, ', ') as pallet_id
-            from temp_history where location_type = 'SHELF' 
-            group by bizplace_name, location_name, location_type, location_zone
-            union 
-            select bizplace_name, location_type, location_zone, location_name, 
-            case when in_at between $1 and $2 then 1 else 0 end as inbound_qty,
-            1 as total_qty,
-            case when in_at between $1 and $2 then pallet_id end as inbound_pallet_id,
-            case when in_at not between $1 and $2 then pallet_id end pallet_id 
-            from temp_history where location_type = 'FLOOR'
-          ) as src where 1 = 1
-          ${queryFilter} 
-        )
-      `,
-        queryParams
-      )
-
-      const total: any = await tx.query(`select count(*) from temp_pallet_storage_history`)
-
-      const totalWithOpeningBalance: any = await tx.query(
-        `select count(*) from temp_pallet_storage_history where pallet_id notnull`
-      )
-
-      const result: any = await tx.query(
-        ` 
-        select * from temp_pallet_storage_history order by location_type OFFSET $1 LIMIT $2
-      `,
-        [(params.pagination.page - 1) * params.pagination.limit, params.pagination.limit]
-      )
-
-      tx.query(`
-        drop table temp_history, temp_pallet_storage_history
-      `)
-
-      let items = result.map(itm => {
-        return {
-          ...itm,
-          bizplace: {
-            name: itm.bizplace_name
-          },
-          location: {
-            name: itm.location_name,
-            type: itm.location_type,
-            zone: itm.location_zone
-          },
-          palletId: itm.pallet_id,
-          inboundPalletId: itm.inbound_pallet_id,
-          inboundQty: itm.inbound_qty,
-          totalQty: itm.total_qty
-        }
-      })
-
-      return { items, total: total[0].count, totalWithOpeningBalance: totalWithOpeningBalance[0].count }
-    } catch (ex) {
-      throw ex
-    }
-  }
-
-  @Directive('@transaction')
-  @Query(returns => InventoryHistorySummaryList)
-  async inventoryHistorySummaryReport(
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<InventoryHistorySummaryList> {
-    try {
-      const { tx } = context.state
-
-      let bizplaceFilter: Filter = { name: '', operator: '', value: '' }
-
-      let userFilter = params.filters.find(data => data.name === 'user')
-      let fromDate = params.filters.find(data => data.name === 'fromDate')
-      let toDate = params.filters.find(data => data.name === 'toDate')
-      let byPallet = params.filters.find(data => data.name === 'byPallet')
-
-      if (userFilter) {
-        const user = (await tx.getRepository(User).findOne({
-          where: { id: userFilter.value },
-          relations: ['bizplaces']
-        })) as User & { bizplaces: Bizplace[] }
-
-        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')
-      }
-
-      if (!bizplaceFilter || !fromDate || !toDate) throw 'Invalid input'
-
-      const bizplace: Bizplace = await tx.getRepository(Bizplace).findOneBy({
-        id: bizplaceFilter.value
-      })
-
-      let [result, total] = byPallet.value
-        ? await massageInventoryPalletSummary(tx, params, bizplace, context)
-        : await massageInventorySummary(tx, params, bizplace, context)
-
-      let items = result.map(itm => {
-        return {
-          ...itm,
-          batchId: itm.batch_id,
-          packingType: itm.packing_type,
-          packingSize: itm.packing_size,
-          openingQty: itm.opening_qty,
-          missingQty: itm.missing_qty,
-          adjustmentQty: itm.adjustment_qty,
-          closingQty: itm.closing_qty,
-          totalInQty: itm.total_in_qty,
-          totalOutQty: itm.total_out_qty,
-          product: {
-            id: itm.product_id,
-            sku: itm.product_sku,
-            name: itm.product_name,
-            description: itm.product_description,
-            type: itm.product_type
-          }
-        }
-      })
-
-      return {
-        items,
-        total: total[0].count,
-        totalInboundQty: total[0].totalinqty || 0,
-        totalOpeningBal: total[0].totalopeningbal || 0
-      }
-    } catch (error) {
-      throw error
-    }
-  }
-
-  @Directive('@transaction')
-  @Query(returns => InventoryList)
-  async onhandInventories(
-    @Ctx() context: ResolverContext,
-    @Arg('filters', type => [Filter], { nullable: true }) filters?: Filter[],
-    @Arg('pagination', type => Pagination, { nullable: true }) pagination?: Pagination,
-    @Arg('sortings', type => [Sorting], { nullable: true }) sortings?: Sorting[],
-    @Arg('locationSortingRules', type => [Sorting], { nullable: true }) locationSortingRules?: Sorting[],
-    @Arg('setPagination', type => Boolean, { defaultValue: true }) setPagination?: Boolean
-  ): Promise<InventoryList> {
-    const { domain, user, tx } = context.state
-
-    // define all inputs
-    let userFilter = filters.find(data => data.name === 'user')
-    let product = filters.find(data => data.name === 'product')
-    let createdAt = filters.find(data => data.name === 'created_at')
-    let location = filters.find(data => data.name === 'location')
-    let batchId = filters.find(data => data.name === 'batchId')
-    let palletId = filters.find(data => data.name === 'palletId')
-    let cartonId = filters.find(data => data.name === 'cartonId')
-    let packingType = filters.find(data => data.name === 'packingType')
-    let timezoneOffset = filters.find(data => data.name === 'timezoneOffset').value + ' minutes'
-
-    // expiration date filter
-    let expiration = filters.find(data => data.name === 'expiration').value
-    let expFromDate = filters.find(data => data.name === 'expFromDate')
-    let expToDate = filters.find(data => data.name === 'expToDate')
-
-    let bizplaceFilter = { name: '', operator: '', value: [] }
-
-    // prepare query filters
-    if (userFilter) {
-      const user = (await tx.getRepository(User).findOne({
-        where: { id: userFilter.value },
-        relations: ['bizplaces']
-      })) as User & { bizplaces: Bizplace[] }
-
-      const bizplace: Bizplace = user.bizplaces[0]
-
-      if (!bizplace) throw 'Invalid input'
-
-      bizplaceFilter = { name: 'bizplace', operator: 'eq', value: [bizplace.id] }
-    } else {
-      bizplaceFilter = !filters.find((filter: any) => filter.name === 'bizplace')
-        ? ({
-            name: 'bizplace',
-            operator: 'in',
-            value: await getPermittedBizplaceIds(domain, user),
-            relation: true
-          } as any)
-        : {
-            ...filters.find(data => data.name === 'bizplace'),
-            value: [filters.find(data => data.name === 'bizplace').value]
-          }
-    }
-
-    let queryFilter = ``
-    let bizplaces = bizplaceFilter.value.map(id => `('${id}')`).join(',')
-
-    if (product) {
-      let products = product.value
-        .toLowerCase()
-        .split(',')
-        .map(prod => {
-          return "'%" + prod.trim().replace(/'/g, "''") + "%'"
-        })
-        .join(',')
-
-      queryFilter =
-        queryFilter +
-        ` and exists (
-            select prd.id as product_id from products prd
-            inner join bizplaces b on b.id = prd.bizplace_id 
-            inner join companies c on c.domain_id = b.domain_id 
-            inner join bizplaces b2 on b2.company_id = c.id
-            where exists (
-              SELECT * FROM tmp_bizfilter bizFilter
-              WHERE bizFilter.bizplace_id = "b2"."id"
-            )
-            and (lower(prd.name) like any(array[${products}])
-            or lower(prd.description) like any(array[${products}])
-            or lower(prd.sku) like any(array[${products}])
-            or lower(prd.brand) like any(array[${products}]))
-            and prd.id = rih.product_id
-            group by prd.id
-        )`
-    }
-
-    if (location) {
-      let locations = location.value
-        .map(loc => {
-          return "'" + loc + "'"
-        })
-        .join(',')
-
-      queryFilter =
-        queryFilter +
-        `and exists (
-          select loc.id from locations loc where
-          loc.id = any(array[${locations}]::uuid[])
-          and loc.id = rih.location_id
-        )`
-    }
-
-    // default sorting
-    let queryOrder = 'order by created_at desc'
-    if (sortings && sortings.length > 0) {
-      const arrObjectMap = [
-        { name: 'palletId', value: 'rih.pallet_id' },
-        { name: 'cartonId', value: 'rih.carton_id' },
-        { name: 'batchId', value: 'rih.batch_id' },
-        { name: 'initialInboundAt', value: 'rih.initial_inbound_at' },
-        { name: 'bizplace|name', value: 'bz.name' },
-        { name: 'product|name', value: 'prd.sku' },
-        { name: 'remainQty', value: 'rih.qty' },
-        { name: 'location|name', value: 'loc.name' }
-      ]
-      sortings.forEach((sorting, idx) => {
-        let itmIndex = arrObjectMap.findIndex(x => x.name === sorting.name)
-
-        queryOrder = `${idx === 0 ? 'order by' : queryOrder + ','} ${
-          itmIndex >= 0 ? arrObjectMap[itmIndex].value : sorting.name
-        } ${sorting.desc ? 'DESC' : 'ASC'}`
-      })
-    }
-
-    if (batchId) queryFilter = `${queryFilter} and lower(rih.batch_id) like '${batchId.value.toLowerCase()}' `
-
-    if (palletId) queryFilter = `${queryFilter} and rih.pallet_id like '${palletId.value}' `
-
-    if (cartonId) queryFilter = `${queryFilter} and rih.carton_id like '${cartonId.value}' `
-
-    if (packingType) queryFilter = `${queryFilter} and rih.packing_type like '${packingType.value}' `
-
-    let expirationQueryFilter = ``
-    if (expiration)
-      expirationQueryFilter = ` and iv.expiration_date >= '${expFromDate.value}'::timestamp + '${timezoneOffset}'::INTERVAL and 
-      iv.expiration_date <= '${expToDate.value}'::timestamp + '${timezoneOffset}'::INTERVAL + '1 day'::INTERVAL`
-
-    // query the results
-    await tx.query(`
-      CREATE TEMP TABLE tmp_bizfilter on commit drop AS (
-        SELECT bizplace_id::uuid FROM (VALUES ${bizplaces}) AS bizFilter(bizplace_id)
-      );
-    `)
-
-    await tx.query(
-      `
-      create temp table tmp_src on commit drop as (
-        select domain_id, pallet_id, carton_id, seq, qty, uom_value, packing_type, batch_id, batch_id_ref, created_at, status, unit_cost,
-        product_id::uuid as product_id, bizplace_id::uuid as bizplace_id, location_id::uuid as location_id 
-        from reduced_inventory_histories rih 
-        where domain_id = $1 and created_at < $2::timestamp + $3::INTERVAL + '1 day'::INTERVAL 
-      );
-    `,
-      [domain.id, createdAt.value, timezoneOffset]
-    )
-
-    await tx.query(
-      `
-      CREATE TEMP TABLE tmp_src_group on commit drop AS (
-        select ih.domain_id, ih.pallet_id, sum(ih.qty) as qty, sum(ih.uom_value) as uom_value, max(ih.seq) as last_seq, max(ih.created_at) as created_at,
-        min(ih.created_at) as initial_inbound_at
-        from tmp_src ih
-        group by ih.domain_id, ih.pallet_id
-      );
-    `
-    )
-
-    await tx.query(
-      `          
-        create temp table tmp_data on commit drop as (
-          select dt.*, rih.carton_id, rih.batch_id, rih.batch_id_ref, rih.product_id, rih.packing_type, rih.bizplace_id, rih.location_id, rih.unit_cost,iv.id as inventory_id, iv.uom, 
-          iv.expiration_date, iv.manufacture_date, iv.reusable_pallet_id, iv.remark
-          from
-          (
-            SELECT ih.*, ih2.status FROM tmp_src_group ih
-            INNER JOIN inventory_histories ih2 
-            ON ih.domain_id = ih2.domain_id 
-            AND ih.pallet_id = ih2.pallet_id
-            AND ih.last_seq = ih2.seq            
-          ) dt
-          inner join tmp_src rih on dt.domain_id = rih.domain_id and dt.pallet_id = rih.pallet_id and dt.last_seq = rih.seq and rih.status <> 'TERMINATED'
-          inner join inventories iv on iv.domain_id = dt.domain_id and iv.pallet_id = dt.pallet_id and iv.status <> 'MISSING'
-          where exists (
-            SELECT * FROM tmp_bizfilter bizFilter
-            WHERE bizFilter.bizplace_id = "rih"."bizplace_id"
-          )
-          ${queryFilter}
-          ${expirationQueryFilter}
-        );
-      `
-    )
-
-    const total: any = await tx.query(`select count(*) from tmp_data`)
-
-    const result: any = await tx.query(
-      ` 
-          select 
-          rih.domain_id, rih.pallet_id as "palletId", rih.carton_id as "cartonId", rih.qty as "remainQty", 
-          TRUNC(rih.uom_value::numeric,2) as "uomValue", rih.uom, rih.last_seq, rih.created_at,
-          rih.initial_inbound_at as "initialInboundAt", rih.unit_cost as "unitCost",
-          case when rih.reusable_pallet_id is not null then concat(rih.batch_id, ' (', plt.name, ')') else rih.batch_id end as "batchId",
-          rih.batch_id_ref as "batchIdRef", rih.product_id, rih.packing_type as "packingType", rih.bizplace_id, rih.location_id,
-          prd.id as product_id, prd.name as product_name, prd.sku as product_sku, prd.brand as product_brand, prd.description as product_description, prd.volume as product_volume,
-          bz.id as bizplace_id, bz.name as bizplace_name, 
-          loc.id as location_id, loc.name as location_name, loc."zone" as location_zone, loc."row" as location_row, loc."column" as location_column, loc.shelf as location_shelf,
-          wh.name as warehouse_name, plt.name as reusable_pallet_name,
-          rih.remark,
-          rih.manufacture_date as "manufactureDate",
-          rih.expiration_date as "expirationDate",
-          coalesce((
-            select sum(oi1.release_qty) as nonLoadedQty from order_inventories oi1
-            inner join release_goods rg1 on rg1.id = oi1.release_good_id 
-            where rg1.status in ('PICKING', 'LOADING') 
-            and oi1.inventory_id = rih.inventory_id 
-            and oi1.status in ('PICKED', 'LOADING')
-            and rg1.domain_id = '${domain.id}'
-            group by oi1.inventory_id
-          ),0) as "nonLoadedQty",
-          TRUNC(coalesce((
-            select sum(oi1.release_uom_value) as nonLoadedUomValue from order_inventories oi1
-            inner join release_goods rg1 on rg1.id = oi1.release_good_id 
-            where rg1.status in ('PICKING', 'LOADING') 
-            and oi1.inventory_id = rih.inventory_id 
-            and oi1.status in ('PICKED', 'LOADING')
-            and rg1.domain_id = '${domain.id}'
-            group by oi1.inventory_id
-          ),0)::numeric,2) as "nonLoadedUomValue"
-          from tmp_data rih
-          left join pallets plt on plt.id = rih.reusable_pallet_id
-          inner join products prd on prd.id = rih.product_id
-          inner join bizplaces bz on bz.id = rih.bizplace_id
-          inner join locations loc on loc.id = rih.location_id
-          inner join warehouses wh on wh.id = loc.warehouse_id
-          WHERE 1 = 1
-          ${queryOrder}
-          ${setPagination ? 'OFFSET ' + (pagination.page - 1) * pagination.limit + ' LIMIT ' + pagination.limit : ''}
-      `
-    )
-
-    // map all results
-    let items = result.map(itm => {
-      return {
-        ...itm,
-        bizplace: {
-          id: itm.bizplace_id,
-          name: itm.bizplace_name
-        },
-        location: {
-          id: itm.location_id,
-          name: itm.location_name,
-          type: itm.location_type,
-          zone: itm.location_zone
-        },
-        product: {
-          id: itm.product_id,
-          name: itm.product_name,
-          description: itm.product_description,
-          sku: itm.product_sku,
-          brand: itm.product_brand,
-          volume: itm.product_volume
-        }
-      }
-    })
-
-    return { items, total: total[0].count }
-  }
-
-  @Directive('@transaction')
-  @Query(returns => RawInventoryHistoryList)
-  async bizplaceInventoryHistoriesForExport(
-    @Ctx() context: ResolverContext,
-    @Arg('inventoryHistory', type => InventoryHistoryPatch, { nullable: true })
-    inventoryHistory?: InventoryHistoryPatch,
-    @Arg('filters', type => [Filter], { nullable: true }) filters?: Filter[]
-  ): Promise<RawInventoryHistoryList> {
-    const { domain, tx } = context.state
-
-    const customerBizplace: Bizplace = await tx.getRepository(Bizplace).findOneBy({ id: 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)
-
-    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()
-
-      filters.push({
-        name: 'product_id',
-        operator: 'in',
-        value: _products.map((product: Product) => product.id)
-      })
-    }
-
-    if (inventoryHistory && inventoryHistory.warehouseName) {
-      const _warehouses: Warehouse[] = await tx.getRepository(Warehouse).findBy({
-        domain: { id: domain.id },
-        name: Raw(alias => `LOWER(${alias}) LIKE '${inventoryHistory.warehouseName.toLowerCase()}'`)
-      })
-
-      filters.push({
-        name: 'warehouse_id',
-        operator: 'in',
-        value: _warehouses.map((warehouse: Warehouse) => warehouse.id)
-      })
-    }
-
-    if (inventoryHistory && inventoryHistory.locationName) {
-      const _locations = await tx.getRepository(Location).find({
-        where: {
-          domain: { id: domain.id },
-          name: Raw(alias => `LOWER(${alias}) LIKE '${inventoryHistory.locationName.toLowerCase()}'`)
-        }
-      })
-
-      filters.push({
-        name: 'location_id',
-        operator: 'in',
-        value: _locations.map((location: Location) => location.id)
-      })
-    }
-
-    filters.push(
-      {
-        name: 'createdAt',
-        operator: 'between',
-        value: [fromDate, toDate]
-      },
-      {
-        name: 'bizplace_id',
-        operator: 'eq',
-        value: customerBizplace.id
-      }
-    )
-
-    const qb: SelectQueryBuilder<InventoryHistory> = getRepository(InventoryHistory).createQueryBuilder('ih')
-    buildQuery(qb, { filters }, context)
-
-    qb.select('prd.sku', 'sku')
-      .addSelect('prd.name', 'productName')
-      .addSelect('prd.description', 'productDescription')
-      .addSelect('prd.brand', 'brand')
-      .addSelect('ih.seq', 'seq')
-      .addSelect('ih.pallet_id', 'palletId')
-      .addSelect('ih.carton_id', 'cartonId')
-      .addSelect('ih.batch_id', 'batchId')
-      .addSelect('ih.batch_id_ref', 'batchIdRef')
-      .addSelect('ih.opening_qty', 'openingQty')
-      .addSelect('ih.qty', 'qty')
-      .addSelect('ih.opening_uom_value', 'openingUomValue')
-      .addSelect('ih.uom_value', 'uomValue')
-      .addSelect('ih.uom', 'uom')
-      .addSelect('ih.zone', 'zone')
-      .addSelect('ih.order_no', 'orderNo')
-      .addSelect('ih.order_ref_no', 'refNo')
-      .addSelect('ih.status', 'status')
-      .addSelect('ih.transaction_type', 'transactionType')
-      .addSelect('bzp.name', 'bizplace')
-      .addSelect('wh.name', 'warehouse')
-      .addSelect('lc.name', 'location')
-      .addSelect('ih.created_at', 'createdAt')
-      .addSelect('ih.updated_at', 'updatedAt')
-      .addSelect('up.name', 'updater')
-      .leftJoin('ih.product', 'prd')
-      .leftJoin('ih.warehouse', 'wh')
-      .leftJoin('ih.location', 'lc')
-      .leftJoin('ih.bizplace', 'bzp')
-      .leftJoin('ih.updater', 'up')
-      .orderBy('ih.pallet_id')
-      .addOrderBy('ih.seq')
-
-    const [items, total] = await Promise.all([qb.getRawMany(), qb.getCount()])
-
-    return { items, total }
-  }
-
-  @Directive('@transaction')
-  @Query(returns => InventoryHistoryVolumeSummaryReportList)
-  async inventoryHistoryVolumeSummaryReport(
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<InventoryHistoryVolumeSummaryReportList> {
-    try {
-      const { domain, user, tx } = context.state
-
-      let bizplaceFilter: Filter = { name: '', operator: '', value: '' }
-
-      let userFilter = params.filters.find(data => data.name === 'user')
-      let fromDate = params.filters.find(data => data.name === 'fromDate')
-      let toDate = params.filters.find(data => data.name === 'toDate')
-
-      if (userFilter) {
-        const user = (await tx.getRepository(User).findOne({
-          where: { id: userFilter.value },
-          relations: ['bizplaces']
-        })) as User & { bizplaces: Bizplace[] }
-
-        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')
-      }
-
-      if (!bizplaceFilter || !fromDate || !toDate) throw 'Invalid input'
-
-      const bizplace: Bizplace = await tx.getRepository(Bizplace).findOneBy({
-        id: bizplaceFilter.value
-      })
-
-      //check if all product details got volume
-      let foundPermittedBizplace: Bizplace
-
-      if (bizplace) {
-        foundPermittedBizplace = await tx.getRepository(Bizplace).findOne({
-          where: { id: bizplace.id },
-          relations: ['company', 'company.domain']
-        })
-
-        const companyDomain: Domain = foundPermittedBizplace.company.domain
-
-        let foundProductDetail = await tx
-          .getRepository(ProductDetail)
-          .findOne({ where: { domain: { id: companyDomain.id }, volume: IsNull() || 0 } })
-
-        if (foundProductDetail) {
-          throw new Error('there is product master with empty volume')
-        }
-      }
-
-      await tx.query(
-        `
-        create temp table temp_reduced_inventory_histories ON COMMIT drop as (
-          select
-          row_number() over (order by cast(rih.created_at + (interval '8 hour') as DATE) ASC) as row,
-          SUM(case when rih.transaction_type in ('UNLOADING', 'RETURN') then rih.qty end) as "inboundQty",
-          round(cast(SUM(case when rih.transaction_type in ('UNLOADING', 'RETURN') then rih.qty * pd.volume end) as numeric), 2) as "inboundVolume",
-          SUM(case when rih.transaction_type in ('ADJUSTMENT', 'NEW', 'CC_ADJUSTMENT') then rih.qty end) as "adjustedQty",
-          round(cast(SUM(case when rih.transaction_type in ('ADJUSTMENT', 'NEW', 'CC_ADJUSTMENT') and rih.status <> 'MISSING' then rih.qty * pd.volume end) as numeric), 2) as "adjustedVolume", 
-          SUM(case when rih.transaction_type = 'ADJUSTMENT' and status = 'MISSING' then rih.opening_qty end) as "missingQty",
-          round(cast(SUM(case when rih.transaction_type = 'ADJUSTMENT' and status = 'MISSING' then rih.opening_qty * pd.volume end) as numeric), 2) as "missingVolume",
-          SUM(case when rih.transaction_type = 'PICKING' then -(rih.qty) end) as "outboundQty",
-          round(cast(SUM(case when rih.transaction_type = 'PICKING' then -(rih.qty) * pd.volume end) as numeric), 2) as "outboundVolume",
-          SUM(case when rih.transaction_type in ('UNLOADING', 'ADJUSTMENT', 'PICKING', 'NEW', 'RETURN', 'CC_ADJUSTMENT') then rih.qty end) - SUM(case when rih.transaction_type = 'ADJUSTMENT' and status = 'MISSING' then rih.opening_qty else 0 end) as "tempTotal",
-          round(cast(SUM(case when rih.transaction_type in ('UNLOADING', 'ADJUSTMENT', 'PICKING', 'NEW', 'RETURN', 'CC_ADJUSTMENT') then rih.qty * pd.volume end) - round(cast(SUM(case when rih.transaction_type = 'ADJUSTMENT' and status = 'MISSING' then rih.opening_qty * pd.volume else 0 end) as numeric), 2) as numeric), 2) as "tempTotalVolume",
-          rih.bizplace_id as bizplace_id,
-          cast(rih.created_at + (interval '8 hour') as DATE) as "tempDate"
-          from reduced_inventory_histories rih
-          left join product_details pd on pd.product_id = rih.product_id and pd.packing_type = rih.packing_type
-          where rih.status not like 'TERMINATED' and rih.bizplace_id = $1
-          group by CAST(rih.created_at + (interval '8 hour') as DATE), rih.bizplace_id
-        )
-      `,
-        [bizplace.id]
-      )
-
-      await tx.query(
-        `
-        create temp table temp_reduced_inventory_histories_with_date_range ON COMMIT drop as (
-          select 
-          coalesce(tmp."tempDate", dr.range_date) as date,
-          row_number() over (order by coalesce(tmp."tempDate", dr.range_date) ASC) as row, 
-          coalesce(tmp."inboundQty", 0) as "inboundQty", 
-          coalesce(tmp."inboundVolume", 0) as "inboundVolume", 
-          coalesce(tmp."adjustedQty", 0) as "adjustedQty", 
-          coalesce(tmp."adjustedVolume", 0) as "adjustedVolume", 
-          coalesce(tmp."missingQty", 0) as "missingQty", 
-          coalesce(tmp."missingVolume", 0) as "missingVolume", 
-          coalesce(tmp."outboundQty", 0) as "outboundQty", 
-          coalesce(tmp."outboundVolume", 0) as "outboundVolume",
-          '${bizplace.id}' as bizplace_id,
-          (case when tmp."tempTotal" isnull then 0 else tmp."tempTotal" end) as total, (case when tmp."tempTotalVolume" isnull then 0 else tmp."tempTotalVolume" end) as "totalVolume" 
-          from temp_reduced_inventory_histories tmp 
-          full join (
-            select date_trunc('day', dd):: date as range_date
-                  from generate_series
-                  ( $1::timestamp 
-                  , $2::timestamp
-                  , '1 day'::interval) dd
-          ) dr on dr.range_date = tmp."tempDate" order by date
-        )
-        `,
-        [fromDate.value, toDate.value]
-      )
-
-      await tx.query(
-        `
-        create temp table temp_result ON COMMIT drop as(
-          select lag(sub."closingQty", 1, 0) over (partition by sub.bizplace_id order by sub.date) as "openingQty", 
-          lag(sub."closingVolume", 1, 0) over (partition by sub.bizplace_id order by sub.date) as "openingVolume", sub.* from(
-          select (select sum(tmp2.total) from temp_reduced_inventory_histories_with_date_range tmp2 where tmp2.row <= tmp.row) as "closingQty",
-          (select sum(tmp2."totalVolume") from temp_reduced_inventory_histories_with_date_range tmp2 where tmp2.row <= tmp.row) as "closingVolume", tmp.* from
-          temp_reduced_inventory_histories_with_date_range tmp) sub
-        )
-      `
-      )
-
-      await tx.query(
-        `
-        create temp table temp_final ON COMMIT drop as(
-          select * from temp_result tr where tr.date between $1 and $2 OFFSET $3 LIMIT $4
-        )
-        `,
-        [fromDate.value, toDate.value, (params.pagination.page - 1) * params.pagination.limit, params.pagination.limit]
-      )
-
-      const result: any = await tx.query(
-        `
-        select * from temp_final
-        `
-      )
-
-      const total: any = await tx.query(
-        `
-      select count(*), sum(tmp."inboundQty") as "totalInboundQty", sum(tmp."inboundVolume") as "totalInboundVolume", 
-      sum(tmp."adjustedQty") as "totalAdjustedQty", sum(tmp."adjustedVolume") as "totalAdjustedVolume", 
-      sum(tmp."missingQty") as "totalMissingQty", sum(tmp."missingVolume") as "totalMissingVolume", 
-      sum(tmp."outboundQty") as "totalOutboundQty", sum(tmp."outboundVolume") as "totalOutboundVolume" from temp_final tmp
-      `
-      )
-
-      return {
-        items: result,
-        total: total[0].count,
-        totalOpeningQty: result?.length > 0 ? result[0].openingQty : 0,
-        totalOpeningVolume: result?.length > 0 ? result[0].openingVolume : 0,
-        totalInboundQty: result?.length > 0 ? total[0].totalInboundQty : 0,
-        totalInboundVolume: result?.length > 0 ? total[0].totalInboundVolume : 0,
-        totalAdjustedQty: result?.length > 0 ? total[0].totalAdjustedQty : 0,
-        totalAdjustedVolume: result?.length > 0 ? total[0].totalAdjustedVolume : 0,
-        totalMissingQty: result?.length > 0 ? total[0].totalMissingQty : 0,
-        totalMissingVolume: result?.length > 0 ? total[0].totalMissingVolume : 0,
-        totalOutboundQty: result?.length > 0 ? total[0].totalOutboundQty : 0,
-        totalOutboundVolume: result?.length > 0 ? total[0].totalOutboundVolume : 0,
-        totalClosingQty: result?.length > 0 ? result[result.length - 1].closingQty : 0,
-        totalClosingVolume: result?.length > 0 ? result[result.length - 1].closingVolume : 0
-      }
-    } catch (error) {
-      throw error
-    }
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() inventoryHistory: InventoryHistory) {
-    return await getRepository(Domain).findOneBy({ id: inventoryHistory.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() inventoryHistory: InventoryHistory) {
-    return await getRepository(User).findOneBy({ id: inventoryHistory.updaterId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() inventoryHistory: InventoryHistory) {
-    return await getRepository(User).findOneBy({ id: inventoryHistory.creatorId })
-  }
-}
-
-async function massageInventorySummary(
-  tx: EntityManager,
-  params: ListParam,
-  bizplace: Bizplace,
-  context: ResolverContext
-) {
-  await productsQuery(tx, params, bizplace)
-  await filterInventoryQuery(tx, params, bizplace, context)
-
-  let fromDate = params.filters.find(data => data.name === 'fromDate')
-  let hasTransactionOrBalanceFilter = params.filters.find(data => data.name === 'hasTransactionOrBalance')
-
-  let hasTransactionOrBalanceQuery = ''
-  if (hasTransactionOrBalanceFilter && hasTransactionOrBalanceFilter.value) {
-    hasTransactionOrBalanceQuery = 'and (opening_qty > 0 or total_in_qty > 0 or adjustment_qty > 0)'
-  }
-  await tx.query(
-    `
-    create temp table temp_inventory_summary ON COMMIT DROP as (
-      select src.*,
-      opening_qty + adjustment_qty + total_in_qty + total_out_qty + missing_qty  as closing_qty
-      from (
-        select prd.sku AS product_sku, prd.name as product_name, prd.description as product_description, prd.type AS product_type, ih.packing_type, ih.packing_size,
-        sum(case when ih.created_at >= $1 and ih.transaction_type = 'ADJUSTMENT' then ih.qty else 0 end) as adjustment_qty,
-        sum(case when ih.created_at < $1 then qty else 0 end) as opening_qty,
-        sum(case when  ih.status = 'MISSING' then -ih.opening_qty else 0 end) as missing_qty,
-        sum(case when ih.created_at >= $1 then case when ih.qty > 0 and ih.transaction_type <> 'ADJUSTMENT' then ih.qty else 0 end else 0 end) as total_in_qty,
-        sum(case when ih.created_at >= $1 then case when ih.qty < 0 and ih.transaction_type <> 'ADJUSTMENT' then ih.qty else 0 end else 0 end) as total_out_qty,
-        ih.product_id
-        from temp_inv_history ih
-        inner join temp_products prd on prd.id = ih.product_id
-        group by prd.sku, prd.name, prd.description, prd.type, ih.product_id, ih.packing_type, ih.packing_size
-      ) src
-      where 1=1
-      ${hasTransactionOrBalanceQuery}
-    )
-  `,
-    [fromDate.value]
-  )
-
-  const total: any = await tx.query(`select count(*) from temp_inventory_summary`)
-
-  const result: any = await tx.query(
-    `
-    select * from temp_inventory_summary ORDER BY product_name, product_description, product_type, packing_type, packing_size OFFSET $1 LIMIT $2
-  `,
-    [(params.pagination.page - 1) * params.pagination.limit, params.pagination.limit]
-  )
-
-  return [result, total]
-}
-
-async function massageInventoryPalletSummary(
-  tx: EntityManager,
-  params: ListParam,
-  bizplace: Bizplace,
-  context: ResolverContext
-) {
-  await productsQuery(tx, params, bizplace)
-  await filterInventoryQuery(tx, params, bizplace, context)
-
-  let fromDate = params.filters.find(data => data.name === 'fromDate')
-  let toDate = params.filters.find(data => data.name === 'toDate')
-  let hasTransactionOrBalanceFilter = params.filters.find(data => data.name === 'hasTransactionOrBalance')
-
-  let hasTransactionOrBalanceQuery = ''
-  if (hasTransactionOrBalanceFilter && hasTransactionOrBalanceFilter.value) {
-    hasTransactionOrBalanceQuery = 'and (opening_qty > 0 or total_in_qty > 0 or adjustment_qty > 0)'
-  }
-  await tx.query(
-    `
-    create temp table temp_inventory_pallet_summary ON COMMIT DROP as (
-      select invh.*,
-      invh.opening_qty + invh.total_in_qty + invh.total_out_qty + invh.adjustment_qty as closing_qty from (
-        select product_sku, product_id, product_name, product_description, product_type,
-        SUM(case when invHistory.created_at < $1 then
-          case when invHistory.status = 'STORED' then 1 
-          when invhistory.status = 'TERMINATED' then -1
-            else 0 end
-            else 0 end) as opening_qty,
-        SUM(case when invHistory.created_at >= $1 and invHistory.created_at <= $2 then 
-          case when (invHistory.transaction_type = 'UNLOADING' or invHistory.transaction_type = 'NEW') then 1 else 0 end
-            else 0 end) as total_in_qty,
-        SUM(case when invHistory.created_at >= $1 and invHistory.created_at <= $2 then 
-          case when invHistory.status = 'TERMINATED' AND invHistory.transaction_type <> 'ADJUSTMENT' then -1 else 0 end
-            else 0 end) as total_out_qty,
-        SUM(case when invHistory.created_at >= $1 and invHistory.created_at <= $2 then 
-          case when invHistory.status = 'TERMINATED' AND invHistory.transaction_type = 'ADJUSTMENT' then -1 
-               when invHistory.status = 'STORED' AND invHistory.transaction_type = 'ADJUSTMENT' then 1 else 0 end
-            else 0 end) as adjustment_qty
-        from(
-          select pallet_id, seq, status, transaction_type, product_sku, product_id, product_name, product_description, product_type,
-          inventory_history_id, packing_type, packing_size, qty, opening_qty, created_at from (
-            select row_number() over(partition by invh.pallet_id order by invh.created_at asc) as rn, invh.* ,
-            prd.sku as product_sku, prd.name as product_name, prd.description as product_description, prd.type AS product_type
-            from temp_inv_history invh
-            inner join temp_products prd on prd.id = invh.product_id
-            where (transaction_type = 'UNLOADING' or invh.transaction_type = 'NEW')
-              and invh.created_at >= $1
-          ) as invIn where rn = 1
-          union all
-          select pallet_id, seq, status, transaction_type, product_sku, product_id, product_name, product_description, product_type,
-          inventory_history_id, packing_type, packing_size, qty, opening_qty, created_at from (
-            SELECT row_number() over(partition by pallet_id, invh.product_id order by seq asc) as rn, 
-            invh.pallet_id, invh.product_id, invh.packing_type, invh.packing_size,
-            invh.batch_id, invh.inventory_history_id, 
-            invh.seq, 'STORED' AS status, invh.transaction_type, invh.qty, invh.opening_qty,
-            invh.created_at,
-            prd.sku as product_sku, prd.name as product_name, prd.description as product_description, prd.type AS product_type
-            from temp_inv_history invh
-            inner join temp_products prd on prd.id = invh.product_id
-            where invh.created_at < $1
-            and (invh.status = 'STORED' or invh.status = 'UNLOADED')
-          ) as invStored where rn = 1
-          union all
-          select pallet_id, seq, status, transaction_type, product_sku, product_id, product_name, product_description, product_type,
-          inventory_history_id, packing_type, packing_size, qty, opening_qty, started_at as created_at from (
-            select row_number() over(partition by invh.pallet_id, invh.product_id order by invh.seq desc) as rn, invh.*,
-            prd.sku as product_sku, prd.name as product_name, prd.description as product_description, prd.type AS product_type, repeatedGroup.started_at
-            from temp_inv_history invh
-            inner join (
-              select pallet_id, min(created_at) as started_at, max(created_at) as ended_at, min(seq) as min_seq, max(seq) as max_seq, status from (
-                select startData.*, sum(startflag) over (partition by pallet_id order by seq) as grp from (
-                  select s.*,  
-                  (case when lag(status) over (partition by pallet_id order by seq) = status then 0 else 1 end) as startflag
-                  from temp_inv_history s
-                ) startData
-              ) endData
-              group by pallet_id, grp, status
-            ) repeatedGroup on repeatedGroup.pallet_id = invh.pallet_id and repeatedGroup.min_seq <= invh.seq and repeatedGroup.max_seq >= invh.seq
-            inner join temp_products prd on prd.id = invh.product_id
-          ) as invOut where rn = 1 AND status ='TERMINATED'
-          union all
-          SELECT invh.pallet_id, invh.seq, invh.status, invh.transaction_type,
-          prd.sku AS product_sku, invh.product_id, prd.name AS product_name, prd.description AS product_description, prd.type AS product_type,
-          invh.inventory_history_id, invh.packing_type, invh.packing_size, invh.qty, invh.opening_qty, invh.created_at
-          FROM temp_inv_history invh
-          INNER JOIN (
-            SELECT invh.pallet_id, invh.seq AS stored_seq, invh2.seq AS terminated_seq FROM temp_inv_history invh
-            INNER JOIN temp_inv_history invh2 ON invh2.pallet_id = invh.pallet_id AND invh2.status='STORED' AND invh2.seq = invh.seq + 1 AND invh2.product_id <> invh.product_id
-            WHERE invh.transaction_type = 'ADJUSTMENT'
-          ) dt ON dt.pallet_id = invh.pallet_id AND (dt.stored_seq = invh.seq OR dt.terminated_seq = invh.seq)
-          inner join temp_products prd on prd.id = invh.product_id
-          where invh.created_at >= $1
-          ORDER BY product_name, pallet_id, seq 
-        ) as invHistory         
-        group by product_sku, product_id, product_name, product_description, product_type
-      ) invh
-      where 1=1
-      ${hasTransactionOrBalanceQuery}
-    )
-  `,
-    [fromDate.value, toDate.value]
-  )
-
-  const total: any = await tx.query(
-    `select count(*) as count, sum(total_in_qty) as totalInQty, sum(opening_qty) as totalOpeningBal from temp_inventory_pallet_summary`
-  )
-
-  const result: any = await tx.query(
-    `
-    select *, 'PALLET' as packing_type from temp_inventory_pallet_summary ORDER BY product_name, product_description OFFSET $1 LIMIT $2
-  `,
-    [(params.pagination.page - 1) * params.pagination.limit, params.pagination.limit]
-  )
-
-  return [result, total]
-}
-
-async function productsQuery(tx: EntityManager, params: ListParam, bizplace: Bizplace) {
-  let product = params.filters.find(data => data.name === 'product')
-  let productDesc = params.filters.find(data => data.name === 'productDescription')
-  let productType = params.filters.find(data => data.name === 'productType')
-
-  let productQuery = ''
-  if (product) {
-    let productValue = product.value
-      .toLowerCase()
-      .split(',')
-      .map(prod => {
-        return "'%" + prod.trim().replace(/'/g, "''") + "%'"
-      })
-      .join(',')
-    productQuery = `AND (
-      Lower(prd.name) LIKE ANY(ARRAY[${productValue}])
-      OR Lower(prd.sku) LIKE ANY(ARRAY[${productValue}])
-      OR Lower(prd.description) LIKE ANY(ARRAY[${productValue}])
-    )`
-  }
-
-  let productDescQuery = ''
-  if (productDesc) {
-    productDescQuery = "AND Lower(prd.description) LIKE '%" + productDesc.value.toLowerCase() + "%'"
-  }
-
-  let productTypeQuery = ''
-  if (productType) {
-    productTypeQuery = "AND prd.type = '" + productType.value + "'"
-  }
-
-  await tx.query(
-    `
-    create temp table temp_products ON COMMIT DROP AS
-    (
-      select prd.id, prd.name, prd.sku, prd.description, prd.id::varchar as product_id, prd.type from products prd
-      inner join bizplaces b on b.id = prd.bizplace_id 
-      inner join companies c on c.domain_id = b.domain_id 
-      inner join bizplaces b2 on b2.company_id = c.id
-      where b2.id = $1
-      ${productQuery}
-      ${productDescQuery}
-      ${productTypeQuery}
-      GROUP BY prd.id, prd.sku, prd.name, prd.description
-    )`,
-    [bizplace.id]
-  )
-}
-
-async function filterInventoryQuery(
-  tx: EntityManager,
-  params: ListParam,
-  bizplace: Bizplace,
-  context: ResolverContext
-) {
-  let toDate = params.filters.find(data => data.name === 'toDate')
-  let batchNo = params.filters.find(data => data.name === 'batchNo')
-
-  let batchNoQuery = ''
-  if (batchNo) {
-    batchNoQuery =
-      'AND Lower(ih.batch_id) LIKE ANY(ARRAY[' +
-      batchNo.value
-        .toLowerCase()
-        .split(',')
-        .map(prod => {
-          return "'%" + prod.trim().replace(/'/g, "''") + "%'"
-        })
-        .join(',') +
-      '])'
-  }
-
-  await tx.query(
-    `
-    create temp table temp_inv_history ON COMMIT DROP as (
-      select i2.pallet_id, ih.product_id::uuid, ih.packing_type, i2.packing_size, ih.batch_id,
-      ih.id as inventory_history_id, ih.seq, ih.status, ih.transaction_type, ih.qty, ih.opening_qty, ih.created_at
-      from inventories i2
-      inner join reduced_inventory_histories ih on ih.pallet_id = i2.pallet_id and ih.domain_id = i2.domain_id
-      where
-      ih.domain_id = $1
-      and ih.bizplace_id = $2
-      and ih.created_at <= $3
-      ${batchNoQuery}
-    )
-  `,
-    [context.state.domain.id, bizplace.id, toDate.value]
-  )
-}