@things-factory/sales-base 4.3.49 → 4.3.54

package/server/service/arrival-notice/arrival-notice-mutation.ts

@@ -14,7 +14,7 @@ import {
 import { generateId } from '@things-factory/id-rule-base'
 import { sendNotification } from '@things-factory/notification'
 import { Product } from '@things-factory/product-base'
-import { Setting } from '@things-factory/setting-base'
+import { PartnerSetting, Setting } from '@things-factory/setting-base'
 import { Domain } from '@things-factory/shell'
 
 import {
@@ -66,6 +66,7 @@ export class ArrivalNoticeMutation {
     const createdArrivalNotice: ArrivalNotice = await generateArrivalNoticeFunction(
       null,
       arrivalNotice,
+      false,
       files,
       context,
       tx
@@ -198,7 +199,7 @@ export class ArrivalNoticeMutation {
     @Arg('file', type => GraphQLUpload, { nullable: true }) file?: FileUpload
   ): Promise<ArrivalNotice> {
     const { tx }: { tx: EntityManager } = context.state
-    const createdGAN: ArrivalNotice = await generateArrivalNoticeFunction(null, arrivalNotice, file, context, tx)
+    const createdGAN: ArrivalNotice = await generateArrivalNoticeFunction(null, arrivalNotice, false, file, context, tx)
 
     debug('createdGAN', createdGAN)
 
@@ -235,15 +236,20 @@ export class ArrivalNoticeMutation {
   async bulkGenerateArrivalNotices(
     @Ctx() context: any,
     @Arg('rawArrivalNotices', type => [NewArrivalNotice], { nullable: true }) rawArrivalNotices: NewArrivalNotice[],
-    @Arg('bizplaceId', type => String) bizplaceId: string
+    @Arg('bizplaceId', type => String) bizplaceId: string,
+    @Arg('bufferLocation', type => String, { nullable: true }) bufferLocation: string
   ): Promise<ArrivalNoticeList> {
     const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
     let createdArrivalNoticeIds: string[] = [],
       createdOrderProductIds: string[] = [],
       errorsCaught: any[] = [],
       finalArrivalNoticeList: ArrivalNotice[] = []
+    let opStatus = ORDER_PRODUCT_STATUS.PENDING_RECEIVE
+    let anStatus = ORDER_STATUS.PENDING_RECEIVE
 
-    const foundBizplace: Bizplace = await tx.getRepository(Bizplace).findOne(bizplaceId)
+    const foundBizplace: Bizplace = await tx
+      .getRepository(Bizplace)
+      .findOne({ where: { id: bizplaceId }, relations: ['domain'] })
 
     if (!foundBizplace) throw new Error('company not found')
 
@@ -262,6 +268,27 @@ export class ArrivalNoticeMutation {
       }
     })
 
+    const ganProcessingSetting: Setting = await tx.getRepository(Setting).findOne({
+      where: { domain, category: 'id-rule', name: 'gan-order-processing' }
+    })
+
+    const partnerGanProcessingSetting: PartnerSetting = await tx.getRepository(PartnerSetting).findOne({
+      where: { setting: ganProcessingSetting, domain, partnerDomain: foundBizplace.domain.id }
+    })
+
+    // If status of GAN is PENDING_RECEIVE then directly to assign warehouse
+    if (ganProcessingSetting) {
+      let setting = !isNaN(partnerGanProcessingSetting?.value)
+        ? partnerGanProcessingSetting?.value
+        : ganProcessingSetting.value
+
+      // CONFIRM to assign if setting value is 1
+      if (setting == 1) {
+        opStatus = ORDER_PRODUCT_STATUS.ARRIVED
+        anStatus = ORDER_STATUS.ARRIVED
+      }
+    }
+
     // extract rawArrivalNotices data into normal ArrivalNotice format
     let arrivalNotices: Partial<ArrivalNotice[]> = extractArrivalNotices(validatedArrivalNotices)
 
@@ -336,12 +363,12 @@ export class ArrivalNoticeMutation {
         // update arrivalNotices status to PENDING_RECEIVE
         await childTx
           .getRepository(ArrivalNotice)
-          .update({ id: In(createdArrivalNoticeIds) }, { status: ORDER_STATUS.PENDING_RECEIVE, updater: user })
+          .update({ id: In(createdArrivalNoticeIds) }, { status: anStatus, updater: user })
 
         // update orderProducts status to PENDING_RECEIVE
         await childTx
           .getRepository(OrderProduct)
-          .update({ id: In(createdOrderProductIds) }, { status: ORDER_PRODUCT_STATUS.PENDING_RECEIVE, updater: user })
+          .update({ id: In(createdOrderProductIds) }, { status: opStatus, updater: user })
 
         finalArrivalNoticeList = await childTx.getRepository(ArrivalNotice).find({
           where: { id: In(createdArrivalNoticeIds) },
@@ -423,6 +450,7 @@ export async function deleteArrivalNotice(
 export async function generateArrivalNoticeFunction(
   _: any,
   arrivalNotice: any,
+  fromPo: Boolean,
   files: FileUpload[],
   context: any,
   tx?: EntityManager
@@ -474,7 +502,7 @@ export async function generateArrivalNoticeFunction(
     domain,
     bizplace: myBizplace,
     looseItem: arrivalNotice?.looseItem ? arrivalNotice.looseItem : false,
-    status: ORDER_STATUS.PENDING,
+    status: fromPo ? ORDER_STATUS.INTRANSIT : ORDER_STATUS.PENDING,
     creator: user,
     updater: user
   })
@@ -484,7 +512,7 @@ export async function generateArrivalNoticeFunction(
     domain,
     createdArrivalNotice,
     orderProducts.map((op: OrderProduct) => {
-      return { ...op, status: ORDER_PRODUCT_STATUS.PENDING }
+      return { ...op, status: fromPo ? ORDER_PRODUCT_STATUS.INTRANSIT : ORDER_PRODUCT_STATUS.PENDING }
     }),
     user,
     tx
@@ -508,7 +536,7 @@ export async function generateArrivalNoticeFunction(
           vas: await tx.getRepository(Vas).findOne({ domain, id: ov.vas.id }),
           type: ORDER_TYPES.ARRIVAL_NOTICE,
           arrivalNotice: createdArrivalNotice,
-          status: ORDER_VAS_STATUS.PENDING,
+          status: fromPo ? ORDER_VAS_STATUS.INTRANSIT : ORDER_VAS_STATUS.PENDING,
           creator: user,
           updater: user
         }
@@ -542,6 +570,7 @@ export async function confirmArrivalNoticeFunction(
     where: { domain, name, status: ORDER_STATUS.PENDING },
     relations: [
       'bizplace',
+      'bizplace.domain',
       'releaseGood',
       'orderProducts',
       'orderProducts.product',
@@ -555,25 +584,56 @@ export async function confirmArrivalNoticeFunction(
   let foundOPs: OrderProduct[] = foundArrivalNotice.orderProducts
   let foundOVs: OrderVas[] = foundArrivalNotice.orderVass
   let customerBizplace: Bizplace = foundArrivalNotice.bizplace
+  let opStatus = ORDER_PRODUCT_STATUS.PENDING_RECEIVE
+  let anStatus = ORDER_STATUS.PENDING_RECEIVE
+  let ovStatus = ORDER_VAS_STATUS.PENDING_RECEIVE
+  let acceptedByUser = null
+  let acceptedTime = null
+
+  const ganProcessingSetting: Setting = await tx.getRepository(Setting).findOne({
+    where: { domain, category: 'id-rule', name: 'gan-order-processing' }
+  })
+
+  const partnerGanProcessingSetting: PartnerSetting = await tx.getRepository(PartnerSetting).findOne({
+    where: { setting: ganProcessingSetting, domain, partnerDomain: customerBizplace?.domain }
+  })
+
+  // If status of GAN is PENDING_RECEIVE then directly to assign warehouse
+  if (ganProcessingSetting) {
+    let setting = !isNaN(partnerGanProcessingSetting?.value)
+      ? partnerGanProcessingSetting?.value
+      : ganProcessingSetting.value
+
+    // CONFIRM to assign if setting value is 1
+    if (setting == 1) {
+      opStatus = ORDER_PRODUCT_STATUS.ARRIVED
+      anStatus = ORDER_STATUS.ARRIVED
+      ovStatus = ORDER_VAS_STATUS.ARRIVED
+      acceptedByUser = user
+      acceptedTime = new Date()
+    }
+  }
 
   if (!foundArrivalNotice) throw new Error(`Arrival notice doesn't exists.`)
 
   // 1. GAN Status change (PENDING => PENDING_RECEIVE)
-  const arrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).save({
+  let arrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).save({
     ...foundArrivalNotice,
-    status: ORDER_STATUS.PENDING_RECEIVE,
-    updater: user
+    status: anStatus,
+    updater: user,
+    acceptedBy: acceptedByUser,
+    acceptedAt: acceptedTime
   })
 
   foundOPs = foundOPs.map((op: OrderProduct) => {
-    return { ...op, status: ORDER_PRODUCT_STATUS.PENDING_RECEIVE }
+    return { ...op, status: opStatus }
   })
   await tx.getRepository(OrderProduct).save(foundOPs)
 
   // 2. Update order vas status if it exists.
   if (foundOVs && foundOVs.length) {
     foundOVs = foundOVs.map((ov: OrderVas) => {
-      return { ...ov, status: ORDER_VAS_STATUS.PENDING_RECEIVE }
+      return { ...ov, status: ovStatus }
     })
 
     await tx.getRepository(OrderVas).save(foundOVs)
@@ -623,22 +683,50 @@ export async function receiveArrivalNoticeFunction(_: any, name: String, context
   try {
     const foundArrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
       where: { domain, name, status: ORDER_STATUS.PENDING_RECEIVE },
-      relations: ['bizplace', 'collectionOrders', 'orderProducts', 'orderVass']
+      relations: ['bizplace', 'bizplace.domain', 'collectionOrders', 'orderProducts', 'orderVass']
     })
 
-    if (!foundArrivalNotice) throw new Error(`Arrival notice doesn't exists.`)
-
     let foundOPs: OrderProduct[] = foundArrivalNotice.orderProducts
     let foundOVs: OrderVas[] = foundArrivalNotice.orderVass
     let foundCOs: CollectionOrder[] = await tx.getRepository(CollectionOrder).find({
       where: { domain, refNo: foundArrivalNotice.name }
     })
+    let customerBizplace: Bizplace = foundArrivalNotice.bizplace
+    let opStatus = ORDER_PRODUCT_STATUS.INTRANSIT
+    let anStatus = ORDER_STATUS.INTRANSIT
+    let ovStatus = ORDER_VAS_STATUS.INTRANSIT
+    let coStatus = ORDER_STATUS.READY_TO_DISPATCH
+
+    const ganProcessingSetting: Setting = await tx.getRepository(Setting).findOne({
+      where: { domain, category: 'id-rule', name: 'gan-order-processing' }
+    })
+
+    const partnerGanProcessingSetting: PartnerSetting = await tx.getRepository(PartnerSetting).findOne({
+      where: { setting: ganProcessingSetting, domain, partnerDomain: customerBizplace?.domain }
+    })
+
+    // If status of GAN is INTRANSIT then directly to assign warehouse
+    if (ganProcessingSetting) {
+      let setting = !isNaN(partnerGanProcessingSetting?.value)
+        ? partnerGanProcessingSetting?.value
+        : ganProcessingSetting.value
+
+      // RECEIVE to assign if setting value is 2
+      if (setting == 2) {
+        opStatus = ORDER_PRODUCT_STATUS.ARRIVED
+        anStatus = ORDER_STATUS.ARRIVED
+        ovStatus = ORDER_VAS_STATUS.ARRIVED
+        coStatus = ORDER_STATUS.READY_TO_DISPATCH
+      }
+    }
+
+    if (!foundArrivalNotice) throw new Error(`Arrival notice doesn't exists.`)
 
     // 1. Update status of order products (PENDING_RECEIVE => INTRANSIT)
     foundOPs = foundOPs.map((op: OrderProduct) => {
       return {
         ...op,
-        status: ORDER_PRODUCT_STATUS.INTRANSIT,
+        status: opStatus,
         updater: user
       }
     })
@@ -649,7 +737,7 @@ export async function receiveArrivalNoticeFunction(_: any, name: String, context
       foundOVs = foundOVs.map((ov: OrderVas) => {
         return {
           ...ov,
-          status: ORDER_VAS_STATUS.INTRANSIT,
+          status: ovStatus,
           updater: user
         }
       })
@@ -661,7 +749,7 @@ export async function receiveArrivalNoticeFunction(_: any, name: String, context
       foundCOs = foundCOs.map((co: CollectionOrder) => {
         return {
           ...co,
-          status: ORDER_STATUS.READY_TO_DISPATCH,
+          status: coStatus,
           updater: user
         }
       })
@@ -686,9 +774,9 @@ export async function receiveArrivalNoticeFunction(_: any, name: String, context
     }
 
     // 4. Update status of arrival notice (PENDING_RECEIVE => INTRANSIT)
-    await tx.getRepository(ArrivalNotice).save({
+    let rcvArrivalNotice = await tx.getRepository(ArrivalNotice).save({
       ...foundArrivalNotice,
-      status: ORDER_STATUS.INTRANSIT,
+      status: anStatus,
       acceptedBy: user,
       acceptedAt: new Date(),
       updater: user

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

@@ -1,13 +1,58 @@
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-
-import { DISPATCHMENT_STATUS } from '../../constants'
+import { In, Not } from 'typeorm'
+import { DISPATCHMENT_STATUS, MANIFEST_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'
+import i18next from 'i18next'
 
 @Resolver(Manifest)
 export class ManifestMutation {
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To update Manifest' })
+  async updateManifest(
+    @Arg('manifestId', { nullable: true }) manifestId: string,
+    @Arg('status', { nullable: true }) status: string,
+    @Arg('shippingProvider', { nullable: true }) shippingProvider: string,
+    @Arg('removeOrders', type => [String], { nullable: true }) removeOrders: string[],
+    @Ctx() context: any
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+    const ManifestRepo = tx.getRepository(Manifest)
+    //update status
+    if (status) {
+      if (status == MANIFEST_STATUS.OPEN) {
+        //check if there is only one manifest is open, if yes update it to in queue and update current to open
+
+        let foundOpenOrder = await ManifestRepo.find({
+          where: { domain, shippingProvider, status: MANIFEST_STATUS.OPEN }
+        })
+
+        if (foundOpenOrder.length == 1) {
+          await ManifestRepo.update({ id: foundOpenOrder[0].id }, { status: MANIFEST_STATUS.IN_QUEUE })
+        } else if (foundOpenOrder.length > 1) {
+          let manifestNames = foundOpenOrder.map(itm => itm.name)
+          throw new Error(i18next.t('error.Manifest(s) (x) already in open status', { x: manifestNames.toString() }))
+        }
+      }
+
+      await ManifestRepo.update({ id: manifestId }, { status })
+    }
+
+    //remove orders from manifest
+    if (removeOrders?.length > 0) {
+      //check if user removing all tracking no, if yes then delete
+      let totalTrackingNo = await tx.getRepository(ReleaseGood).count({ where: { manifest: manifestId } })
+      await tx.getRepository(ReleaseGood).update({ domain, refNo: In(removeOrders) }, { manifest: null })
+      if (removeOrders.length == totalTrackingNo) {
+        await tx.getRepository(Manifest).delete(manifestId)
+        return false
+      }
+    }
+    return true
+  }
+
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete Manifest' })
   async deleteManifest(@Arg('name') name: string, @Ctx() context: any): Promise<boolean> {
@@ -64,6 +109,36 @@ export class ManifestMutation {
     return true
   }
 
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To add tracking no into manifest' })
+  async addTrackingNo(
+    @Arg('manifestId', { nullable: true }) manifestId: string,
+    @Arg('trackingNo', { nullable: true }) trackingNo: string,
+    @Arg('shippingProvider', { nullable: true }) shippingProvider: string,
+    @Ctx() context: any
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+    const releaseGoodRepo = tx.getRepository(ReleaseGood)
+    //check if order belongs to same shipping provider
+    let foundReleaseOrder = await releaseGoodRepo.findOne({ where: { trackingNo }, relations: ['manifest'] })
+
+    if (!foundReleaseOrder) {
+      throw new Error(i18next.t('error.release_order_not_found'))
+    }
+
+    if (foundReleaseOrder.manifest) {
+      throw new Error(i18next.t('error.tracking_no_already_scanned_before'))
+    }
+
+    if (foundReleaseOrder.transporter !== shippingProvider) {
+      throw new Error(i18next.t('error.tracking_no_belongs_to_x', { x: foundReleaseOrder.transporter }))
+    }
+
+    await releaseGoodRepo.update({ id: foundReleaseOrder.id }, { manifest: manifestId })
+
+    return true
+  }
+
   @Directive('@transaction')
   @Mutation(returns => Manifest, { description: 'To dispatch Manifest when courier service collect packages' })
   async dispatchManifest(
@@ -74,7 +149,7 @@ export class ManifestMutation {
     const { domain, user, tx } = context.state
 
     const manifest: Manifest = await tx.getRepository(Manifest).findOne({
-      where: { domain, name, status: ManifestStatus.OPEN }
+      where: { domain, name, status: Not(MANIFEST_STATUS.CLOSED) }
     })
     if (!manifest) throw new Error(`Unable to find ${name}`)
 

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 { getRepository, SelectQueryBuilder } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
-import { convertListParams, Domain, ListParam } from '@things-factory/shell'
+import { convertListParams, Domain, ListParam, buildQuery, 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: any,
+    @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 releaseGoods: ReleaseGood[] = await getRepository(ReleaseGood).find({ where: { manifest } })
+    const releaseGoods: ReleaseGood[] = await getRepository(ReleaseGood).find({
+      ...convertedParams,
+      where: { manifest }
+    })
 
     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
       }
     })
 
@@ -40,6 +69,22 @@ export class ManifestQuery {
   async manifests(@Args() params: ListParam, @Ctx() context: any): 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,19 +111,24 @@ 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: item.id } })
+      })
+    )
     return { items, total }
   }
 

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/purchase-order/purchase-order-mutation.ts

@@ -23,7 +23,8 @@ import {
   ATTACHMENT_TYPE,
   ORDER_NUMBER_RULE_TYPE,
   ORDER_NUMBER_SETTING_KEY,
-  PURCHASE_ORDER_STATUS
+  PURCHASE_ORDER_STATUS,
+  ORDER_STATUS
 } from '../../constants'
 import { OrderNoGenerator } from '../../utils'
 import {
@@ -109,12 +110,14 @@ export class PurchaseOrderMutation {
     }
 
     delete newGANOrder.id
+    //change gan status to intransit and call check arrived notice function right
+    newGANOrder.status = ORDER_STATUS.INTRANSIT
 
-    const createdGAN: ArrivalNotice = await generateArrivalNoticeFunction(null, newGANOrder, [], context, tx)
+    const createdGAN: ArrivalNotice = await generateArrivalNoticeFunction(null, newGANOrder, true, [], context, tx)
 
-    await confirmArrivalNoticeFunction(createdGAN.name, context, tx)
+    // await confirmArrivalNoticeFunction(createdGAN.name, context, tx)
 
-    await receiveArrivalNoticeFunction(null, createdGAN.name, context)
+    // await receiveArrivalNoticeFunction(null, createdGAN.name, context)
 
     await checkArrivedNoticeFunction(createdGAN.name, context, tx)
 
@@ -264,7 +267,9 @@ export async function createPurchaseOrderFunction(
     }
   })
 
-  orderNo = poNoSetting ? await generateId({ domain, type: ORDER_NUMBER_RULE_TYPE.PO_NUMBER, seed: {} }) : OrderNoGenerator.purchaseOrder()
+  orderNo = poNoSetting
+    ? await generateId({ domain, type: ORDER_NUMBER_RULE_TYPE.PO_NUMBER, seed: {} })
+    : OrderNoGenerator.purchaseOrder()
 
   // // 1. Create purchase order
   const createdPurchaseOrder: PurchaseOrder = await tx.getRepository(PurchaseOrder).save({