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

package/server/service/manifest/manifest-query.ts

@@ -1,8 +1,8 @@
 import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository } from 'typeorm'
+import { SelectQueryBuilder } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
-import { convertListParams, Domain, ListParam } from '@things-factory/shell'
+import { buildQuery, convertListParams, Domain, getRepository, ListParam, Sorting } from '@things-factory/shell'
 
 import { ReleaseGood } from '../release-good/release-good'
 import { Manifest } from './manifest'
@@ -11,11 +11,38 @@ import { ManifestList } from './manifest-type'
 @Resolver(Manifest)
 export class ManifestQuery {
   @Query(returns => Manifest, { description: 'To fetch a Manifest' })
-  async manifest(@Arg('name') name: string, @Ctx() context: any): Promise<Manifest> {
+  async manifest(
+    @Arg('name') name: string,
+    @Ctx() context: ResolverContext,
+    @Arg('sortings', type => [Sorting], { nullable: true }) sortings?: Sorting[]
+  ): Promise<Manifest> {
+    const phoneSort = sortings.findIndex(sort => sort.name === 'phone')
+    if (phoneSort >= 0) {
+      sortings[phoneSort].name = 'phone1'
+    }
+
+    const deliveryAddressSort = sortings.findIndex(sort => sort.name === 'deliveryAddress')
+    if (deliveryAddressSort >= 0) {
+      sortings[deliveryAddressSort].name = 'deliveryAddress1'
+    }
+
+    const orderRemarkSort = sortings.findIndex(sort => sort.name === 'orderRemark')
+    if (orderRemarkSort >= 0) {
+      sortings[orderRemarkSort].name = 'remark'
+    }
+
+    const orderStatusSort = sortings.findIndex(sort => sort.name === 'orderStatus')
+    if (orderStatusSort >= 0) {
+      sortings[orderStatusSort].name = 'status'
+    }
+    const convertedParams = convertListParams({ sortings })
     const { domain, tx } = context.state
-    const manifest: Manifest = await getRepository(Manifest).findOne({ where: { domain, name } })
+    const manifest: Manifest = await getRepository(Manifest).findOne({ where: { domain: { id: domain.id }, name } })
 
-    const releaseGoods: ReleaseGood[] = await getRepository(ReleaseGood).find({ where: { manifest } })
+    const releaseGoods: ReleaseGood[] = await getRepository(ReleaseGood).find({
+      ...convertedParams,
+      where: { manifest: { id: manifest.id } }
+    })
 
     const trackingNos: any[] = releaseGoods.map(releaseGood => {
       return {
@@ -26,7 +53,9 @@ export class ManifestQuery {
         postalCode: releaseGood.postalCode,
         city: releaseGood.city,
         phone: releaseGood.phone1,
-        dispatchmentStatus: releaseGood.dispatchmentStatus
+        dispatchmentStatus: releaseGood.dispatchmentStatus,
+        orderStatus: releaseGood.status,
+        orderRemark: releaseGood.remark
       }
     })
 
@@ -37,9 +66,25 @@ export class ManifestQuery {
   }
 
   @Query(returns => ManifestList, { description: 'To fetch multiple Manifests' })
-  async manifests(@Args() params: ListParam, @Ctx() context: any): Promise<ManifestList> {
+  async manifests(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<ManifestList> {
     const { domain } = context.state
 
+    let orderInfoFilter
+    const orderInfoParamIdx = params.filters.findIndex(param => param.name === 'orderInfo')
+    if (orderInfoParamIdx >= 0) {
+      orderInfoFilter = params.filters[orderInfoParamIdx].value.toLowerCase().split(',').join('|')
+
+      params.filters.splice(orderInfoParamIdx, 1)
+    }
+
+    let trackingNoFilter
+    const trackingNoParamIdx = params.filters.findIndex(param => param.name === 'trackingNo')
+    if (trackingNoParamIdx >= 0) {
+      trackingNoFilter = params.filters[trackingNoParamIdx].value
+
+      params.filters.splice(trackingNoParamIdx, 1)
+    }
+
     const fromDateParamIdx = params.filters.findIndex(param => param.name === 'fromDate')
     if (fromDateParamIdx >= 0) {
       let fromDateVal = new Date(params.filters[fromDateParamIdx].value)
@@ -66,34 +111,39 @@ export class ManifestQuery {
       })
     }
 
-    params.filters.push({
-      name: 'domain',
-      operator: 'eq',
-      value: domain.id,
-      relation: true
-    })
-
-    const convertedParams = convertListParams(params)
-    const [items, total] = await getRepository(Manifest).findAndCount({
-      ...convertedParams,
-      relations: ['domain', 'creator', 'updater']
-    })
-
+    const qb: SelectQueryBuilder<Manifest> = getRepository(Manifest).createQueryBuilder('mf')
+    buildQuery(qb, params, context)
+    qb.innerJoin('release_goods', 'rg', 'rg.manifest_id = mf.id')
+    orderInfoFilter
+      ? qb.andWhere(
+          '(rg.name ~* :orderInfoFilter or rg.ref_no ~* :orderInfoFilter or rg.ref_no_2 ~* :orderInfoFilter or rg.ref_no_3 ~* :orderInfoFilter)',
+          { orderInfoFilter }
+        )
+      : ''
+    trackingNoFilter ? qb.andWhere('rg.tracking_no ilike :trackingNo', { trackingNo: trackingNoFilter }) : ''
+
+    const [items, total] = await qb.getManyAndCount()
+
+    await Promise.all(
+      items.map(async item => {
+        item.totalTrackingNo = await getRepository(ReleaseGood).count({ where: { manifest: { id: item.id } } })
+      })
+    )
     return { items, total }
   }
 
   @FieldResolver(type => Domain)
   async domain(@Root() manifest: Manifest): Promise<Domain> {
-    return await getRepository(Domain).findOne(manifest.domainId)
+    return await getRepository(Domain).findOneBy({ id: manifest.domainId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() manifest: Manifest): Promise<User> {
-    return await getRepository(User).findOne(manifest.updaterId)
+    return await getRepository(User).findOneBy({ id: manifest.updaterId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() manifest: Manifest): Promise<User> {
-    return await getRepository(User).findOne(manifest.creatorId)
+    return await getRepository(User).findOneBy({ id: manifest.creatorId })
   }
 }

package/server/service/manifest/manifest-type.ts

@@ -75,4 +75,10 @@ export class TrackingNo {
 
   @Field({ nullable: true })
   city?: string
+
+  @Field({ nullable: true })
+  orderStatus?: string
+
+  @Field({ nullable: true })
+  orderRemark?: string
 }

package/server/service/manifest/manifest.ts

@@ -1,4 +1,4 @@
-import { Field, ID, ObjectType, registerEnumType } from 'type-graphql'
+import { Field, ID, ObjectType, registerEnumType, Int } from 'type-graphql'
 import {
   Column,
   CreateDateColumn,
@@ -21,7 +21,8 @@ const DATABASE_TYPE = ORMCONFIG.type
 
 export enum ManifestStatus {
   OPEN = 'OPEN',
-  CLOSED = 'CLOSED'
+  CLOSED = 'CLOSED',
+  IN_QUEUE = 'IN_QUEUE'
 }
 
 registerEnumType(ManifestStatus, {
@@ -80,6 +81,9 @@ export class Manifest {
   @Field(type => [TrackingNo], { nullable: true })
   trackingNos?: TrackingNo[]
 
+  @Field(type => Int, { nullable: true })
+  totalTrackingNo?: number
+
   @CreateDateColumn()
   @Field({ nullable: true })
   createdAt?: Date

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

@@ -1,17 +1,15 @@
-import { OrderInventoryPatch } from './order-inventory-types'
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager, In } from 'typeorm'
-
-import { Domain } from '@things-factory/shell'
+import { In } from 'typeorm'
 
 import { OrderInventory } from './order-inventory'
+import { OrderInventoryPatch } from './order-inventory-types'
 
 @Resolver(OrderInventory)
 export class OrderInventoryMutation {
   @Mutation(returns => Boolean)
   @Directive('@transaction')
-  async deleteOrderInventory(@Arg('name') name: string, @Ctx() context: any): Promise<boolean> {
-    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+  async deleteOrderInventory(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { tx, domain } = context.state
 
     await tx.getRepository(OrderInventory).delete({ domain, name })
     return true
@@ -19,11 +17,14 @@ export class OrderInventoryMutation {
 
   @Mutation(returns => Boolean)
   @Directive('@transaction')
-  async deleteOrderInventories(@Arg('names', type => [String]) names: string[], @Ctx() context: any): Promise<boolean> {
-    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+  async deleteOrderInventories(
+    @Arg('names', type => [String]) names: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { tx, domain } = context.state
 
     await tx.getRepository(OrderInventory).delete({
-      domain,
+      domain: { id: domain.id },
       name: In(names)
     })
     return true
@@ -32,14 +33,14 @@ export class OrderInventoryMutation {
   @Mutation(returns => OrderInventory)
   @Directive('@transaction')
   async updateOrderInventorySerialNumber(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @Arg('orderInventory', type => OrderInventoryPatch, { nullable: true }) orderInventory?: OrderInventoryPatch
   ): Promise<OrderInventory> {
     try {
-      const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+      const { tx, domain } = context.state
 
       let foundOI: OrderInventory = await tx.getRepository(OrderInventory).findOne({
-        where: { domain, id: orderInventory.id }
+        where: { domain: { id: domain.id }, id: orderInventory.id }
       })
 
       foundOI.serialNumber = orderInventory.serialNumber