@things-factory/warehouse-base 4.0.0-alpha.8 → 4.0.0-beta.2

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

@@ -1,233 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Bizplace } from '@things-factory/biz-base'
-import { Domain, ListParam } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-export const inventoryHistoryReport = {
-  async inventoryHistoryReport(_: any, params: ListParam, context: any) {
-    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,
-          orderName: item.order_name,
-          orderRefNo: item.ref_no,
-          createdAt: item.created_at
-        }
-      })
-
-      return items
-    } catch (error) {
-      throw error
-    }
-  }
-}

package/server/graphql/resolvers/inventory-history/inventory-history-summary-report.ts

@@ -1,317 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Bizplace } from '@things-factory/biz-base'
-import { ListParam } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-
-export const inventoryHistorySummaryReport = {
-  async inventoryHistorySummaryReport(_: any, params: ListParam, context: any) {
-    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
-    }
-  }
-}
-
-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 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]
-  )
-
-  tx.query(`
-    drop table temp_products, temp_inv_history, temp_inventory_summary
-  `)
-
-  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 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, weight, opening_weight, 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, weight, opening_weight, 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.weight, invh.opening_weight,
-            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, weight, opening_weight, 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.weight, invh.opening_weight, 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]
-  )
-
-  tx.query(`
-    drop table temp_products, temp_inv_history, temp_inventory_pallet_summary
-  `)
-
-  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 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() + "%'"
-  }
-
-  await tx.query(
-    `
-    create temp table temp_products 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}
-      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 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.weight, ih.opening_weight, 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]
-  )
-}

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

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