@things-factory/sales-base 5.0.13 → 6.0.0-alpha.1

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

@@ -1,12 +1,11 @@
 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 { EntityManager, getRepository, In } from 'typeorm'
+import { In } from 'typeorm'
 
 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 { getRepository } from '@things-factory/shell'
 import { TransportDriver, TransportVehicle } from '@things-factory/transport-base'
 
 import { ArrivalNotice, CollectionOrderPatch, GenerateCollectionOrder } from '../'
@@ -21,13 +20,13 @@ export class CollectionOrderMutation {
   async updateCollectionOrder(
     @Arg('name') name: string,
     @Arg('patch', type => CollectionOrderPatch) patch: CollectionOrderPatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<CollectionOrder> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    const { tx, domain, user } = context.state
 
     const collectionOrder = await tx.getRepository(CollectionOrder).findOne({
       where: {
-        domain,
+        domain: { id: domain.id },
         name,
         bizplace: In(await getPermittedBizplaceIds(domain, user))
       }
@@ -42,15 +41,15 @@ export class CollectionOrderMutation {
 
   @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
+  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, name }
+      where: { domain: { id: domain.id }, name }
     })
     if (foundCO) {
       const previousAttachment: Attachment = await tx.getRepository(Attachment).findOne({
-        where: { domain, refBy: foundCO.id }
+        where: { domain: { id: domain.id }, refBy: foundCO.id }
       })
       if (previousAttachment) await deleteAttachment(null, { id: previousAttachment.id }, context)
       await tx.getRepository(CollectionOrder).delete({ domain, name })
@@ -63,9 +62,9 @@ export class CollectionOrderMutation {
   async generateCollectionOrder(
     @Arg('collectionOrder', type => GenerateCollectionOrder) collectionOrder: GenerateCollectionOrder,
     @Arg('attachments', type => [GraphQLUpload], { nullable: true }) attachments: FileUpload[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<CollectionOrder> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    const { tx, domain, user } = context.state
 
     const myBizplace: Bizplace = await getMyBizplace(domain, user)
     // 1. Create collection order
@@ -74,7 +73,7 @@ export class CollectionOrderMutation {
       domain,
       bizplace: myBizplace,
       arrivalNotice: await tx.getRepository(ArrivalNotice).findOne({
-        where: { domain, name: collectionOrder.refNo }
+        where: { domain: { id: domain.id }, name: collectionOrder.refNo }
       }),
       status: ORDER_STATUS.PENDING,
       creator: user,
@@ -99,11 +98,11 @@ export class CollectionOrderMutation {
 
   @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
+  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, name },
+      where: { domain: { id: domain.id }, name },
       relations: ['creator', 'updater']
     })
 
@@ -123,12 +122,12 @@ export class CollectionOrderMutation {
 
   @Directive('@transaction')
   @Mutation(returns => CollectionOrder)
-  async receiveCollectionOrder(@Arg('name') name: string, @Ctx() context: any): Promise<CollectionOrder> {
+  async receiveCollectionOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<CollectionOrder> {
     try {
-      const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+      const { tx, domain, user } = context.state
 
       const collectionOrder: CollectionOrder = await tx.getRepository(CollectionOrder).findOne({
-        where: { domain, name }
+        where: { domain: { id: domain.id }, name }
       })
 
       if (!collectionOrder) throw new Error(`Collection order doesn't exists.`)
@@ -149,15 +148,15 @@ export class CollectionOrderMutation {
   @Directive('@transaction')
   @Mutation(returns => CollectionOrder)
   async checkCollectedOrder(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @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 { tx, domain, user } = context.state
 
       const collectionOrder: CollectionOrder = await tx.getRepository(CollectionOrder).findOne({
-        where: { domain, name }
+        where: { domain: { id: domain.id }, name }
       })
 
       if (!collectionOrder) throw new Error(`Collection order doesn't exists.`)
@@ -179,14 +178,14 @@ export class CollectionOrderMutation {
   @Directive('@transaction')
   @Mutation(returns => CollectionOrder)
   async dispatchCollectionOrder(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @Arg('orderInfo', type => CollectionOrderPatch, { nullable: true }) orderInfo?: CollectionOrderPatch
   ): Promise<CollectionOrder> {
     try {
-      const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+      const { tx, domain, user } = context.state
 
       const foundCollectionOrder: CollectionOrder = await tx.getRepository(CollectionOrder).findOne({
-        where: { domain, name: orderInfo.name }
+        where: { domain: { id: domain.id }, name: orderInfo.name }
       })
 
       if (!foundCollectionOrder) throw new Error(`Collection order doesn't exists.`)
@@ -195,12 +194,12 @@ export class CollectionOrderMutation {
       await tx.getRepository(CollectionOrder).save({
         ...foundCollectionOrder,
         name: OrderNoGenerator.collectionOrder(),
-        transportDriver: await tx.getRepository(TransportDriver).findOne({
-          domain,
+        transportDriver: await tx.getRepository(TransportDriver).findOneBy({
+          domain: { id: domain.id },
           id: foundCollectionOrder.transportDriver.id
         }),
-        transportVehicle: await tx.getRepository(TransportVehicle).findOne({
-          domain,
+        transportVehicle: await tx.getRepository(TransportVehicle).findOneBy({
+          domain: { id: domain.id },
           id: foundCollectionOrder.transportVehicle.id
         }),
         status: ORDER_STATUS.COLLECTING,
@@ -218,13 +217,13 @@ export class CollectionOrderMutation {
   async rejectCollectionOrder(
     @Arg('name') name: string,
     @Arg('patch', type => CollectionOrderPatch) patch: CollectionOrderPatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<CollectionOrder> {
     try {
-      const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+      const { tx, domain, user } = context.state
 
       const collectionOrder: CollectionOrder = await tx.getRepository(CollectionOrder).findOne({
-        where: { domain, name }
+        where: { domain: { id: domain.id }, name }
       })
 
       if (!collectionOrder) throw new Error(`Collection order doesn't exists.`)

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

@@ -1,9 +1,11 @@
+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, Pagination, Sorting } from '@things-factory/shell'
-import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository, In, Not } from 'typeorm'
+import { convertListParams, Domain, Filter, getRepository, Pagination, Sorting } from '@things-factory/shell'
+
 import { CollectionOrderList } from '../'
 import { ORDER_STATUS } from '../../constants'
 import { CollectionOrder } from './collection-order'
@@ -11,12 +13,12 @@ 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
+  async collectionOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<CollectionOrder> {
+    const { domain, user } = context.state
 
     const foundCO = await getRepository(CollectionOrder).findOne({
       where: {
-        domain,
+        domain: { id: domain.id },
         name,
         bizplace: In(await getPermittedBizplaceIds(domain, user))
       },
@@ -25,7 +27,7 @@ export class CollectionOrderQuery {
 
     const foundAttachments = await getRepository(Attachment).find({
       where: {
-        domain,
+        domain: { id: domain.id },
         refBy: foundCO.id
       }
     })
@@ -35,12 +37,12 @@ export class CollectionOrderQuery {
 
   @Query(returns => CollectionOrderList)
   async collectionOrders(
-    @Ctx() context: any,
+    @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 }: { domain: Domain; user: User } = context.state
+    const { domain, user } = context.state
 
     const convertedParams = convertListParams({ filters, pagination, sortings })
     convertedParams.where.bizplace = In(await getPermittedBizplaceIds(domain, user))
@@ -55,19 +57,20 @@ export class CollectionOrderQuery {
 
   @Query(returns => CollectionOrderList)
   async collectionOrderRequests(
-    @Ctx() context: any,
+    @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 }: { domain: Domain; user: User } = context.state
+    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.bizplace = In(await getPermittedBizplaceIds(domain, user))
+
+    ;(convertedParams as any).bizplace = In(await getPermittedBizplaceIds(domain, user))
 
     const [items, total] = await getRepository(CollectionOrder).findAndCount({
       ...convertedParams,
@@ -79,16 +82,16 @@ export class CollectionOrderQuery {
 
   @FieldResolver(type => Domain)
   async domain(@Root() collectionOrder: CollectionOrder): Promise<Domain> {
-    return await getRepository(Domain).findOne(collectionOrder.domainId)
+    return await getRepository(Domain).findOneBy({ id: collectionOrder.domainId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() collectionOrder: CollectionOrder): Promise<User> {
-    return await getRepository(User).findOne(collectionOrder.creatorId)
+    return await getRepository(User).findOneBy({ id: collectionOrder.creatorId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() collectionOrder: CollectionOrder): Promise<User> {
-    return await getRepository(User).findOne(collectionOrder.updaterId)
+    return await getRepository(User).findOneBy({ id: collectionOrder.updaterId })
   }
 }