@things-factory/sales-base 8.0.0-beta.0 → 8.0.0-beta.2

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

@@ -1,245 +0,0 @@
-import type { FileUpload } from 'graphql-upload/GraphQLUpload.js'
-import GraphQLUpload from 'graphql-upload/GraphQLUpload.js'
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { In } from 'typeorm'
-
-import { Attachment, createAttachments, deleteAttachment } from '@things-factory/attachment-base'
-import { Bizplace, getMyBizplace, getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { getRepository } from '@things-factory/shell'
-import { TransportDriver, TransportVehicle } from '@things-factory/transport-base'
-
-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: ResolverContext
-  ): Promise<CollectionOrder> {
-    const { tx, domain, user } = context.state
-
-    const collectionOrder = await tx.getRepository(CollectionOrder).findOne({
-      where: {
-        domain: { id: domain.id },
-        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: ResolverContext): Promise<boolean> {
-    const { tx, domain } = context.state
-
-    const foundCO = await tx.getRepository(CollectionOrder).findOne({
-      where: { domain: { id: domain.id }, name }
-    })
-    if (foundCO) {
-      const previousAttachment: Attachment = await tx.getRepository(Attachment).findOne({
-        where: { domain: { id: domain.id }, refBy: foundCO.id }
-      })
-      if (previousAttachment) await deleteAttachment(null, { id: previousAttachment.id }, context)
-      await tx.getRepository(CollectionOrder).delete({ domain: { id: domain.id }, 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: ResolverContext
-  ): Promise<CollectionOrder> {
-    const { tx, domain, 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: { id: domain.id }, name: collectionOrder.refNo }
-      }),
-      status: ORDER_STATUS.PENDING,
-      creator: user,
-      updater: user
-    })
-
-    // 2. Create attachment
-    if (!attachments) return createdCollectionOrder
-
-    attachments = attachments.map(attachment => {
-      return {
-        refType: 'ORDER',
-        refBy: createdCollectionOrder.id,
-        file: attachment,
-        category: 'ORDER' /* TODO use refType */
-      }
-    })
-    await createAttachments(null, { attachments }, context)
-
-    return createdCollectionOrder
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => CollectionOrder)
-  async confirmCollectionOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<CollectionOrder> {
-    const { tx, domain, user } = context.state
-
-    const foundCollectionOrder: CollectionOrder = await tx.getRepository(CollectionOrder).findOne({
-      where: { domain: { id: domain.id }, 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: ResolverContext): Promise<CollectionOrder> {
-    try {
-      const { tx, domain, user } = context.state
-
-      const collectionOrder: CollectionOrder = await tx.getRepository(CollectionOrder).findOne({
-        where: { domain: { id: domain.id }, 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: ResolverContext,
-    @Arg('name') name: string,
-    @Arg('patch', type => CollectionOrderPatch, { nullable: true }) patch?: CollectionOrderPatch
-  ): Promise<CollectionOrder> {
-    try {
-      const { tx, domain, user } = context.state
-
-      const collectionOrder: CollectionOrder = await tx.getRepository(CollectionOrder).findOne({
-        where: { domain: { id: domain.id }, 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: ResolverContext,
-    @Arg('orderInfo', type => CollectionOrderPatch, { nullable: true }) orderInfo?: CollectionOrderPatch
-  ): Promise<CollectionOrder> {
-    try {
-      const { tx, domain, user } = context.state
-
-      const foundCollectionOrder: CollectionOrder = await tx.getRepository(CollectionOrder).findOne({
-        where: { domain: { id: domain.id }, 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).findOneBy({
-          domain: { id: domain.id },
-          id: foundCollectionOrder.transportDriver.id
-        }),
-        transportVehicle: await tx.getRepository(TransportVehicle).findOneBy({
-          domain: { id: domain.id },
-          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: ResolverContext
-  ): Promise<CollectionOrder> {
-    try {
-      const { tx, domain, user } = context.state
-
-      const collectionOrder: CollectionOrder = await tx.getRepository(CollectionOrder).findOne({
-        where: { domain: { id: domain.id }, 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

@@ -1,97 +0,0 @@
-import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { In, Not } from 'typeorm'
-
-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, getRepository, Pagination, Sorting } from '@things-factory/shell'
-
-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: ResolverContext): Promise<CollectionOrder> {
-    const { domain, user } = context.state
-
-    const foundCO = await getRepository(CollectionOrder).findOne({
-      where: {
-        domain: { id: domain.id },
-        name,
-        bizplace: In(await getPermittedBizplaceIds(domain, user))
-      },
-      relations: ['domain', 'bizplace', 'arrivalNotice', 'transportDriver', 'transportVehicle', 'creator', 'updater']
-    })
-
-    const foundAttachments = await getRepository(Attachment).find({
-      where: {
-        domain: { id: domain.id },
-        refBy: foundCO.id
-      }
-    })
-
-    return { ...foundCO, attachments: foundAttachments }
-  }
-
-  @Query(returns => CollectionOrderList)
-  async collectionOrders(
-    @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<CollectionOrderList> {
-    const { domain, 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: 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<CollectionOrderList> {
-    const { domain, 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 as any).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).findOneBy({ id: collectionOrder.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() collectionOrder: CollectionOrder): Promise<User> {
-    return await getRepository(User).findOneBy({ id: collectionOrder.creatorId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() collectionOrder: CollectionOrder): Promise<User> {
-    return await getRepository(User).findOneBy({ id: collectionOrder.updaterId })
-  }
-}

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

@@ -1,165 +0,0 @@
-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

@@ -1,135 +0,0 @@
-import { Attachment } from '@things-factory/attachment-base'
-import { User } from '@things-factory/auth-base'
-import { Bizplace } from '@things-factory/biz-base'
-import { Domain, roundTransformer } 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, transformer: roundTransformer })
-  @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

@@ -1,9 +0,0 @@
-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]
-
-export * from './collection-order-mutation'
-export * from './collection-order-query'