@things-factory/sales-base 4.0.12 → 4.0.17

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

@@ -1,112 +1,102 @@
-import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
-import { getRepository, In } from 'typeorm'
-import { Manifest } from './manifest'
-import { NewManifest, ManifestPatch } from './manifest-type'
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+
+import { DISPATCHMENT_STATUS } from '../../constants'
+import { OrderNoGenerator } from '../../utils'
+import { ReleaseGood } from '../release-good/release-good'
+import { Manifest, ManifestStatus } from './manifest'
+import { ManifestPatch, NewManifest } from './manifest-type'
 
 @Resolver(Manifest)
 export class ManifestMutation {
   @Directive('@transaction')
-  @Mutation(returns => Manifest, { description: 'To create new Manifest' })
-  async createManifest(@Arg('manifest') manifest: NewManifest, @Ctx() context: any): Promise<Manifest> {
-    const { domain, user, tx } = context.state
-
-    return await tx.getRepository(Manifest).save({
-      ...manifest,
-      domain,
-      creator: user,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Manifest, { description: 'To modify Manifest information' })
-  async updateManifest(
-    @Arg('id') id: string,
-    @Arg('patch') patch: ManifestPatch,
-    @Ctx() context: any
-  ): Promise<Manifest> {
-    const { domain, user, tx } = context.state
-
-    const repository = tx.getRepository(Manifest)
-    const manifest = await repository.findOne({
-      where: { domain, id }
-    })
+  @Mutation(returns => Boolean, { description: 'To delete Manifest' })
+  async deleteManifest(@Arg('name') name: string, @Ctx() context: any): Promise<boolean> {
+    const { domain, tx } = context.state
 
-    return await repository.save({
-      ...manifest,
-      ...patch,
-      updater: user
-    })
+    await tx.getRepository(Manifest).delete({ domain, name })
+    return true
   }
 
   @Directive('@transaction')
-  @Mutation(returns => [Manifest], { description: "To modify multiple Manifests' information" })
-  async updateMultipleManifest(
-    @Arg('patches', type => [ManifestPatch]) patches: ManifestPatch[],
-    @Ctx() context: any
-  ): Promise<Manifest[]> {
+  @Mutation(returns => Boolean, { description: 'To generate new Manifest' })
+  async generateManifest(@Arg('manifest') manifest: NewManifest, @Ctx() context: any): Promise<boolean> {
     const { domain, user, tx } = context.state
-
-    let results = []
-    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
-    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-    const manifestRepo = tx.getRepository(Manifest)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await manifestRepo.save({
-          ...newRecord,
-          domain,
-          creator: user,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: '+' })
+    const manifestItems: any[] = manifest.manifestItems
+
+    // regroup array of object by transporter
+    let shippingProviderGrouping: any = manifestItems.reduce((a, b) => {
+      a[b.transporter] = [...(a[b.transporter] || []), b]
+      return a
+    }, {})
+
+    for (const transporter in shippingProviderGrouping) {
+      const items: any[] = shippingProviderGrouping[transporter]
+
+      const openManifest: Manifest = await tx
+        .getRepository(Manifest)
+        .findOne({ domain, shippingProvider: transporter, status: ManifestStatus.OPEN })
+
+      let manifest: Manifest
+
+      if (openManifest) {
+        manifest = openManifest
+      } else {
+        manifest = new Manifest()
+        manifest.domain = domain
+        manifest.shippingProvider = transporter
+        manifest.name = OrderNoGenerator.manifest()
+        manifest.creator = user
+        manifest = await tx.getRepository(Manifest).save(manifest)
       }
-    }
 
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const newRecord = _updateRecords[i]
-        const manifest = await manifestRepo.findOne(newRecord.id)
-
-        const result = await manifestRepo.save({
-          ...manifest,
-          ...newRecord,
-          updater: user
+      await Promise.all(
+        items.map(async item => {
+          let releaseOrder: ReleaseGood = await tx
+            .getRepository(ReleaseGood)
+            .findOne({ domain, refNo: item.refNo, trackingNo: item.trackingNo })
+          releaseOrder.manifest = manifest
+          releaseOrder.updater = user
+          await tx.getRepository(ReleaseGood).save(releaseOrder)
         })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
+      )
     }
 
-    return results
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete Manifest' })
-  async deleteManifest(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(Manifest).delete({ domain, id })
     return true
   }
 
   @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple manifests' })
-  async deleteManifests(
-    @Arg('ids', type => [String]) ids: string[],
+  @Mutation(returns => Manifest, { description: 'To dispatch Manifest when courier service collect packages' })
+  async dispatchManifest(
+    @Arg('name') name: string,
+    @Arg('patch') patch: ManifestPatch,
     @Ctx() context: any
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
+  ): Promise<Manifest> {
+    const { domain, user, tx } = context.state
 
-    await tx.getRepository(Manifest).delete({
-      domain,
-      id: In(ids)
+    const manifest: Manifest = await tx.getRepository(Manifest).findOne({
+      where: { domain, name, status: ManifestStatus.OPEN }
     })
+    if (!manifest) throw new Error(`Unable to find ${name}`)
 
-    return true
+    let releaseGoods: any[] = await tx.getRepository(ReleaseGood).find({ where: { domain, manifest } })
+
+    releaseGoods = await Promise.all(
+      releaseGoods.map((releaseGood: ReleaseGood) => {
+        return {
+          ...releaseGood,
+          dispatchmentStatus: DISPATCHMENT_STATUS.DISPATCHED,
+          updater: user
+        }
+      })
+    )
+    await tx.getRepository(ReleaseGood).save(releaseGoods)
+
+    return await tx.getRepository(Manifest).save({
+      ...manifest,
+      ...patch,
+      status: ManifestStatus.CLOSED,
+      dispatchedAt: new Date(),
+      updater: user
+    })
   }
 }

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

@@ -1,27 +1,83 @@
-import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
+import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
 import { getRepository } from 'typeorm'
-import { Domain, ListParam, convertListParams } from '@things-factory/shell'
+
 import { User } from '@things-factory/auth-base'
+import { convertListParams, Domain, ListParam } from '@things-factory/shell'
+
+import { ReleaseGood } from '../release-good/release-good'
 import { Manifest } from './manifest'
 import { ManifestList } from './manifest-type'
 
 @Resolver(Manifest)
 export class ManifestQuery {
   @Query(returns => Manifest, { description: 'To fetch a Manifest' })
-  async manifest(@Arg('id') id: string, @Ctx() context: any): Promise<Manifest> {
-    const { domain } = context.state
+  async manifest(@Arg('name') name: string, @Ctx() context: any): Promise<Manifest> {
+    const { domain, tx } = context.state
+    const manifest: Manifest = await tx.getRepository(Manifest).findOne({ where: { domain, name } })
 
-    return await getRepository(Manifest).findOne({
-      where: { domain, id }
+    const releaseGoods: ReleaseGood[] = await tx.getRepository(ReleaseGood).find({ where: { manifest } })
+
+    const trackingNos: any[] = releaseGoods.map(releaseGood => {
+      return {
+        trackingNo: releaseGood.trackingNo,
+        refNo: releaseGood.refNo,
+        deliveryAddress: releaseGood.deliveryAddress1,
+        attentionTo: releaseGood.attentionTo,
+        postalCode: releaseGood.postalCode,
+        city: releaseGood.city,
+        phone: releaseGood.phone1,
+        dispatchmentStatus: releaseGood.dispatchmentStatus
+      }
     })
+
+    return {
+      ...manifest,
+      trackingNos
+    }
   }
 
   @Query(returns => ManifestList, { description: 'To fetch multiple Manifests' })
   async manifests(@Args() params: ListParam, @Ctx() context: any): Promise<ManifestList> {
     const { domain } = context.state
 
-    const convertedParams = convertListParams(params, domain.id)
-    const [items, total] = await getRepository(Manifest).findAndCount(convertedParams)
+    const fromDateParamIdx = params.filters.findIndex(param => param.name === 'fromDate')
+    if (fromDateParamIdx >= 0) {
+      let fromDateVal = new Date(params.filters[fromDateParamIdx].value)
+      params.filters.splice(fromDateParamIdx, 1)
+
+      params.filters.push({
+        name: 'createdAt',
+        operator: 'gte',
+        value: fromDateVal.toISOString(),
+        relation: false
+      })
+    }
+
+    const toDateParamIdx = params.filters.findIndex(param => param.name === 'toDate')
+    if (toDateParamIdx >= 0) {
+      let toDateVal = new Date(params.filters[toDateParamIdx].value)
+      params.filters.splice(toDateParamIdx, 1)
+
+      params.filters.push({
+        name: 'createdAt',
+        operator: 'lt',
+        value: new Date(toDateVal.setDate(toDateVal.getDate() + 1)).toISOString(),
+        relation: false
+      })
+    }
+
+    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']
+    })
 
     return { items, total }
   }

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

@@ -1,23 +1,11 @@
-import { ObjectType, Field, InputType, Int, ID, registerEnumType } from 'type-graphql'
+import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
 
 import { Manifest, ManifestStatus } from './manifest'
 
 @InputType()
 export class NewManifest {
-  @Field()
-  name: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field(type => ManifestStatus, { nullable: true })
-  state?: ManifestStatus
-
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Field({ nullable: true })
-  params?: string
+  @Field(type => [ManifestItem])
+  manifestItems: ManifestItem[]
 }
 
 @InputType()
@@ -29,16 +17,28 @@ export class ManifestPatch {
   name?: string
 
   @Field({ nullable: true })
-  description?: string
+  shippingProvider?: string
+
+  @Field({ nullable: true })
+  dispatcherName?: string
+
+  @Field({ nullable: true })
+  dispatcherIdentity?: string
 
   @Field(type => ManifestStatus, { nullable: true })
-  state?: ManifestStatus
+  status?: ManifestStatus
+}
 
+@InputType()
+export class ManifestItem {
   @Field({ nullable: true })
-  active?: boolean
+  trackingNo?: string
 
-  @Field()
-  cuFlag: string
+  @Field({ nullable: true })
+  refNo?: string
+
+  @Field({ nullable: true })
+  transporter?: string
 }
 
 @ObjectType()
@@ -49,3 +49,30 @@ export class ManifestList {
   @Field(type => Int)
   total: number
 }
+
+@ObjectType()
+export class TrackingNo {
+  @Field({ nullable: true })
+  trackingNo?: string
+
+  @Field({ nullable: true })
+  refNo?: string
+
+  @Field({ nullable: true })
+  dispatchmentStatus?: string
+
+  @Field({ nullable: true })
+  deliveryAddress?: string
+
+  @Field({ nullable: true })
+  attentionTo?: string
+
+  @Field({ nullable: true })
+  postalCode?: string
+
+  @Field({ nullable: true })
+  phone?: string
+
+  @Field({ nullable: true })
+  city?: string
+}

package/server/service/manifest/manifest.ts

@@ -14,6 +14,8 @@ import { User } from '@things-factory/auth-base'
 import { config } from '@things-factory/env'
 import { Domain } from '@things-factory/shell'
 
+import { TrackingNo } from './manifest-type'
+
 const ORMCONFIG = config.get('ormconfig', {})
 const DATABASE_TYPE = ORMCONFIG.type
 
@@ -74,6 +76,9 @@ export class Manifest {
   })
   status: ManifestStatus
 
+  @Field(type => [TrackingNo], { nullable: true })
+  trackingNos?: TrackingNo[]
+
   @CreateDateColumn()
   @Field({ nullable: true })
   createdAt?: Date

package/server/service/others/other-types.ts

@@ -26,6 +26,9 @@ export class InventoryProductGroup {
   @Field({ nullable: true })
   productName: string
 
+  @Field({ nullable: true })
+  productBrand: string
+
   @Field({ nullable: true })
   packingType: string