@things-factory/sales-base 5.0.13 → 6.0.0-alpha.1

package/server/service/release-good/release-good-query.ts

@@ -1,27 +1,26 @@
-import orderBy from 'lodash/orderBy'
 import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { EntityManager, getRepository, In, Repository, SelectQueryBuilder } from 'typeorm'
+import { EntityManager, In, OrderByCondition, Repository, SelectQueryBuilder } from 'typeorm'
 
 import { Attachment } from '@things-factory/attachment-base'
 import { checkUserBelongsDomain, User } from '@things-factory/auth-base'
 import { Bizplace, getCompanyBizplace, getMyBizplace, getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { Product } from '@things-factory/product-base'
-import { buildQuery, Domain, Filter, ListParam, Pagination, Sorting } from '@things-factory/shell'
+import { logger } from '@things-factory/env'
+import { buildQuery, Domain, Filter, getRepository, ListParam, Pagination, Sorting } from '@things-factory/shell'
 import { Inventory, LOCATION_TYPE } from '@things-factory/warehouse-base'
 
 import { ATTACHMENT_TYPE, ORDER_INVENTORY_STATUS, ORDER_STATUS } from '../../constants'
 import { OrderInventory } from '../order-inventory/order-inventory'
 import { ShippingOrder } from '../shipping-order/shipping-order'
 import { ReleaseGood } from './release-good'
-import { InventoryInfos, NewReleaseGood, ReleasableInventoryList, ReleaseGoodList } from './release-good-types'
+import { NewReleaseGood, ReleasableInventoryList, ReleaseGoodList } from './release-good-types'
 
 @Resolver(ReleaseGood)
 export class ReleaseGoodQuery {
   @Directive('@privilege(category: "order_customer", privilege: "query")')
   @Query(returns => ReleaseGoodList)
-  async releaseGoods(@Ctx() context: any, @Args() params: ListParam): Promise<ReleaseGoodList> {
+  async releaseGoods(@Ctx() context: ResolverContext, @Args() params: ListParam): Promise<ReleaseGoodList> {
     try {
-      const { domain, user }: { domain: Domain; user: User } = context.state
+      const { domain, user } = context.state
 
       if (!params.filters.find((filter: any) => filter.name === 'bizplace')) {
         params.filters.push({
@@ -62,52 +61,47 @@ export class ReleaseGoodQuery {
       buildQuery(qb, params, context)
       let items: any
       let total: number
-      if (!params.filters.find((filter: any) => filter.name === 'releaseGoodOnly')) {
-        qb.addSelect('COALESCE("cc".rank, 99999)', 'rank')
-        qb.leftJoinAndSelect('rg.domain', 'domain')
-        qb.leftJoinAndSelect('rg.bizplace', 'bizplace')
-        qb.leftJoinAndSelect('rg.orderInventories', 'oi')
-        qb.leftJoinAndSelect('rg.orderProducts', 'op')
-        qb.leftJoinAndSelect('oi.inventory', 'inv')
-        qb.leftJoinAndSelect('oi.product', 'prod')
-        qb.leftJoinAndSelect('rg.arrivalNotice', 'an')
-        qb.leftJoinAndSelect('rg.creator', 'creator')
-        qb.leftJoinAndSelect('rg.updater', 'updater')
-        qb.leftJoin(
-          subQuery => {
-            return subQuery
-              .select(`ccd.rank`, 'rank')
-              .addSelect(`ccd.name`, 'status')
-              .from(`common_code_details`, 'ccd')
-              .innerJoin(`ccd.commonCode`, 'cc')
-              .where(`ccd.domain_id = :domainId`, { domainId: domain.id })
-              .andWhere(`cc.name = 'RO_LIST_STATUS'`)
-          },
-          'cc',
-          'cc.status = rg.status'
-        )
+      qb.addSelect('COALESCE("cc".rank, 99999)', 'rank')
+      qb.leftJoinAndSelect('rg.domain', 'domain')
+      qb.leftJoinAndSelect('rg.bizplace', 'bizplace')
+      qb.leftJoinAndSelect('rg.orderInventories', 'oi')
+      qb.leftJoinAndSelect('rg.orderProducts', 'op')
+      qb.leftJoinAndSelect('oi.inventory', 'inv')
+      qb.leftJoinAndSelect('oi.product', 'prod')
+      qb.leftJoinAndSelect('rg.arrivalNotice', 'an')
+      qb.leftJoinAndSelect('rg.creator', 'creator')
+      qb.leftJoinAndSelect('rg.updater', 'updater')
+      qb.leftJoin(
+        subQuery => {
+          return subQuery
+            .select(`ccd.rank`, 'rank')
+            .addSelect(`ccd.name`, 'status')
+            .from(`common_code_details`, 'ccd')
+            .innerJoin(`ccd.commonCode`, 'cc')
+            .where(`ccd.domain_id = :domainId`, { domainId: domain.id })
+            .andWhere(`cc.name = 'RO_LIST_STATUS'`)
+        },
+        'cc',
+        'cc.status = rg.status'
+      )
 
-        const arrChildSortData = ['bizplace']
-        const sort = (params.sortings || []).reduce(
-          (acc, sort) => ({
-            ...acc,
-            [arrChildSortData.indexOf(sort.name) >= 0 ? sort.name + '.name' : 'rg.' + sort.name]: sort.desc
-              ? 'DESC'
-              : 'ASC'
-          }),
-          !params.sortings.some(e => e.name === 'status') ? { rank: 'ASC' } : {}
-        )
+      const arrChildSortData = ['bizplace']
+      const sort: OrderByCondition = (params.sortings || []).reduce(
+        (acc, sort) => ({
+          ...acc,
+          [arrChildSortData.indexOf(sort.name) >= 0 ? sort.name + '.name' : 'rg.' + sort.name]: sort.desc
+            ? 'DESC'
+            : 'ASC'
+        }),
+        !params.sortings.some(e => e.name === 'status') ? { rank: 'ASC' } : {}
+      )
 
-        qb.orderBy(sort)
+      qb.orderBy(sort)
+
+      let [itemsRes, totalRes] = await qb.getManyAndCount()
+      items = itemsRes
+      total = totalRes
 
-        let [itemsRes, totalRes] = await qb.getManyAndCount()
-        items = itemsRes
-        total = totalRes
-      } else {
-        let itemsRes = await qb.getOne()
-        items = itemsRes ? [itemsRes] : []
-        total = items.length
-      }
       return { items, total }
     } catch (error) {
       throw error
@@ -116,88 +110,113 @@ export class ReleaseGoodQuery {
 
   @Directive('@privilege(category: "order", privilege: "query")')
   @Query(returns => ReleaseGood)
-  async releaseGood(@Ctx() context: any, @Arg('name') name: string): Promise<ReleaseGood> {
-    const { domain, user }: { domain: Domain; user: User } = context.state
-
-    return await getRepository(ReleaseGood).findOne({
-      where: {
-        domain,
-        name,
-        bizplace: In(await getPermittedBizplaceIds(domain, user))
-      },
-      relations: [
-        'domain',
-        'bizplace',
-        'shippingOrder',
-        'arrivalNotice',
-        'orderInventories',
-        'orderInventories.product',
-        'orderInventories.inventory',
-        'orderInventories.inventory.product',
-        'orderVass',
-        'orderVass.vas',
-        'creator',
-        'updater'
-      ]
-    })
+  async releaseGood(
+    @Ctx() context: ResolverContext,
+    @Arg('name', { nullable: true }) name: string,
+    @Arg('trackingNo', { nullable: true }) trackingNo: string
+  ): Promise<ReleaseGood> {
+    const { domain, user } = context.state
+
+    if (name) {
+      return await getRepository(ReleaseGood).findOne({
+        where: {
+          domain: { id: domain.id },
+          name,
+          bizplace: In(await getPermittedBizplaceIds(domain, user))
+        },
+        relations: [
+          'domain',
+          'bizplace',
+          'shippingOrder',
+          'arrivalNotice',
+          'orderInventories',
+          'orderInventories.product',
+          'orderInventories.inventory',
+          'orderInventories.inventory.product',
+          'orderVass',
+          'orderVass.vas',
+          'creator',
+          'updater'
+        ]
+      })
+    } else if (trackingNo) {
+      let releaseGood = await getRepository(ReleaseGood).findOne({
+        where: {
+          domain: { id: domain.id },
+          trackingNo,
+          bizplace: In(await getPermittedBizplaceIds(domain, user))
+        },
+        relations: ['bizplace']
+      })
+
+      if (!releaseGood) {
+        throw new Error('Tracking No not found in any orders')
+      } else {
+        return releaseGood
+      }
+    }
   }
 
   @Directive('@privilege(category: "order", privilege: "query")')
   @Directive('@transaction')
   @Query(returns => ReleaseGood)
   async releaseGoodDetail(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @Arg('refNo', { nullable: true }) refNo?: string,
     @Arg('name', { nullable: true }) name?: string
   ): Promise<ReleaseGood> {
-    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
-    let param: any
-
-    if (name) param = { domain, name }
-    else param = { domain, refNo }
-
-    const releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
-      where: { ...param },
-      relations: [
-        'domain',
-        'bizplace',
-        'shippingOrder',
-        'arrivalNotice',
-        'orderInventories',
-        'orderInventories.inventory',
-        'orderInventories.product',
-        'orderInventories.inventory.product',
-        'orderInventories.inventory.location',
-        'orderVass',
-        'orderVass.vas',
-        'orderVass.targetProduct',
-        'orderVass.inventory',
-        'creator',
-        'updater',
-        'deliverTo'
-      ]
-    })
-
-    if (releaseGood) {
-      const roBizId: string = releaseGood.bizplace.id
-      const shippingOrder: ShippingOrder = releaseGood.shippingOrder
-      const foundAttachments: Attachment[] = await tx.getRepository(Attachment).find({
-        where: {
-          domain,
-          refBy: releaseGood.id,
-          category: ATTACHMENT_TYPE.DELIVERY_ORDER
-        }
+    try {
+      const { domain, tx } = context.state
+      let param: any
+
+      if (name) param = { domain, name }
+      else param = { domain, refNo }
+
+      const releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
+        where: { ...param },
+        relations: [
+          'domain',
+          'bizplace',
+          'shippingOrder',
+          'arrivalNotice',
+          'orderProducts',
+          'orderProducts.product',
+          'orderVass',
+          'orderVass.vas',
+          'orderVass.targetProduct',
+          'orderVass.inventory',
+          'creator',
+          'updater'
+        ]
       })
 
-      await prepOITempTable(domain, tx)
+      if (releaseGood) {
+        let oiQb: SelectQueryBuilder<OrderInventory> = tx
+          .getRepository(OrderInventory)
+          .createQueryBuilder('oi')
+          .leftJoinAndSelect('oi.inventory', 'inventory')
+          .leftJoinAndSelect('oi.product', 'product')
+          .leftJoinAndSelect('inventory.location', 'location')
+          .where('oi.domain_id = :domainId', { domainId: domain.id })
+          .andWhere('oi.release_good_id = :releaseGoodId', { releaseGoodId: releaseGood.id })
+          .andWhere('oi.status NOT IN (:...orderInventoryStatus)', {
+            orderInventoryStatus: [ORDER_INVENTORY_STATUS.COMPLETE_SPLIT, ORDER_INVENTORY_STATUS.REPLACED]
+          })
+          .orderBy('product.sku', 'ASC')
+
+        let orderInventories: OrderInventory[] = await oiQb.getMany()
 
-      let invInfos = await Promise.all(
-        releaseGood.orderInventories
-          .filter(
-            itm =>
-              itm.status !== ORDER_INVENTORY_STATUS.COMPLETE_SPLIT && itm.status !== ORDER_INVENTORY_STATUS.REPLACED
-          )
-          .map(async (orderInv: OrderInventory) => {
+        const shippingOrder: ShippingOrder = releaseGood.shippingOrder
+        const foundAttachments: Attachment[] = await tx.getRepository(Attachment).find({
+          where: {
+            domain,
+            refBy: releaseGood.id,
+            category: ATTACHMENT_TYPE.DELIVERY_ORDER
+          }
+        })
+
+        let invInfos = await Promise.all(
+          orderInventories.map(async (orderInv: OrderInventory) => {
             if (orderInv?.inventory?.id) {
               const inventory: Inventory = orderInv.inventory
               return {
@@ -206,11 +225,11 @@ export class ReleaseGoodQuery {
                 batchId: inventory.batchId,
                 batchIdRef: inventory.batchIdRef,
                 palletId: inventory.palletId,
-                product: inventory.product,
-                productIdRef: inventory.product.id,
-                productName: `${inventory.product.name} (${inventory.product.description})`,
-                packingType: inventory.packingType,
-                packingSize: inventory.packingSize,
+                product: orderInv.product,
+                productIdRef: orderInv.product.id,
+                productName: `${orderInv.product.name} (${orderInv.product.description})`,
+                packingType: orderInv.packingType,
+                packingSize: orderInv.packingSize,
                 location: inventory.location,
                 qty: inventory.qty,
                 lockedQty: inventory.lockedQty,
@@ -220,54 +239,43 @@ export class ReleaseGoodQuery {
                 invStatus: inventory.status,
                 releaseQty: orderInv.releaseQty,
                 releaseUomValue: orderInv.releaseUomValue,
-                status: orderInv.status
-              }
-            } else {
-              const { batchId, batchIdRef, product, packingType, packingSize, releaseQty, releaseUomValue } = orderInv
-              const { id: productIdRef, name: productName }: Product = product
-              const { qty, uomValue, uom } = await getAvailableAmount(roBizId, productIdRef, batchId, packingType, tx)
-
-              return {
-                batchId,
-                batchIdRef,
-                productIdRef,
-                product,
-                productName,
-                packingType,
-                packingSize,
-                qty,
-                uom,
-                uomValue,
-                releaseQty,
-                releaseUomValue
+                status: orderInv.status,
+                refWorksheetId: orderInv.refWorksheetId
               }
             }
           })
-      )
-
-      const result = {
-        ...releaseGood,
-        attachment: foundAttachments,
-        shippingOrderInfo: {
-          containerNo: shippingOrder?.containerNo || '',
-          containerLeavingDate: shippingOrder?.containerLeavingDate || '',
-          containerArrivalDate: shippingOrder?.containerArrivalDate || '',
-          shipName: shippingOrder?.shipName || ''
-        },
-        inventoryInfos: orderBy<InventoryInfos>(invInfos, ['product.sku'], ['asc'])
-      }
+        )
 
-      dropOITempTable(domain, tx)
+        const result = {
+          ...releaseGood,
+          attachment: foundAttachments,
+          shippingOrderInfo: {
+            containerNo: shippingOrder?.containerNo || '',
+            containerSize: shippingOrder?.containerSize || '',
+            containerLeavingDate: shippingOrder?.containerLeavingDate || '',
+            containerArrivalDate: shippingOrder?.containerArrivalDate || '',
+            containerClosureDate: shippingOrder?.containerClosureDate || '',
+            shipName: shippingOrder?.shipName || '',
+            remark: shippingOrder?.remark || '',
+            remindContainerDeparture: shippingOrder?.remindContainerDeparture || null
+          },
+          inventoryInfos: invInfos
+        }
 
-      return result
+        return result
+      }
+    } catch (error) {
+      logger.error(`release-good-query[releaseGoodDetail]: ${error}`)
+      throw new Error(error)
     }
   }
 
   @Directive('@privilege(category: "order_warehouse", privilege: "query")')
   @Query(returns => ReleaseGoodList)
-  async releaseGoodRequests(@Ctx() context: any, @Args() params: ListParam): Promise<ReleaseGoodList> {
+  async releaseGoodRequests(@Ctx() context: ResolverContext, @Args() params: ListParam): Promise<ReleaseGoodList> {
     try {
-      const { domain, user }: { domain: Domain; user: User } = context.state
+      console.time('t1')
+      const { domain, user } = context.state
 
       const statusFilter = params.filters.some(e => e.name === 'status')
       const bizplaceFilter = params.filters.find(param => param.name === 'bizplaceId')
@@ -275,6 +283,9 @@ export class ReleaseGoodQuery {
       const skuFilter = params.filters.find(param => param.name === 'sku')
       const routeId = params.filters.find(param => param.name === 'routeId')
       const orderRemarkFilter = params.filters.find(param => param.name === 'orderRemark')
+      const manifestedFilter = params.filters.find(param => param.name === 'manifested')
+      const orderInfoFilter = params.filters.find(param => param.name === 'name')
+      const typeFilter = params.filters.find(param => param.name === 'type')?.value
 
       if (await checkUserBelongsDomain(domain, user)) {
         if (!statusFilter && !params.filters.some(e => e.name === 'name')) {
@@ -300,6 +311,10 @@ export class ReleaseGoodQuery {
         params.filters = params.filters.filter(param => param.name !== 'sku')
       }
 
+      if (orderInfoFilter) {
+        params.filters = params.filters.filter(param => param.name !== 'name')
+      }
+
       if (routeId) {
         if (routeId.value == true) {
           params.filters.find(param => param.name === 'routeId').value = 'null'
@@ -330,15 +345,37 @@ export class ReleaseGoodQuery {
         }
       }
 
+      if (manifestedFilter) {
+        const manifestedIdx = params.filters.findIndex(param => param.name === 'manifested')
+        if (manifestedFilter.value == true) {
+          params.filters.splice(manifestedIdx, 1)
+          params.filters.push({
+            name: 'manifestId',
+            operator: 'is_not_null',
+            value: null,
+            relation: false
+          })
+        } else {
+          params.filters.splice(manifestedIdx, 1)
+          params.filters.push({
+            name: 'manifestId',
+            operator: 'is_null',
+            value: null,
+            relation: false
+          })
+        }
+      }
+
       const fromDateParamIdx = params.filters.findIndex(param => param.name === 'fromDate')
       if (fromDateParamIdx >= 0) {
         let fromDateVal = new Date(params.filters[fromDateParamIdx].value)
+        let releaseDateFrom = params.filters.find(param => param.name === 'fromDate')?.value
         params.filters.splice(fromDateParamIdx, 1)
 
         params.filters.push({
-          name: 'createdAt',
+          name: typeFilter == 'b2c' ? 'releaseDate' : 'createdAt',
           operator: 'gte',
-          value: fromDateVal.toISOString(),
+          value: typeFilter == 'b2c' ? releaseDateFrom : fromDateVal.toISOString(),
           relation: false
         })
       }
@@ -346,12 +383,14 @@ export class ReleaseGoodQuery {
       const toDateParamIdx = params.filters.findIndex(param => param.name === 'toDate')
       if (toDateParamIdx >= 0) {
         let toDateVal = new Date(params.filters[toDateParamIdx].value)
+        let releaseDateTo = params.filters.find(param => param.name === 'toDate')?.value
         params.filters.splice(toDateParamIdx, 1)
 
         params.filters.push({
-          name: 'createdAt',
-          operator: 'lt',
-          value: new Date(toDateVal.setDate(toDateVal.getDate() + 1)).toISOString(),
+          name: typeFilter == 'b2c' ? 'releaseDate' : 'createdAt',
+          operator: typeFilter == 'b2c' ? 'lte' : 'lt',
+          value:
+            typeFilter == 'b2c' ? releaseDateTo : new Date(toDateVal.setDate(toDateVal.getDate() + 1)).toISOString(),
           relation: false
         })
       }
@@ -385,20 +424,58 @@ export class ReleaseGoodQuery {
       )
 
       if (skuFilter) {
+        let removeSymbol = skuFilter.value
+          .split('')
+          .filter(res => res !== '%')
+          .join('')
+
+        let products = removeSymbol
+          .toLowerCase()
+          .split(',')
+          .map(prod => {
+            return "'%" + prod.trim().replace(/'/g, "''") + "%'"
+          })
+          .join(',')
+
         qb.andWhere(
           `
         exists (select * from  order_inventories oi  
         inner join products p on oi.product_id = p.id
         inner join inventories i on i.product_id = p.id
         where oi.release_good_id = rg.id
-        and lower(p.sku) like :sku)
-        `,
-          { sku: skuFilter.value.toLowerCase() }
+        and (lower(p.sku) like any(array[${products}])
+        or lower(p.brand_sku) like any(array[${products}])
+        or lower(p.name) like any(array[${products}])
+        or lower(p.description) like any(array[${products}]))
         )
+        `
+        )
+      }
+
+      if (orderInfoFilter) {
+        let removeSymbol = orderInfoFilter.value
+          .split('')
+          .filter(res => res !== '%')
+          .join('')
+
+        let orderInfos = removeSymbol
+          .toLowerCase()
+          .split(',')
+          .map(prod => {
+            return "'%" + prod.trim().replace(/'/g, "''") + "%'"
+          })
+          .join(',')
+
+        qb.andWhere(`(
+          lower(rg.name) like any(array[${orderInfos}])
+          or lower(rg.ref_no) like any(array[${orderInfos}])
+          or lower(rg.ref_no_2) like any(array[${orderInfos}])
+          or lower(rg.ref_no_3) like any(array[${orderInfos}])
+        )`)
       }
 
       const arrChildSortData = ['bizplace', 'creator']
-      const sort = (params.sortings || []).reduce(
+      const sort: OrderByCondition = (params.sortings || []).reduce(
         (acc, sort) => ({
           ...acc,
           [arrChildSortData.indexOf(sort.name) >= 0 ? sort.name + '.name' : 'rg.' + sort.name]: sort.desc
@@ -412,15 +489,20 @@ export class ReleaseGoodQuery {
 
       let [items, total] = await qb.getManyAndCount()
 
-      items = items.map(item => {
-        return {
-          ...item,
-          orderRemark: item?.remark ? true : false
-        }
-      })
-
+      items = items
+        .filter(item => {
+          return item.domainId === domain.id
+        })
+        .map(item => {
+          return {
+            ...item,
+            orderRemark: item?.remark ? true : false
+          }
+        })
+      console.timeEnd('t1')
       return { items, total }
     } catch (error) {
+      logger.error(`release-good-query[releaseGoodRequests]: ${error}`)
       throw error
     }
   }
@@ -428,7 +510,7 @@ export class ReleaseGoodQuery {
   @Directive('@privilege(category: "order", privilege: "query")')
   @Query(returns => ReleasableInventoryList)
   async releasableInventories(
-    @Ctx() context: any,
+    @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[]
@@ -548,11 +630,11 @@ export class ReleaseGoodQuery {
   @Directive('@transaction')
   @Query(returns => [ReleaseGood])
   async bulkReleaseGoodsAvailableItems(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @Arg('rawReleaseGoods', type => [NewReleaseGood], { nullable: true }) rawReleaseGoods: NewReleaseGood[],
     @Arg('bizplaceId', type => String) bizplaceId: string
   ): Promise<ReleaseGood[]> {
-    const { tx }: { tx: EntityManager } = context.state
+    const { tx } = context.state
     const availableItems: any[] = await bulkReleaseGoodsAvailableItemsFunction(rawReleaseGoods, bizplaceId, context, tx)
 
     return availableItems
@@ -560,24 +642,24 @@ export class ReleaseGoodQuery {
 
   @FieldResolver(type => Domain)
   async domain(@Root() releaseGood: ReleaseGood): Promise<Domain> {
-    return await getRepository(Domain).findOne(releaseGood.domainId)
+    return await getRepository(Domain).findOneBy({ id: releaseGood.domainId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() releaseGood: ReleaseGood): Promise<User> {
-    return await getRepository(User).findOne(releaseGood.creatorId)
+    return await getRepository(User).findOneBy({ id: releaseGood.creatorId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() releaseGood: ReleaseGood): Promise<User> {
-    return await getRepository(User).findOne(releaseGood.updaterId)
+    return await getRepository(User).findOneBy({ id: releaseGood.updaterId })
   }
 }
 
 async function prepOITempTable(domain: Domain, tx: EntityManager) {
   await tx.query(
     `
-    CREATE TEMP TABLE oi AS (
+    CREATE TEMP TABLE oi ON COMMIT DROP AS (
       SELECT
         SUM(oi.release_qty) as release_qty,
         SUM(oi.release_uom_value) as release_uom_value,
@@ -660,7 +742,7 @@ export async function bulkReleaseGoodsAvailableItemsFunction(
   context: any,
   tx?: EntityManager
 ): Promise<any[]> {
-  const { domain }: { domain: Domain } = context.state
+  const { domain } = context.state
   const companyBizplaceId: Bizplace = await getCompanyBizplace(null, null, bizplaceId)
 
   if (!rawReleaseGoods) return