@things-factory/sales-base 4.0.0-alpha.9 → 4.0.0-beta.0

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

@@ -0,0 +1,456 @@
+import { Attachment, createAttachments, deleteAttachment } 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 } from '@things-factory/product-base'
+import { Setting } from '@things-factory/setting-base'
+import { Domain } from '@things-factory/shell'
+import { Location } from '@things-factory/warehouse-base'
+import { FileUpload, GraphQLUpload } from 'graphql-upload'
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager, getRepository, Repository } from 'typeorm'
+import {
+  ArrivalNotice,
+  NewPurchaseOrder,
+  OrderProduct,
+  PurchaseOrder,
+  PurchaseOrderOtherCharge,
+  PurchaseOrderPatch
+} from '../'
+import {
+  ATTACHMENT_TYPE,
+  ORDER_NUMBER_RULE_TYPE,
+  ORDER_NUMBER_SETTING_KEY,
+  PURCHASE_ORDER_STATUS
+} from '../../constants'
+import { OrderNoGenerator } from '../../utils'
+import {
+  checkArrivedNoticeFunction,
+  confirmArrivalNoticeFunction,
+  generateArrivalNoticeFunction,
+  receiveArrivalNoticeFunction
+} 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: any,
+    @Arg('purchaseOrder', type => PurchaseOrderPatch) purchaseOrder: PurchaseOrderPatch,
+    @Arg('file', type => GraphQLUpload, { nullable: true }) file?: FileUpload
+  ): Promise<PurchaseOrder> {
+    try {
+      const { tx }: { tx: EntityManager } = context.state
+      const createdPurchaseOrder: PurchaseOrder = await upsertPurchaseOrderFunction(
+        null,
+        purchaseOrder,
+        file,
+        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: any): Promise<PurchaseOrder> {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+
+    const findPurchaseOrder: PurchaseOrder = await getRepository(PurchaseOrder).findOne({
+      where: { domain, id },
+      relations: ['orderProducts', 'orderProducts.product', 'bufferLocation', 'bizplace', 'domain']
+    })
+
+    // const findPurchaseOrder: PurchaseOrder = await tx.getRepository(PurchaseOrder).findOne({id}, { relations:['bizplace']})
+    // const findOrderProducts: OrderProduct[] = await tx.getRepository(OrderProduct).find({purchaseOrder: findPurchaseOrder})
+
+    // // 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
+
+    const createdGAN: ArrivalNotice = await generateArrivalNoticeFunction(null, newGANOrder, [], 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: any): Promise<PurchaseOrder> {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+
+    const findPurchaseOrder: PurchaseOrder = await getRepository(PurchaseOrder).findOne({
+      where: { domain, 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: any
+  ): Promise<PurchaseOrder> {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: 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: any
+  ): Promise<PurchaseOrder> {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+
+    const repository = tx.getRepository(PurchaseOrder)
+    const purchaseOrder = await repository.findOne({
+      where: { domain, name }
+    })
+
+    return await repository.save({
+      ...purchaseOrder,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deletePurchaseOrder(@Arg('name') name: string, @Ctx() context: any): Promise<boolean> {
+    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+    await tx.getRepository(PurchaseOrder).delete({ domain, name })
+    return true
+  }
+}
+
+export async function upsertPurchaseOrderFunction(
+  _: any,
+  purchaseOrder: any,
+  file: Attachment,
+  context: any,
+  tx?: EntityManager
+): Promise<PurchaseOrder> {
+  const { domain, user }: { domain: Domain; user: User } = context.state
+  let orderProducts: OrderProduct[] = purchaseOrder.orderProducts
+
+  if (!purchaseOrder.id) {
+    purchaseOrder = await createPurchaseOrderFunction(_, purchaseOrder, file, context, tx)
+  } else {
+    purchaseOrder = await updatePurchaseOrderFunction(_, purchaseOrder, file, context, tx)
+  }
+
+  return purchaseOrder
+}
+
+export async function createPurchaseOrderFunction(
+  _: any,
+  purchaseOrder: any,
+  file: Attachment,
+  context: any,
+  tx?: EntityManager
+): Promise<PurchaseOrder> {
+  const { domain, user }: { domain: Domain; user: 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).findOne({ id: purchaseOrder.supplier.id })
+  } else {
+    arrError.push(`No supplier was selected`)
+  }
+
+  if (purchaseOrder?.bufferLocation?.id) {
+    purchaseOrder.bufferLocation = await getRepository(Location).findOne({ 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,
+      name: ORDER_NUMBER_SETTING_KEY.PO_NUMBER_RULE
+    }
+  })
+
+  if (poNoSetting) {
+    orderNo = await generateId({ domain, type: ORDER_NUMBER_RULE_TYPE.PO_NUMBER, seed: {} })
+  } else {
+    orderNo = 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 (file?.length) {
+    const attachments: Attachment[] = file.map(attachment => {
+      return {
+        file: attachment,
+        refBy: createdPurchaseOrder.id,
+        category: ATTACHMENT_TYPE.PO
+      }
+    })
+    await createAttachments(_, { attachments }, context)
+  }
+
+  return createdPurchaseOrder
+}
+
+export async function updatePurchaseOrderFunction(
+  _: any,
+  purchaseOrder: any,
+  file: Attachment,
+  context: any,
+  tx?: EntityManager
+): Promise<PurchaseOrder> {
+  const { domain, user }: { domain: Domain; user: 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).findOne({ id: purchaseOrder.supplier.id })
+  }
+
+  if (purchaseOrder?.bufferLocation?.id) {
+    purchaseOrder.bufferLocation = await getRepository(Location).findOne({ 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,
+      refBy: purchaseOrder.id,
+      category: ATTACHMENT_TYPE.PO
+    }
+  })
+
+  // // 6. Remove All Attachment
+  for await (const file of foundAttachments.filter(attachment => !file.find(file => file.id == attachment.id))) {
+    await deleteAttachment(_, { id: file.id }, context)
+  }
+
+  // // 7. Add New Attachment
+  const newAttachments = file.filter(attachment => !attachment.id)
+  if (newAttachments.length > 0) {
+    const attachments: Attachment[] = newAttachments.map(attachment => {
+      return {
+        file: attachment,
+        refBy: updatePurchaseOrder.id,
+        category: ATTACHMENT_TYPE.PO
+      }
+    })
+    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<Product> = tx?.getRepository(PurchaseOrder) || getRepository(PurchaseOrder)
+    const bizplaceRepo: Repository<Product> = 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)
+    })
+
+    purchaseOrder = await purchaseOrderRepo.findOne(purchaseOrder.id)
+
+    bizplace = await bizplaceRepo.findOne(bizplace.id)
+
+    orderProducts = await Promise.all(
+      orderProducts.map(async (op: OrderProduct) => {
+        if (!op?.id) delete op.id
+        return {
+          ...op,
+          domain,
+          bizplace: bizplace,
+          name: op?.id ? op.name : OrderNoGenerator.orderProduct(),
+          product: await productRepo.findOne(op.product.id),
+          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

@@ -0,0 +1,88 @@
+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, Pagination, Sorting } from '@things-factory/shell'
+import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { EntityManager, getRepository, In } from 'typeorm'
+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: any,
+    @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: any): Promise<PurchaseOrder> {
+    const { tx }: { tx: EntityManager } = context.state
+    return getPurchaseOrderFunction(null, name, context, tx)
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() purchaseOrder: PurchaseOrder): Promise<Domain> {
+    return await getRepository(Domain).findOne(purchaseOrder.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() purchaseOrder: PurchaseOrder): Promise<User> {
+    return await getRepository(User).findOne(purchaseOrder.creatorId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() purchaseOrder: PurchaseOrder): Promise<User> {
+    return await getRepository(User).findOne(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, name, bizplace: 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,
+      refBy: result.id,
+      category: ATTACHMENT_TYPE.PO
+    }
+  })
+
+  return {
+    ...result,
+    attachment: foundAttachments
+  }
+}

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

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