@things-factory/sales-base 8.0.0-beta.1 → 8.0.0-beta.2

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

@@ -1,284 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,129 +0,0 @@
-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

@@ -1,280 +0,0 @@
-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 })
-  }
-}