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

package/server/service/index.ts

@@ -0,0 +1,142 @@
+/* IMPORT ENTITIES AND RESOLVERS */
+import { entities as ReverseKittingOrderInventoryEntities, resolvers as ReverseKittingOrderInventoryResolvers } from './reverse-kitting-order-inventory'
+import { entities as ReverseKittingOrderEntities, resolvers as ReverseKittingOrderResolvers } from './reverse-kitting-order'
+import { entities as ArrivalNoticeEntity, resolvers as ArrivalNoticeResolvers } from './arrival-notice'
+import { entities as ClaimEntity, resolvers as ClaimResolvers } from './claim'
+import { entities as ClaimDetailEntity, resolvers as ClaimDetailResolvers } from './claim-detail'
+import { entities as ClaimOrderEntity, resolvers as ClaimOrderResolvers } from './claim-order'
+import { entities as CollectionOrderEntity, resolvers as CollectionOrderResolvers } from './collection-order'
+import { entities as DeliveryOrderEntity, resolvers as DeliveryOrderResolvers } from './delivery-order'
+import { entities as GoodsReceivalNoteEntity, resolvers as GoodsReceivalNoteResolvers } from './goods-receival-note'
+import { entities as InventoryCheckEntity, resolvers as InventoryCheckResolvers } from './inventory-check'
+import { entities as InvoiceEntity, resolvers as InvoiceResolvers } from './invoice'
+import { entities as JobSheetEntity, resolvers as JobSheetResolvers } from './job-sheet'
+import { entities as OrderInventoryEntity, resolvers as OrderInventoryResolvers } from './order-inventory'
+import { entities as OrderProductEntity, resolvers as OrderProductResolvers } from './order-product'
+import { entities as OrderVasEntity, resolvers as OrderVasResolvers } from './order-vas'
+import { resolvers as OthersResolvers } from './others'
+import { entities as PurchaseOrderEntity, resolvers as PurchaseOrderResolvers } from './purchase-order'
+import {
+  entities as PurchaseOrderOtherChargeEntity,
+  resolvers as PurchaseOrderOtherChargeResolvers
+} from './purchase-order-other-charge'
+import { entities as ReleaseGoodEntity, resolvers as ReleaseGoodResolvers } from './release-good'
+import {
+  entities as RetailReplenishmentOrderEntity,
+  resolvers as RetailReplenishmentOrderResolvers
+} from './retail-replenishment-order'
+import { entities as ReturnOrderEntity, resolvers as ReturnOrderResolvers } from './return-order'
+import { entities as ShippingOrderEntity, resolvers as ShippingOrderResolvers } from './shipping-order'
+import { entities as TransferOrderEntity, resolvers as TransferOrderResolvers } from './transfer-order'
+import { entities as VasEntity, resolvers as VasResolvers } from './vas'
+import { entities as VasOrderEntity, resolvers as VasOrderResolvers } from './vas-order'
+
+/* EXPORT ENTITY TYPES */
+export * from './reverse-kitting-order-inventory/reverse-kitting-order-inventory'
+export * from './reverse-kitting-order/reverse-kitting-order'
+export * from './arrival-notice/arrival-notice'
+export * from './claim-detail/claim-detail'
+export * from './claim-order/claim-order'
+export * from './claim/claim'
+export * from './collection-order/collection-order'
+export * from './delivery-order/delivery-order'
+export * from './goods-receival-note/goods-receival-note'
+export * from './inventory-check/inventory-check'
+export * from './invoice/invoice'
+export * from './job-sheet/job-sheet'
+export * from './order-inventory/order-inventory'
+export * from './order-product/order-product'
+export * from './order-vas/order-vas'
+export * from './purchase-order-other-charge/purchase-order-other-charge'
+export * from './purchase-order/purchase-order'
+export * from './release-good/release-good'
+export * from './retail-replenishment-order/retail-replenishment-order'
+export * from './return-order/return-order'
+export * from './shipping-order/shipping-order'
+export * from './transfer-order/transfer-order'
+export * from './vas-order/vas-order'
+export * from './vas/vas'
+
+/* EXPORT TYPES */
+export * from './arrival-notice/arrival-notice-types'
+export * from './claim-detail/claim-detail-types'
+export * from './claim-order/claim-order-types'
+export * from './claim/claim-types'
+export * from './collection-order/collection-order-types'
+export * from './delivery-order/delivery-order-types'
+export * from './goods-receival-note/goods-receival-note-types'
+export * from './inventory-check/inventory-check-types'
+export * from './invoice/invoice-types'
+export * from './job-sheet/job-sheet-types'
+export * from './order-inventory/order-inventory-types'
+export * from './order-product/order-product-types'
+export * from './order-vas/order-vas-types'
+export * from './others/other-types'
+export * from './purchase-order-other-charge/purchase-order-other-charge-types'
+export * from './purchase-order/purchase-order-types'
+export * from './release-good/release-good-types'
+export * from './retail-replenishment-order/retail-replenishment-order-types'
+export * from './return-order/return-order-types'
+export * from './shipping-order/shipping-order-types'
+export * from './transfer-order/transfer-order-types'
+export * from './vas-order/vas-order-types'
+export * from './vas/vas-types'
+
+export const entities = [
+  /* ENTITIES */
+	...ReverseKittingOrderInventoryEntities,
+	...ReverseKittingOrderEntities,
+  ...ArrivalNoticeEntity,
+  ...ClaimEntity,
+  ...ClaimDetailEntity,
+  ...ClaimOrderEntity,
+  ...CollectionOrderEntity,
+  ...DeliveryOrderEntity,
+  ...GoodsReceivalNoteEntity,
+  ...InventoryCheckEntity,
+  ...InvoiceEntity,
+  ...JobSheetEntity,
+  ...OrderInventoryEntity,
+  ...OrderProductEntity,
+  ...OrderVasEntity,
+  ...PurchaseOrderEntity,
+  ...PurchaseOrderOtherChargeEntity,
+  ...ReleaseGoodEntity,
+  ...RetailReplenishmentOrderEntity,
+  ...ReturnOrderEntity,
+  ...ShippingOrderEntity,
+  ...TransferOrderEntity,
+  ...VasEntity,
+  ...VasOrderEntity
+]
+
+export const schema = {
+  resolverClasses: [
+    /* RESOLVER CLASSES */
+		...ReverseKittingOrderInventoryResolvers,
+		...ReverseKittingOrderResolvers,
+    ...ArrivalNoticeResolvers,
+    ...ClaimResolvers,
+    ...ClaimDetailResolvers,
+    ...ClaimOrderResolvers,
+    ...CollectionOrderResolvers,
+    ...DeliveryOrderResolvers,
+    ...GoodsReceivalNoteResolvers,
+    ...InventoryCheckResolvers,
+    ...InvoiceResolvers,
+    ...JobSheetResolvers,
+    ...OrderInventoryResolvers,
+    ...OrderProductResolvers,
+    ...OrderVasResolvers,
+    ...OthersResolvers,
+    ...PurchaseOrderResolvers,
+    ...PurchaseOrderOtherChargeResolvers,
+    ...ReleaseGoodResolvers,
+    ...RetailReplenishmentOrderResolvers,
+    ...ReturnOrderResolvers,
+    ...ShippingOrderResolvers,
+    ...TransferOrderResolvers,
+    ...VasResolvers,
+    ...VasOrderResolvers
+  ]
+}

package/server/service/inventory-check/index.ts

@@ -0,0 +1,6 @@
+import { InventoryCheck } from './inventory-check'
+import { InventoryCheckMutation } from './inventory-check-mutation'
+import { InventoryCheckQuery } from './inventory-check-query'
+
+export const entities = [InventoryCheck]
+export const resolvers = [InventoryCheckQuery, InventoryCheckMutation]

package/server/service/inventory-check/inventory-check-mutation.ts

@@ -0,0 +1,144 @@
+import { User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { Domain } from '@things-factory/shell'
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager, In } from 'typeorm'
+import { InventoryCheckPatch, NewInventoryCheck } from '../'
+import { ORDER_STATUS, ORDER_TYPES } from '../../constants'
+import { OrderNoGenerator } from '../../utils/order-no-generator'
+import { InventoryCheck } from './inventory-check'
+
+@Resolver(InventoryCheck)
+export class InventoryCheckMutation {
+  @Mutation(returns => InventoryCheck)
+  @Directive('@transaction')
+  async createInventoryCheck(
+    @Arg('inventoryCheck', type => NewInventoryCheck) inventoryCheck: NewInventoryCheck,
+    @Ctx() context: any
+  ): Promise<InventoryCheck> {
+    const { tx }: { tx: EntityManager } = context.state
+    return await tx.getRepository(InventoryCheck).save({
+      ...inventoryCheck,
+      domain: context.state.domain,
+      creator: context.state.user,
+      updater: context.state.user
+    })
+  }
+
+  @Mutation(returns => InventoryCheck)
+  @Directive('@transaction')
+  async updateInventoryCheck(
+    @Arg('name') name: string,
+    @Arg('patch', type => InventoryCheckPatch) patch: InventoryCheckPatch,
+    @Ctx() context: any
+  ): Promise<InventoryCheck> {
+    const { tx }: { tx: EntityManager } = context.state
+
+    const repository = tx.getRepository(InventoryCheck)
+    const inventoryCheck = await repository.findOne({
+      where: { domain: context.state.domain, name }
+    })
+
+    return await repository.save({
+      ...inventoryCheck,
+      ...patch,
+      updater: context.state.user
+    })
+  }
+
+  @Mutation(returns => InventoryCheck)
+  @Directive('@transaction')
+  async generateCycleCount(
+    @Arg('executionDate') executionDate: string,
+    @Arg('customerId') customerId: string,
+    @Ctx() context: any
+  ): Promise<InventoryCheck> {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    return await generateCycleCount(tx, domain, user, executionDate, customerId)
+  }
+
+  @Mutation(returns => [InventoryCheck])
+  @Directive('@transaction')
+  async updateMultipleInventoryCheck(
+    @Arg('patches', type => [InventoryCheckPatch]) patches: InventoryCheckPatch[],
+    @Ctx() context: any
+  ): Promise<InventoryCheck[]> {
+    const { tx }: { tx: EntityManager } = context.state
+
+    let results: InventoryCheck[] = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const inventoryCheckRepo = tx.getRepository(InventoryCheck)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await inventoryCheckRepo.save({
+          ...newRecord,
+          domain: context.state.domain,
+          creator: context.state.user,
+          updater: context.state.user
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const newRecord = _updateRecords[i]
+        const inventoryCheck = await inventoryCheckRepo.findOne(newRecord.id)
+
+        const result = await inventoryCheckRepo.save({
+          ...inventoryCheck,
+          ...newRecord,
+          updater: context.state.user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Mutation(returns => Boolean)
+  @Directive('@transaction')
+  async deleteInventoryCheck(@Arg('name') name: string, @Ctx() context: any): Promise<boolean> {
+    const { tx }: { tx: EntityManager } = context.state
+    await tx.getRepository(InventoryCheck).delete({ domain: context.state.domain, name })
+    return true
+  }
+
+  @Mutation(returns => Boolean)
+  @Directive('@transaction')
+  async deleteInventoryChecks(@Arg('names', type => [String]) names: string[], @Ctx() context: any): Promise<boolean> {
+    const { tx }: { tx: EntityManager } = context.state
+    await tx.getRepository(InventoryCheck).delete({
+      domain: context.state.domain,
+      name: In(names)
+    })
+    return true
+  }
+}
+
+export async function generateCycleCount(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  executionDate: string,
+  customerId: string
+): Promise<InventoryCheck> {
+  const customerBizplace: Bizplace = await tx.getRepository(Bizplace).findOne(customerId)
+
+  return tx.getRepository(InventoryCheck).save({
+    name: OrderNoGenerator.cycleCount(),
+    executionDate,
+    type: ORDER_TYPES.CYCLE_COUNT,
+    status: ORDER_STATUS.PENDING,
+    bizplace: customerBizplace,
+    domain,
+    updater: user
+  })
+}

package/server/service/inventory-check/inventory-check-query.ts

@@ -0,0 +1,47 @@
+import { User } from '@things-factory/auth-base'
+import { convertListParams, Domain, Filter, Pagination, Sorting } from '@things-factory/shell'
+import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { getRepository } from 'typeorm'
+import { InventoryCheckList } from '../'
+import { InventoryCheck } from './inventory-check'
+
+@Resolver(InventoryCheck)
+export class InventoryCheckQuery {
+  @Query(returns => InventoryCheckList)
+  async inventoryChecks(
+    @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<InventoryCheckList> {
+    const convertedParams = convertListParams({ filters, pagination, sortings })
+    const [items, total] = await getRepository(InventoryCheck).findAndCount({
+      ...convertedParams,
+      relations: ['domain', 'creator', 'updater']
+    })
+    return { items, total }
+  }
+
+  @Query(returns => InventoryCheck)
+  async inventoryCheck(@Arg('name') name: string, @Ctx() context: any): Promise<InventoryCheck> {
+    return await getRepository(InventoryCheck).findOne({
+      where: { domain: context.state.domain, name },
+      relations: ['domain', 'creator', 'updater']
+    })
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() inventoryCheck: InventoryCheck): Promise<Domain> {
+    return await getRepository(Domain).findOne(inventoryCheck.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() inventoryCheck: InventoryCheck): Promise<User> {
+    return await getRepository(User).findOne(inventoryCheck.creatorId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() inventoryCheck: InventoryCheck): Promise<User> {
+    return await getRepository(User).findOne(inventoryCheck.updaterId)
+  }
+}

package/server/service/inventory-check/inventory-check-types.ts

@@ -0,0 +1,48 @@
+import { Field, InputType, Int, ObjectType } from 'type-graphql'
+import { NewOrderInventory } from '../order-inventory/order-inventory-types'
+import { InventoryCheck } from './inventory-check'
+
+@ObjectType()
+export class InventoryCheckList {
+  @Field(type => [InventoryCheck], { nullable: true })
+  items: InventoryCheck[]
+
+  @Field(type => Int, { nullable: true })
+  total: number
+}
+
+@InputType()
+export class NewInventoryCheck {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field({ nullable: true })
+  status: string
+
+  @Field({ nullable: true })
+  executionDate: string
+
+  @Field(type => NewOrderInventory, { nullable: true })
+  orderInventories: NewOrderInventory[]
+
+  @Field({ nullable: true })
+  type: string
+}
+
+@InputType()
+export class InventoryCheckPatch {
+  @Field({ nullable: true })
+  id: string
+
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field({ nullable: true })
+  cuFlag: string
+}

package/server/service/inventory-check/inventory-check.ts

@@ -0,0 +1,90 @@
+import { User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { Domain } from '@things-factory/shell'
+import { Field, ID, ObjectType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  OneToMany,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+import { OrderInventory } from '../'
+
+@Entity()
+@Index('ix_inventory-check_0', (inventoryCheck: InventoryCheck) => [inventoryCheck.domain, inventoryCheck.name], {
+  unique: true
+})
+@ObjectType()
+export class InventoryCheck {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain, { nullable: true })
+  domain: Domain
+
+  @RelationId((inventoryCheck: InventoryCheck) => inventoryCheck.domain)
+  domainId: string
+
+  @ManyToOne(type => Bizplace)
+  @Field(type => Bizplace, { nullable: true })
+  bizplace: Bizplace
+
+  @RelationId((inventoryCheck: InventoryCheck) => inventoryCheck.bizplace)
+  bizplaceId: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  description: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  executionDate: string
+
+  @Column()
+  @Field()
+  type: string
+
+  @Column()
+  @Field()
+  status: string
+
+  @OneToMany(type => OrderInventory, orderInventory => orderInventory.inventoryCheck)
+  @Field(type => OrderInventory, { nullable: true })
+  orderInventories: OrderInventory[]
+
+  @CreateDateColumn()
+  @Field()
+  createdAt: Date
+
+  @UpdateDateColumn()
+  @Field()
+  updatedAt: Date
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  creator: User
+
+  @RelationId((inventoryCheck: InventoryCheck) => inventoryCheck.creator)
+  creatorId: string
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  updater: User
+
+  @RelationId((inventoryCheck: InventoryCheck) => inventoryCheck.updater)
+  updaterId: string
+
+  @Field({ nullable: true })
+  cuFlag: string
+}

package/server/service/invoice/index.ts

@@ -0,0 +1,6 @@
+import { Invoice } from './invoice'
+import { InvoiceMutation } from './invoice-mutation'
+import { InvoiceQuery } from './invoice-query'
+
+export const entities = [Invoice]
+export const resolvers = [InvoiceQuery, InvoiceMutation]

package/server/service/invoice/invoice-mutation.ts

@@ -0,0 +1,52 @@
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager } from 'typeorm'
+import { InvoicePatch, NewInvoice } from '../'
+import { Invoice } from './invoice'
+
+@Resolver(Invoice)
+export class InvoiceMutation {
+  @Mutation(returns => Invoice)
+  @Directive('@transaction')
+  async createInvoice(@Arg('invoice', type => NewInvoice) invoice: NewInvoice, @Ctx() context: any): Promise<Invoice> {
+    const { tx }: { tx: EntityManager } = context.state
+
+    return await tx.getRepository(Invoice).save({
+      ...invoice,
+      domain: context.state.domain,
+      creator: context.state.user,
+      updater: context.state.user
+    })
+  }
+
+  @Mutation(returns => Invoice)
+  @Directive('@transaction')
+  async updateInvoice(
+    @Arg('name') name: string,
+    @Arg('patch', type => InvoicePatch) patch: InvoicePatch,
+    @Ctx() context: any
+  ): Promise<Invoice> {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+
+    const repository = tx.getRepository(Invoice)
+    const invoice = await repository.findOne({
+      where: { domain, name }
+    })
+
+    return await repository.save({
+      ...invoice,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Mutation(returns => Boolean)
+  @Directive('@transaction')
+  async deleteInvoice(@Arg('name') name: string, @Ctx() context: any): Promise<boolean> {
+    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+
+    await tx.getRepository(Invoice).delete({ domain, name })
+    return true
+  }
+}

package/server/service/invoice/invoice-query.ts

@@ -0,0 +1,54 @@
+import { User } from '@things-factory/auth-base'
+import { buildQuery, Domain, Filter, Pagination, Sorting } from '@things-factory/shell'
+import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { getRepository } from 'typeorm'
+import { InvoiceList } from '../'
+import { Invoice } from './invoice'
+
+@Resolver(Invoice)
+export class InvoiceQuery {
+  @Query(returns => InvoiceList)
+  async invoices(
+    @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<InvoiceList> {
+    const queryBuilder = getRepository(Invoice).createQueryBuilder()
+    buildQuery(queryBuilder, { filters, pagination, sortings }, context)
+    const [items, total] = await queryBuilder
+      .leftJoinAndSelect('Invoice.domain', 'Domain')
+      .leftJoinAndSelect('Invoice.customer', 'Bizplace')
+      .leftJoinAndSelect('Invoice.purchaseOrder', 'PurchaseOrder')
+      .leftJoinAndSelect('Invoice.creator', 'Creator')
+      .leftJoinAndSelect('Invoice.updater', 'Updater')
+      .getManyAndCount()
+
+    return { items, total }
+  }
+
+  @Query(returns => Invoice)
+  async invoice(@Arg('name') name: string, @Ctx() context: any): Promise<Invoice> {
+    const { domain }: { domain: Domain } = context.state
+
+    return await getRepository(Invoice).findOne({
+      where: { domain, name },
+      relations: ['domain', 'customer', 'purchaseOrder', 'creator', 'updater']
+    })
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() invoice: Invoice): Promise<Domain> {
+    return await getRepository(Domain).findOne(invoice.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() invoice: Invoice): Promise<User> {
+    return await getRepository(User).findOne(invoice.creatorId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() invoice: Invoice): Promise<User> {
+    return await getRepository(User).findOne(invoice.updaterId)
+  }
+}

package/server/service/invoice/invoice-types.ts

@@ -0,0 +1,66 @@
+import { Field, InputType, Int, ObjectType } from 'type-graphql'
+import { PurchaseOrderPatch } from '../purchase-order/purchase-order-types'
+import { Invoice } from './invoice'
+
+@ObjectType()
+export class InvoiceList {
+  @Field(type => [Invoice], { nullable: true })
+  items: Invoice[]
+
+  @Field(type => Int, { nullable: true })
+  total: number
+}
+
+@InputType()
+export class NewInvoice {
+  @Field()
+  name: string
+
+  @Field()
+  customer: string
+
+  @Field()
+  issuedOn: string
+
+  @Field()
+  paymentDue: string
+
+  @Field()
+  version: string
+
+  @Field(type => PurchaseOrderPatch)
+  purchaseOrder: PurchaseOrderPatch
+
+  @Field()
+  state: string
+
+  @Field({ nullable: true })
+  description: string
+}
+
+@InputType()
+export class InvoicePatch {
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  customer: string
+
+  @Field({ nullable: true })
+  issuedOn: string
+
+  @Field({ nullable: true })
+  paymentDue: string
+
+  @Field({ nullable: true })
+  version: string
+
+  @Field(type => PurchaseOrderPatch, { nullable: true })
+  purchaseOrder: PurchaseOrderPatch
+
+  @Field({ nullable: true })
+  state: string
+
+  @Field({ nullable: true })
+  description: string
+}