@things-factory/warehouse-base 3.7.13 → 3.8.1

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

@@ -0,0 +1,1434 @@
+import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { Between, Brackets, EntityManager, getRepository, In, Raw, SelectQueryBuilder } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Bizplace, getMyBizplace, getPermittedBizplaceIds } from '@things-factory/biz-base'
+import { Product } from '@things-factory/product-base'
+import { convertListParams, Domain, Filter, ListParam, Pagination, Sorting } from '@things-factory/shell'
+
+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
+} from './inventory-history-types'
+
+@Resolver(InventoryHistory)
+export class InventoryHistoryQuery {
+  @Query(returns => InventoryHistoryList)
+  async inventoryHistories(@Args() params: ListParam, @Ctx() context: any): Promise<InventoryHistoryList> {
+    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 }
+  }
+
+  @Query(returns => InventoryHistory)
+  async inventoryHistory(@Arg('name') name: string, @Ctx() context: any): Promise<InventoryHistory> {
+    const { domain }: { domain: Domain } = context.state
+
+    return await getRepository(InventoryHistory).findOne({
+      where: { domain: domain, name, relations: ['domain', 'creator', 'updater'] }
+    })
+  }
+
+  @Directive('@transaction')
+  @Query(returns => InventoryHistoryList)
+  async bizplaceInventoryHistories(
+    @Ctx() context: any,
+    @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 }: { 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 }
+  }
+
+  @Directive('@transaction')
+  @Query(returns => [InventoryHistory])
+  async inventoryHistoryReport(@Args() params: ListParam, @Ctx() context: any): Promise<InventoryHistory[]> {
+    try {
+      const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
+
+      let bizplaceFilter = { 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: 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')
+      }
+
+      if (!bizplaceFilter || !fromDate || !toDate) throw 'Invalid input'
+
+      const bizplace: Bizplace = await tx.getRepository(Bizplace).findOne({
+        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.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.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.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.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 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.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 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 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.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 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 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 batch_id, product_name, packing_type, sum(qty) as totalQty, count(*) as totalRow from temp_inv_history ih2 
+            group by batch_id, product_name, packing_type
+          ) src 
+          where src.batch_id = invh.batch_id and src.product_name = invh.product_name and src.packing_type = invh.packing_type
+          ${hasTransactionOrBalanceQuery}
+        )
+        ORDER BY 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,
+            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
+        }
+      })
+
+      return items
+    } catch (error) {
+      throw error
+    }
+  }
+
+  @Directive('@transaction')
+  @Query(returns => [InventoryHistory])
+  async inventoryHistoryPalletReport(@Args() params: ListParam, @Ctx() context: any): Promise<InventoryHistory[]> {
+    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.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() params: ListParam,
+    @Ctx() context: any
+  ): Promise<InventoryHistory[]> {
+    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.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() params: ListParam,
+    @Ctx() context: any
+  ): Promise<InventoryHistoryPalletReportList> {
+    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')
+
+      if (!bizplaceFilter || !fromDate || !toDate) throw 'Invalid input'
+
+      const bizplace: Bizplace = await tx.getRepository(Bizplace).findOne({
+        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() params: ListParam,
+    @Ctx() context: any
+  ): Promise<InventoryHistorySummaryList> {
+    try {
+      const { tx }: { tx: EntityManager } = context.state
+
+      let bizplaceFilter = { 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: 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')
+      }
+
+      if (!bizplaceFilter || !fromDate || !toDate) throw 'Invalid input'
+
+      const bizplace: Bizplace = await tx.getRepository(Bizplace).findOne({
+        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,
+          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: any,
+    @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 }: { domain: Domain; user: User; tx: EntityManager } = 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: 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 = !filters.find((filter: any) => filter.name === 'bizplace')
+        ? {
+            name: 'bizplace',
+            operator: 'in',
+            value: await getPermittedBizplaceIds(domain, user),
+            relation: true
+          }
+        : {
+            ...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,
+        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_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, iv.uom, 
+          iv.expiration_date, iv.reusable_pallet_id, iv.remark
+          from
+          (
+            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
+          ) 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
+          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", rih.uom_value as "uomValue", rih.uom, rih.last_seq, rih.created_at,
+          rih.initial_inbound_at as "initialInboundAt",
+          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,
+          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.expiration_date as "expirationDate"
+          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
+        }
+      }
+    })
+
+    return { items, total: total[0].count }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() inventoryHistory: InventoryHistory) {
+    return await getRepository(Domain).findOne(inventoryHistory.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() inventoryHistory: InventoryHistory) {
+    return await getRepository(User).findOne(inventoryHistory.updaterId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() inventoryHistory: InventoryHistory) {
+    return await getRepository(User).findOne(inventoryHistory.creatorId)
+  }
+}
+
+async function massageInventorySummary(tx: EntityManager, params: ListParam, bizplace: Bizplace, context: any) {
+  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 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.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: any) {
+  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: any) {
+  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
+      i2.domain_id = $1
+      and i2.bizplace_id = $2
+      and ih.created_at <= $3
+      ${batchNoQuery}
+    )
+  `,
+    [context.state.domain.id, bizplace.id, toDate.value]
+  )
+}