@things-factory/sales-base 8.0.0-beta.9 → 8.0.1

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

@@ -0,0 +1,284 @@
+import { Field, ID, ObjectType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  JoinColumn,
+  ManyToOne,
+  OneToMany,
+  OneToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+
+import { Attachment } from '@things-factory/attachment-base'
+import { User } from '@things-factory/auth-base'
+import { Bizplace, ContactPoint } from '@things-factory/biz-base'
+import { config } from '@things-factory/env'
+import { Domain } from '@things-factory/shell'
+
+import { OrderProduct, ReleaseGood, ShippingOrder, ShippingOrderInfo } from '../'
+import { ReleaseOrderType } from '../../constants'
+
+const ORMCONFIG = config.get('ormconfig', {})
+const DATABASE_TYPE = ORMCONFIG.type
+
+// export enum DraftReleaseGoodStatus {
+//   STATUS_A = 'STATUS_A',
+//   STATUS_B = 'STATUS_B'
+// }
+
+// registerEnumType(DraftReleaseGoodStatus, {
+//   name: 'DraftReleaseGoodStatus',
+//   description: 'state enumeration of a draftReleaseGood'
+// })
+
+@Entity()
+@Index(
+  'ix_draft_release_good_0',
+  (draftReleaseGood: DraftReleaseGood) => [draftReleaseGood.domain, draftReleaseGood.name],
+  { unique: true }
+)
+@ObjectType({ description: 'Entity for DraftReleaseGood' })
+export class DraftReleaseGood {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain, { nullable: true })
+  domain: Domain
+
+  @RelationId((draftReleaseGood: DraftReleaseGood) => draftReleaseGood.domain)
+  domainId: string
+
+  @ManyToOne(type => Bizplace)
+  @Field(type => Bizplace, { nullable: true })
+  bizplace: Bizplace
+
+  @RelationId((draftReleaseGood: DraftReleaseGood) => draftReleaseGood.bizplace)
+  bizplaceId: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  name: string
+
+  @OneToOne(type => ReleaseGood)
+  @JoinColumn()
+  @Field(type => ReleaseGood, { nullable: true })
+  releaseGood: ReleaseGood
+
+  @RelationId((draftReleaseGood: DraftReleaseGood) => draftReleaseGood.releaseGood)
+  releaseGoodId: string
+
+  @OneToOne(type => ShippingOrder)
+  @JoinColumn()
+  @Field(type => ShippingOrder, { nullable: true })
+  shippingOrder: ShippingOrder
+
+  @RelationId((releaseGood: ReleaseGood) => releaseGood.shippingOrder)
+  shippingOrderId: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  collectionOrderNo: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  description: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  truckNo: string
+
+  @Column({
+    type:
+      DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
+        ? 'enum'
+        : DATABASE_TYPE == 'oracle'
+          ? 'varchar2'
+          : DATABASE_TYPE == 'mssql'
+            ? 'nvarchar'
+            : 'varchar',
+    enum:
+      DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
+        ? ReleaseOrderType
+        : undefined,
+    length: DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb' ? undefined : 32,
+    default: ReleaseOrderType.B2B
+  })
+  @Field()
+  type: ReleaseOrderType
+
+  @Column({ default: false })
+  @Field()
+  exportOption: Boolean
+
+  @Column({ default: false })
+  @Field()
+  courierOption: Boolean
+
+  @Column({ default: false })
+  @Field()
+  packingOption: Boolean
+
+  @Column()
+  @Field()
+  ownTransport: Boolean
+
+  @Field(type => ShippingOrderInfo, { nullable: true })
+  shippingOrderInfo?: ShippingOrderInfo
+
+  @OneToMany(type => OrderProduct, orderProduct => orderProduct.draftReleaseGood)
+  @Field(type => [OrderProduct], { nullable: true })
+  orderProducts: OrderProduct[]
+
+  @Column()
+  @Field()
+  status: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  refNo: String
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  refNo2: String
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  refNo3: String
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  releaseDate: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  remark: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  marketplaceOrderStatus: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  billingAddress: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  pickupAddress: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  pickupTime: Date
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  handoverType: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  dropoffAddress: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  deliveryAddress1: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  deliveryAddress2: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  deliveryAddress3: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  deliveryAddress4: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  deliveryAddress5: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  attentionTo: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  attentionCompany: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  city: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  state: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  postalCode: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  country: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  phone1: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  phone2: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  email: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  packageId: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  source: string
+
+  @ManyToOne(type => ContactPoint)
+  @Field(type => ContactPoint, { nullable: true })
+  deliverTo: ContactPoint
+
+  @RelationId((draftReleaseGood: DraftReleaseGood) => draftReleaseGood.deliverTo)
+  deliverToId: string
+
+  @Field(type => [Attachment], { nullable: true })
+  attachment?: Attachment[]
+
+  @CreateDateColumn()
+  @Field()
+  createdAt: Date
+
+  @UpdateDateColumn()
+  @Field()
+  updatedAt: Date
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  creator: User
+
+  @RelationId((draftReleaseGood: DraftReleaseGood) => draftReleaseGood.creator)
+  creatorId: string
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  updater: User
+
+  @RelationId((draftReleaseGood: DraftReleaseGood) => draftReleaseGood.updater)
+  updaterId: string
+
+  @Field()
+  computedStatus: string
+}

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

@@ -0,0 +1,9 @@
+import { DraftReleaseGood } from './draft-release-good'
+import { DraftReleaseGoodQuery } from './draft-release-good-query'
+import { DraftReleaseGoodMutation } from './draft-release-good-mutation'
+
+export const entities = [DraftReleaseGood]
+export const resolvers = [DraftReleaseGoodQuery, DraftReleaseGoodMutation]
+
+export * from './draft-release-good-mutation'
+export * from './draft-release-good-query'

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

@@ -0,0 +1,129 @@
+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, 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'
+import { GoodsReceivalNote } from './goods-receival-note'
+
+@Resolver(GoodsReceivalNote)
+export class GoodsReceivalNoteMutation {
+  @Mutation(returns => GoodsReceivalNote)
+  @Directive('@privilege(category: "order_warehouse", privilege: "mutation")')
+  @Directive('@transaction')
+  async generateGoodsReceivalNote(
+    @Ctx() context: ResolverContext,
+    @Arg('grn', type => NewGoodsReceivalNote, { nullable: true }) grn?: NewGoodsReceivalNote
+  ): Promise<GoodsReceivalNote> {
+    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: ResolverContext): Promise<boolean> {
+    const { tx, domain } = context.state
+    await tx.getRepository(GoodsReceivalNote).delete({ domain: { id: domain.id }, name })
+    return true
+  }
+
+  @Mutation(returns => Boolean)
+  @Directive('@privilege(category: "order_warehouse", privilege: "mutation")')
+  @Directive('@transaction')
+  async deleteGoodsReceivalNotes(
+    @Arg('names', type => [String]) names: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { tx, domain } = context.state
+    await tx.getRepository(GoodsReceivalNote).delete({
+      domain: { id: domain.id },
+      name: In(names)
+    })
+    return true
+  }
+
+  @Mutation(returns => GoodsReceivalNote)
+  @Directive('@transaction')
+  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: { id: domain.id }, name }
+    })
+
+    return await tx.getRepository(GoodsReceivalNote).save({
+      ...goodsReceivalNote,
+      status: GRN_STATUS.RECEIVED,
+      customerStatus: GRN_STATUS.RECEIVED,
+      updater: user
+    })
+  }
+
+  @Mutation(returns => GoodsReceivalNote)
+  @Directive('@transaction')
+  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: { id: domain.id }, name }
+    })
+
+    return await tx.getRepository(GoodsReceivalNote).save({
+      ...goodsReceivalNote,
+      status: GRN_STATUS.SENT,
+      customerStatus: GRN_STATUS.PENDING_RECEIVE,
+      updater: user
+    })
+  }
+}
+
+export async function generateGoodsReceivalNote(
+  grn: { refNo: string; customer: string },
+  domain: Domain,
+  user: User,
+  tx?: EntityManager
+): Promise<GoodsReceivalNote> {
+  // 1. Create grn
+  const grnRepo: Repository<GoodsReceivalNote> =
+    tx?.getRepository(GoodsReceivalNote) || getRepository(GoodsReceivalNote)
+  const bizplaceRepo: Repository<Bizplace> = tx?.getRepository(Bizplace) || getRepository(Bizplace)
+  const ganRepo: Repository<ArrivalNotice> = tx?.getRepository(ArrivalNotice) || getRepository(ArrivalNotice)
+  const settingRepo: Repository<Setting> = tx?.getRepository(Setting) || getRepository(Setting)
+  let orderNo: string = ''
+
+  const bizplace: Bizplace = await bizplaceRepo.findOne({ where: { id: grn.customer } })
+  const arrivalNotice: ArrivalNotice = await ganRepo.findOne({ where: { domain: { id: domain.id }, name: grn.refNo } })
+  const grnNoSetting: Setting = await settingRepo.findOne({
+    where: {
+      domain: { id: domain.id },
+      name: ORDER_NUMBER_SETTING_KEY.GRN_NUMBER_RULE
+    }
+  })
+
+  if (grnNoSetting) {
+    orderNo = await generateId({ domain, type: ORDER_NUMBER_RULE_TYPE.GRN_NUMBER, seed: {} })
+  } else {
+    orderNo = OrderNoGenerator.goodsReceiveNote()
+  }
+
+  return await grnRepo.save({
+    ...grn,
+    name: orderNo,
+    domain,
+    bizplace,
+    arrivalNotice,
+    status: GRN_STATUS.PENDING_RECEIVE,
+    creator: user,
+    updater: user
+  })
+}

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

@@ -0,0 +1,280 @@
+import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { IsNull, Not, OrderByCondition, SelectQueryBuilder } from 'typeorm'
+
+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: ResolverContext,
+    @Args(type => ListParam) params: ListParam
+  ): Promise<GoodsReceivalNoteList> {
+    const { domain, user } = context.state
+
+    const fromDateParamIdx = params.filters.findIndex(param => param.name === 'fromDate')
+    if (fromDateParamIdx >= 0) {
+      let fromDateVal = new Date(params.filters[fromDateParamIdx].value)
+      params.filters.splice(fromDateParamIdx, 1)
+
+      params.filters.push({
+        name: 'createdAt',
+        operator: 'gte',
+        value: fromDateVal.toISOString(),
+        relation: false
+      })
+    }
+
+    const toDateParamIdx = params.filters.findIndex(param => param.name === 'toDate')
+    if (toDateParamIdx >= 0) {
+      let toDateVal = new Date(params.filters[toDateParamIdx].value)
+      params.filters.splice(toDateParamIdx, 1)
+
+      params.filters.push({
+        name: 'createdAt',
+        operator: 'lt',
+        value: new Date(toDateVal.setDate(toDateVal.getDate() + 1)).toISOString(),
+        relation: false
+      })
+    }
+
+    let refNoFilter = params.filters.find(x => x.name == 'refNo')
+    let refNo2Filter = params.filters.find(x => x.name == 'refNo2')
+    let refNo3Filter = params.filters.find(x => x.name == 'refNo3')
+    let ganNameFilter = params.filters.find(x => x.name == 'arrivalNoticeNo')
+    let bizplaceFilter = params.filters.find(x => x.name == 'bizplaceName')
+    let ganStatusFilter = params.filters.find(x => x.name == 'ganStatus')
+    let grnStatusFilter = params.filters.find(x => x.name == 'grnStatus')
+    let orderProductsApiFilter = params.filters.find(x => x.name == 'orderProductsApi')
+
+    params.filters = params.filters.filter(
+      x =>
+        x.name != 'refNo' &&
+        x.name != 'refNo2' &&
+        x.name != 'refNo3' &&
+        x.name != 'arrivalNoticeNo' &&
+        x.name != 'bizplaceName' &&
+        x.name != 'ganStatus' &&
+        x.name != 'grnStatus'
+    )
+
+    const qb: SelectQueryBuilder<GoodsReceivalNote> = getRepository(GoodsReceivalNote).createQueryBuilder('grn')
+    buildQuery(qb, params, context)
+    qb.addSelect('COALESCE("cc".rank, 9999)', 'rank')
+    qb.leftJoinAndSelect('grn.domain', 'domain')
+    qb.leftJoinAndSelect('grn.bizplace', 'bizplace')
+    qb.leftJoinAndSelect('grn.creator', 'creator')
+    qb.leftJoinAndSelect('grn.updater', 'updater')
+    qb.innerJoinAndSelect('grn.arrivalNotice', 'arrivalNotice')
+    if (orderProductsApiFilter?.value) {
+      qb.innerJoinAndSelect('arrivalNotice.orderProducts', 'orderProducts')
+      qb.innerJoinAndSelect('orderProducts.product', 'product')
+    }
+    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 = 'GRN_STATUS'`)
+          .andWhere(`cc.name = 'GAN_REQUESTS_STATUS'`)
+      },
+      'cc',
+      'cc.status = arrivalNotice.status'
+    )
+
+    let permittedBizplaceIds = await getPermittedBizplaceIds(domain, user)
+    qb.andWhere('grn.bizplace_id IN (:...bizplaceIds)', { bizplaceIds: permittedBizplaceIds })
+
+    if (refNoFilter?.value) {
+      qb.andWhere('arrivalNotice.ref_no ilike :refNo', { refNo: refNoFilter.value })
+    }
+    if (refNo2Filter?.value) {
+      qb.andWhere('arrivalNotice.ref_no_2 ilike :refNo2', { refNo2: refNo2Filter.value })
+    }
+    if (refNo3Filter?.value) {
+      qb.andWhere('arrivalNotice.ref_no_3 ilike :refNo3', { refNo3: refNo3Filter.value })
+    }
+    if (ganNameFilter?.value) {
+      qb.andWhere('arrivalNotice.name ilike :ganName', { ganName: ganNameFilter.value })
+    }
+    if (bizplaceFilter?.value) {
+      qb.andWhere('bizplace.name ilike :bizName', { bizName: bizplaceFilter.value })
+    }
+
+    if (ganStatusFilter?.value) {
+      qb.andWhere('arrivalNotice.status ilike :ganStatus', { ganStatus: ganStatusFilter.value })
+    }
+    if (grnStatusFilter?.value) {
+      qb.andWhere('grn.status ilike :grnStatus', { grnStatus: grnStatusFilter.value })
+    }
+
+    const arrChildSortData = ['refNo', 'refNo2', 'refNo3']
+    const arrNameSortData = ['bizplace', 'arrivalNotice', 'updater']
+    const arrGanStatusSortData = ['ganStatus']
+    const arrGrnStatuSortData = ['status']
+    const sort: OrderByCondition = (params.sortings || []).reduce(
+      (acc, sort) => ({
+        ...acc,
+        [arrChildSortData.indexOf(sort.name) >= 0
+          ? 'arrivalNotice.' + sort.name
+          : arrNameSortData.indexOf(sort.name) >= 0
+            ? sort.name + '.name'
+            : arrGanStatusSortData.indexOf(sort.name) >= 0
+              ? 'arrivalNotice.status'
+              : arrGrnStatuSortData.indexOf(sort.name) >= 0
+                ? 'grn.status'
+                : 'grn.' + sort.name]: sort.desc ? 'DESC' : 'ASC'
+      }),
+      !params.sortings.some(e => e.name === 'status') ? { rank: 'ASC' } : {}
+    )
+
+    qb.orderBy(sort)
+
+    const [items, total] = await qb.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @Query(returns => GoodsReceivalNote)
+  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: { id: partnerBiz.domain.id }, domain: { id: domain.id } },
+      relations: ['domain']
+    })
+
+    const domainOwner: Domain = partnerDomain.domain
+    const domainBizplace: Bizplace = await getRepository(Bizplace).findOne({
+      where: { domain: { id: domainOwner.id } },
+      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: { id: domainBizplace.id } }
+    })
+
+    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).findOneBy({ id: goodsReceivalNote.domainId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() goodsReceivalNote: GoodsReceivalNote): Promise<User> {
+    return await getRepository(User).findOneBy({ id: goodsReceivalNote.creatorId })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() goodsReceivalNote: GoodsReceivalNote): Promise<User> {
+    return await getRepository(User).findOneBy({ id: goodsReceivalNote.updaterId })
+  }
+}