@things-factory/sales-base 4.0.0-alpha.6 → 4.0.0-beta.0

package/server/service/collection-order/collection-order-mutation.ts

@@ -0,0 +1,238 @@
+import { Attachment, createAttachments, deleteAttachment } from '@things-factory/attachment-base'
+import { User } from '@things-factory/auth-base'
+import { Bizplace, getMyBizplace, getPermittedBizplaceIds } from '@things-factory/biz-base'
+import { Domain } from '@things-factory/shell'
+import { TransportDriver, TransportVehicle } from '@things-factory/transport-base'
+import { FileUpload, GraphQLUpload } from 'graphql-upload'
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager, getRepository, In } from 'typeorm'
+import { ArrivalNotice, CollectionOrderPatch, GenerateCollectionOrder } from '../'
+import { ORDER_STATUS } from '../../constants'
+import { OrderNoGenerator } from '../../utils'
+import { CollectionOrder } from './collection-order'
+
+@Resolver(CollectionOrder)
+export class CollectionOrderMutation {
+  @Directive('@transaction')
+  @Mutation(returns => CollectionOrder)
+  async updateCollectionOrder(
+    @Arg('name') name: string,
+    @Arg('patch', type => CollectionOrderPatch) patch: CollectionOrderPatch,
+    @Ctx() context: any
+  ): Promise<CollectionOrder> {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+
+    const collectionOrder = await tx.getRepository(CollectionOrder).findOne({
+      where: {
+        domain,
+        name,
+        bizplace: In(await getPermittedBizplaceIds(domain, user))
+      }
+    })
+
+    return await tx.getRepository(CollectionOrder).save({
+      ...collectionOrder,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteCollectionOrder(@Arg('name') name: string, @Ctx() context: any): Promise<boolean> {
+    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+
+    const foundCO = await tx.getRepository(CollectionOrder).findOne({
+      where: { domain, name }
+    })
+    if (foundCO) {
+      const previousAttachment: Attachment = await tx.getRepository(Attachment).findOne({
+        where: { domain, refBy: foundCO.id }
+      })
+      if (previousAttachment) await deleteAttachment(null, { id: previousAttachment.id }, context)
+      await tx.getRepository(CollectionOrder).delete({ domain, name })
+    }
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => CollectionOrder)
+  async generateCollectionOrder(
+    @Arg('collectionOrder', type => GenerateCollectionOrder) collectionOrder: GenerateCollectionOrder,
+    @Arg('attachments', type => [GraphQLUpload], { nullable: true }) attachments: FileUpload[],
+    @Ctx() context: any
+  ): Promise<CollectionOrder> {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+
+    const myBizplace: Bizplace = await getMyBizplace(domain, user)
+    // 1. Create collection order
+    const createdCollectionOrder: CollectionOrder = await tx.getRepository(CollectionOrder).save({
+      ...collectionOrder,
+      domain,
+      bizplace: myBizplace,
+      arrivalNotice: await tx.getRepository(ArrivalNotice).findOne({
+        where: { domain, name: collectionOrder.refNo }
+      }),
+      status: ORDER_STATUS.PENDING,
+      creator: user,
+      updater: user
+    })
+
+    // 2. Create attachment
+    if (!attachments) return createdCollectionOrder
+
+    attachments = attachments.map(attachment => {
+      return { refBy: createdCollectionOrder.id, file: attachment, category: 'ORDER' }
+    })
+    await createAttachments(null, { attachments }, context)
+
+    return createdCollectionOrder
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => CollectionOrder)
+  async confirmCollectionOrder(@Arg('name') name: string, @Ctx() context: any): Promise<CollectionOrder> {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+
+    const foundCollectionOrder: CollectionOrder = await tx.getRepository(CollectionOrder).findOne({
+      where: { domain, name },
+      relations: ['creator', 'updater']
+    })
+
+    let collectionOrder: CollectionOrder
+    if (!foundCollectionOrder) throw new Error(`Collection Order doesn't exists.`)
+    if (foundCollectionOrder.status !== ORDER_STATUS.PENDING) throw new Error('Not confirmable status.')
+
+    // Collection Order Status change (PENDING => PENDING_RECEIVE)
+    collectionOrder = await tx.getRepository(CollectionOrder).save({
+      ...foundCollectionOrder,
+      status: ORDER_STATUS.PENDING_RECEIVE,
+      updater: user
+    })
+
+    return collectionOrder
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => CollectionOrder)
+  async receiveCollectionOrder(@Arg('name') name: string, @Ctx() context: any): Promise<CollectionOrder> {
+    try {
+      const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+
+      const collectionOrder: CollectionOrder = await tx.getRepository(CollectionOrder).findOne({
+        where: { domain, name }
+      })
+
+      if (!collectionOrder) throw new Error(`Collection order doesn't exists.`)
+      if (collectionOrder.status !== ORDER_STATUS.PENDING_RECEIVE) throw new Error(`Status is not receivable.`)
+
+      await tx.getRepository(CollectionOrder).save({
+        ...collectionOrder,
+        status: ORDER_STATUS.READY_TO_DISPATCH,
+        updater: user
+      })
+
+      return collectionOrder
+    } catch (e) {
+      throw e
+    }
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => CollectionOrder)
+  async checkCollectedOrder(
+    @Ctx() context: any,
+    @Arg('name') name: string,
+    @Arg('patch', type => CollectionOrderPatch, { nullable: true }) patch?: CollectionOrderPatch
+  ): Promise<CollectionOrder> {
+    try {
+      const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+
+      const collectionOrder: CollectionOrder = await tx.getRepository(CollectionOrder).findOne({
+        where: { domain, name }
+      })
+
+      if (!collectionOrder) throw new Error(`Collection order doesn't exists.`)
+      if (collectionOrder.status !== ORDER_STATUS.COLLECTING) throw new Error(`Status is not receivable.`)
+
+      await getRepository(CollectionOrder).save({
+        ...collectionOrder,
+        ...patch,
+        status: ORDER_STATUS.DONE,
+        updater: user
+      })
+
+      return collectionOrder
+    } catch (e) {
+      throw e
+    }
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => CollectionOrder)
+  async dispatchCollectionOrder(
+    @Ctx() context: any,
+    @Arg('orderInfo', type => CollectionOrderPatch, { nullable: true }) orderInfo?: CollectionOrderPatch
+  ): Promise<CollectionOrder> {
+    try {
+      const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+
+      const foundCollectionOrder: CollectionOrder = await tx.getRepository(CollectionOrder).findOne({
+        where: { domain, name: orderInfo.name }
+      })
+
+      if (!foundCollectionOrder) throw new Error(`Collection order doesn't exists.`)
+      if (foundCollectionOrder.status !== ORDER_STATUS.READY_TO_DISPATCH) throw new Error(`Status is not receivable.`)
+
+      await tx.getRepository(CollectionOrder).save({
+        ...foundCollectionOrder,
+        name: OrderNoGenerator.collectionOrder(),
+        transportDriver: await tx.getRepository(TransportDriver).findOne({
+          domain,
+          id: foundCollectionOrder.transportDriver.id
+        }),
+        transportVehicle: await tx.getRepository(TransportVehicle).findOne({
+          domain,
+          id: foundCollectionOrder.transportVehicle.id
+        }),
+        status: ORDER_STATUS.COLLECTING,
+        updater: user
+      })
+
+      return foundCollectionOrder
+    } catch (e) {
+      throw e
+    }
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => CollectionOrder)
+  async rejectCollectionOrder(
+    @Arg('name') name: string,
+    @Arg('patch', type => CollectionOrderPatch) patch: CollectionOrderPatch,
+    @Ctx() context: any
+  ): Promise<CollectionOrder> {
+    try {
+      const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+
+      const collectionOrder: CollectionOrder = await tx.getRepository(CollectionOrder).findOne({
+        where: { domain, name }
+      })
+
+      if (!collectionOrder) throw new Error(`Collection order doesn't exists.`)
+      if (!patch.remark) throw new Error('Remark is not exist.')
+      if (collectionOrder.status !== ORDER_STATUS.PENDING_RECEIVE) throw new Error(`Status is not receivable.`)
+
+      await tx.getRepository(CollectionOrder).save({
+        ...collectionOrder,
+        ...patch,
+        status: ORDER_STATUS.REJECTED,
+        updater: user
+      })
+
+      return collectionOrder
+    } catch (e) {
+      throw e
+    }
+  }
+}

package/server/service/collection-order/collection-order-query.ts

@@ -0,0 +1,94 @@
+import { Attachment } from '@things-factory/attachment-base'
+import { User } from '@things-factory/auth-base'
+import { 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, Not } from 'typeorm'
+import { CollectionOrderList } from '../'
+import { ORDER_STATUS } from '../../constants'
+import { CollectionOrder } from './collection-order'
+
+@Resolver(CollectionOrder)
+export class CollectionOrderQuery {
+  @Query(returns => CollectionOrder)
+  async collectionOrder(@Arg('name') name: string, @Ctx() context: any): Promise<CollectionOrder> {
+    const { domain, user }: { domain: Domain; user: User } = context.state
+
+    const foundCO = await getRepository(CollectionOrder).findOne({
+      where: {
+        domain,
+        name,
+        bizplace: In(await getPermittedBizplaceIds(domain, user))
+      },
+      relations: ['domain', 'bizplace', 'arrivalNotice', 'transportDriver', 'transportVehicle', 'creator', 'updater']
+    })
+
+    const foundAttachments = await getRepository(Attachment).find({
+      where: {
+        domain,
+        refBy: foundCO.id
+      }
+    })
+
+    return { ...foundCO, attachments: foundAttachments }
+  }
+
+  @Query(returns => CollectionOrderList)
+  async collectionOrders(
+    @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<CollectionOrderList> {
+    const { domain, user }: { domain: Domain; user: User } = context.state
+
+    const convertedParams = convertListParams({ filters, pagination, sortings })
+    convertedParams.where.bizplace = In(await getPermittedBizplaceIds(domain, user))
+
+    const [items, total] = await getRepository(CollectionOrder).findAndCount({
+      ...convertedParams,
+      relations: ['domain', 'bizplace', 'arrivalNotice', 'transportDriver', 'transportVehicle', 'creator', 'updater']
+    })
+
+    return { items, total }
+  }
+
+  @Query(returns => CollectionOrderList)
+  async collectionOrderRequests(
+    @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<CollectionOrderList> {
+    const { domain, user }: { domain: Domain; user: User } = context.state
+
+    const convertedParams = convertListParams({ filters, pagination, sortings })
+
+    if (!convertedParams.where || !convertedParams.where.status) {
+      convertedParams.where.status = Not(In([ORDER_STATUS.PENDING, ORDER_STATUS.EDITING]))
+    }
+    convertedParams.bizplace = In(await getPermittedBizplaceIds(domain, user))
+
+    const [items, total] = await getRepository(CollectionOrder).findAndCount({
+      ...convertedParams,
+      relations: ['domain', 'bizplace', 'arrivalNotice', 'transportDriver', 'transportVehicle', 'creator', 'updater']
+    })
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() collectionOrder: CollectionOrder): Promise<Domain> {
+    return await getRepository(Domain).findOne(collectionOrder.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() collectionOrder: CollectionOrder): Promise<User> {
+    return await getRepository(User).findOne(collectionOrder.creatorId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() collectionOrder: CollectionOrder): Promise<User> {
+    return await getRepository(User).findOne(collectionOrder.updaterId)
+  }
+}

package/server/service/collection-order/collection-order-types.ts

@@ -0,0 +1,165 @@
+import { ObjectRef } from '@things-factory/shell'
+import { Field, Float, ID, InputType, Int, ObjectType } from 'type-graphql'
+import { CollectionOrder } from './collection-order'
+
+@ObjectType()
+export class CollectionOrderList {
+  @Field(type => [CollectionOrder], { nullable: true })
+  items: CollectionOrder[]
+
+  @Field(type => Int, { nullable: true })
+  total: number
+}
+
+@InputType()
+export class NewCollectionOrder {
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field({ nullable: true })
+  from: string
+
+  @Field({ nullable: true })
+  to: string
+
+  @Field({ nullable: true })
+  truckNo: string
+
+  @Field({ nullable: true })
+  refNo: string
+
+  @Field({ nullable: true })
+  telNo: string
+
+  @Field(type => Float, { nullable: true })
+  loadWeight: number
+
+  @Field({ nullable: true })
+  urgency: Boolean
+
+  @Field({ nullable: true })
+  cargoType: string
+
+  @Field({ nullable: true })
+  looseItem: Boolean
+
+  @Field(type => ObjectRef, { nullable: true })
+  arrivalNotice: ObjectRef
+
+  @Field({ nullable: true })
+  collectionDateTime: string
+
+  @Field()
+  collectionDate: string
+
+  @Field({ nullable: true })
+  status: string
+}
+
+@InputType()
+export class GenerateCollectionOrder {
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field({ nullable: true })
+  from: string
+
+  @Field({ nullable: true })
+  to: string
+
+  @Field({ nullable: true })
+  truckNo: string
+
+  @Field({ nullable: true })
+  refNo: string
+
+  @Field({ nullable: true })
+  telNo: string
+
+  @Field(type => Float, { nullable: true })
+  loadWeight: number
+
+  @Field({ nullable: true })
+  looseItem: Boolean
+
+  @Field({ nullable: true })
+  urgency: Boolean
+
+  @Field({ nullable: true })
+  cargoType: string
+
+  @Field({ nullable: true })
+  collectionDateTime: string
+
+  @Field()
+  collectionDate: string
+
+  @Field({ nullable: true })
+  status: string
+}
+
+@InputType()
+export class CollectionOrderPatch {
+  @Field(type => ID, { nullable: true })
+  id: string
+
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field({ nullable: true })
+  from: string
+
+  @Field({ nullable: true })
+  to: string
+
+  @Field({ nullable: true })
+  refNo: string
+
+  @Field(type => Float, { nullable: true })
+  loadWeight: number
+
+  @Field({ nullable: true })
+  urgency: Boolean
+
+  @Field({ nullable: true })
+  looseItem: Boolean
+
+  @Field({ nullable: true })
+  cargoType: string
+
+  @Field({ nullable: true })
+  collectionDateTime: string
+
+  @Field({ nullable: true })
+  collectionDate: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  arrivalNotice: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  transportDriver: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  transportVehicle: ObjectRef
+
+  @Field({ nullable: true })
+  telNo: string
+
+  @Field({ nullable: true })
+  remark: string
+
+  @Field({ nullable: true })
+  truckNo: string
+
+  @Field({ nullable: true })
+  status: string
+}

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

@@ -0,0 +1,146 @@
+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, ObjectType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  JoinColumn,
+  ManyToOne,
+  OneToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+import { ArrivalNotice } from '../'
+
+@Entity()
+@Index('ix_collection-order_0', (collectionOrder: CollectionOrder) => [collectionOrder.domain, collectionOrder.name], {
+  unique: true
+})
+@ObjectType()
+export class CollectionOrder {
+  @PrimaryGeneratedColumn('uuid')
+  @Field()
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain, { nullable: true })
+  domain: Domain
+
+  @RelationId((collectionOrder: CollectionOrder) => collectionOrder.domain)
+  domainId: string
+
+  @ManyToOne(type => Bizplace)
+  @Field(type => Bizplace, { nullable: true })
+  bizplace: Bizplace
+
+  @RelationId((collectionOrder: CollectionOrder) => collectionOrder.bizplace)
+  bizplaceId: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  from: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  to: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  collectionDateTime: Date
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  collectionDate: string
+
+  @Column('float', { nullable: true })
+  @Field({ nullable: true })
+  loadWeight: Number
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  cargoType: string
+
+  @OneToOne(type => TransportDriver)
+  @JoinColumn()
+  @Field(type => TransportDriver, { nullable: true })
+  transportDriver: TransportDriver
+
+  @OneToOne(type => TransportVehicle)
+  @JoinColumn()
+  @Field(type => TransportVehicle, { nullable: true })
+  transportVehicle: TransportVehicle
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  urgency: Boolean
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  looseItem: Boolean
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  refNo: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  truckNo: string
+
+  @ManyToOne(type => ArrivalNotice)
+  @Field(type => ArrivalNotice, { nullable: true })
+  arrivalNotice: ArrivalNotice
+
+  @RelationId((collectionOrder: CollectionOrder) => collectionOrder.arrivalNotice)
+  arrivalNoticeId: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  telNo: 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
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  creator: User
+
+  @RelationId((collectionOrder: CollectionOrder) => collectionOrder.creator)
+  creatorId: string
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  updater: User
+
+  @RelationId((collectionOrder: CollectionOrder) => collectionOrder.updater)
+  updaterId: string
+
+  @Field(type => Attachment, { nullable: true })
+  attachments: Attachment[]
+}

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

@@ -0,0 +1,6 @@
+import { CollectionOrder } from './collection-order'
+import { CollectionOrderMutation } from './collection-order-mutation'
+import { CollectionOrderQuery } from './collection-order-query'
+
+export const entities = [CollectionOrder]
+export const resolvers = [CollectionOrderQuery, CollectionOrderMutation]