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

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

@@ -1,44 +1,40 @@
-import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root, Directive } from 'type-graphql'
-import { getRepository, SelectQueryBuilder, EntityManager, In, getManager } from 'typeorm'
-
-import { checkUserBelongsDomain, User } from '@things-factory/auth-base'
-import { Bizplace, getPermittedBizplaces, getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { buildQuery, Domain, ListParam, Filter, Pagination, Sorting } from '@things-factory/shell'
-
-import { DRAFT_RELEASE_ORDER_STATUS, ORDER_STATUS } from '../../constants'
-import { DraftReleaseGood } from './draft-release-good'
-import { DraftReleaseGoodList } from './draft-release-good-type'
+import { Arg, Args, Ctx, Directive, Query, Resolver } from 'type-graphql'
+import { EntityManager, In, OrderByCondition, SelectQueryBuilder } from 'typeorm'
 
 import { Attachment } from '@things-factory/attachment-base'
-import { ATTACHMENT_TYPE } from '../../constants'
+import { User } from '@things-factory/auth-base'
+import { Bizplace, getPermittedBizplaceIds, getPermittedBizplaces } from '@things-factory/biz-base'
+import { buildQuery, Domain, getRepository, ListParam } from '@things-factory/shell'
 
+import { ATTACHMENT_TYPE, DRAFT_RELEASE_ORDER_STATUS } from '../../constants'
 import { InventoryUtil } from '../../utils'
-import { OrderProduct } from '../order-product/order-product'
+import { DraftReleaseGood } from './draft-release-good'
+import { DraftReleaseGoodList } from './draft-release-good-type'
 
 @Resolver(DraftReleaseGood)
 export class DraftReleaseGoodQuery {
   @Query(returns => DraftReleaseGood, { description: 'To fetch a DraftReleaseGood' })
-  async draftReleaseGood(@Arg('id') id: string, @Ctx() context: any): Promise<DraftReleaseGood> {
+  async draftReleaseGood(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<DraftReleaseGood> {
     const { domain } = context.state
 
     return await getRepository(DraftReleaseGood).findOne({
-      where: { domain, id }
+      where: { domain: { id: domain.id }, id }
     })
   }
 
   @Directive('@transaction')
   @Query(returns => DraftReleaseGood, { description: 'To fetch a DraftReleaseGood' })
-  async draftReleaseGoodByName(@Arg('name') name: string, @Ctx() context: any): Promise<DraftReleaseGood> {
-    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
+  async draftReleaseGoodByName(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<DraftReleaseGood> {
+    const { domain, tx } = context.state
 
     return getDraftReleaseGoodFunction(null, name, context, tx)
   }
 
   @Directive('@transaction')
   @Query(returns => DraftReleaseGoodList, { description: 'To fetch multiple DraftReleaseGoods' })
-  async draftReleaseGoods(@Args() params: ListParam, @Ctx() context: any): Promise<DraftReleaseGoodList> {
+  async draftReleaseGoods(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<DraftReleaseGoodList> {
     try {
-      const { domain, user, tx }: { domain: Domain; user: User, tx: EntityManager } = context.state
+      const { domain, user, tx } = context.state
 
       const statusFilter = params.filters.find(e => e.name === 'status')
       const bizplaceFilter = params.filters.find(param => param.name === 'bizplaceId')
@@ -55,7 +51,9 @@ export class DraftReleaseGoodQuery {
         })
       }
 
-      params.filters = params.filters.filter(itm => itm.name !== 'noOfItems' && itm.name !== 'sku' && itm.name !== 'status')
+      params.filters = params.filters.filter(
+        itm => itm.name !== 'noOfItems' && itm.name !== 'sku' && itm.name !== 'status'
+      )
 
       if (orderRemarkFilter) {
         const orderRemarkIdx = params.filters.findIndex(param => param.name === 'orderRemark')
@@ -104,27 +102,31 @@ export class DraftReleaseGoodQuery {
         })
       }
 
-      tx.query(`
+      tx.query(
+        `
         create temp table temp_op_calculation on commit drop as (
-          select drg1.id, sum(case when wboi."remainQty" >= op.release_qty then 0 else 1 end) as insufficient_count, count(*) as total_row 
-          from draft_release_goods drg1
+          SELECT drg1.id from draft_release_goods drg1
           left join order_products op on drg1.id = op.draft_release_good_id
-          left join warehouse_bizplace_onhand_inventories wboi 
-            on (wboi."productId" = op.product_id or wboi."productBundleId" = op.product_id) 
-            and wboi."packingType" = op.packing_type 
-            and wboi."packingSize" = op.packing_size 
-            and wboi.uom = op.uom
+          where drg1.status ='DRAFT' AND drg1.domain_id = $1
+          AND NOT EXISTS (
+            SELECT * FROM warehouse_bizplace_onhand_inventories wboi 
+            where (wboi."productId" = op.product_id or wboi."productBundleId" = op.product_id) 
             and wboi."domainId" = op.domain_id
             and wboi."bizplaceId" = op.bizplace_id
-          where op.domain_id = $1 and drg1.status ='DRAFT'
-          group by drg1.id
+            AND wboi."remainQty" >= op.release_qty
+          ) GROUP BY drg1.id
         )
-      `, [domain.id])
+      `,
+        [domain.id]
+      )
 
       const qb: SelectQueryBuilder<DraftReleaseGood> = tx.getRepository(DraftReleaseGood).createQueryBuilder('drg')
       buildQuery(qb, params, context)
       qb.addSelect('COALESCE("cc".rank, 99999)', 'rank')
-      qb.addSelect(`CASE WHEN "drg".status = 'DRAFT' and (tmp_calc.insufficient_count > 0 or tmp_calc.total_row = 0) then 'INSUFFICIENT' else "drg".status END`, 'computed_status')
+      qb.addSelect(
+        `CASE WHEN "drg".status = 'DRAFT' and tmp_calc.id IS NOT null then 'INSUFFICIENT' else "drg".status END`,
+        'computed_status'
+      )
       qb.leftJoin(`temp_op_calculation`, 'tmp_calc', 'tmp_calc.id = drg.id')
       qb.leftJoinAndSelect('drg.domain', 'domain')
       qb.leftJoinAndSelect('drg.bizplace', 'bizplace')
@@ -194,7 +196,7 @@ export class DraftReleaseGoodQuery {
       }
 
       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' : 'drg.' + sort.name]: sort.desc
@@ -205,10 +207,11 @@ export class DraftReleaseGoodQuery {
       )
 
       qb.orderBy(sort)
+      qb.offset((params.pagination.page - 1) * params.pagination.limit)
+      qb.limit(params.pagination.limit)
 
       let [items, total] = await Promise.all([qb.getRawMany(), qb.getCount()])
 
-
       items = items.map(itm => {
         return {
           id: itm.drg_id,
@@ -234,7 +237,6 @@ export class DraftReleaseGoodQuery {
     } catch (error) {
       throw error
     }
-
   }
 }
 
@@ -244,7 +246,7 @@ export async function getDraftReleaseGoodFunction(_: any, name: any, context: an
 
     let permittedBizplaces = await getPermittedBizplaces(domain, user)
     let result = await tx.getRepository(DraftReleaseGood).findOne({
-      where: { domain, name, bizplace: In(permittedBizplaces.map(biz => biz.id)) },
+      where: { domain: { id: domain.id }, name, bizplace: In(permittedBizplaces.map(biz => biz.id)) },
       relations: [
         'releaseGood',
         'orderProducts',
@@ -260,7 +262,6 @@ export async function getDraftReleaseGoodFunction(_: any, name: any, context: an
 
     if (!result?.id) throw new Error(`Failed to find draft release good ${name}`)
 
-
     let foundPermittedBizplace: Bizplace
     let companyBizplace: Bizplace
 
@@ -269,7 +270,8 @@ export async function getDraftReleaseGoodFunction(_: any, name: any, context: an
 
       if (foundPermittedBizplace) {
         if (!foundPermittedBizplace.company?.id) {
-          foundPermittedBizplace = await tx.getRepository(Bizplace).findOne(foundPermittedBizplace.id, {
+          foundPermittedBizplace = await tx.getRepository(Bizplace).findOne({
+            where: { id: foundPermittedBizplace.id },
             relations: ['company', 'company.domain']
           })
         }
@@ -282,22 +284,58 @@ export async function getDraftReleaseGoodFunction(_: any, name: any, context: an
 
     let productInventory
     if (result.orderProducts.length > 0)
-      productInventory = await InventoryUtil.bizplaceProductInventory(bizplaces, { filters: [{ name: 'bizplaceId', operator: 'eq', value: result.bizplace.id }, { name: 'productId', operator: 'in', value: [...result.orderProducts.filter(itm => itm?.product).map(itm => { return itm.product.id }), ...result.orderProducts.filter(itm => itm?.productBundle).map(itm => { return itm.productBundle.id })] }] }, context, tx)
+      productInventory = await InventoryUtil.bizplaceProductInventory(
+        bizplaces,
+        {
+          filters: [
+            { name: 'bizplaceId', operator: 'eq', value: result.bizplace.id },
+            {
+              name: 'productId',
+              operator: 'in',
+              value: [
+                ...result.orderProducts
+                  .filter(itm => itm?.product)
+                  .map(itm => {
+                    return itm.product.id
+                  }),
+                ...result.orderProducts
+                  .filter(itm => itm?.productBundle)
+                  .map(itm => {
+                    return itm.productBundle.id
+                  })
+              ]
+            }
+          ]
+        },
+        context,
+        tx
+      )
 
     result.orderProducts = result.orderProducts.map(itm => {
-      let foundProductInv = productInventory?.items.find(i => (i.productId == itm?.product?.id || i.productId == itm?.productBundle?.id) && i.packingType == itm.packingType && i.packingSize == itm.packingSize && i.uom == itm.uom)
+      let foundProductInv = productInventory?.items.find(
+        i =>
+          (i.productId == itm?.product?.id || i.productId == itm?.productBundle?.id) &&
+          i.packingType == itm.packingType &&
+          i.packingSize == itm.packingSize &&
+          i.uom == itm.uom
+      )
       return {
         ...itm,
-        product: itm.product || { id: foundProductInv.productId, name: foundProductInv.productName, brand: foundProductInv.productBrand, sku: foundProductInv.productSKU },
+        product: itm.product || {
+          id: foundProductInv.productId,
+          name: foundProductInv.productName,
+          brand: foundProductInv.productBrand,
+          sku: foundProductInv.productSKU
+        },
         groupType: foundProductInv ? foundProductInv.groupType : 'SINGLE',
         remainQty: foundProductInv ? foundProductInv.remainQty : 0,
         remainUomValue: foundProductInv ? foundProductInv.remainUomValue : 0,
-        remainUomValueWithUom: foundProductInv ? foundProductInv.remainUomValueWithUom : 0,
+        remainUomValueWithUom: foundProductInv ? foundProductInv.remainUomValueWithUom : 0
       }
     })
     const foundAttachments: Attachment[] = await tx.getRepository(Attachment).find({
       where: {
-        domain,
+        domain: { id: domain.id },
         refBy: result.id,
         category: ATTACHMENT_TYPE.DGRN
       }
@@ -307,8 +345,7 @@ export async function getDraftReleaseGoodFunction(_: any, name: any, context: an
       ...result,
       attachment: foundAttachments
     }
-
   } catch (error) {
     console.error(error)
   }
-}
+}

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

@@ -1,4 +1,4 @@
-import { Field, ID, Float, ObjectType, registerEnumType } from 'type-graphql'
+import { Field, ID, ObjectType } from 'type-graphql'
 import {
   Column,
   CreateDateColumn,
@@ -98,8 +98,8 @@ export class DraftReleaseGood {
       DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
         ? 'enum'
         : DATABASE_TYPE == 'oracle'
-          ? 'varchar2'
-          : 'smallint',
+        ? 'varchar2'
+        : 'smallint',
     enum: ReleaseOrderType,
     default: ReleaseOrderType.B2B
   })
@@ -233,6 +233,10 @@ export class DraftReleaseGood {
   @Field({ nullable: true })
   email: string
 
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  packageId: string
+
   @ManyToOne(type => ContactPoint)
   @Field(type => ContactPoint, { nullable: true })
   deliverTo: ContactPoint

package/server/service/goods-receival-note/goods-receival-note-mutation.ts

@@ -1,10 +1,12 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager, In, Repository } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
 import { generateId } from '@things-factory/id-rule-base'
 import { Setting } from '@things-factory/setting-base'
-import { Domain } from '@things-factory/shell'
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager, getRepository, In, Repository } from 'typeorm'
+import { Domain, getRepository } from '@things-factory/shell'
+
 import { ArrivalNotice, NewGoodsReceivalNote } from '../'
 import { GRN_STATUS, ORDER_NUMBER_RULE_TYPE, ORDER_NUMBER_SETTING_KEY } from '../../constants'
 import { OrderNoGenerator } from '../../utils/order-no-generator'
@@ -16,18 +18,18 @@ export class GoodsReceivalNoteMutation {
   @Directive('@privilege(category: "order_warehouse", privilege: "mutation")')
   @Directive('@transaction')
   async generateGoodsReceivalNote(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @Arg('grn', type => NewGoodsReceivalNote, { nullable: true }) grn?: NewGoodsReceivalNote
   ): Promise<GoodsReceivalNote> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    const { tx, domain, user } = context.state
     return await generateGoodsReceivalNote(grn, domain, user, tx)
   }
 
   @Mutation(returns => Boolean)
   @Directive('@privilege(category: "order_warehouse", privilege: "mutation")')
   @Directive('@transaction')
-  async deleteGoodsReceivalNote(@Arg('name') name: string, @Ctx() context: any): Promise<boolean> {
-    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+  async deleteGoodsReceivalNote(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { tx, domain } = context.state
     await tx.getRepository(GoodsReceivalNote).delete({ domain, name })
     return true
   }
@@ -37,11 +39,11 @@ export class GoodsReceivalNoteMutation {
   @Directive('@transaction')
   async deleteGoodsReceivalNotes(
     @Arg('names', type => [String]) names: string[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<boolean> {
-    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+    const { tx, domain } = context.state
     await tx.getRepository(GoodsReceivalNote).delete({
-      domain,
+      domain: { id: domain.id },
       name: In(names)
     })
     return true
@@ -49,11 +51,14 @@ export class GoodsReceivalNoteMutation {
 
   @Mutation(returns => GoodsReceivalNote)
   @Directive('@transaction')
-  async receivedGoodsReceivalNote(@Arg('name') name: string, @Ctx() context: any): Promise<GoodsReceivalNote> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async receivedGoodsReceivalNote(
+    @Arg('name') name: string,
+    @Ctx() context: ResolverContext
+  ): Promise<GoodsReceivalNote> {
+    const { tx, domain, user } = context.state
 
     const goodsReceivalNote = await tx.getRepository(GoodsReceivalNote).findOne({
-      where: { domain, name }
+      where: { domain: { id: domain.id }, name }
     })
 
     return await tx.getRepository(GoodsReceivalNote).save({
@@ -66,11 +71,11 @@ export class GoodsReceivalNoteMutation {
 
   @Mutation(returns => GoodsReceivalNote)
   @Directive('@transaction')
-  async sendGoodsReceivalNote(@Arg('name') name: string, @Ctx() context: any): Promise<GoodsReceivalNote> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async sendGoodsReceivalNote(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<GoodsReceivalNote> {
+    const { tx, domain, user } = context.state
 
     const goodsReceivalNote = await tx.getRepository(GoodsReceivalNote).findOne({
-      where: { domain, name }
+      where: { domain: { id: domain.id }, name }
     })
 
     return await tx.getRepository(GoodsReceivalNote).save({
@@ -97,10 +102,10 @@ export async function generateGoodsReceivalNote(
   let orderNo: string = ''
 
   const bizplace: Bizplace = await bizplaceRepo.findOne({ where: { id: grn.customer } })
-  const arrivalNotice: ArrivalNotice = await ganRepo.findOne({ where: { domain, name: grn.refNo } })
+  const arrivalNotice: ArrivalNotice = await ganRepo.findOne({ where: { domain: { id: domain.id }, name: grn.refNo } })
   const grnNoSetting: Setting = await settingRepo.findOne({
     where: {
-      domain,
+      domain: { id: domain.id },
       name: ORDER_NUMBER_SETTING_KEY.GRN_NUMBER_RULE
     }
   })

package/server/service/goods-receival-note/goods-receival-note-query.ts

@@ -1,18 +1,22 @@
 import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository, SelectQueryBuilder } from 'typeorm'
+import { IsNull, Not, OrderByCondition, SelectQueryBuilder } from 'typeorm'
 
-import { User } from '@things-factory/auth-base'
-import { getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { buildQuery, Domain, ListParam } from '@things-factory/shell'
+import { Partner, User } from '@things-factory/auth-base'
+import { Bizplace, ContactPoint, getPermittedBizplaceIds } from '@things-factory/biz-base'
+import { buildQuery, Domain, getRepository, ListParam } from '@things-factory/shell'
+import { ReducedInventoryHistory } from '@things-factory/warehouse-base'
 
 import { GoodsReceivalNoteList } from '../'
+import { DateTimeConverter } from '../../utils/datetime-util'
+import { ArrivalNotice } from '../arrival-notice/arrival-notice'
+import { OrderProduct } from '../order-product/order-product'
 import { GoodsReceivalNote } from './goods-receival-note'
 
 @Resolver(GoodsReceivalNote)
 export class GoodsReceivalNoteQuery {
   @Query(returns => GoodsReceivalNoteList)
-  async goodsReceivalNotes(@Ctx() context: any, @Args() params: ListParam): Promise<GoodsReceivalNoteList> {
-    const { domain, user }: { domain: Domain; user: User } = context.state
+  async goodsReceivalNotes(@Ctx() context: ResolverContext, @Args() params: ListParam): Promise<GoodsReceivalNoteList> {
+    const { domain, user } = context.state
 
     const fromDateParamIdx = params.filters.findIndex(param => param.name === 'fromDate')
     if (fromDateParamIdx >= 0) {
@@ -117,7 +121,7 @@ export class GoodsReceivalNoteQuery {
     const arrNameSortData = ['bizplace', 'arrivalNotice', 'updater']
     const arrGanStatusSortData = ['ganStatus']
     const arrGrnStatuSortData = ['status']
-    const sort = (params.sortings || []).reduce(
+    const sort: OrderByCondition = (params.sortings || []).reduce(
       (acc, sort) => ({
         ...acc,
         [arrChildSortData.indexOf(sort.name) >= 0
@@ -141,26 +145,133 @@ export class GoodsReceivalNoteQuery {
   }
 
   @Query(returns => GoodsReceivalNote)
-  async goodsReceivalNote(@Arg('name') name: string, @Ctx() context: any): Promise<GoodsReceivalNote> {
-    const { domain }: { domain: Domain } = context.state
-    return await getRepository(GoodsReceivalNote).findOne({
-      where: { domain, name },
-      relations: ['domain', 'bizplace', 'bizplace.company', 'arrivalNotice', 'creator', 'updater']
+  async goodsReceivalNote(
+    @Arg('name') name: string,
+    @Arg('timezoneOffSet') timezoneOffSet: string,
+    @Ctx() context: ResolverContext
+  ): Promise<any> {
+    const { domain } = context.state
+
+    const foundGRN: GoodsReceivalNote = await getRepository(GoodsReceivalNote).findOne({
+      where: { domain: { id: domain.id }, name },
+      relations: [
+        'domain',
+        'bizplace',
+        'bizplace.domain',
+        'bizplace.company',
+        'arrivalNotice',
+        'arrivalNotice.purchaseOrder'
+      ]
+    })
+
+    const foundGAN: ArrivalNotice = foundGRN.arrivalNotice
+    const ownRefNo = foundGAN.refNo
+
+    const partnerBiz: Bizplace = foundGRN.bizplace
+
+    const partnerDomain: Partner = await getRepository(Partner).findOne({
+      where: { partnerDomain: partnerBiz.domain, domain },
+      relations: ['domain']
+    })
+
+    const domainOwner: Domain = partnerDomain.domain
+    const domainBizplace: Bizplace = await getRepository(Bizplace).findOne({
+      where: { domain: domainOwner },
+      relations: ['company']
+    })
+
+    const qbReducedInventory = await getRepository(ReducedInventoryHistory)
+      .createQueryBuilder('ivh')
+      .select('product_id', 'productId')
+      .addSelect('batch_id', 'batchId')
+      .addSelect('reusable_pallet_id', 'reusablePalletId')
+      .addSelect('packing_type', 'packingType')
+      .addSelect('sum(qty)', 'qty')
+      .addSelect('sum(uom_value)', 'uomValue')
+      .addSelect('uom', 'uom')
+      .addSelect('count(distinct pallet_id)', 'pallet')
+      .addSelect(`string_agg(distinct expiration_date::varchar,', ' order by expiration_date::varchar)`, 'expiryDate')
+      .addSelect(`string_agg(distinct pallet_id::varchar,', ' order by pallet_id::varchar)`, 'palletId')
+      .where('ivh.domain_id = :domainId', { domainId: domain.id })
+      .andWhere('ivh.ref_order_id = :refOrderId', { refOrderId: foundGAN.id })
+      .andWhere(`ivh.transaction_type = 'UNLOADING'`)
+      .groupBy('reusable_pallet_id')
+      .addGroupBy('product_id')
+      .addGroupBy('batch_id')
+      .addGroupBy('packing_type')
+      .addGroupBy('uom')
+      .getRawMany()
+
+    // 5. find domain contact point
+    const foundCP: ContactPoint = await getRepository(ContactPoint).findOne({
+      where: { domain: { id: domain.id }, bizplace: domainBizplace }
     })
+
+    const inboundInventories: any[] = await qbReducedInventory
+
+    const targetProducts: OrderProduct[] = await getRepository(OrderProduct).find({
+      where: {
+        domain: { id: domain.id },
+        arrivalNotice: { id: foundGAN.id },
+        actualPalletQty: Not(IsNull()),
+        actualPackQty: Not(IsNull())
+      },
+      relations: ['product', 'arrivalNotice', 'arrivalNotice.purchaseOrder']
+    })
+
+    const data = {
+      grnNo: foundGRN.name,
+      ganNo: foundGAN.name,
+      refGANNo: foundGAN.refNo || '',
+      refGANNo2: foundGAN.refNo2 || '',
+      refGANNo3: foundGAN.refNo3 || '',
+      companyDomain: domainBizplace.company.name,
+      supplier: foundCP.name || '',
+      date: foundGAN.acceptedAt ? DateTimeConverter.datetime(foundGAN.acceptedAt, timezoneOffSet) : '',
+      productLists: targetProducts.map((item, idx) => {
+        let unloadInvHistory = inboundInventories.find(
+          ih =>
+            ih.productId == item.product.id &&
+            ih.batchId == item.batchId &&
+            ih.packingType == item.packingType &&
+            ih.uom == item.uom
+        )
+
+        return {
+          list_no: idx + 1,
+          po: item?.arrivalNotice?.purchaseOrder?.name ? item?.arrivalNotice?.purchaseOrder.name : '',
+          batchNo: item.batchId || '',
+          productSKU: `${item.product.sku}`,
+          productName: `${item.product.name}(${item.product.description})`,
+          productType: item.packingType,
+          productBatch: item.batchId,
+          expectedQty: item.packQty,
+          actualQty: unloadInvHistory.qty || item.actualPackQty,
+          actualUomValue: item.uomValue * item.actualPackQty,
+          productUom: `${unloadInvHistory.uom || item.uom}`,
+          expiryDate: unloadInvHistory.expiryDate || '',
+          unitPrice: item.unitPrice.toFixed(2) || 0.0,
+          manufactureDate: item.manufactureDate || '',
+          remark: (item.remark ? item.remark : '') + (item.issue ? ' [Issue]: ' + item.issue : '')
+        }
+      })
+    }
+
+    return data
   }
 
   @FieldResolver(type => Domain)
   async domain(@Root() goodsReceivalNote: GoodsReceivalNote): Promise<Domain> {
-    return await getRepository(Domain).findOne(goodsReceivalNote.domainId)
+    return await getRepository(Domain).findOneBy({ id: goodsReceivalNote.domainId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() goodsReceivalNote: GoodsReceivalNote): Promise<User> {
-    return await getRepository(User).findOne(goodsReceivalNote.creatorId)
+    return await getRepository(User).findOneBy({ id: goodsReceivalNote.creatorId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() goodsReceivalNote: GoodsReceivalNote): Promise<User> {
-    return await getRepository(User).findOne(goodsReceivalNote.updaterId)
+    return await getRepository(User).findOneBy({ id: goodsReceivalNote.updaterId })
   }
 }

package/server/service/goods-receival-note/goods-receival-note-types.ts

@@ -11,6 +11,54 @@ export class GoodsReceivalNoteList {
   total: number
 }
 
+// Need to review with better class name
+@ObjectType()
+export class ProductListsType {
+
+  @Field({ nullable: true })
+  po: string
+
+  @Field({ nullable: true })
+  batchNo: string
+
+  @Field({ nullable: true })
+  productSKU: string
+
+  @Field({ nullable: true })
+  productName: string
+
+  @Field({ nullable: true })
+  productType: string
+
+  @Field({ nullable: true })
+  productBatch: string
+
+  @Field({nullable:true})
+  @Field({ nullable: true })
+  expectedQty: number
+
+  @Field({ nullable: true })
+  actualQty: number
+
+  @Field({ nullable: true })
+  actualUomValue: number
+
+  @Field({ nullable: true })
+  productUom: string
+
+  @Field({ nullable: true })
+  expiryDate: string
+
+  @Field({ nullable: true })
+  unitPrice: number
+
+  @Field({ nullable: true })
+  manufactureDate: string
+
+  @Field({ nullable: true })
+  remark: string
+}
+
 @InputType()
 export class NewGoodsReceivalNote {
   @Field({ nullable: true })

package/server/service/goods-receival-note/goods-receival-note.ts

@@ -16,6 +16,7 @@ import {
   UpdateDateColumn
 } from 'typeorm'
 import { ArrivalNotice } from '../'
+import { ProductListsType } from './goods-receival-note-types'
 
 @Entity()
 @Index(
@@ -92,4 +93,35 @@ export class GoodsReceivalNote {
 
   @Field(type => [Attachment], { nullable: true })
   attachments: Attachment[]
+
+  @Field({nullable:true})
+  grnNo: string
+
+  @Field({nullable:true})
+  ganNo: string
+
+  @Field({nullable:true})
+  refGANNo: string
+
+  @Field({nullable:true})
+  refGANNo2: string
+
+  @Field({nullable:true})
+  refGANNo3: string
+
+  @Field({nullable:true})
+  timezoneOffSet: string
+
+  @Field(type=>[ProductListsType],{nullable:true})
+  productLists: ProductListsType[]
+
+  @Field({nullable:true})
+  companyDomain: string
+
+  @Field({nullable:true})
+  supplier: string
+
+  @Field({nullable:true})
+  date: string
+  
 }