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

package/server/service/purchase-order/purchase-order-mutation.ts

@@ -1,458 +0,0 @@
-import type { FileUpload } from 'graphql-upload/GraphQLUpload.js'
-import GraphQLUpload from 'graphql-upload/GraphQLUpload.js'
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager, Repository } from 'typeorm'
-
-import { Attachment, createAttachments, deleteAttachmentsByRef } from '@things-factory/attachment-base'
-import { User } from '@things-factory/auth-base'
-import { Bizplace, ContactPoint, getPermittedBizplaces } from '@things-factory/biz-base'
-import { generateId } from '@things-factory/id-rule-base'
-import { Product, ProductDetail } from '@things-factory/product-base'
-import { Setting } from '@things-factory/setting-base'
-import { Domain, getRepository } from '@things-factory/shell'
-import { Location } from '@things-factory/warehouse-base'
-
-import {
-  ArrivalNotice,
-  NewPurchaseOrder,
-  OrderProduct,
-  PurchaseOrder,
-  PurchaseOrderOtherCharge,
-  PurchaseOrderPatch
-} from '../'
-import {
-  ATTACHMENT_TYPE,
-  ORDER_NUMBER_RULE_TYPE,
-  ORDER_NUMBER_SETTING_KEY,
-  ORDER_STATUS,
-  PURCHASE_ORDER_STATUS
-} from '../../constants'
-import { OrderNoGenerator } from '../../utils'
-import { checkArrivedNoticeFunction, generateArrivalNoticeFunction } from '../arrival-notice/arrival-notice-mutation'
-import { getPurchaseOrderFunction } from './purchase-order-query'
-
-@Resolver(PurchaseOrder)
-export class PurchaseOrderMutation {
-  @Directive('@privilege(category: "order_customer", privilege: "mutation")')
-  @Directive('@transaction')
-  @Mutation(returns => PurchaseOrder)
-  async upsertPurchaseOrder(
-    @Ctx() context: ResolverContext,
-    @Arg('purchaseOrder', type => PurchaseOrderPatch) purchaseOrder: PurchaseOrderPatch,
-    @Arg('files', type => [GraphQLUpload], { nullable: true }) files?: FileUpload
-  ): Promise<PurchaseOrder> {
-    try {
-      const { tx } = context.state
-      const createdPurchaseOrder: PurchaseOrder = await upsertPurchaseOrderFunction(
-        null,
-        purchaseOrder,
-        files,
-        context,
-        tx
-      )
-
-      return createdPurchaseOrder
-    } catch (error) {
-      throw error
-    }
-  }
-
-  @Directive('@privilege(category: "order_customer", privilege: "mutation")')
-  @Directive('@transaction')
-  @Mutation(returns => PurchaseOrder)
-  async approvePurchaseOrder(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<PurchaseOrder> {
-    const { tx, domain, user } = context.state
-
-    const findPurchaseOrder: PurchaseOrder = await getRepository(PurchaseOrder).findOne({
-      where: { domain: { id: domain.id }, id },
-      relations: ['orderProducts', 'orderProducts.product', 'bufferLocation', 'bizplace', 'domain']
-    })
-
-    // const findPurchaseOrder: PurchaseOrder = await tx.getRepository(PurchaseOrder).findOne({where: {id}, relations:['bizplace']})
-    // const findOrderProducts: OrderProduct[] = await tx.getRepository(OrderProduct).findBy({purchaseOrder: {id: findPurchaseOrder.id}}})
-
-    // // 1. Approve purchase order
-    const approvePurchaseOrder: PurchaseOrder = await tx.getRepository(PurchaseOrder).save({
-      ...findPurchaseOrder,
-      status: PURCHASE_ORDER_STATUS.APPROVED,
-      approvedBy: user,
-      approvedOn: new Date().toUTCString(),
-      updater: user
-    })
-
-    await tx.getRepository(OrderProduct).save(
-      findPurchaseOrder.orderProducts.map(itm => {
-        return {
-          ...itm,
-          status: PURCHASE_ORDER_STATUS.APPROVED
-        }
-      })
-    )
-
-    // // 2. Create and confirm arrival notice
-    let newGANOrder = {
-      ...findPurchaseOrder,
-      orderProducts: findPurchaseOrder.orderProducts.map(itm => {
-        delete itm.id, itm.name
-        return {
-          ...itm
-        }
-      }),
-      customerBizplaceId: findPurchaseOrder.bizplace.id,
-      purchaseOrder: approvePurchaseOrder,
-      orderVass: [],
-      creator: user,
-      updater: user
-    }
-
-    delete newGANOrder.id
-    //change gan status to intransit and call check arrived notice function right
-    newGANOrder.status = ORDER_STATUS.INTRANSIT
-
-    const createdGAN: ArrivalNotice = await generateArrivalNoticeFunction(null, newGANOrder, true, [], context, tx)
-
-    // await confirmArrivalNoticeFunction(createdGAN.name, context, tx)
-
-    // await receiveArrivalNoticeFunction(null, createdGAN.name, context)
-
-    await checkArrivedNoticeFunction(createdGAN.name, context, tx)
-
-    return approvePurchaseOrder
-  }
-
-  @Directive('@privilege(category: "order_customer", privilege: "mutation")')
-  @Directive('@transaction')
-  @Mutation(returns => PurchaseOrder)
-  async rejectPurchaseOrder(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<PurchaseOrder> {
-    const { tx, domain, user } = context.state
-
-    const findPurchaseOrder: PurchaseOrder = await getRepository(PurchaseOrder).findOne({
-      where: { domain: { id: domain.id }, id },
-      relations: ['orderProducts']
-    })
-    // // 1. Reject purchase order
-    const rejectedPurchaseOrder: PurchaseOrder = await tx.getRepository(PurchaseOrder).save({
-      ...findPurchaseOrder,
-      status: PURCHASE_ORDER_STATUS.REJECTED,
-      updater: user
-    })
-
-    await tx.getRepository(OrderProduct).save(
-      findPurchaseOrder.orderProducts.map(itm => {
-        return {
-          ...itm,
-          status: PURCHASE_ORDER_STATUS.REJECTED
-        }
-      })
-    )
-
-    return rejectedPurchaseOrder
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => PurchaseOrder)
-  async createPurchaseOrder(
-    @Arg('purchaseOrder', type => NewPurchaseOrder) purchaseOrder: NewPurchaseOrder,
-    @Ctx() context: ResolverContext
-  ): Promise<PurchaseOrder> {
-    const { tx, domain, user } = context.state
-
-    return await tx.getRepository(PurchaseOrder).save({
-      ...purchaseOrder,
-      domain,
-      creator: user,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => PurchaseOrder)
-  async updatePurchaseOrder(
-    @Arg('name') name: string,
-    @Arg('patch', type => PurchaseOrderPatch) patch: PurchaseOrderPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<PurchaseOrder> {
-    const { tx, domain, user } = context.state
-
-    const repository = tx.getRepository(PurchaseOrder)
-    const purchaseOrder = await repository.findOne({
-      where: { domain: { id: domain.id }, name }
-    })
-
-    return await repository.save({
-      ...purchaseOrder,
-      ...patch,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean)
-  async deletePurchaseOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { tx, domain } = context.state
-    await tx.getRepository(PurchaseOrder).delete({ domain: { id: domain.id }, name })
-    return true
-  }
-}
-
-export async function upsertPurchaseOrderFunction(
-  _: any,
-  purchaseOrder: any,
-  files: FileUpload[],
-  context: any,
-  tx?: EntityManager
-): Promise<PurchaseOrder> {
-  if (!purchaseOrder.id) {
-    purchaseOrder = await createPurchaseOrderFunction(_, purchaseOrder, files, context, tx)
-  } else {
-    purchaseOrder = await updatePurchaseOrderFunction(_, purchaseOrder, files, context, tx)
-  }
-
-  return purchaseOrder
-}
-
-export async function createPurchaseOrderFunction(
-  _: any,
-  purchaseOrder: any,
-  files: FileUpload[],
-  context: any,
-  tx?: EntityManager
-): Promise<PurchaseOrder> {
-  const { domain, user } = context.state
-  let orderProducts: OrderProduct[] = purchaseOrder.orderProducts
-  let otherCharges: PurchaseOrderOtherCharge[] = purchaseOrder.otherCharges
-
-  let myBizplace: Bizplace
-  let orderNo: string = ''
-  let arrError: string[] = []
-
-  const settingRepo: Repository<Setting> = tx?.getRepository(Setting) || getRepository(Setting)
-
-  if (purchaseOrder?.bizplace?.id) {
-    const permittedBizplaces: Bizplace[] = await getPermittedBizplaces(domain, user)
-    let foundPermittedBizplace: Bizplace = permittedBizplaces.find(biz => biz.id == purchaseOrder.bizplace.id)
-
-    if (!foundPermittedBizplace) throw new Error(`This user does not permitted for this company`)
-
-    purchaseOrder.bizplace = foundPermittedBizplace
-  } else {
-    arrError.push(`No bizplace was selected`)
-  }
-
-  if (purchaseOrder?.supplier?.id) {
-    purchaseOrder.supplier = await getRepository(ContactPoint).findOneBy({ id: purchaseOrder.supplier.id })
-  } else {
-    arrError.push(`No supplier was selected`)
-  }
-
-  if (purchaseOrder?.bufferLocation?.id) {
-    purchaseOrder.bufferLocation = await getRepository(Location).findOneBy({ id: purchaseOrder.bufferLocation.id })
-  } else {
-    arrError.push(`No buffer location was selected`)
-  }
-
-  if (arrError.length > 0) {
-    throw new Error(arrError.join(', '))
-  }
-
-  // // find PO number rule setting
-  const poNoSetting: Setting = await settingRepo.findOne({
-    where: {
-      domain: { id: domain.id },
-      name: ORDER_NUMBER_SETTING_KEY.PO_NUMBER_RULE
-    }
-  })
-
-  orderNo = poNoSetting
-    ? await generateId({ domain, type: ORDER_NUMBER_RULE_TYPE.PO_NUMBER, seed: {} })
-    : OrderNoGenerator.purchaseOrder()
-
-  // // 1. Create purchase order
-  const createdPurchaseOrder: PurchaseOrder = await tx.getRepository(PurchaseOrder).save({
-    ...purchaseOrder,
-    name: orderNo,
-    domain,
-    looseItem: purchaseOrder?.looseItem ? purchaseOrder.looseItem : false,
-    creator: user,
-    updater: user
-  })
-
-  // // 2. Create purchase order product
-  await upsertPurchaseOrderProducts(domain, purchaseOrder.bizplace, createdPurchaseOrder, orderProducts, user, tx)
-
-  // // 3. Create purchase order misc charges
-  for await (let oc of otherCharges) {
-    delete oc.id
-    await tx.getRepository(PurchaseOrderOtherCharge).save({
-      ...oc,
-      domain,
-      purchaseOrder: createdPurchaseOrder,
-      creator: user,
-      updater: user
-    })
-  }
-
-  // // 4. Create Attacments
-  if (files?.length) {
-    const attachments: Partial<Attachment>[] = files.map(attachment => {
-      return {
-        file: attachment,
-        refType: ATTACHMENT_TYPE.PO,
-        refBy: createdPurchaseOrder.id,
-        category: ATTACHMENT_TYPE.PO /* TODO use refType */
-      }
-    })
-    await createAttachments(_, { attachments }, context)
-  }
-
-  return createdPurchaseOrder
-}
-
-export async function updatePurchaseOrderFunction(
-  _: any,
-  purchaseOrder: any,
-  files: FileUpload[],
-  context: any,
-  tx?: EntityManager
-): Promise<PurchaseOrder> {
-  const { domain, user } = context.state
-
-  let existingPurchaseOrder: any = await getPurchaseOrderFunction(_, purchaseOrder.name, context, tx)
-
-  let orderProducts: OrderProduct[] = purchaseOrder.orderProducts
-  let otherCharges: PurchaseOrderOtherCharge[] = purchaseOrder.otherCharges
-
-  if (purchaseOrder?.bizplace?.id) {
-    const permittedBizplaces: Bizplace[] = await getPermittedBizplaces(domain, user)
-    let foundPermittedBizplace: Bizplace = permittedBizplaces.find(biz => biz.id == purchaseOrder.bizplace.id)
-
-    if (!foundPermittedBizplace) throw new Error(`This user does not permitted for this company`)
-
-    purchaseOrder.bizplace = foundPermittedBizplace
-  }
-
-  if (purchaseOrder?.supplier?.id) {
-    purchaseOrder.supplier = await getRepository(ContactPoint).findOneBy({ id: purchaseOrder.supplier.id })
-  }
-
-  if (purchaseOrder?.bufferLocation?.id) {
-    purchaseOrder.bufferLocation = await getRepository(Location).findOneBy({ id: purchaseOrder.bufferLocation.id })
-  }
-
-  // // 1. Update purchase order
-  const updatePurchaseOrder: PurchaseOrder = await tx.getRepository(PurchaseOrder).save({
-    ...existingPurchaseOrder,
-    ...purchaseOrder,
-    domain,
-    creator: user,
-    updater: user
-  })
-
-  // // 2. Update purchase order product
-  await upsertPurchaseOrderProducts(domain, purchaseOrder.bizplace, purchaseOrder, orderProducts, user, tx)
-
-  // // 3. Delete Removed Other Charges
-  const otherChargesRepo: Repository<PurchaseOrderOtherCharge> =
-    tx?.getRepository(PurchaseOrderOtherCharge) || getRepository(PurchaseOrderOtherCharge)
-  let removeOC = existingPurchaseOrder.otherCharges.filter(
-    existingOC => (otherCharges.filter(inOC => inOC.id == existingOC.id).length = 0)
-  )
-  removeOC.forEach(async oc => {
-    await otherChargesRepo.delete(oc)
-  })
-
-  // // 4. Process Purchase Other Other Charges Data and Insert/ Update data
-  for await (let oc of otherCharges) {
-    if (!oc?.id) delete oc.id
-    await otherChargesRepo.save({
-      ...oc,
-      domain,
-      purchaseOrder: existingPurchaseOrder,
-      creator: oc?.id ? oc.creator : user,
-      updater: user
-    })
-  }
-
-  // // 5. Remove Purchase Order Products
-  const foundAttachments: Attachment[] = await getRepository(Attachment).find({
-    where: {
-      domain: { id: domain.id },
-      refBy: purchaseOrder.id,
-      category: ATTACHMENT_TYPE.PO
-    }
-  })
-
-  // // 6. Remove All Attachment
-  if (foundAttachments?.length) {
-    await deleteAttachmentsByRef(_, { refBys: foundAttachments.map(file => file.refBy) }, context)
-  }
-
-  // // 7. Add New Attachment
-  if (files?.length > 0) {
-    const attachments: Partial<Attachment>[] = files.map(attachment => {
-      return {
-        file: attachment,
-        refType: ATTACHMENT_TYPE.PO,
-        refBy: updatePurchaseOrder.id,
-        category: ATTACHMENT_TYPE.PO /* TODO use refType */
-      }
-    })
-    await createAttachments(_, { attachments }, context)
-  }
-
-  return existingPurchaseOrder
-}
-
-export async function upsertPurchaseOrderProducts(
-  domain: Domain,
-  bizplace: Bizplace,
-  purchaseOrder: PurchaseOrder,
-  orderProducts: OrderProduct[],
-  user: User,
-  tx?: EntityManager
-): Promise<void> {
-  try {
-    const purchaseOrderRepo: Repository<PurchaseOrder> =
-      tx?.getRepository(PurchaseOrder) || getRepository(PurchaseOrder)
-    const bizplaceRepo: Repository<Bizplace> = tx?.getRepository(Bizplace) || getRepository(Bizplace)
-    const orderProductRepo: Repository<OrderProduct> = tx?.getRepository(OrderProduct) || getRepository(OrderProduct)
-    const productRepo: Repository<Product> = tx?.getRepository(Product) || getRepository(Product)
-
-    // // Remove all existing order products that do not exist in current input
-    let removeOP = purchaseOrder.orderProducts.filter(
-      existingOP => (orderProducts.filter(inOP => inOP.id == existingOP.id).length = 0)
-    )
-    removeOP.forEach(async op => {
-      await orderProductRepo.delete(op.id)
-    })
-
-    purchaseOrder = await purchaseOrderRepo.findOneBy({ id: purchaseOrder.id })
-
-    bizplace = await bizplaceRepo.findOneBy({ id: bizplace.id })
-
-    orderProducts = await Promise.all(
-      orderProducts.map(async (op: OrderProduct) => {
-        if (!op?.id) delete op.id
-        let foundProductDetail: ProductDetail = await tx
-          .getRepository(ProductDetail)
-          .findOne({ where: { product: { id: op.product.id }, packingType: op.packingType } })
-        return {
-          ...op,
-          domain,
-          bizplace: bizplace,
-          name: op?.id ? op.name : OrderNoGenerator.orderProduct(),
-          product: await productRepo.findOneBy({ id: op.product.id }),
-          packingSize: foundProductDetail?.packingSize || 1,
-          purchaseOrder: purchaseOrder,
-          status: purchaseOrder.status,
-          creator: op?.id ? op.creator : user,
-          updater: user
-        }
-      })
-    )
-
-    await orderProductRepo.save(orderProducts)
-  } catch (error) {
-    throw error
-  }
-}

package/server/service/purchase-order/purchase-order-query.ts

@@ -1,90 +0,0 @@
-import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { EntityManager, In } from 'typeorm'
-
-import { Attachment } from '@things-factory/attachment-base'
-import { User } from '@things-factory/auth-base'
-import { Bizplace, getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { buildQuery, Domain, Filter, getRepository, Pagination, Sorting } from '@things-factory/shell'
-
-import { PurchaseOrderList } from '../'
-import { ATTACHMENT_TYPE } from '../../constants'
-import { PurchaseOrder } from './purchase-order'
-
-@Resolver(PurchaseOrder)
-export class PurchaseOrderQuery {
-  @Query(returns => PurchaseOrderList)
-  async purchaseOrders(
-    @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[]
-  ): Promise<PurchaseOrderList> {
-    const queryBuilder = getRepository(PurchaseOrder).createQueryBuilder()
-    buildQuery(queryBuilder, { filters, pagination, sortings }, context)
-    const [items, total] = await queryBuilder
-      .leftJoinAndSelect('PurchaseOrder.supplier', 'Supplier')
-      .leftJoinAndSelect('PurchaseOrder.domain', 'Domain')
-      .leftJoinAndSelect('PurchaseOrder.creator', 'Creator')
-      .leftJoinAndSelect('PurchaseOrder.updater', 'Updater')
-      .leftJoinAndSelect('PurchaseOrder.arrivalNotice', 'ArrivalNotice')
-      .getManyAndCount()
-
-    return { items, total }
-  }
-
-  @Query(returns => PurchaseOrder)
-  async purchaseOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<PurchaseOrder> {
-    const { tx } = context.state
-    return getPurchaseOrderFunction(null, name, context, tx)
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() purchaseOrder: PurchaseOrder): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({ id: purchaseOrder.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() purchaseOrder: PurchaseOrder): Promise<User> {
-    return await getRepository(User).findOneBy({ id: purchaseOrder.creatorId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() purchaseOrder: PurchaseOrder): Promise<User> {
-    return await getRepository(User).findOneBy({ id: purchaseOrder.updaterId })
-  }
-}
-
-export async function getPurchaseOrderFunction(_: any, name: any, context: any, tx?: EntityManager) {
-  const { domain, user, bizplace }: { domain: Domain; user: User; bizplace: Bizplace } = context.state
-
-  let result = await getRepository(PurchaseOrder).findOne({
-    where: { domain: { id: domain.id }, name, bizplace: { id: In(await getPermittedBizplaceIds(domain, user)) } },
-    relations: [
-      'arrivalNotice',
-      'supplier',
-      'orderProducts',
-      'orderProducts.product',
-      'otherCharges',
-      'bufferLocation',
-      'bizplace',
-      'domain',
-      'creator',
-      'updater'
-    ]
-  })
-
-  if (!result?.id) throw new Error(`Failed to find arrival notice with ${name}`)
-
-  const foundAttachments: Attachment[] = await getRepository(Attachment).find({
-    where: {
-      domain: { id: domain.id },
-      refBy: result.id,
-      category: ATTACHMENT_TYPE.PO
-    }
-  })
-
-  return {
-    ...result,
-    attachment: foundAttachments
-  }
-}

package/server/service/purchase-order/purchase-order-types.ts

@@ -1,154 +0,0 @@
-import { ObjectRef } from '@things-factory/shell'
-import { Field, InputType, Int, ObjectType } from 'type-graphql'
-import { OrderProductPatch } from '../order-product/order-product-types'
-import { PurchaseOrder, PurchaseOrderOtherChargePatch, PurchaseOrderOtherCharge } from '../'
-
-@ObjectType()
-export class PurchaseOrderList {
-  @Field(type => [PurchaseOrder], { nullable: true })
-  items: PurchaseOrder[]
-
-  @Field(type => Int, { nullable: true })
-  total: number
-}
-
-@InputType()
-export class NewPurchaseOrder {
-  @Field(type => ObjectRef, { nullable: true })
-  bizplace: ObjectRef
-
-  @Field(type => ObjectRef, { nullable: true })
-  bufferLocation: ObjectRef
-
-  @Field({ nullable: true })
-  container: boolean
-
-  @Field({ nullable: true })
-  containerNo: string
-
-  @Field({ nullable: true })
-  containerSize: string
-
-  @Field({ nullable: true })
-  currency: string
-
-  @Field({ nullable: true })
-  deliveryOrderNo: string
-
-  @Field({ nullable: true })
-  description: string
-
-  @Field({ nullable: true })
-  etaDate: string
-
-  @Field({ nullable: true })
-  importCargo: boolean
-
-  @Field({ nullable: true })
-  issuedOn: string
-
-  @Field({ nullable: true })
-  looseItem: boolean
-
-  @Field({ nullable: true })
-  name: string
-
-  @Field(type => [OrderProductPatch], { nullable: true })
-  orderProducts: OrderProductPatch[]
-
-  @Field(type => [PurchaseOrderOtherChargePatch], { nullable: true })
-  otherCharges: (PurchaseOrderOtherCharge | PurchaseOrderOtherChargePatch)[]
-
-  @Field({ nullable: true })
-  ownTransport: boolean
-
-  @Field({ nullable: true })
-  refNo: string
-
-  @Field({ nullable: true })
-  remark: string
-
-  @Field({ nullable: true })
-  status: string
-
-  @Field(type => ObjectRef, { nullable: true })
-  warehouse: ObjectRef
-
-  @Field(type => ObjectRef, { nullable: true })
-  supplier: ObjectRef
-
-  @Field({ nullable: true })
-  truckNo: string
-}
-
-@InputType()
-export class PurchaseOrderPatch {
-  @Field({ nullable: true })
-  id: string
-
-  @Field({ nullable: true })
-  name: string
-
-  @Field({ nullable: true })
-  description: string
-
-  @Field(type => ObjectRef, { nullable: true })
-  bizplace: ObjectRef
-
-  @Field(type => ObjectRef, { nullable: true })
-  bufferLocation: ObjectRef
-
-  @Field({ nullable: true })
-  container: boolean
-
-  @Field({ nullable: true })
-  containerNo: string
-
-  @Field({ nullable: true })
-  containerSize: string
-
-  @Field({ nullable: true })
-  currency: string
-
-  @Field({ nullable: true })
-  deliveryOrderNo: string
-
-  @Field({ nullable: true })
-  etaDate: string
-
-  @Field({ nullable: true })
-  importCargo: boolean
-
-  @Field({ nullable: true })
-  issuedOn: string
-
-  @Field({ nullable: true })
-  looseItem: boolean
-
-  @Field(type => [OrderProductPatch], { nullable: true })
-  orderProducts: OrderProductPatch[]
-
-  @Field(type => [PurchaseOrderOtherChargePatch], { nullable: true })
-  otherCharges: PurchaseOrderOtherChargePatch[]
-
-  @Field({ nullable: true })
-  ownTransport: boolean
-
-  @Field({ nullable: true })
-  refNo: string
-
-  @Field({ nullable: true })
-  remark: string
-
-  @Field({ nullable: true })
-  status: string
-
-  @Field(type => ObjectRef, { nullable: true })
-  warehouse: ObjectRef
-
-  @Field(type => ObjectRef, { nullable: true })
-  supplier: ObjectRef
-
-  @Field({ nullable: true })
-  truckNo: string
-}