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

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

@@ -0,0 +1,189 @@
+import { Attachment } from '@things-factory/attachment-base'
+import { User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { Domain } from '@things-factory/shell'
+import { TransportDriver, TransportVehicle } from '@things-factory/transport-base'
+import { Field, ID, ObjectType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  OneToMany,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+import { OrderInventory, ReleaseGood, RetailReplenishmentOrder, TransferOrder } from '../'
+
+@Entity()
+@Index('ix_delivery-order_0', (deliveryOrder: DeliveryOrder) => [deliveryOrder.domain, deliveryOrder.name], {
+  unique: true
+})
+@Index('ix_delivery-order_1', (deliveryOrder: DeliveryOrder) => [deliveryOrder.domain, deliveryOrder.bizplace])
+@Index('ix_delivery-order_2', (deliveryOrder: DeliveryOrder) => [deliveryOrder.domain, deliveryOrder.releaseGood])
+@ObjectType()
+export class DeliveryOrder {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain, { nullable: true })
+  domain: Domain
+
+  @RelationId((deliveryOrder: DeliveryOrder) => deliveryOrder.domain)
+  domainId: string
+
+  @ManyToOne(type => Bizplace)
+  @Field(type => Bizplace, { nullable: true })
+  bizplace: Bizplace
+
+  @RelationId((deliveryOrder: DeliveryOrder) => deliveryOrder.bizplace)
+  bizplaceId: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  from: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  to: string
+
+  @Column({ type: 'uuid', nullable: true })
+  @Field({ nullable: true })
+  contactPointRefId: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  truckNo: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  ownCollection: Boolean
+
+  @ManyToOne(type => ReleaseGood)
+  @Field(type => ReleaseGood, { nullable: true })
+  releaseGood: ReleaseGood
+
+  @RelationId((deliveryOrder: DeliveryOrder) => deliveryOrder.releaseGood)
+  releaseGoodId: string
+
+  @ManyToOne(type => TransferOrder)
+  @Field(type => TransferOrder, { nullable: true })
+  transferOrder: TransferOrder
+
+  @RelationId((deliveryOrder: DeliveryOrder) => deliveryOrder.transferOrder)
+  transferOrderId: string
+
+  @ManyToOne(type => RetailReplenishmentOrder)
+  @Field(type => RetailReplenishmentOrder, { nullable: true })
+  retailReplenishmentOrder: RetailReplenishmentOrder
+
+  @RelationId((deliveryOrder: DeliveryOrder) => deliveryOrder.retailReplenishmentOrder)
+  retailReplenishmentOrderId: string
+
+  @OneToMany(type => OrderInventory, orderInventory => orderInventory.deliveryOrder)
+  @Field(type => OrderInventory, { nullable: true })
+  orderInventories: OrderInventory[]
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  looseItem: Boolean
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  deliveryDate: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  deliveryDateTime: Date
+
+  @Column('float', { nullable: true })
+  @Field({ nullable: true })
+  loadWeight: Number
+
+  @ManyToOne(type => TransportDriver)
+  @Field(type => TransportDriver, { nullable: true })
+  transportDriver: TransportDriver
+
+  @RelationId((deliveryOrder: DeliveryOrder) => deliveryOrder.transportDriver)
+  transportDriverId: string
+
+  @ManyToOne(type => TransportVehicle)
+  @Field(type => TransportVehicle, { nullable: true })
+  transportVehicle: TransportVehicle
+
+  @RelationId((deliveryOrder: DeliveryOrder) => deliveryOrder.transportVehicle)
+  transportVehicleId: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  cargoType: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  urgency: Boolean
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  telNo: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  refNo: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  otherDriver: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  palletQty: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  remark: string
+
+  @Column()
+  @Field()
+  status: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  description: string
+
+  @CreateDateColumn()
+  @Field()
+  createdAt: Date
+
+  @UpdateDateColumn()
+  @Field()
+  updatedAt: Date
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  reusablePallet: string
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  creator: User
+
+  @RelationId((deliveryOrder: DeliveryOrder) => deliveryOrder.creator)
+  creatorId: string
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  updater: User
+
+  @RelationId((deliveryOrder: DeliveryOrder) => deliveryOrder.updater)
+  updaterId: string
+
+  @Field(type => [Attachment], { nullable: true })
+  attachments: Attachment[]
+}

package/server/service/delivery-order/index.ts

@@ -0,0 +1,9 @@
+import { DeliveryOrder } from './delivery-order'
+import { DeliveryOrderMutation } from './delivery-order-mutation'
+import { DeliveryOrderQuery } from './delivery-order-query'
+
+export const entities = [DeliveryOrder]
+export const resolvers = [DeliveryOrderQuery, DeliveryOrderMutation]
+
+export * from './delivery-order-mutation'
+export * from './delivery-order-query'

package/server/service/goods-receival-note/goods-receival-note-mutation.ts

@@ -0,0 +1,124 @@
+import { User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { generateId } from '@things-factory/id-rule-base'
+import { Setting } from '@things-factory/setting-base'
+import { Domain } from '@things-factory/shell'
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager, getRepository, In, Repository } from 'typeorm'
+import { ArrivalNotice, NewGoodsReceivalNote } from '../'
+import { GRN_STATUS, ORDER_NUMBER_RULE_TYPE, ORDER_NUMBER_SETTING_KEY } from '../../constants'
+import { OrderNoGenerator } from '../../utils/order-no-generator'
+import { GoodsReceivalNote } from './goods-receival-note'
+
+@Resolver(GoodsReceivalNote)
+export class GoodsReceivalNoteMutation {
+  @Mutation(returns => GoodsReceivalNote)
+  @Directive('@privilege(category: "order_warehouse", privilege: "mutation")')
+  @Directive('@transaction')
+  async generateGoodsReceivalNote(
+    @Ctx() context: any,
+    @Arg('grn', type => NewGoodsReceivalNote, { nullable: true }) grn?: NewGoodsReceivalNote
+  ): Promise<GoodsReceivalNote> {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    return await generateGoodsReceivalNote(grn, domain, user, tx)
+  }
+
+  @Mutation(returns => Boolean)
+  @Directive('@privilege(category: "order_warehouse", privilege: "mutation")')
+  @Directive('@transaction')
+  async deleteGoodsReceivalNote(@Arg('name') name: string, @Ctx() context: any): Promise<boolean> {
+    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+    await tx.getRepository(GoodsReceivalNote).delete({ domain, name })
+    return true
+  }
+
+  @Mutation(returns => Boolean)
+  @Directive('@privilege(category: "order_warehouse", privilege: "mutation")')
+  @Directive('@transaction')
+  async deleteGoodsReceivalNotes(
+    @Arg('names', type => [String]) names: string[],
+    @Ctx() context: any
+  ): Promise<boolean> {
+    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+    await tx.getRepository(GoodsReceivalNote).delete({
+      domain,
+      name: In(names)
+    })
+    return true
+  }
+
+  @Mutation(returns => GoodsReceivalNote)
+  @Directive('@transaction')
+  async receivedGoodsReceivalNote(@Arg('name') name: string, @Ctx() context: any): Promise<GoodsReceivalNote> {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+
+    const goodsReceivalNote = await tx.getRepository(GoodsReceivalNote).findOne({
+      where: { domain, name }
+    })
+
+    return await tx.getRepository(GoodsReceivalNote).save({
+      ...goodsReceivalNote,
+      status: GRN_STATUS.RECEIVED,
+      customerStatus: GRN_STATUS.RECEIVED,
+      updater: user
+    })
+  }
+
+  @Mutation(returns => GoodsReceivalNote)
+  @Directive('@transaction')
+  async sendGoodsReceivalNote(@Arg('name') name: string, @Ctx() context: any): Promise<GoodsReceivalNote> {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+
+    const goodsReceivalNote = await tx.getRepository(GoodsReceivalNote).findOne({
+      where: { domain, name }
+    })
+
+    return await tx.getRepository(GoodsReceivalNote).save({
+      ...goodsReceivalNote,
+      status: GRN_STATUS.SENT,
+      customerStatus: GRN_STATUS.PENDING_RECEIVE,
+      updater: user
+    })
+  }
+}
+
+export async function generateGoodsReceivalNote(
+  grn: { refNo: string; customer: string },
+  domain: Domain,
+  user: User,
+  tx?: EntityManager
+): Promise<GoodsReceivalNote> {
+  // 1. Create grn
+  const grnRepo: Repository<GoodsReceivalNote> =
+    tx?.getRepository(GoodsReceivalNote) || getRepository(GoodsReceivalNote)
+  const bizplaceRepo: Repository<Bizplace> = tx?.getRepository(Bizplace) || getRepository(Bizplace)
+  const ganRepo: Repository<ArrivalNotice> = tx?.getRepository(ArrivalNotice) || getRepository(ArrivalNotice)
+  const settingRepo: Repository<Setting> = tx?.getRepository(Setting) || getRepository(Setting)
+  let orderNo: string = ''
+
+  const bizplace: Bizplace = await bizplaceRepo.findOne({ where: { id: grn.customer } })
+  const arrivalNotice: ArrivalNotice = await ganRepo.findOne({ where: { domain, name: grn.refNo } })
+  const grnNoSetting: Setting = await settingRepo.findOne({
+    where: {
+      domain,
+      name: ORDER_NUMBER_SETTING_KEY.GRN_NUMBER_RULE
+    }
+  })
+
+  if (grnNoSetting) {
+    orderNo = await generateId({ domain, type: ORDER_NUMBER_RULE_TYPE.GRN_NUMBER, seed: {} })
+  } else {
+    orderNo = OrderNoGenerator.goodsReceiveNote()
+  }
+
+  return await grnRepo.save({
+    ...grn,
+    name: orderNo,
+    domain,
+    bizplace,
+    arrivalNotice,
+    status: GRN_STATUS.PENDING_RECEIVE,
+    creator: user,
+    updater: user
+  })
+}

package/server/service/goods-receival-note/goods-receival-note-query.ts

@@ -0,0 +1,98 @@
+import { User } from '@things-factory/auth-base'
+import { Bizplace, getPermittedBizplaceIds } from '@things-factory/biz-base'
+import { convertListParams, Domain, Filter, Pagination, Sorting } from '@things-factory/shell'
+import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { getRepository, In, IsNull } from 'typeorm'
+import { ArrivalNotice, GoodsReceivalNoteList } from '../'
+import { GoodsReceivalNote } from './goods-receival-note'
+
+@Resolver(GoodsReceivalNote)
+export class GoodsReceivalNoteQuery {
+  @Query(returns => GoodsReceivalNoteList)
+  async goodsReceivalNotes(
+    @Ctx() context: any,
+    @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<GoodsReceivalNoteList> {
+    const { domain, user }: { domain: Domain; user: User } = context.state
+
+    const convertedParams = convertListParams({ filters, pagination, sortings })
+
+    const arrivalNoticeParam: any = filters.find((param: any) => param.name === 'arrivalNoticeNo')
+    const arrivalNoticeRefNoParam = filters.find(param => param.name === 'arrivalNoticeRefNo')
+
+    const bizplaceParam = filters.find(param => param.name === 'bizplaceName')
+    if (bizplaceParam) {
+      const foundBizplaces: Bizplace[] = await getRepository(Bizplace).find({
+        where: {
+          ...convertListParams({ filters: [{ ...bizplaceParam, name: 'name' }] }).where
+        }
+      })
+
+      // remove non-column params
+      delete convertedParams.where.bizplaceName
+
+      if (foundBizplaces && foundBizplaces.length) {
+        convertedParams.where.bizplace = In(foundBizplaces.map((foundBizplace: Bizplace) => foundBizplace.id))
+      } else {
+        convertedParams.where.bizplace = IsNull()
+      }
+    } else {
+      convertedParams.where.bizplace = In(await getPermittedBizplaceIds(domain, user))
+      convertedParams.where.domain = domain
+    }
+
+    if (arrivalNoticeParam || arrivalNoticeRefNoParam) {
+      let arrFilters = []
+      if (arrivalNoticeParam) {
+        arrFilters.push({ ...arrivalNoticeParam, name: 'name' })
+      }
+      if (arrivalNoticeRefNoParam) arrFilters.push({ ...arrivalNoticeRefNoParam, name: 'refNo' })
+      const foundArrivalNotices: ArrivalNotice[] = await getRepository(ArrivalNotice).find({
+        ...convertListParams({ filters: arrFilters })
+      })
+
+      // remove non-column params
+      delete convertedParams.where.arrivalNoticeNo
+      delete convertedParams.where.arrivalNoticeRefNo
+
+      if (foundArrivalNotices && foundArrivalNotices.length) {
+        convertedParams.where.arrivalNotice = In(foundArrivalNotices.map((foundAN: ArrivalNotice) => foundAN.id))
+      } else {
+        convertListParams.where.arrivalNotice = IsNull()
+      }
+    }
+
+    let [items, total] = await getRepository(GoodsReceivalNote).findAndCount({
+      ...convertedParams,
+      relations: ['domain', 'arrivalNotice', 'bizplace', 'creator', 'updater']
+    })
+
+    return { items, total }
+  }
+
+  @Query(returns => GoodsReceivalNote)
+  async goodsReceivalNote(@Arg('name') name: string, @Ctx() context: any): Promise<GoodsReceivalNote> {
+    const { domain }: { domain: Domain } = context.state
+    return await getRepository(GoodsReceivalNote).findOne({
+      where: { domain, name },
+      relations: ['domain', 'bizplace', 'bizplace.company', 'arrivalNotice', 'creator', 'updater']
+    })
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() goodsReceivalNote: GoodsReceivalNote): Promise<Domain> {
+    return await getRepository(Domain).findOne(goodsReceivalNote.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() goodsReceivalNote: GoodsReceivalNote): Promise<User> {
+    return await getRepository(User).findOne(goodsReceivalNote.creatorId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() goodsReceivalNote: GoodsReceivalNote): Promise<User> {
+    return await getRepository(User).findOne(goodsReceivalNote.updaterId)
+  }
+}

package/server/service/goods-receival-note/goods-receival-note-types.ts

@@ -0,0 +1,57 @@
+import { ObjectRef } from '@things-factory/shell'
+import { Field, InputType, Int, ObjectType } from 'type-graphql'
+import { GoodsReceivalNote } from './goods-receival-note'
+
+@ObjectType()
+export class GoodsReceivalNoteList {
+  @Field(type => [GoodsReceivalNote], { nullable: true })
+  items: GoodsReceivalNote[]
+
+  @Field(type => Int, { nullable: true })
+  total: number
+}
+
+@InputType()
+export class NewGoodsReceivalNote {
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field({ nullable: true })
+  status: string
+
+  @Field({ nullable: true })
+  refNo: string
+
+  @Field({ nullable: true })
+  customer: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  arrivalNotice: ObjectRef
+}
+
+@InputType()
+export class GoodsReceivalNotePatch {
+  @Field({ nullable: true })
+  id: string
+
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field({ nullable: true })
+  customerStatus: string
+
+  @Field({ nullable: true })
+  status: string
+
+  @Field({ nullable: true })
+  refNo: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  arrivalNotice: ObjectRef
+}

package/server/service/goods-receival-note/goods-receival-note.ts

@@ -0,0 +1,91 @@
+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,
+  CreateDateColumn,
+  Entity,
+  Index,
+  JoinColumn,
+  ManyToOne,
+  OneToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+import { ArrivalNotice } from '../'
+
+@Entity()
+@Index(
+  'ix_goods-receival-note_0',
+  (goodsReceivalNote: GoodsReceivalNote) => [goodsReceivalNote.domain, goodsReceivalNote.name],
+  { unique: true }
+)
+@ObjectType()
+export class GoodsReceivalNote {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain, { nullable: true })
+  domain: Domain
+
+  @RelationId((grn: GoodsReceivalNote) => grn.domain)
+  domainId: string
+
+  @ManyToOne(type => Bizplace)
+  @Field(type => Bizplace, { nullable: true })
+  bizplace: Bizplace
+
+  @RelationId((grn: GoodsReceivalNote) => grn.bizplace)
+  bizplaceId: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column()
+  @Field()
+  refNo: string
+
+  @OneToOne(type => ArrivalNotice)
+  @JoinColumn()
+  @Field(type => ArrivalNotice, { nullable: true })
+  arrivalNotice: ArrivalNotice
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  description: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  customerStatus: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  status: string
+
+  @CreateDateColumn()
+  @Field()
+  createdAt: Date
+
+  @UpdateDateColumn()
+  @Field()
+  updatedAt: Date
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  creator: User
+
+  @RelationId((grn: GoodsReceivalNote) => grn.creator)
+  creatorId: string
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  updater: User
+
+  @RelationId((grn: GoodsReceivalNote) => grn.updater)
+  updaterId: string
+}

package/server/service/goods-receival-note/index.ts

@@ -0,0 +1,9 @@
+import { GoodsReceivalNote } from './goods-receival-note'
+import { GoodsReceivalNoteMutation } from './goods-receival-note-mutation'
+import { GoodsReceivalNoteQuery } from './goods-receival-note-query'
+
+export const entities = [GoodsReceivalNote]
+export const resolvers = [GoodsReceivalNoteQuery, GoodsReceivalNoteMutation]
+
+export * from './goods-receival-note-mutation'
+export * from './goods-receival-note-query'