@things-factory/sales-base 3.8.26 → 3.8.30

package/server/entities/invoice-product.ts

@@ -0,0 +1,64 @@
+import { Column, CreateDateColumn, Entity, Index, ManyToOne, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Product } from '@things-factory/product-base'
+import { Domain } from '@things-factory/shell'
+
+import { Invoice } from './invoice'
+
+@Entity()
+@Index('ix_invoice_product_0', (invoiceProduct: InvoiceProduct) => [invoiceProduct.id], {
+  unique: true
+})
+export class InvoiceProduct {
+  @PrimaryGeneratedColumn('uuid')
+  id: string
+
+  @ManyToOne(type => Domain)
+  domain: Domain
+
+  @Column({ nullable: true })
+  sku: string
+
+  @Column()
+  name: string
+
+  @Column({
+    nullable: true
+  })
+  description: string
+
+  @ManyToOne(type => Invoice)
+  invoice: Invoice
+
+  @ManyToOne(type => Product, { nullable: true })
+  product: Product
+
+  @Column('int', { default: 0 })
+  qty: number
+
+  @Column('float', { default: 0 })
+  otherCharges: number
+
+  @Column('float', { default: 0 })
+  unitPrice: number
+
+  @Column('float', { default: 0 })
+  paidPrice: number
+
+  @CreateDateColumn()
+  createdAt: Date
+
+  @UpdateDateColumn()
+  updatedAt: Date
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  creator: User
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  updater: User
+}

package/server/entities/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 {
   Column,
   CreateDateColumn,
@@ -8,14 +5,20 @@ import {
   Index,
   JoinColumn,
   ManyToOne,
+  OneToMany,
   OneToOne,
   PrimaryGeneratedColumn,
   UpdateDateColumn
 } from 'typeorm'
-import { PurchaseOrder } from './purchase-order'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { ReleaseGood } from '../entities'
+import { InvoiceProduct } from './invoice-product'
 
 @Entity()
-@Index('ix_invoice_0', (invoice: Invoice) => [invoice.domain, invoice.name, invoice.customer])
+@Index('ix_invoice_0', (invoice: Invoice) => [invoice.id], { unique: true })
 export class Invoice {
   @PrimaryGeneratedColumn('uuid')
   id: string
@@ -26,29 +29,134 @@ export class Invoice {
   @Column()
   name: string
 
-  @ManyToOne(type => Bizplace)
-  customer: Bizplace
+  @Column({
+    nullable: true
+  })
+  description: string
 
-  @Column('date')
-  issuedOn: Date
+  @OneToMany(type => InvoiceProduct, invoiceProduct => invoiceProduct.invoice)
+  invoiceProducts: InvoiceProduct[]
 
-  @Column('date')
-  paymentDue: Date
+  @OneToOne(type => ReleaseGood, { nullable: true })
+  @JoinColumn()
+  releaseGood: ReleaseGood
 
-  @Column()
-  version: string
+  @Column({ default: '' })
+  refNo1: string
 
-  @OneToOne(type => PurchaseOrder)
-  @JoinColumn()
-  purchaseOrder: PurchaseOrder
+  @Column({ default: '' })
+  refNo2: string
 
-  @Column()
-  state: string
+  @Column({ default: '' })
+  refNo3: string
+
+  @Column({ nullable: true })
+  issuedOn: Date
 
   @Column({
+    type: 'uuid',
     nullable: true
   })
-  description: string
+  contactPointRefId: string
+
+  @Column()
+  from: string
+
+  @Column()
+  fromContactPhone: string
+
+  @Column({ nullable: true })
+  fromAddress1: string
+
+  @Column({ nullable: true })
+  fromAddress2: string
+
+  @Column({ nullable: true })
+  fromAddress3: string
+
+  @Column({ nullable: true })
+  fromAddress4: string
+
+  @Column({ nullable: true })
+  fromAddress5: string
+
+  @Column({ nullable: true })
+  fromPostcode: string
+
+  @Column({ nullable: true })
+  fromCity: string
+
+  @Column({ nullable: true })
+  fromState: string
+
+  @Column({ nullable: true })
+  fromCountry: string
+
+  @Column()
+  deliverTo: string
+
+  @Column()
+  deliverToPhone: string
+
+  @Column()
+  deliveryAddress1: string
+
+  @Column({ nullable: true })
+  deliveryAddress2: string
+
+  @Column({ nullable: true })
+  deliveryAddress3: string
+
+  @Column({ nullable: true })
+  deliveryAddress4: string
+
+  @Column({ nullable: true })
+  deliveryAddress5: string
+
+  @Column()
+  deliveryPostcode: string
+
+  @Column()
+  deliveryCity: string
+
+  @Column()
+  deliveryState: string
+
+  @Column()
+  deliveryCountry: string
+
+  @Column()
+  billTo: string
+
+  @Column()
+  billToPhone: string
+
+  @Column()
+  billingAddress1: string
+
+  @Column({ nullable: true })
+  billingAddress2: string
+
+  @Column({ nullable: true })
+  billingAddress3: string
+
+  @Column({ nullable: true })
+  billingAddress4: string
+
+  @Column({ nullable: true })
+  billingAddress5: string
+
+  @Column()
+  billingPostcode: string
+
+  @Column()
+  billingCity: string
+
+  @Column()
+  billingState: string
+
+  @Column()
+  billingCountry: string
 
   @ManyToOne(type => User, {
     nullable: true

package/server/entities/release-good.ts

@@ -40,6 +40,8 @@ export enum DispatchmentStatus {
 }
 @Entity()
 @Index('ix_release-good_0', (releaseGood: ReleaseGood) => [releaseGood.domain, releaseGood.name], { unique: true })
+@Index('ix_release-good_1', (releaseGood: ReleaseGood) => [releaseGood.domain, releaseGood.refNo])
+@Index('ix_release-good_2', (releaseGood: ReleaseGood) => [releaseGood.domain, releaseGood.refNo2])
 export class ReleaseGood {
   @PrimaryGeneratedColumn('uuid')
   id: string

package/server/graphql/resolvers/index.ts

@@ -7,6 +7,7 @@ import * as DeliveryOrder from './delivery-order'
 import * as GoodsReceivalNote from './goods-receival-note'
 import * as InventoryCheck from './inventory-check'
 import * as Invoice from './invoice'
+import * as InvoiceProduct from './invoice-product'
 import * as JobSheet from './job-sheet'
 import * as Manifest from './manifest'
 import * as OrderInventory from './order-inventory'
@@ -27,6 +28,7 @@ import * as VasOrder from './vas-order'
 
 export const queries = [
   Invoice.Query,
+  InvoiceProduct.Query,
   InventoryCheck.Query,
   JobSheet.Query,
   PurchaseOrder.Query,
@@ -55,6 +57,7 @@ export const queries = [
 
 export const mutations = [
   Invoice.Mutation,
+  InvoiceProduct.Mutation,
   JobSheet.Mutation,
   InventoryCheck.Mutation,
   PurchaseOrder.Mutation,

package/server/graphql/resolvers/invoice/create-invoice.ts

@@ -1,17 +1,54 @@
+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 { EntityManager } from 'typeorm'
-import { Invoice } from '../../../entities'
+
+import { Invoice, InvoiceProduct, ReleaseGood } from '../../../entities'
+import { OrderNoGenerator } from '../../../utils'
 
 export const createInvoice = {
   async createInvoice(_: any, { invoice }, context: any) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    let invoiceProducts: InvoiceProduct[] = invoice.invoiceProducts
 
-    return await tx.getRepository(Invoice).save({
-      domain,
+    let createdInvoice: Invoice = await tx.getRepository(Invoice).save({
       ...invoice,
-      creator: user,
-      updater: 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
   }
 }
+
+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/graphql/resolvers/invoice-product/create-invoice-product.ts

@@ -0,0 +1,16 @@
+import { getRepository } from 'typeorm'
+import { InvoiceProduct } from '../../../entities'
+
+export const createInvoiceProduct = {
+  async createInvoiceProduct(_: any, { invoiceProduct }, context: any) {
+    const { domain, user } = context.state
+
+    return await getRepository(InvoiceProduct).save({
+      ...invoiceProduct,
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+}
+

package/server/graphql/resolvers/invoice-product/delete-invoice-product.ts

@@ -0,0 +1,13 @@
+import { getRepository } from 'typeorm'
+import { InvoiceProduct } from '../../../entities'
+
+export const deleteInvoiceProduct = {
+  async deleteInvoiceProduct(_: any, { name }, context: any) {
+    const { domain, user } = context.state
+
+    await getRepository(InvoiceProduct).delete({ domain, name })
+    
+    return true
+  }
+}
+

package/server/graphql/resolvers/invoice-product/delete-invoice-products.ts

@@ -0,0 +1,16 @@
+import { getRepository, In } from 'typeorm'
+import { InvoiceProduct } from '../../../entities'
+
+export const deleteInvoiceProducts = {
+  async deleteInvoiceProducts(_: any, { names }, context: any) {
+    const { domain, user } = context.state
+
+    await getRepository(InvoiceProduct).delete({ 
+        domain,
+        name: In(names)
+    })
+    
+    return true
+  }
+}
+

package/server/graphql/resolvers/invoice-product/index.ts

@@ -0,0 +1,18 @@
+import { createInvoiceProduct } from './create-invoice-product'
+import { deleteInvoiceProduct } from './delete-invoice-product'
+import { deleteInvoiceProducts } from './delete-invoice-products'
+import { Query as InvoiceProductQuery } from './invoice-product-query'
+import { updateInvoiceProduct } from './update-invoice-product'
+import { updateMultipleInvoiceProduct } from './update-multiple-invoice-product'
+
+export const Query = {
+  ...InvoiceProductQuery
+}
+
+export const Mutation = {
+  ...updateInvoiceProduct,
+  ...updateMultipleInvoiceProduct,
+  ...createInvoiceProduct,
+  ...deleteInvoiceProduct,
+  ...deleteInvoiceProducts
+}

package/server/graphql/resolvers/invoice-product/invoice-product-query.ts

@@ -0,0 +1,38 @@
+import { getRepository } from 'typeorm'
+import { Domain, ListParam, convertListParams } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { InvoiceProduct as InvoiceProductEntity } from '../../../entities'
+
+export const Query = {
+  async invoiceProduct(_: any, { name }, context: any) {
+    const { domain, user } = context.state
+    const repository = getRepository(InvoiceProductEntity)
+
+    return await repository.findOne({
+      where: { domain, name }
+    })
+  },
+
+  async invoiceProducts(_: any, params: ListParam, context: any) {
+    const convertedParams = convertListParams(params)
+    const [items, total] = await getRepository(InvoiceProductEntity).findAndCount({
+      ...convertedParams
+    })
+    
+    return { items, total }
+  }
+}
+
+export const InvoiceProduct = {
+  async domain(invoiceProduct) {
+    return await getRepository(Domain).findOne(invoiceProduct.domainId)
+  },
+
+  async creator(invoiceProduct) {
+    return await getRepository(User).findOne(invoiceProduct.creatorId)
+  },
+
+  async updater(invoiceProduct) {
+    return await getRepository(User).findOne(invoiceProduct.updaterId)
+  }
+}

package/server/graphql/resolvers/invoice-product/update-invoice-product.ts

@@ -0,0 +1,19 @@
+import { getRepository } from 'typeorm'
+import { InvoiceProduct } from '../../../entities'
+
+export const updateInvoiceProduct = {
+  async updateInvoiceProduct(_: any, { name, patch }, context: any) {
+    const { domain, user } = context.state
+
+    const repository = getRepository(InvoiceProduct)
+    const invoiceProduct = await repository.findOne({ 
+      where: { domain, name }
+    })
+
+    return await repository.save({
+      ...invoiceProduct,
+      ...patch,
+      updater: user
+    })
+  }
+}

package/server/graphql/resolvers/invoice-product/update-multiple-invoice-product.ts

@@ -0,0 +1,46 @@
+import { getRepository } from 'typeorm'
+import { InvoiceProduct } from '../../../entities'
+
+export const updateMultipleInvoiceProduct = {
+  async updateMultipleInvoiceProduct(_: any, { patches }, context: any) {
+    const { domain, user } = context.state
+    
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const invoiceProductRepo = getRepository(InvoiceProduct)
+
+    if (_createRecords.length > 0) {
+        for (let i = 0; i < _createRecords.length; i++) {
+          const newRecord = _createRecords[i]
+          
+          const result = await invoiceProductRepo.save({
+            ...newRecord,
+            domain: domain,
+            creator: user,
+            updater: user,
+          })
+          
+          results.push({ ...result, cuFlag: '+' })
+        }
+    }
+
+    if (_updateRecords.length > 0) {
+        for (let i = 0; i < _updateRecords.length; i++) {
+          const newRecord = _updateRecords[i]
+          const invoiceProduct = await invoiceProductRepo.findOne({ domain, id: newRecord.id})
+  
+          const result = await invoiceProductRepo.save({
+            ...invoiceProduct,
+            ...newRecord,
+            updater: user
+          })
+  
+          results.push({ ...result, cuFlag: 'M' })
+        }
+    }
+  
+    return results
+  }
+}
+

package/server/graphql/resolvers/release-good/confirm-release-good.ts

@@ -115,11 +115,9 @@ export async function confirmReleaseGood(name: string, context: any, tx?: Entity
         if (foundMarketplaceProductVariations) {
           await Promise.all(
             foundMarketplaceProductVariations.map(async variation => {
-              if (variation.marketplaceProduct.marketplaceStore.id != matchedMarketplaceStore.id) {
-                variation.reserveQty -= oi.releaseQty
+              variation.reserveQty -= oi.releaseQty
 
-                await tx.getRepository(MarketplaceProductVariation).save(variation)
-              }
+              await tx.getRepository(MarketplaceProductVariation).save(variation)
             })
           )
         }

package/server/graphql/types/index.ts

@@ -7,6 +7,7 @@ import * as DeliveryOrder from './delivery-order'
 import * as GoodsReceivalNote from './goods-receival-note'
 import * as InventoryCheck from './inventory-check'
 import * as Invoice from './invoice'
+import * as InvoiceProduct from './invoice-product'
 import * as JobSheet from './job-sheet'
 import * as Manifest from './manifest'
 import * as OrderInventory from './order-inventory'
@@ -29,6 +30,7 @@ export const queries = [
   RetailReplenishmentOrder.Query,
   TransferOrder.Query,
   Invoice.Query,
+  InvoiceProduct.Query,
   InventoryCheck.Query,
   JobSheet.Query,
   PurchaseOrder.Query,
@@ -58,6 +60,7 @@ export const mutations = [
   RetailReplenishmentOrder.Mutation,
   TransferOrder.Mutation,
   Invoice.Mutation,
+  InvoiceProduct.Mutation,
   InventoryCheck.Mutation,
   JobSheet.Mutation,
   PurchaseOrder.Mutation,
@@ -86,6 +89,7 @@ export const types = [
   ...RetailReplenishmentOrder.Types,
   ...TransferOrder.Types,
   ...Invoice.Types,
+  ...InvoiceProduct.Types,
   ...InventoryCheck.Types,
   ...JobSheet.Types,
   ...PurchaseOrder.Types,

package/server/graphql/types/invoice/invoice-patch.ts

@@ -3,12 +3,45 @@ import gql from 'graphql-tag'
 export const InvoicePatch = gql`
   input InvoicePatch {
     name: String
-    customer: String
+    refNo1: String
+    refNo2: String
+    refNo3: String
     issuedOn: String
+    contactPointRefId: String
+    from: String
+    fromContactPhone: String
+    fromAddress1: String
+    fromAddress2: String
+    fromAddress3: String
+    fromAddress4: String
+    fromAddress5: String
+    fromPostcode: String
+    fromCity: String
+    fromState: String
+    fromCountry: String
+    deliverTo: String
+    deliverToPhone: String
+    deliveryAddress1: String
+    deliveryAddress2: String
+    deliveryAddress3: String
+    deliveryAddress4: String
+    deliveryAddress5: String
+    deliveryCity: String
+    deliveryState: String
+    deliveryCountry: String
+    billTo: String
+    billToPhone: String
+    billingAddress1: String
+    billingAddress2: String
+    billingAddress3: String
+    billingAddress4: String
+    billingAddress5: String
+    billingPostcode: String
+    billingCity: String
+    billingState: String
+    billingCountry: String
     paymentDue: String
-    version: String
-    purchaseOrder: String
-    state: String
-    description: String
+    invoiceProducts: [ObjectRef]
+    releaseGood: ObjectRef
   }
 `

package/server/graphql/types/invoice/invoice.ts

@@ -5,12 +5,46 @@ export const Invoice = gql`
     id: String
     domain: Domain
     name: String
-    customer: Bizplace
+    refNo1: String
+    refNo2: String
+    refNo3: String
     issuedOn: String
+    contactPointRefId: String
+    from: String
+    fromContactPhone: String
+    fromAddress1: String
+    fromAddress2: String
+    fromAddress3: String
+    fromAddress4: String
+    fromAddress5: String
+    fromPostcode: String
+    fromCity: String
+    fromState: String
+    fromCountry: String
+    deliverTo: String
+    deliverToPhone: String
+    deliveryAddress1: String
+    deliveryAddress2: String
+    deliveryAddress3: String
+    deliveryAddress4: String
+    deliveryAddress5: String
+    deliveryCity: String
+    deliveryState: String
+    deliveryCountry: String
+    billTo: String
+    billToPhone: String
+    billingAddress1: String
+    billingAddress2: String
+    billingAddress3: String
+    billingAddress4: String
+    billingAddress5: String
+    billingPostcode: String
+    billingCity: String
+    billingState: String
+    billingCountry: String
     paymentDue: String
-    version: String
-    purchaseOrder: PurchaseOrder
-    state: String
+    invoiceProducts: [InvoiceProduct]
+    releaseGood: ReleaseGood
     description: String
     creator: User
     updater: User