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

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

@@ -1,7 +1,7 @@
 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, getConnection, getRepository, In, Repository } from 'typeorm'
+import { EntityManager, getConnection, In, Repository } from 'typeorm'
 
 import { Attachment, createAttachments } from '@things-factory/attachment-base'
 import { Role, User } from '@things-factory/auth-base'
@@ -14,10 +14,9 @@ import {
   getPermittedBizplaces
 } from '@things-factory/biz-base'
 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 { Domain } from '@things-factory/shell'
+import { PartnerSetting, Setting } from '@things-factory/setting-base'
+import { Domain, getRepository } from '@things-factory/shell'
 
 import {
   ORDER_NUMBER_RULE_TYPE,
@@ -50,8 +49,8 @@ export class ArrivalNoticeMutation {
   @Directive('@privilege(category: "order_customer", privilege: "mutation")')
   @Directive('@transaction')
   @Mutation(returns => Boolean)
-  async deleteArrivalNotice(@Arg('name') name: string, @Ctx() context: any): Promise<Boolean> {
-    const { tx, user, domain }: { tx: EntityManager; user: User; domain: Domain } = context.state
+  async deleteArrivalNotice(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<Boolean> {
+    const { tx, user, domain } = context.state
 
     return await deleteArrivalNotice(tx, name, user, domain)
   }
@@ -60,14 +59,15 @@ export class ArrivalNoticeMutation {
   @Directive('@transaction')
   @Mutation(returns => ArrivalNotice)
   async generateArrivalNotice(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @Arg('arrivalNotice', type => NewArrivalNotice) arrivalNotice: NewArrivalNotice,
     @Arg('files', type => [GraphQLUpload], { nullable: true }) files?: FileUpload[]
   ): Promise<ArrivalNotice> {
-    const { tx }: { tx: EntityManager } = context.state
+    const { tx } = context.state
     const createdArrivalNotice: ArrivalNotice = await generateArrivalNoticeFunction(
       null,
       arrivalNotice,
+      false,
       files,
       context,
       tx
@@ -79,13 +79,14 @@ export class ArrivalNoticeMutation {
   @Directive('@privilege(category: "order_customer", privilege: "mutation")')
   @Directive('@transaction')
   @Mutation(returns => ArrivalNotice)
-  async confirmArrivalNotice(@Arg('name') name: string, @Ctx() context: any): Promise<ArrivalNotice> {
-    const { tx }: { tx: EntityManager } = context.state
+  async confirmArrivalNotice(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<ArrivalNotice> {
+    const { tx } = context.state
     const arrivalNotice: ArrivalNotice = await confirmArrivalNoticeFunction(name, context, tx)
 
     // If current GAN has cross docking
     if (arrivalNotice.crossDocking) {
-      const { releaseGood } = await tx.getRepository(ArrivalNotice).findOne(arrivalNotice.id, {
+      const { releaseGood } = await tx.getRepository(ArrivalNotice).findOne({
+        where: { id: arrivalNotice.id },
         relations: ['releaseGood']
       })
 
@@ -101,7 +102,7 @@ export class ArrivalNoticeMutation {
   @Directive('@privilege(category: "order_warehouse", privilege: "mutation")')
   @Directive('@transaction')
   @Mutation(returns => ArrivalNotice)
-  async receiveArrivalNotice(@Arg('name') name: string, @Ctx() context: any): Promise<ArrivalNotice> {
+  async receiveArrivalNotice(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<ArrivalNotice> {
     const receiveArrivalNotice: ArrivalNotice = await receiveArrivalNoticeFunction(null, name, context)
 
     return receiveArrivalNotice
@@ -110,8 +111,8 @@ export class ArrivalNoticeMutation {
   @Directive('@privilege(category: "order_warehouse", privilege: "mutation")')
   @Directive('@transaction')
   @Mutation(returns => ArrivalNotice)
-  async checkArrivedNotice(@Arg('name') name: string, @Ctx() context: any): Promise<ArrivalNotice> {
-    const { tx }: { tx: EntityManager } = context.state
+  async checkArrivedNotice(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<ArrivalNotice> {
+    const { tx } = context.state
 
     return await checkArrivedNoticeFunction(name, context, tx)
   }
@@ -122,21 +123,20 @@ export class ArrivalNoticeMutation {
   async rejectArrivalNotice(
     @Arg('name') name: string,
     @Arg('patch', type => ArrivalNoticePatch) patch: ArrivalNoticePatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<ArrivalNotice> {
-    const { tx }: { tx: EntityManager } = context.state
+    const { tx } = context.state
 
     const arrivalNotice: ArrivalNotice = await rejectArrivalNotice(tx, name, patch.remark, context)
 
     if (arrivalNotice.crossDocking) {
-      const { releaseGood }: { releaseGood: ReleaseGood } = await tx
-        .getRepository(ArrivalNotice)
-        .findOne(arrivalNotice.id, {
-          relations: ['releaseGood']
-        })
+      const { releaseGood }: { releaseGood: ReleaseGood } = await tx.getRepository(ArrivalNotice).findOne({
+        where: { id: arrivalNotice.id },
+        relations: ['releaseGood']
+      })
 
       if (releaseGood.status !== ORDER_STATUS.REJECTED) {
-        await rejectReleaseGood(tx, releaseGood.name, patch.remark, context)
+        await rejectReleaseGood(tx, context, releaseGood.name, patch.remark)
       }
     }
 
@@ -147,13 +147,13 @@ export class ArrivalNoticeMutation {
   @Directive('@transaction')
   @Mutation(returns => Boolean)
   async addEditArrivalNoticeProducts(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @Arg('ganNo') ganNo: string,
     @Arg('newOrderProducts', type => [NewOrderProduct], { nullable: true }) newOrderProducts?: NewOrderProduct[],
     @Arg('existingOrderProducts', type => [OrderProductPatch], { nullable: true })
     existingOrderProducts?: OrderProductPatch[]
   ): Promise<Boolean> {
-    const { user, domain, tx }: { user: User; domain: Domain; tx: EntityManager } = context.state
+    const { user, domain, tx } = context.state
 
     let arrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
       where: { name: ganNo },
@@ -182,10 +182,14 @@ export class ArrivalNoticeMutation {
         url: context.header.referer,
         data: { url: context.header.referer }
       }
-      await sendNotification({
-        receivers,
-        message: { ...msg }
-      })
+      /**
+       * @notes Temporary off sendNotification due to suspect of causing wms down
+       */
+
+      // await sendNotification({
+      //   receivers,
+      //   message: { ...msg }
+      // })
     }
 
     return true
@@ -195,12 +199,12 @@ export class ArrivalNoticeMutation {
   @Directive('@transaction')
   @Mutation(returns => ArrivalNotice)
   async addArrivalNotice(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @Arg('arrivalNotice', type => NewArrivalNotice) arrivalNotice: NewArrivalNotice,
     @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 { tx } = context.state
+    const createdGAN: ArrivalNotice = await generateArrivalNoticeFunction(null, arrivalNotice, false, file, context, tx)
 
     debug('createdGAN', createdGAN)
 
@@ -215,7 +219,7 @@ export class ArrivalNoticeMutation {
   @Directive('@transaction')
   @Mutation(returns => ArrivalNotice)
   async updateArrivalNoticeDetails(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @Arg('arrivalNotice', type => ArrivalNoticePatch) arrivalNotice: ArrivalNoticePatch
   ): Promise<ArrivalNotice> {
     const { domain, tx } = context.state
@@ -228,24 +232,29 @@ export class ArrivalNoticeMutation {
     }
 
     await tx.getRepository(ArrivalNotice).update(existingArrivalNotice.id, arrivalNotice)
-    return await tx.getRepository(ArrivalNotice).findOne(existingArrivalNotice.id)
+    return await tx.getRepository(ArrivalNotice).findOneBy({ id: existingArrivalNotice.id })
   }
 
   @Directive('@privilege(category: "order_customer", privilege: "mutation")')
   @Directive('@transaction')
   @Mutation(returns => ArrivalNoticeList)
   async bulkGenerateArrivalNotices(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @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
+    const { domain, user, tx } = 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')
 
@@ -259,11 +268,32 @@ export class ArrivalNoticeMutation {
     // check for custom GAN order no setting
     const ganNoSetting: Setting = await tx.getRepository(Setting).findOne({
       where: {
-        domain,
+        domain: { id: domain.id },
         name: ORDER_NUMBER_SETTING_KEY.GAN_NUMBER_RULE
       }
     })
 
+    const ganProcessingSetting: Setting = await tx.getRepository(Setting).findOne({
+      where: { domain: { id: domain.id }, 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)
 
@@ -310,7 +340,7 @@ export class ArrivalNoticeMutation {
                 domain,
                 bizplace: foundBizplace,
                 name: OrderNoGenerator.orderProduct(),
-                // product: await childTx.getRepository(Product).findOne(op.product.id),
+                // product: await childTx.getRepository(Product).findOneBy({ id: op.product.id }),
                 status: ORDER_PRODUCT_STATUS.PENDING,
                 arrivalNotice: createdArrivalNotice,
                 creator: user
@@ -338,12 +368,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) },
@@ -372,7 +402,7 @@ export async function deleteArrivalNotice(
   domain: Domain
 ): Promise<boolean> {
   let foundArrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
-    where: { domain, name },
+    where: { domain: { id: domain.id }, name },
     relations: ['bizplace', 'releaseGood', 'orderProducts', 'orderVass', 'collectionOrders', 'creator', 'updater']
   })
 
@@ -425,11 +455,12 @@ export async function deleteArrivalNotice(
 export async function generateArrivalNoticeFunction(
   _: any,
   arrivalNotice: any,
+  fromPo: Boolean,
   files: FileUpload[],
   context: any,
   tx?: EntityManager
 ): Promise<ArrivalNotice> {
-  const { domain, user }: { domain: Domain; user: User } = context.state
+  const { domain, user } = context.state
   let orderProducts: OrderProduct[] = arrivalNotice.orderProducts
   let orderVass: OrderVas[] = arrivalNotice.orderVass
   let myBizplace: Bizplace
@@ -458,7 +489,7 @@ export async function generateArrivalNoticeFunction(
   if (arrivalNotice.supplier) {
     const supplier: ContactPoint = await tx
       .getRepository(ContactPoint)
-      .findOne({ where: { bizplace: arrivalNotice.supplier, domain }, relation: ['bizplace'] })
+      .findOne({ where: { bizplace: arrivalNotice.supplier, domain }, relations: ['bizplace'] })
 
     if (!supplier) throw new Error('contact point does not exist')
 
@@ -467,7 +498,7 @@ export async function generateArrivalNoticeFunction(
   // find GAN number rule setting
   const ganNoSetting: Setting = await settingRepo.findOne({
     where: {
-      domain,
+      domain: { id: domain.id },
       name: ORDER_NUMBER_SETTING_KEY.GAN_NUMBER_RULE
     }
   })
@@ -485,7 +516,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
   })
@@ -495,7 +526,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 +539,7 @@ export async function generateArrivalNoticeFunction(
     orderVass = await Promise.all(
       orderVass.map(async (ov: OrderVas) => {
         if (ov.targetProduct) {
-          ov.targetProduct = await tx.getRepository(Product).findOne(ov.targetProduct.id)
+          ov.targetProduct = await tx.getRepository(Product).findOneBy({ id: ov.targetProduct.id })
         }
 
         return {
@@ -516,10 +547,10 @@ export async function generateArrivalNoticeFunction(
           domain,
           bizplace: myBizplace,
           name: OrderNoGenerator.orderVas(),
-          vas: await tx.getRepository(Vas).findOne({ domain, id: ov.vas.id }),
+          vas: await tx.getRepository(Vas).findOneBy({ domain: { id: domain.id }, 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
         }
@@ -548,12 +579,13 @@ export async function confirmArrivalNoticeFunction(
   context: any,
   tx?: EntityManager
 ): Promise<ArrivalNotice> {
-  const { user, domain }: { user: User; domain: Domain } = context.state
+  const { user, domain } = context.state
 
   const foundArrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
-    where: { domain, name, status: ORDER_STATUS.PENDING },
+    where: { domain: { id: domain.id }, name, status: ORDER_STATUS.PENDING },
     relations: [
       'bizplace',
+      'bizplace.domain',
       'releaseGood',
       'orderProducts',
       'orderProducts.product',
@@ -567,25 +599,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: { id: domain.id }, 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)
@@ -620,37 +683,73 @@ export async function confirmArrivalNoticeFunction(
         data: { url: context.header.referer }
       }
 
-      await sendNotification({
-        receivers,
-        message: { ...msg }
-      })
+      /**
+       * @notes Temporary off sendNotification due to suspect of causing wms down
+       */
+
+      // await sendNotification({
+      //   receivers,
+      //   message: { ...msg }
+      // })
     }
   }
 
   return arrivalNotice
 }
 
-export async function receiveArrivalNoticeFunction(_: any, name: String, context: any): Promise<ArrivalNotice> {
-  const { user, domain, tx }: { user: User; domain: Domain; tx: EntityManager } = context.state
+export async function receiveArrivalNoticeFunction(
+  _: any,
+  name: string,
+  context: ResolverContext
+): Promise<ArrivalNotice> {
+  const { user, domain, tx } = context.state
   try {
     const foundArrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
-      where: { domain, name, status: ORDER_STATUS.PENDING_RECEIVE },
-      relations: ['bizplace', 'collectionOrders', 'orderProducts', 'orderVass']
+      where: { domain: { id: domain.id }, name, status: ORDER_STATUS.PENDING_RECEIVE },
+      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 }
+      where: { domain: { id: domain.id }, 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: { id: domain.id }, 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
       }
     })
@@ -661,7 +760,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
         }
       })
@@ -673,7 +772,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
         }
       })
@@ -691,16 +790,21 @@ export async function receiveArrivalNoticeFunction(_: any, name: String, context
         url: context.header.referer,
         data: { url: context.header.referer }
       }
-      await sendNotification({
-        receivers,
-        message: { ...msg }
-      })
+
+      /**
+       * @notes Temporary off sendNotification due to suspect of causing wms down
+       */
+
+      // await sendNotification({
+      //   receivers,
+      //   message: { ...msg }
+      // })
     }
 
     // 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
@@ -717,10 +821,10 @@ export async function checkArrivedNoticeFunction(
   context: any,
   tx?: EntityManager
 ): Promise<ArrivalNotice> {
-  const { user, domain }: { user: User; domain: Domain } = context.state
+  const { user, domain } = context.state
   try {
     const foundArrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
-      where: { domain, name, status: ORDER_STATUS.INTRANSIT },
+      where: { domain: { id: domain.id }, name, status: ORDER_STATUS.INTRANSIT },
       relations: ['bizplace', 'collectionOrders', 'orderProducts', 'orderVass']
     })
 
@@ -781,10 +885,15 @@ export async function checkArrivedNoticeFunction(
         url: context.header.referer,
         data: { url: context.header.referer }
       }
-      await sendNotification({
-        receivers,
-        message: { ...msg }
-      })
+
+      /**
+       * @notes Temporary off sendNotification due to suspect of causing wms down
+       */
+
+      // await sendNotification({
+      //   receivers,
+      //   message: { ...msg }
+      // })
     }
 
     return foundArrivalNotice
@@ -799,10 +908,10 @@ export async function rejectArrivalNotice(
   remark: string,
   context: any
 ): Promise<ArrivalNotice> {
-  const { user, domain }: { user: User; domain: Domain } = context.state
+  const { user, domain } = context.state
 
   const foundArrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
-    where: { domain, name, status: ORDER_STATUS.PENDING_RECEIVE },
+    where: { domain: { id: domain.id }, name, status: ORDER_STATUS.PENDING_RECEIVE },
     relations: ['bizplace', 'orderProducts', 'orderVass', 'collectionOrders']
   })
 
@@ -859,10 +968,14 @@ export async function rejectArrivalNotice(
       data: { url: context.header.referer }
     }
 
-    await sendNotification({
-      receivers,
-      message: { ...msg }
-    })
+    /**
+     * @notes Temporary off sendNotification due to suspect of causing wms down
+     */
+
+    // await sendNotification({
+    //   receivers,
+    //   message: { ...msg }
+    // })
   }
 
   return foundArrivalNotice
@@ -880,7 +993,7 @@ export async function addArrivalNoticeProducts(
 
   if (!arrivalNotice?.bizplace || !arrivalNotice?.orderProducts?.length) {
     arrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
-      where: { domain, name: arrivalNotice.name },
+      where: { domain: { id: domain.id }, name: arrivalNotice.name },
       relations: ['bizplace', 'orderProducts']
     })
   }
@@ -892,7 +1005,7 @@ export async function addArrivalNoticeProducts(
         domain,
         bizplace: arrivalNotice.bizplace,
         name: OrderNoGenerator.orderProduct(),
-        product: await productRepo.findOne(op.product.id),
+        product: await productRepo.findOneBy({ id: op.product.id }),
         arrivalNotice,
         creator: user
       }