@things-factory/sales-base 4.0.0-y.0 → 4.0.0

package/server/service/purchase-order/purchase-order.ts

@@ -0,0 +1,165 @@
+import { User } from '@things-factory/auth-base'
+import { Bizplace, ContactPoint } from '@things-factory/biz-base'
+import { Domain } from '@things-factory/shell'
+import { Location } from '@things-factory/warehouse-base'
+import { Field, ID, ObjectType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  OneToMany,
+  OneToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+import { ArrivalNotice, OrderProduct, PurchaseOrderOtherCharge, PurchaseOrderOtherChargePatch } from '../'
+import { PURCHASE_ORDER_STATUS } from '../../constants'
+
+@Entity()
+@Index('ix_purchase-order_0', (purchaseOrder: PurchaseOrder) => [
+  purchaseOrder.domain,
+  purchaseOrder.bizplace,
+  purchaseOrder.name
+])
+@ObjectType()
+export class PurchaseOrder {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain, { nullable: true })
+  domain: Domain
+
+  @RelationId((purchaseOrder: PurchaseOrder) => purchaseOrder.domain)
+  domainId: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  remark: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  deliveryOrderNo: string
+
+  @Column({ default: PURCHASE_ORDER_STATUS.DRAFT })
+  @Field()
+  status: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  refNo: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  issuedOn: Date
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  etaDate: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  truckNo: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  containerNo: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  containerSize: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  container: boolean
+
+  @Column()
+  @Field()
+  ownTransport: boolean
+
+  @Column()
+  @Field()
+  importCargo: boolean
+
+  @ManyToOne(type => Bizplace)
+  @Field(type => Bizplace, { nullable: true })
+  bizplace: Bizplace
+
+  @RelationId((purchaseOrder: PurchaseOrder) => purchaseOrder.bizplace)
+  bizplaceId: string
+
+  @Column()
+  @Field()
+  currency: string
+
+  @OneToMany(type => OrderProduct, orderProduct => orderProduct.purchaseOrder)
+  @Field(type => [OrderProduct], { nullable: true })
+  orderProducts: OrderProduct[]
+
+  @OneToMany(type => PurchaseOrderOtherCharge, otherCharge => otherCharge.purchaseOrder)
+  @Field(type => PurchaseOrderOtherCharge, { nullable: true })
+  otherCharges: (PurchaseOrderOtherCharge | PurchaseOrderOtherChargePatch)[]
+
+  @ManyToOne(type => ContactPoint)
+  @Field(type => ContactPoint, { nullable: true })
+  supplier: ContactPoint
+
+  @RelationId((purchaseOrder: PurchaseOrder) => purchaseOrder.supplier)
+  supplierId: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  looseItem: boolean
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  approvedOn: Date
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  approvedBy: User
+
+  @RelationId((purchaseOrder: PurchaseOrder) => purchaseOrder.approvedBy)
+  approvedById: string
+
+  @OneToOne(() => ArrivalNotice, arrivalNotice => arrivalNotice.purchaseOrder)
+  @Field(type => ArrivalNotice, { nullable: true })
+  arrivalNotice: ArrivalNotice
+
+  @ManyToOne(type => Location)
+  @Field(type => Location, { nullable: true })
+  bufferLocation: Location
+
+  @RelationId((purchaseOrder: PurchaseOrder) => purchaseOrder.bufferLocation)
+  bufferLocationId: string
+
+  @CreateDateColumn()
+  @Field()
+  createdAt: Date
+
+  @UpdateDateColumn()
+  @Field()
+  updatedAt: Date
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  creator: User
+
+  @RelationId((purchaseOrder: PurchaseOrder) => purchaseOrder.creator)
+  creatorId: string
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  updater: User
+
+  @RelationId((purchaseOrder: PurchaseOrder) => purchaseOrder.updater)
+  updaterId: string
+}

package/server/service/purchase-order-other-charge/index.ts

@@ -0,0 +1,9 @@
+import { PurchaseOrderOtherCharge } from './purchase-order-other-charge'
+import { PurchaseOrderOtherChargeMutation } from './purchase-order-other-charge-mutation'
+import { PurchaseOrderOtherChargeQuery } from './purchase-order-other-charge-query'
+
+export const entities = [PurchaseOrderOtherCharge]
+export const resolvers = [PurchaseOrderOtherChargeQuery, PurchaseOrderOtherChargeMutation]
+
+export * from './purchase-order-other-charge-mutation'
+export * from './purchase-order-other-charge-query'

package/server/service/purchase-order-other-charge/purchase-order-other-charge-mutation.ts

@@ -0,0 +1,31 @@
+import { Domain } from '@things-factory/shell'
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager, In } from 'typeorm'
+import { PurchaseOrderOtherCharge } from './purchase-order-other-charge'
+
+@Resolver(PurchaseOrderOtherCharge)
+export class PurchaseOrderOtherChargeMutation {
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deletePurchaseOrderOtherCharge(@Arg('name') name: string, @Ctx() context: any): Promise<boolean> {
+    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+
+    await tx.getRepository(PurchaseOrderOtherCharge).delete({ domain, name })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deletePurchaseOrderOtherCharges(
+    @Arg('names', type => [String]) names: string[],
+    @Ctx() context: any
+  ): Promise<boolean> {
+    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+
+    await tx.getRepository(PurchaseOrderOtherCharge).delete({
+      domain,
+      name: In(names)
+    })
+    return true
+  }
+}

package/server/service/purchase-order-other-charge/purchase-order-other-charge-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 { PurchaseOrderOtherChargeList } from '../'
+import { PurchaseOrderOtherCharge } from './purchase-order-other-charge'
+
+@Resolver(PurchaseOrderOtherCharge)
+export class PurchaseOrderOtherChargeQuery {
+  @Query(returns => PurchaseOrderOtherChargeList)
+  async purchaseOrderOtherCharges(
+    @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<PurchaseOrderOtherChargeList> {
+    const convertedParams = convertListParams({ filters, pagination, sortings })
+    const [items, total] = await getRepository(PurchaseOrderOtherCharge).findAndCount({
+      ...convertedParams,
+      relations: ['domain', 'creator', 'updater']
+    })
+    return { items, total }
+  }
+
+  @Query(returns => PurchaseOrderOtherCharge)
+  async purchaseOrderOtherCharge(@Ctx() context: any, @Arg('name') name: string): Promise<PurchaseOrderOtherCharge> {
+    const { domain }: { domain: Domain } = context.state
+
+    return await getRepository(PurchaseOrderOtherCharge).findOne({
+      where: { domain, name, relations: ['domain', 'creator', 'updater'] }
+    })
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() purchaseOrderOtherCharge: PurchaseOrderOtherCharge): Promise<Domain> {
+    return await getRepository(Domain).findOne(purchaseOrderOtherCharge.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() purchaseOrderOtherCharge: PurchaseOrderOtherCharge): Promise<User> {
+    return await getRepository(User).findOne(purchaseOrderOtherCharge.creatorId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() purchaseOrderOtherCharge: PurchaseOrderOtherCharge): Promise<User> {
+    return await getRepository(User).findOne(purchaseOrderOtherCharge.updaterId)
+  }
+}

package/server/service/purchase-order-other-charge/purchase-order-other-charge-types.ts

@@ -0,0 +1,44 @@
+import { Field, Float, InputType, Int, ObjectType } from 'type-graphql'
+import { PurchaseOrderOtherCharge } from './purchase-order-other-charge'
+
+@ObjectType()
+export class PurchaseOrderOtherChargeList {
+  @Field(type => [PurchaseOrderOtherCharge], { nullable: true })
+  items: PurchaseOrderOtherCharge[]
+
+  @Field(type => Int, { nullable: true })
+  total: number
+}
+
+@InputType()
+export class NewPurchaseOrderOtherCharge {
+  @Field()
+  name: string
+
+  @Field()
+  totalAmt: number
+
+  @Field({ nullable: true })
+  applyInItems: Boolean
+}
+
+@InputType()
+export class PurchaseOrderOtherChargePatch {
+  @Field({ nullable: true })
+  id: string
+
+  @Field({ nullable: true })
+  name: string
+
+  @Field(type => Float, { nullable: true })
+  totalAmt: number
+
+  @Field({ nullable: true })
+  applyInItems: Boolean
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field({ nullable: true })
+  cuFlag: string
+}

package/server/service/purchase-order-other-charge/purchase-order-other-charge.ts

@@ -0,0 +1,82 @@
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+import { Field, ID, ObjectType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+import { PurchaseOrder } from '../'
+
+@Entity()
+@Index(
+  'ix_purchase_order_other_charge_0',
+  (purchaseOrderOtherCharge: PurchaseOrderOtherCharge) => [
+    purchaseOrderOtherCharge.domain,
+    purchaseOrderOtherCharge.id
+  ],
+  { unique: true }
+)
+@ObjectType()
+export class PurchaseOrderOtherCharge {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain, { nullable: true })
+  domain: Domain
+
+  @RelationId((otherCharge: PurchaseOrderOtherCharge) => otherCharge.domain)
+  domainId: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  description: string
+
+  @ManyToOne(type => PurchaseOrder)
+  @Field(type => PurchaseOrder, { nullable: true })
+  purchaseOrder: PurchaseOrder
+
+  @RelationId((otherCharge: PurchaseOrderOtherCharge) => otherCharge.purchaseOrder)
+  purchaseOrderId: string
+
+  @Column('float', { nullable: true })
+  @Field({ nullable: true })
+  totalAmt: number
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  applyInItems: boolean
+
+  @CreateDateColumn()
+  @Field()
+  createdAt: Date
+
+  @UpdateDateColumn()
+  @Field()
+  updatedAt: Date
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  creator: User
+
+  @RelationId((otherCharge: PurchaseOrderOtherCharge) => otherCharge.creator)
+  creatorId: string
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  updater: User
+
+  @RelationId((otherCharge: PurchaseOrderOtherCharge) => otherCharge.updater)
+  updaterId: string
+}

package/server/service/release-good/index.ts

@@ -0,0 +1,9 @@
+import { ReleaseGood } from './release-good'
+import { ReleaseGoodMutation } from './release-good-mutation'
+import { ReleaseGoodQuery } from './release-good-query'
+
+export const entities = [ReleaseGood]
+export const resolvers = [ReleaseGoodQuery, ReleaseGoodMutation]
+
+export * from './release-good-mutation'
+export * from './release-good-query'