@things-factory/sales-base 4.0.38 → 4.0.42

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

@@ -1,8 +1,13 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager, getRepository, Repository } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
+import { Product } from '@things-factory/product-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 { OrderNoGenerator } from '../../utils'
+import { InvoiceProduct } from '../invoice-product/invoice-product'
 import { Invoice } from './invoice'
 
 @Resolver(Invoice)
@@ -10,14 +15,20 @@ 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
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    let invoiceProducts: any[] = invoice.invoiceProducts
 
-    return await tx.getRepository(Invoice).save({
+    let createdInvoice: Invoice = await tx.getRepository(Invoice).save({
       ...invoice,
-      domain: context.state.domain,
-      creator: context.state.user,
-      updater: context.state.user
+      domain,
+      name: OrderNoGenerator.invoice(),
+      // releaseGood: await tx.getRepository(ReleaseGood).findOne(invoice?.releaseGood.id),
+      creator: user
     })
+
+    await addInvoiceProducts(domain, createdInvoice, invoiceProducts, user, tx)
+
+    return createdInvoice
   }
 
   @Mutation(returns => Invoice)
@@ -50,3 +61,30 @@ export class InvoiceMutation {
     return true
   }
 }
+
+export async function addInvoiceProducts(
+  domain: Domain,
+  invoice: Invoice,
+  invoiceProducts: any[],
+  user: User,
+  tx?: EntityManager
+): Promise<void> {
+  const productRepo: Repository<Product> = tx?.getRepository(Product) || getRepository(Product)
+  const invoiceProductRepo: Repository<InvoiceProduct> =
+    tx?.getRepository(InvoiceProduct) || getRepository(InvoiceProduct)
+
+  const createdInvoiceProducts: InvoiceProduct[] = await Promise.all(
+    invoiceProducts.map(async (invoiceProduct: InvoiceProduct) => {
+      return {
+        name: OrderNoGenerator.invoiceProduct(),
+        ...invoiceProduct,
+        domain,
+        product: await productRepo.findOne(invoiceProduct?.product.id),
+        invoice,
+        creator: user
+      }
+    })
+  )
+
+  await invoiceProductRepo.save(createdInvoiceProducts)
+}

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

@@ -1,9 +1,11 @@
-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 { User } from '@things-factory/auth-base'
+import { buildQuery, Domain, Filter, Pagination, Sorting } from '@things-factory/shell'
+
 import { Invoice } from './invoice'
+import { InvoiceList } from './invoice-types'
 
 @Resolver(Invoice)
 export class InvoiceQuery {
@@ -18,8 +20,6 @@ export class InvoiceQuery {
     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()
@@ -33,7 +33,7 @@ export class InvoiceQuery {
 
     return await getRepository(Invoice).findOne({
       where: { domain, name },
-      relations: ['domain', 'customer', 'purchaseOrder', 'creator', 'updater']
+      relations: ['domain', 'creator', 'updater']
     })
   }
 

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

@@ -1,5 +1,8 @@
 import { Field, InputType, Int, ObjectType } from 'type-graphql'
-import { PurchaseOrderPatch } from '../purchase-order/purchase-order-types'
+
+import { ObjectRef } from '@things-factory/shell'
+
+import { InvoiceProductPatch, NewInvoiceProduct } from '../invoice-product/invoice-product-types'
 import { Invoice } from './invoice'
 
 @ObjectType()
@@ -17,25 +20,130 @@ export class NewInvoice {
   name: string
 
   @Field()
-  customer: string
+  refNo1: string
+
+  @Field()
+  refNo2: string
+
+  @Field()
+  refNo3: string
 
   @Field()
   issuedOn: string
 
   @Field()
-  paymentDue: string
+  contactPointRefId: string
+
+  @Field()
+  from: string
+
+  @Field()
+  fromContactPhone: string
+
+  @Field()
+  fromAddress1: string
+
+  @Field()
+  fromAddress2: string
+
+  @Field()
+  fromAddress3: string
+
+  @Field()
+  fromAddress4: string
+
+  @Field()
+  fromAddress5: string
+
+  @Field()
+  fromPostcode: string
+
+  @Field()
+  fromCity: string
 
   @Field()
-  version: string
+  fromState: string
 
-  @Field(type => PurchaseOrderPatch)
-  purchaseOrder: PurchaseOrderPatch
+  @Field()
+  fromCountry: string
+
+  @Field()
+  deliverTo: string
+
+  @Field()
+  deliverToPhone: string
 
   @Field()
-  state: string
+  deliveryAddress1: string
+
+  @Field()
+  deliveryAddress2: string
+
+  @Field()
+  deliveryAddress3: string
+
+  @Field()
+  deliveryAddress4: string
+
+  @Field()
+  deliveryAddress5: string
+
+  @Field()
+  deliveryCity: string
+
+  @Field()
+  deliveryState: string
+
+  @Field()
+  deliveryCountry: string
+
+  @Field()
+  deliveryPostcode: string
+
+  @Field()
+  billTo: string
+
+  @Field()
+  billToPhone: string
+
+  @Field()
+  billingAddress1: string
+
+  @Field()
+  billingAddress2: string
+
+  @Field()
+  billingAddress3: string
+
+  @Field()
+  billingAddress4: string
+
+  @Field()
+  billingAddress5: string
+
+  @Field()
+  billingPostcode: string
+
+  @Field()
+  billingCity: string
+
+  @Field()
+  billingState: string
+
+  @Field()
+  billingCountry: string
+
+  @Field()
+  paymentDue: String
 
   @Field({ nullable: true })
   description: string
+
+  @Field(type => [NewInvoiceProduct])
+  invoiceProducts: NewInvoiceProduct[]
+
+  @Field(type => ObjectRef)
+  releaseGood: ObjectRef
 }
 
 @InputType()
@@ -43,24 +151,129 @@ export class InvoicePatch {
   @Field({ nullable: true })
   name: string
 
-  @Field({ nullable: true })
-  customer: string
+  @Field()
+  refNo1: string
 
-  @Field({ nullable: true })
+  @Field()
+  refNo2: string
+
+  @Field()
+  refNo3: string
+
+  @Field()
   issuedOn: string
 
-  @Field({ nullable: true })
-  paymentDue: string
+  @Field()
+  contactPointRefId: string
 
-  @Field({ nullable: true })
-  version: string
+  @Field()
+  from: string
 
-  @Field(type => PurchaseOrderPatch, { nullable: true })
-  purchaseOrder: PurchaseOrderPatch
+  @Field()
+  fromContactPhone: string
 
-  @Field({ nullable: true })
-  state: string
+  @Field()
+  fromAddress1: string
+
+  @Field()
+  fromAddress2: string
+
+  @Field()
+  fromAddress3: string
+
+  @Field()
+  fromAddress4: string
+
+  @Field()
+  fromAddress5: string
+
+  @Field()
+  fromPostcode: string
+
+  @Field()
+  fromCity: string
+
+  @Field()
+  fromState: string
+
+  @Field()
+  fromCountry: string
+
+  @Field()
+  deliverTo: string
+
+  @Field()
+  deliverToPhone: string
+
+  @Field()
+  deliveryAddress1: string
+
+  @Field()
+  deliveryAddress2: string
+
+  @Field()
+  deliveryAddress3: string
+
+  @Field()
+  deliveryAddress4: string
+
+  @Field()
+  deliveryAddress5: string
+
+  @Field()
+  deliveryCity: string
+
+  @Field()
+  deliveryState: string
+
+  @Field()
+  deliveryCountry: string
+
+  @Field()
+  deliveryPostcode: string
+
+  @Field()
+  billTo: string
+
+  @Field()
+  billToPhone: string
+
+  @Field()
+  billingAddress1: string
+
+  @Field()
+  billingAddress2: string
+
+  @Field()
+  billingAddress3: string
+
+  @Field()
+  billingAddress4: string
+
+  @Field()
+  billingAddress5: string
+
+  @Field()
+  billingPostcode: string
+
+  @Field()
+  billingCity: string
+
+  @Field()
+  billingState: string
+
+  @Field()
+  billingCountry: string
+
+  @Field()
+  paymentDue: String
 
   @Field({ nullable: true })
   description: string
+
+  @Field(type => [InvoiceProductPatch], { nullable: true })
+  invoiceProducts: InvoiceProductPatch[]
+
+  @Field(type => ObjectRef, { nullable: true })
+  releaseGood: ObjectRef
 }

package/server/service/invoice/invoice.ts

@@ -1,6 +1,3 @@
-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,
@@ -9,15 +6,21 @@ import {
   Index,
   JoinColumn,
   ManyToOne,
+  OneToMany,
   OneToOne,
   PrimaryGeneratedColumn,
   RelationId,
   UpdateDateColumn
 } from 'typeorm'
-import { PurchaseOrder } from '../'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { InvoiceProduct } from '../invoice-product/invoice-product'
+import { ReleaseGood } from '../release-good/release-good'
 
 @Entity()
-@Index('ix_invoice_0', (invoice: Invoice) => [invoice.domain, invoice.name, invoice.customer])
+@Index('ix_invoice_0', (invoice: Invoice) => [invoice.id], { unique: true })
 @ObjectType()
 export class Invoice {
   @PrimaryGeneratedColumn('uuid')
@@ -35,37 +38,168 @@ export class Invoice {
   @Field()
   name: string
 
-  @ManyToOne(type => Bizplace)
-  @Field(type => Bizplace, { nullable: true })
-  customer: Bizplace
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  description: string
+
+  @OneToMany(type => InvoiceProduct, invoiceProduct => invoiceProduct.invoice)
+  invoiceProducts: InvoiceProduct[]
+
+  @OneToOne(type => ReleaseGood, { nullable: true })
+  @JoinColumn()
+  releaseGood: ReleaseGood
+
+  @Column({ default: '' })
+  @Field()
+  refNo1: string
+
+  @Column({ default: '' })
+  @Field()
+  refNo2: string
 
-  @RelationId((invoice: Invoice) => invoice.customer)
-  customerId: string
+  @Column({ default: '' })
+  @Field()
+  refNo3: string
 
-  @Column('date')
+  @Column({ nullable: true })
   @Field()
   issuedOn: Date
 
-  @Column('date')
+  @Column({ type: 'uuid', nullable: true })
+  @Field({ nullable: true })
+  contactPointRefId: string
+
+  @Column()
   @Field()
-  paymentDue: Date
+  from: string
 
   @Column()
   @Field()
-  version: string
+  fromContactPhone: string
 
-  @OneToOne(type => PurchaseOrder)
-  @JoinColumn()
-  @Field(type => PurchaseOrder, { nullable: true })
-  purchaseOrder: PurchaseOrder
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  fromAddress1: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  fromAddress2: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  fromAddress3: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  fromAddress4: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  fromAddress5: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  fromPostcode: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  fromCity: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  fromState: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  fromCountry: string
 
   @Column()
   @Field()
-  state: string
+  deliverTo: string
+
+  @Column()
+  @Field()
+  deliverToPhone: string
+
+  @Column()
+  @Field()
+  deliveryAddress1: string
 
   @Column({ nullable: true })
   @Field({ nullable: true })
-  description: string
+  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()
+  @Field()
+  deliveryPostcode: string
+
+  @Column()
+  @Field()
+  deliveryCity: string
+
+  @Column()
+  @Field()
+  deliveryState: string
+
+  @Column()
+  @Field()
+  deliveryCountry: string
+
+  @Column()
+  @Field()
+  billTo: string
+
+  @Column()
+  @Field()
+  billToPhone: string
+
+  @Column()
+  @Field()
+  billingAddress1: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  billingAddress2: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  billingAddress3: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  billingAddress4: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  billingAddress5: string
+
+  @Column()
+  @Field()
+  billingPostcode: string
+
+  @Column()
+  @Field()
+  billingCity: string
+
+  @Column()
+  @Field()
+  billingState: string
+
+  @Column()
+  @Field()
+  billingCountry: string
 
   @CreateDateColumn()
   @Field()

package/server/service/invoice-product/index.ts

@@ -0,0 +1,9 @@
+import { InvoiceProduct } from './invoice-product'
+import { InvoiceProductMutation } from './invoice-product-mutation'
+import { InvoiceProductQuery } from './invoice-product-query'
+
+export const entities = [InvoiceProduct]
+export const resolvers = [InvoiceProductQuery, InvoiceProductMutation]
+
+export * from './invoice-product-mutation'
+export * from './invoice-product-query'

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

@@ -0,0 +1,54 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+
+import { InvoiceProduct } from '../invoice-product/invoice-product'
+import { InvoiceProductPatch, NewInvoiceProduct } from './invoice-product-types'
+
+@Resolver(InvoiceProduct)
+export class InvoiceProductMutation {
+  @Mutation(returns => InvoiceProduct)
+  @Directive('@transaction')
+  async createInvoiceProduct(
+    @Arg('invoiceProduct', type => NewInvoiceProduct) invoiceProduct: NewInvoiceProduct,
+    @Ctx() context: any
+  ): Promise<InvoiceProduct> {
+    const { domain, user, tx } = context.state
+
+    return await tx.getRepository(InvoiceProduct).save({
+      ...invoiceProduct,
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Mutation(returns => InvoiceProduct)
+  @Directive('@transaction')
+  async updateInvoiceProduct(
+    @Arg('name') name: string,
+    @Arg('patch', type => InvoiceProductPatch) patch: InvoiceProductPatch,
+    @Ctx() context: any
+  ): Promise<InvoiceProduct> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(InvoiceProduct)
+    const invoiceProduct = await repository.findOne({
+      where: { domain, name }
+    })
+
+    return await repository.save({
+      ...invoiceProduct,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Mutation(returns => Boolean)
+  @Directive('@transaction')
+  async deleteInvoiceProduct(@Arg('name') name: string, @Ctx() context: any): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(InvoiceProduct).delete({ domain, name })
+
+    return true
+  }
+}