@things-factory/sales-base 8.0.0-beta.9 → 8.0.0

package/server/service/invoice/invoice.ts

@@ -0,0 +1,230 @@
+import { Field, ID, ObjectType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  JoinColumn,
+  ManyToOne,
+  OneToMany,
+  OneToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+
+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.id], { unique: true })
+@ObjectType()
+export class Invoice {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain, { nullable: true })
+  domain: Domain
+
+  @RelationId((invoice: Invoice) => invoice.domain)
+  domainId: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  description: string
+
+  @OneToMany(type => InvoiceProduct, invoiceProduct => invoiceProduct.invoice)
+  @Field(type => [InvoiceProduct], { nullable: true })
+  invoiceProducts: InvoiceProduct[]
+
+  @OneToOne(type => ReleaseGood, { nullable: true })
+  @Field(type => ReleaseGood, { nullable: true })
+  @JoinColumn()
+  releaseGood: ReleaseGood
+
+  @Column({ default: '' })
+  @Field({ nullable: true })
+  refNo1: string
+
+  @Column({ default: '' })
+  @Field({ nullable: true })
+  refNo2: string
+
+  @Column({ default: '' })
+  @Field({ nullable: true })
+  refNo3: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  issuedOn: Date
+
+  @Column({ type: 'uuid', nullable: true })
+  @Field({ nullable: true })
+  contactPointRefId: string
+
+  @Column()
+  @Field()
+  from: string
+
+  @Column()
+  @Field()
+  fromContactPhone: string
+
+  @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()
+  deliverTo: string
+
+  @Column()
+  @Field()
+  deliverToPhone: string
+
+  @Column()
+  @Field()
+  deliveryAddress1: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  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
+
+  @Field({ nullable: true })
+  paymentDue: string
+
+  @CreateDateColumn()
+  @Field()
+  createdAt: Date
+
+  @UpdateDateColumn()
+  @Field()
+  updatedAt: Date
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  creator: User
+
+  @RelationId((invoice: Invoice) => invoice.creator)
+  creatorId: string
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  updater: User
+
+  @RelationId((invoice: Invoice) => invoice.updater)
+  updaterId: string
+}

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: ResolverContext
+  ): 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: ResolverContext
+  ): Promise<InvoiceProduct> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(InvoiceProduct)
+    const invoiceProduct = await repository.findOne({
+      where: { domain: { id: domain.id }, name }
+    })
+
+    return await repository.save({
+      ...invoiceProduct,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Mutation(returns => Boolean)
+  @Directive('@transaction')
+  async deleteInvoiceProduct(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(InvoiceProduct).delete({ domain: { id: domain.id }, name })
+
+    return true
+  }
+}

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

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

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

@@ -0,0 +1,84 @@
+import { Field, Float, InputType, Int, ObjectType } from 'type-graphql'
+
+import { InvoiceProduct } from './invoice-product'
+
+@ObjectType()
+export class InvoiceProductList {
+  @Field(type => [InvoiceProduct], { nullable: true })
+  items: InvoiceProduct[]
+
+  @Field(type => Int, { nullable: true })
+  total: number
+}
+
+@InputType()
+export class ProductInput {
+  @Field()
+  sku: string
+}
+
+@InputType()
+export class NewInvoiceProduct {
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  sku: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field(type => ProductInput, { nullable: true })
+  product: ProductInput
+
+  @Field(type => Int)
+  qty: number
+
+  @Field(type => Float, { nullable: true })
+  otherCharges: number
+
+  @Field(type => Float)
+  unitPrice: number
+
+  @Field(type => Float)
+  paidPrice: number
+
+  @Field(type => Float, { nullable: true })
+  discount: number
+
+  @Field(type => Float, { nullable: true })
+  shippingFeePaidByCustomer: number
+}
+
+@InputType()
+export class InvoiceProductPatch {
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  sku: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field(type => ProductInput)
+  product: ProductInput
+
+  @Field(type => Int)
+  qty: number
+
+  @Field(type => Float, { nullable: true })
+  otherCharges: number
+
+  @Field(type => Float)
+  unitPrice: number
+
+  @Field(type => Float)
+  paidPrice: number
+
+  @Field(type => Float, { nullable: true })
+  discount: number
+
+  @Field(type => Float, { nullable: true })
+  shippingFeePaidByCustomer: number
+}

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

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

package/server/service/job-sheet/index.ts

@@ -0,0 +1,9 @@
+import { JobSheet } from './job-sheet'
+import { JobSheetMutation } from './job-sheet-mutation'
+import { JobSheetQuery } from './job-sheet-query'
+
+export const entities = [JobSheet]
+export const resolvers = [JobSheetQuery, JobSheetMutation]
+
+export * from './job-sheet-mutation'
+export * from './job-sheet-query'

package/server/service/job-sheet/job-sheet-mutation.ts

@@ -0,0 +1,92 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager, Repository } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain, getRepository } from '@things-factory/shell'
+
+import { ArrivalNotice, ArrivalNoticePatch, JobSheetPatch } from '../'
+import { OrderNoGenerator } from '../../utils/order-no-generator'
+import { JobSheet } from './job-sheet'
+
+@Resolver(JobSheet)
+export class JobSheetMutation {
+  @Directive('@transaction')
+  @Mutation(returns => JobSheet)
+  async generateJobSheet(
+    @Ctx() context: ResolverContext,
+    @Arg('arrivalNotice', type => ArrivalNoticePatch, { nullable: true }) arrivalNotice?: ArrivalNoticePatch
+  ): Promise<JobSheet> {
+    const { domain, user, tx } = context.state
+    return await generateJobSheet(domain, user, arrivalNotice, tx)
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => JobSheet)
+  async updateJobSheet(
+    @Arg('name') name: string,
+    @Arg('patch', type => JobSheetPatch) patch: JobSheetPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<JobSheet> {
+    const { tx, domain, user } = context.state
+
+    const jobSheet = await tx.getRepository(JobSheet).findOne({ where: { domain: { id: domain.id }, name } })
+    if (!jobSheet) throw new Error('No job sheet is found')
+
+    const foundGAN: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
+      where: {
+        domain: { id: domain.id },
+        name: jobSheet.arrivalNoticeRefNo
+      }
+    })
+
+    await tx.getRepository(ArrivalNotice).save({
+      ...foundGAN,
+      ata: patch.ata,
+      updater: user
+    })
+
+    return await tx.getRepository(JobSheet).save({
+      ...jobSheet,
+      containerMtDate: patch?.containerMtDate ? patch.containerMtDate : null,
+      adviseMtDate: patch?.adviseMtDate ? patch.adviseMtDate : null,
+      sumPalletQty: patch?.sumPalletQty ? patch.sumPalletQty : null
+    })
+  }
+}
+
+export async function generateJobSheet(
+  domain: Domain,
+  user: User,
+  arrivalNotice: ArrivalNotice | ArrivalNoticePatch,
+  tx?: EntityManager
+): Promise<JobSheet> {
+  const jobSheetRepo: Repository<JobSheet> = tx?.getRepository(JobSheet) || getRepository(JobSheet)
+
+  let foundJS: JobSheet = null
+  if (arrivalNotice?.refNo) {
+    foundJS = await jobSheetRepo.findOne({
+      where: { domain: { id: domain.id }, name: arrivalNotice.refNo, bizplace: { id: arrivalNotice.bizplace.id } }
+    })
+  }
+
+  let jobName: any = null
+  if (foundJS) {
+    jobName = OrderNoGenerator.jobSheet(domain.name)
+  } else {
+    jobName = arrivalNotice?.refNo
+  }
+
+  // 1. Create job sheet
+  const createdJobSheet: JobSheet = await jobSheetRepo.save({
+    name: jobName ? jobName : OrderNoGenerator.jobSheet(domain.name),
+    domain,
+    bizplace: arrivalNotice.bizplace,
+    containerSize: arrivalNotice?.containerSize ? arrivalNotice.containerSize : null,
+    containerNo: arrivalNotice?.containerNo ? arrivalNotice.containerNo : null,
+    arrivalNoticeRefNo: arrivalNotice.name,
+    creator: user,
+    updater: user
+  })
+
+  return createdJobSheet
+}