@things-factory/sales-base 3.8.27 → 3.8.31

package/server/entities/index.ts

@@ -1,4 +1,3 @@
-import { Manifest } from './manifest'
 import { ArrivalNotice } from './arrival-notice'
 import { Claim } from './claim'
 import { ClaimDetail } from './claim-detail'
@@ -8,7 +7,9 @@ import { DeliveryOrder } from './delivery-order'
 import { GoodsReceivalNote } from './goods-receival-note'
 import { InventoryCheck } from './inventory-check'
 import { Invoice } from './invoice'
+import { InvoiceProduct } from './invoice-product'
 import { JobSheet } from './job-sheet'
+import { Manifest } from './manifest'
 import { OrderInventory } from './order-inventory'
 import { OrderProduct } from './order-product'
 import { OrderReverseKitting } from './order-reverse-kitting'
@@ -25,7 +26,8 @@ import { Vas } from './vas'
 import { VasOrder } from './vas-order'
 
 export const entities = [
-	Manifest,
+  InvoiceProduct,
+  Manifest,
   PurchaseOrderOtherCharge,
   ArrivalNotice,
   OrderProduct,
@@ -53,7 +55,6 @@ export const entities = [
 ]
 
 export {
-	Manifest,
   ArrivalNotice,
   Claim,
   ClaimDetail,
@@ -63,7 +64,9 @@ export {
   GoodsReceivalNote,
   InventoryCheck,
   Invoice,
+  InvoiceProduct,
   JobSheet,
+  Manifest,
   OrderInventory,
   OrderProduct,
   OrderReverseKitting,

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

@@ -39,26 +39,25 @@ export async function confirmReleaseGood(name: string, context: any, tx?: Entity
 
   let foundReleaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
     where: { name, status: ORDER_STATUS.PENDING },
-    relations: [
-      'domain',
-      'bizplace',
-      'bizplace.domain',
-      'bizplace.company',
-      'bizplace.company.domain',
-      'orderProducts',
-      'orderProducts.product',
-      'orderProducts.product.productDetails',
-      'orderInventories',
-      'orderInventories.product',
-      'orderVass'
-    ]
+    relations: ['domain', 'bizplace', 'bizplace.domain', 'bizplace.company', 'bizplace.company.domain', 'orderVass']
   })
 
   if (!foundReleaseGood) throw new Error(`Release good order doesn't exists.`)
-  let foundOIs: OrderInventory[] = foundReleaseGood.orderInventories
+
+  // query orderInventories separately from releaseGood to reduce resource usage
+  let foundOIs: OrderInventory[] = await tx.getRepository(OrderInventory).find({
+    where: { domain, releaseGood: foundReleaseGood },
+    relations: ['product']
+  })
+
+  // query orderProducts separately from releaseGood to reduce resource usage
+  let foundOPs: OrderProduct[] = await tx.getRepository(OrderProduct).find({
+    where: { domain, releaseGood: foundReleaseGood },
+    relations: ['product', 'product.productDetails']
+  })
+
   let foundBundleInfo: any[] = JSON.parse(foundReleaseGood.bundleInfo)
   let foundOVs: OrderVas[] = foundReleaseGood.orderVass
-  let foundOPs: OrderProduct[] = foundReleaseGood.orderProducts
   let customerBizplace: Bizplace = foundReleaseGood.bizplace
   const companyDomain: Domain = customerBizplace?.company.domain
   const sellercraft: Sellercraft = await tx
@@ -68,7 +67,7 @@ export async function confirmReleaseGood(name: string, context: any, tx?: Entity
   if (foundReleaseGood.type == 'b2c') {
     if (sellercraft) {
       const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
-      foundReleaseGood = await sellercraftCtrl.packOrder(sellercraft, foundReleaseGood)
+      foundReleaseGood = await sellercraftCtrl.packOrder(sellercraft, { ...foundReleaseGood, orderProducts: foundOPs })
     } else {
       // find for any existing marketplace store connections
       let marketplaceStores: MarketplaceStore[] = await tx.getRepository(MarketplaceStore).find({
@@ -115,11 +114,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,