@things-factory/sales-base 8.0.2 → 8.0.5

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

@@ -1,1152 +0,0 @@
-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, In, Repository } from 'typeorm'
-
-import { Attachment, createAttachments } from '@things-factory/attachment-base'
-import { Role, User } from '@things-factory/auth-base'
-import {
-  Bizplace,
-  ContactPoint,
-  getDomainUsers,
-  getMyBizplace,
-  getOutletBizplace,
-  getPermittedBizplaces
-} from '@things-factory/biz-base'
-import { generateId } from '@things-factory/id-rule-base'
-import { Product } from '@things-factory/product-base'
-import { PartnerSetting, Setting } from '@things-factory/setting-base'
-import { Domain, getRepository } from '@things-factory/shell'
-
-import {
-  ORDER_NUMBER_RULE_TYPE,
-  ORDER_NUMBER_SETTING_KEY,
-  ORDER_PRODUCT_STATUS,
-  ORDER_STATUS,
-  ORDER_TYPES,
-  ORDER_VAS_STATUS
-} from '../../constants'
-import { ATTACHMENT_TYPE } from '../../constants/attachment-type'
-import { ValidationError } from '../../errors'
-import { OrderNoGenerator } from '../../utils/order-no-generator'
-import { CollectionOrder } from '../collection-order/collection-order'
-import { JobSheet } from '../job-sheet/job-sheet'
-import { generateJobSheet } from '../job-sheet/job-sheet-mutation'
-import { OrderProduct } from '../order-product/order-product'
-import { NewOrderProduct, OrderProductPatch } from '../order-product/order-product-types'
-import { OrderVas } from '../order-vas/order-vas'
-import { ReleaseGood } from '../release-good/release-good'
-import { confirmReleaseGood, deleteReleaseGood, rejectReleaseGood } from '../release-good/release-good-mutation'
-import { Vas } from '../vas/vas'
-import { validateBulkArrivalNoticesFunction } from './'
-import { ArrivalNotice } from './arrival-notice'
-import { ArrivalNoticeList, ArrivalNoticePatch, NewArrivalNotice, RawArrivalNotice } from './arrival-notice-types'
-
-const debug = require('debug')('things-factory:operato-wms:addArrivalNotice')
-
-@Resolver(ArrivalNotice)
-export class ArrivalNoticeMutation {
-  @Directive('@privilege(category: "order_customer", privilege: "mutation")')
-  @Directive('@transaction')
-  @Mutation(returns => Boolean)
-  async deleteArrivalNotice(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<Boolean> {
-    const { tx, user, domain } = context.state
-
-    return await deleteArrivalNotice(tx, name, user, domain)
-  }
-
-  @Directive('@privilege(category: "order_customer", privilege: "mutation")')
-  @Directive('@transaction')
-  @Mutation(returns => ArrivalNotice)
-  async generateArrivalNotice(
-    @Ctx() context: ResolverContext,
-    @Arg('arrivalNotice', type => NewArrivalNotice) arrivalNotice: NewArrivalNotice,
-    @Arg('files', type => [GraphQLUpload], { nullable: true }) files?: FileUpload[]
-  ): Promise<ArrivalNotice> {
-    const { tx } = context.state
-    const createdArrivalNotice: ArrivalNotice = await generateArrivalNoticeFunction(
-      null,
-      arrivalNotice,
-      false,
-      files,
-      context,
-      tx
-    )
-
-    return createdArrivalNotice
-  }
-
-  @Directive('@privilege(category: "order_customer", privilege: "mutation")')
-  @Directive('@transaction')
-  @Mutation(returns => ArrivalNotice)
-  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({
-        where: { id: arrivalNotice.id },
-        relations: ['releaseGood']
-      })
-
-      // If status of related RO is not equal to PENDING_RECEIVE (i.e. Wasn't confirmed yet.)
-      if (releaseGood.status !== ORDER_STATUS.PENDING_RECEIVE) {
-        await confirmReleaseGood(releaseGood.name, context)
-      }
-    }
-
-    return arrivalNotice
-  }
-
-  @Directive('@privilege(category: "order_warehouse", privilege: "mutation")')
-  @Directive('@transaction')
-  @Mutation(returns => ArrivalNotice)
-  async receiveArrivalNotice(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<ArrivalNotice> {
-    const receiveArrivalNotice: ArrivalNotice = await receiveArrivalNoticeFunction(null, name, context)
-
-    return receiveArrivalNotice
-  }
-
-  @Directive('@privilege(category: "order_warehouse", privilege: "mutation")')
-  @Directive('@transaction')
-  @Mutation(returns => ArrivalNotice)
-  async checkArrivedNotice(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<ArrivalNotice> {
-    const { tx } = context.state
-
-    return await checkArrivedNoticeFunction(name, context, tx)
-  }
-
-  @Directive('@privilege(category: "order_warehouse", privilege: "mutation")')
-  @Directive('@transaction')
-  @Mutation(returns => ArrivalNotice)
-  async rejectArrivalNotice(
-    @Arg('name') name: string,
-    @Arg('patch', type => ArrivalNoticePatch) patch: ArrivalNoticePatch,
-    @Ctx() context: ResolverContext
-  ): Promise<ArrivalNotice> {
-    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({
-        where: { id: arrivalNotice.id },
-        relations: ['releaseGood']
-      })
-
-      if (releaseGood.status !== ORDER_STATUS.REJECTED) {
-        await rejectReleaseGood(tx, context, releaseGood.name, patch.remark)
-      }
-    }
-
-    return arrivalNotice
-  }
-
-  @Directive('@privilege(category: "order_warehouse", privilege: "mutation")')
-  @Directive('@transaction')
-  @Mutation(returns => Boolean)
-  async addEditArrivalNoticeProducts(
-    @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 } = context.state
-
-    let arrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
-      where: { name: ganNo },
-      relations: ['bizplace', 'orderProducts']
-    })
-
-    arrivalNotice.status = ORDER_STATUS.PENDING_APPROVAL
-    arrivalNotice.updater = user
-    arrivalNotice = await tx.getRepository(ArrivalNotice).save(arrivalNotice)
-
-    debug('gan-new-order-products', ganNo, newOrderProducts)
-    if (newOrderProducts?.length > 0) await addArrivalNoticeProducts(domain, arrivalNotice, newOrderProducts, user, tx)
-
-    debug('gan-existing-order-products', ganNo, existingOrderProducts)
-    if (existingOrderProducts?.length > 0) await editArrivalNoticeProducts(existingOrderProducts, user, tx)
-
-    // notification logics
-    const users: any[] = await getDomainUsers(arrivalNotice?.bizplace, tx)
-    debug('users', users)
-
-    if (users?.length && context.header?.referer) {
-      const receivers: any[] = users.map(user => user.id)
-      const msg = {
-        title: `Products are added/edited for ${arrivalNotice.name}`,
-        body: `Warehouse need your review for changes to be approved`,
-        url: context.header.referer,
-        data: { url: context.header.referer }
-      }
-      /**
-       * @notes Temporary off sendNotification due to suspect of causing wms down
-       */
-
-      // await sendNotification({
-      //   receivers,
-      //   message: { ...msg }
-      // })
-    }
-
-    return true
-  }
-
-  @Directive('@privilege(category: "order_customer", privilege: "mutation")')
-  @Directive('@transaction')
-  @Mutation(returns => ArrivalNotice)
-  async addArrivalNotice(
-    @Ctx() context: ResolverContext,
-    @Arg('arrivalNotice', type => NewArrivalNotice) arrivalNotice: NewArrivalNotice,
-    @Arg('file', type => GraphQLUpload, { nullable: true }) file?: FileUpload
-  ): Promise<ArrivalNotice> {
-    const { tx } = context.state
-    const createdGAN: ArrivalNotice = await generateArrivalNoticeFunction(null, arrivalNotice, false, file, context, tx)
-
-    debug('createdGAN', createdGAN)
-
-    const confirmedGAN: ArrivalNotice = await confirmArrivalNoticeFunction(createdGAN.name, context, tx)
-
-    debug('confirmedGAN', confirmedGAN)
-
-    return confirmedGAN
-  }
-
-  @Directive('@privilege(category: "order_customer", privilege: "mutation")')
-  @Directive('@transaction')
-  @Mutation(returns => ArrivalNotice)
-  async updateArrivalNoticeDetails(
-    @Ctx() context: ResolverContext,
-    @Arg('arrivalNotice', type => ArrivalNoticePatch) arrivalNotice: ArrivalNoticePatch
-  ): Promise<ArrivalNotice> {
-    const { domain, tx } = context.state
-    let existingArrivalNotice = await tx
-      .getRepository(ArrivalNotice)
-      .findOne({ where: { name: arrivalNotice.name, domain: { id: domain.id } } })
-
-    if (!existingArrivalNotice) {
-      throw new Error('Existing Arrival Notice not found.')
-    }
-
-    await tx.getRepository(ArrivalNotice).update(existingArrivalNotice.id, arrivalNotice)
-    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: ResolverContext,
-    @Arg('rawArrivalNotices', type => [NewArrivalNotice], { nullable: true }) rawArrivalNotices: NewArrivalNotice[],
-    @Arg('bizplaceId', type => String) bizplaceId: string,
-    @Arg('bufferLocation', type => String, { nullable: true }) bufferLocation: string
-  ): Promise<ArrivalNoticeList> {
-    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({ where: { id: bizplaceId }, relations: ['domain'] })
-
-    if (!foundBizplace) throw new Error('company not found')
-
-    // to check whether the raw data are valid
-    const validatedArrivalNotices: RawArrivalNotice[] = await validateBulkArrivalNoticesFunction(
-      rawArrivalNotices,
-      bizplaceId,
-      tx
-    )
-
-    // check for custom GAN order no setting
-    const ganNoSetting: Setting = await tx.getRepository(Setting).findOne({
-      where: {
-        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: { id: ganProcessingSetting.id },
-        domain: { id: domain.id },
-        partnerDomain: { id: foundBizplace.domain.id }
-      }
-    })
-
-    // If status of GAN is PENDING_RECEIVE then directly to assign warehouse
-    if (ganProcessingSetting) {
-      let setting = !isNaN(Number(partnerGanProcessingSetting?.value))
-        ? partnerGanProcessingSetting?.value
-        : ganProcessingSetting.value
-
-      // CONFIRM to assign if setting value is 1
-      if (Number(setting) == 1) {
-        opStatus = ORDER_PRODUCT_STATUS.ARRIVED
-        anStatus = ORDER_STATUS.ARRIVED
-      }
-    }
-
-    // extract rawArrivalNotices data into normal ArrivalNotice format
-    let arrivalNotices: Partial<ArrivalNotice[]> = extractArrivalNotices(validatedArrivalNotices)
-
-    for (let i = 0, l = arrivalNotices.length; i < l; i++) {
-      try {
-        await getConnection().transaction(async childTx => {
-          // check for duplication
-          const duplicatedArrivalNotice: ArrivalNotice = await childTx.getRepository(ArrivalNotice).findOne({
-            where: {
-              refNo: arrivalNotices[i].refNo,
-              refNo2: arrivalNotices[i].refNo2,
-              refNo3: arrivalNotices[i].refNo3,
-              etaDate: arrivalNotices[i].etaDate,
-              truckNo: arrivalNotices[i].truckNo,
-              containerNo: arrivalNotices[i].containerNo,
-              containerSize: arrivalNotices[i].containerSize,
-              looseItem: arrivalNotices[i].looseItem,
-              importCargo: arrivalNotices[i].importCargo
-            }
-          })
-
-          if (duplicatedArrivalNotice) {
-            throw new Error(`duplicated with ${duplicatedArrivalNotice.name}`)
-          }
-
-          // save new arrival notice
-          const createdArrivalNotice: ArrivalNotice = await childTx.getRepository(ArrivalNotice).save({
-            ...arrivalNotices[i],
-            name: ganNoSetting
-              ? await generateId({ domain, type: ORDER_NUMBER_RULE_TYPE.GAN_NUMBER, seed: {} })
-              : OrderNoGenerator.arrivalNotice(),
-            domain,
-            bizplace: foundBizplace,
-            status: ORDER_STATUS.PENDING,
-            creator: user,
-            updater: user
-          })
-
-          // save new order products
-          let createdOrderProducts: OrderProduct[] = await Promise.all(
-            arrivalNotices[i].orderProducts.map(async (op: OrderProduct) => {
-              return {
-                ...op,
-                domain,
-                bizplace: foundBizplace,
-                name: OrderNoGenerator.orderProduct(),
-                // product: await childTx.getRepository(Product).findOneBy({ id: op.product.id }),
-                status: ORDER_PRODUCT_STATUS.PENDING,
-                arrivalNotice: createdArrivalNotice,
-                creator: user
-              }
-            })
-          )
-          createdOrderProducts = await childTx.getRepository(OrderProduct).save(createdOrderProducts)
-
-          // generate new jobsheet
-          await generateJobSheet(domain, user, createdArrivalNotice, childTx)
-
-          // push arrivalNotice and orderProducts IDs if successfully saved
-          createdArrivalNoticeIds.push(createdArrivalNotice.id)
-          createdOrderProductIds.push(...createdOrderProducts.map(op => op.id))
-        })
-      } catch (error) {
-        // collect the arrivalNotice details and its error
-        let rawArrivalNotices: RawArrivalNotice[] = formRawArrivalNotices(arrivalNotices[i], error.message)
-        errorsCaught.push(...rawArrivalNotices)
-      }
-    }
-
-    if (createdArrivalNoticeIds.length && createdOrderProductIds.length) {
-      await getConnection().transaction(async childTx => {
-        // update arrivalNotices status to PENDING_RECEIVE
-        await childTx
-          .getRepository(ArrivalNotice)
-          .update({ id: In(createdArrivalNoticeIds) }, { status: anStatus, updater: user })
-
-        // update orderProducts status to PENDING_RECEIVE
-        await childTx
-          .getRepository(OrderProduct)
-          .update({ id: In(createdOrderProductIds) }, { status: opStatus, updater: user })
-
-        finalArrivalNoticeList = await childTx.getRepository(ArrivalNotice).find({
-          where: { id: In(createdArrivalNoticeIds) },
-          relations: ['orderProducts', 'orderProducts.product', 'bizplace']
-        })
-      })
-    }
-
-    if (errorsCaught.length) {
-      // should return this error list in the grist so that user know which gan need to amend
-      throw new ValidationError({
-        ...ValidationError.ERROR_CODES.INVALID_DATA_FOUND,
-        detail: { data: JSON.stringify(errorsCaught) }
-      })
-    }
-
-    // return arrivalNotices with its orderProducts list
-    return { items: finalArrivalNoticeList, total: 0 }
-  }
-}
-
-export async function deleteArrivalNotice(
-  tx: EntityManager,
-  name: string,
-  user: User,
-  domain: Domain
-): Promise<boolean> {
-  let foundArrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
-    where: { domain: { id: domain.id }, name },
-    relations: ['bizplace', 'releaseGood', 'orderProducts', 'orderVass', 'collectionOrders', 'creator', 'updater']
-  })
-
-  if (!foundArrivalNotice) throw new Error(`Arrival notice doesn't exists.`)
-
-  const foundJS: JobSheet = await tx.getRepository(JobSheet).findOne({
-    where: {
-      bizplace: { id: foundArrivalNotice.bizplace.id },
-      arrivalNoticeRefNo: foundArrivalNotice.name
-    }
-  })
-
-  if (foundJS) await tx.getRepository(JobSheet).delete({ arrivalNoticeRefNo: foundArrivalNotice.name })
-
-  const foundOPs: OrderProduct[] = foundArrivalNotice.orderProducts
-  const foundOVs: OrderVas[] = foundArrivalNotice.orderVass
-
-  // 1. delete order products
-  const productIds = foundOPs.map((product: OrderProduct) => product.id)
-  if (productIds.length) {
-    await tx.getRepository(OrderProduct).delete({ id: In(productIds) })
-  }
-
-  // 2. delete order vass
-  const vasIds = foundOVs.map((vas: OrderVas) => vas.id)
-  if (vasIds.length) {
-    await tx.getRepository(OrderVas).delete({ id: In(vasIds) })
-  }
-
-  await tx.getRepository(ArrivalNotice).save({
-    ...foundArrivalNotice,
-    updater: user
-  })
-
-  // 4. Remove relation with RO if it's cross docking
-  if (foundArrivalNotice.crossDocking && foundArrivalNotice.releaseGood?.id) {
-    let releaseGood: ReleaseGood = foundArrivalNotice.releaseGood
-    releaseGood.arrivalNotice = null
-    releaseGood = await tx.getRepository(ReleaseGood).save(releaseGood)
-
-    await tx.getRepository(ArrivalNotice).delete({ domain: { id: domain.id }, name })
-    await deleteReleaseGood(tx, releaseGood.name, user, domain)
-  } else {
-    // 5. delete GAN
-    await tx.getRepository(ArrivalNotice).delete({ domain: { id: domain.id }, name })
-  }
-  return true
-}
-
-export async function generateArrivalNoticeFunction(
-  _: any,
-  arrivalNotice: any,
-  fromPo: Boolean,
-  files: FileUpload[],
-  context: any,
-  tx?: EntityManager
-): Promise<ArrivalNotice> {
-  const { domain, user } = context.state
-  let orderProducts: OrderProduct[] = arrivalNotice.orderProducts
-  let orderVass: OrderVas[] = arrivalNotice.orderVass
-  let myBizplace: Bizplace
-  let orderNo: string = ''
-
-  const settingRepo: Repository<Setting> = tx?.getRepository(Setting) || getRepository(Setting)
-
-  if (arrivalNotice.bizplace) myBizplace = arrivalNotice.bizplace
-  else if (arrivalNotice.customerBizplaceId) {
-    const permittedBizplaces: Bizplace[] = await getPermittedBizplaces(domain, user)
-    let foundPermittedBizplace: Bizplace = permittedBizplaces.find(biz => biz.id == arrivalNotice.customerBizplaceId)
-
-    if (!foundPermittedBizplace) throw new Error(`This user does not permitted for this company`)
-
-    myBizplace = arrivalNotice.customerBizplaceId
-  } else if (arrivalNotice.partnerBizplaceId) {
-    const permittedBizplaces: Bizplace[] = await getPermittedBizplaces(domain, user)
-    let foundPermittedBizplace: Bizplace = permittedBizplaces.find(biz => biz.id == arrivalNotice.partnerBizplaceId)
-
-    if (!foundPermittedBizplace) throw new Error(`This user does not permitted for this company`)
-
-    myBizplace = arrivalNotice.partnerBizplaceId
-  } else if (arrivalNotice.warehouseId) myBizplace = await getOutletBizplace(arrivalNotice.warehouseId)
-  else myBizplace = await getMyBizplace(domain, user)
-
-  if (arrivalNotice.supplier) {
-    const supplier: ContactPoint = await tx.getRepository(ContactPoint).findOne({
-      where: { id: arrivalNotice.supplier, domain: { id: domain.id } },
-      relations: ['bizplace']
-    })
-
-    if (!supplier) throw new Error('contact point does not exist')
-
-    arrivalNotice.supplier = supplier
-  }
-  // find GAN number rule setting
-  const ganNoSetting: Setting = await settingRepo.findOne({
-    where: {
-      domain: { id: domain.id },
-      name: ORDER_NUMBER_SETTING_KEY.GAN_NUMBER_RULE
-    }
-  })
-
-  if (ganNoSetting) {
-    orderNo = await generateId({ domain, type: ORDER_NUMBER_RULE_TYPE.GAN_NUMBER, seed: {} })
-  } else {
-    orderNo = OrderNoGenerator.arrivalNotice()
-  }
-
-  // 1. Create arrival notice
-  const createdArrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).save({
-    ...arrivalNotice,
-    name: orderNo,
-    domain,
-    bizplace: myBizplace,
-    looseItem: arrivalNotice?.looseItem ? arrivalNotice.looseItem : false,
-    status: fromPo ? ORDER_STATUS.INTRANSIT : ORDER_STATUS.PENDING,
-    creator: user,
-    updater: user
-  })
-
-  // 2. Create arrival notice product
-  await addArrivalNoticeProducts(
-    domain,
-    createdArrivalNotice,
-    orderProducts.map((op: OrderProduct) => {
-      return { ...op, status: fromPo ? ORDER_PRODUCT_STATUS.INTRANSIT : ORDER_PRODUCT_STATUS.PENDING }
-    }),
-    user,
-    tx
-  )
-
-  await generateJobSheet(domain, user, createdArrivalNotice, tx)
-
-  // 3. Create arrival notice vas
-  if (orderVass?.length) {
-    orderVass = await Promise.all(
-      orderVass.map(async (ov: OrderVas) => {
-        if (ov.targetProduct) {
-          ov.targetProduct = await tx.getRepository(Product).findOneBy({ id: ov.targetProduct.id })
-        }
-
-        return {
-          ...ov,
-          domain,
-          bizplace: myBizplace,
-          name: OrderNoGenerator.orderVas(),
-          vas: await tx.getRepository(Vas).findOneBy({ domain: { id: domain.id }, id: ov.vas.id }),
-          type: ORDER_TYPES.ARRIVAL_NOTICE,
-          arrivalNotice: createdArrivalNotice,
-          status: fromPo ? ORDER_VAS_STATUS.INTRANSIT : ORDER_VAS_STATUS.PENDING,
-          creator: user,
-          updater: user
-        }
-      })
-    )
-    await tx.getRepository(OrderVas).save(orderVass)
-  }
-
-  if (files?.length) {
-    const attachments: Partial<Attachment>[] = files.map(attachment => {
-      return {
-        file: attachment,
-        refType: ATTACHMENT_TYPE.GAN,
-        refBy: createdArrivalNotice.id,
-        category: ATTACHMENT_TYPE.GAN /* TODO use refType */
-      }
-    })
-    await createAttachments(_, { attachments }, context)
-  }
-
-  return createdArrivalNotice
-}
-
-export async function confirmArrivalNoticeFunction(
-  name: string,
-  context: any,
-  tx?: EntityManager
-): Promise<ArrivalNotice> {
-  const { user, domain } = context.state
-
-  const foundArrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
-    where: { domain: { id: domain.id }, name, status: ORDER_STATUS.PENDING },
-    relations: [
-      'bizplace',
-      'bizplace.domain',
-      'releaseGood',
-      'orderProducts',
-      'orderProducts.product',
-      'orderVass',
-      'orderVass.vas',
-      'creator',
-      'updater'
-    ]
-  })
-
-  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' }
-  })
-
-  // If status of GAN is PENDING_RECEIVE then directly to assign warehouse
-  if (ganProcessingSetting) {
-    const partnerGanProcessingSetting: PartnerSetting = await tx.getRepository(PartnerSetting).findOne({
-      where: {
-        setting: { id: ganProcessingSetting.id },
-        domain: { id: domain.id },
-        partnerDomain: { id: customerBizplace?.domain?.id }
-      }
-    })
-
-    let setting = !isNaN(Number(partnerGanProcessingSetting?.value))
-      ? partnerGanProcessingSetting?.value
-      : ganProcessingSetting.value
-
-    // CONFIRM to assign if setting value is 1
-    if (Number(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)
-  let arrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).save({
-    ...foundArrivalNotice,
-    status: anStatus,
-    updater: user,
-    acceptedBy: acceptedByUser,
-    acceptedAt: acceptedTime
-  })
-
-  foundOPs = foundOPs.map((op: OrderProduct) => {
-    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: ovStatus }
-    })
-
-    await tx.getRepository(OrderVas).save(foundOVs)
-  }
-
-  // notification logics
-  // get Office Admin Users
-  if (context?.state?.type != 'api') {
-    const users: any[] = await tx
-      .getRepository('users_roles')
-      .createQueryBuilder('ur')
-      .select('ur.users_id', 'id')
-      .where(qb => {
-        const subQuery = qb
-          .subQuery()
-          .select('role.id')
-          .from(Role, 'role')
-          .where("role.name = 'Office Admin'")
-          .andWhere('role.domain_id = :domain', { domain: domain.id })
-          .getQuery()
-        return 'ur.roles_id IN ' + subQuery
-      })
-      .getRawMany()
-
-    // send notification to Office Admin Users
-    if (users?.length && context.header?.referer) {
-      const receivers: any[] = users.map(user => user.id)
-      const msg = {
-        title: `New Arrival Notice from ${customerBizplace.name}`,
-        body: `New incoming order, ${foundArrivalNotice.name} is pending for receiving`,
-        url: context.header.referer,
-        data: { url: context.header.referer }
-      }
-
-      /**
-       * @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: ResolverContext
-): Promise<ArrivalNotice> {
-  const { user, domain, tx } = context.state
-  try {
-    const foundArrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
-      where: { domain: { id: domain.id }, name, status: ORDER_STATUS.PENDING_RECEIVE },
-      relations: ['bizplace', 'bizplace.domain', 'collectionOrders', 'orderProducts', 'orderVass']
-    })
-
-    let foundOPs: OrderProduct[] = foundArrivalNotice.orderProducts
-    let foundOVs: OrderVas[] = foundArrivalNotice.orderVass
-    let foundCOs: CollectionOrder[] = await tx.getRepository(CollectionOrder).find({
-      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' }
-    })
-
-    // If status of GAN is INTRANSIT then directly to assign warehouse
-    if (ganProcessingSetting) {
-      const partnerGanProcessingSetting: PartnerSetting = await tx.getRepository(PartnerSetting).findOne({
-        where: {
-          setting: { id: ganProcessingSetting.id },
-          domain: { id: domain.id },
-          partnerDomain: { id: customerBizplace?.domain?.id }
-        }
-      })
-
-      let setting = !isNaN(Number(partnerGanProcessingSetting?.value))
-        ? partnerGanProcessingSetting?.value
-        : ganProcessingSetting.value
-
-      // RECEIVE to assign if setting value is 2
-      if (Number(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: opStatus,
-        updater: user
-      }
-    })
-    await tx.getRepository(OrderProduct).save(foundOPs)
-
-    // 2. Update status of order vass if it exists (PENDING_RECEIVE => INTRANSIT)
-    if (foundOVs && foundOVs.length) {
-      foundOVs = foundOVs.map((ov: OrderVas) => {
-        return {
-          ...ov,
-          status: ovStatus,
-          updater: user
-        }
-      })
-      await tx.getRepository(OrderVas).save(foundOVs)
-    }
-
-    // 3. If there's collection order, update status of collection order (PENDING_RECEIVE => READY_TO_DISPATCH)
-    if (foundCOs) {
-      foundCOs = foundCOs.map((co: CollectionOrder) => {
-        return {
-          ...co,
-          status: coStatus,
-          updater: user
-        }
-      })
-    }
-
-    // notification logics
-    const users: any[] = await getDomainUsers(foundArrivalNotice?.bizplace, tx)
-
-    // send notification to Customer Users
-    if (users?.length && context.header?.referer) {
-      const receivers: any[] = users.map(user => user.id)
-      const msg = {
-        title: `Latest status for ${foundArrivalNotice.name}`,
-        body: `Your GAN has been received and processed by ${domain.name}`,
-        url: context.header.referer,
-        data: { url: context.header.referer }
-      }
-
-      /**
-       * @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)
-    let rcvArrivalNotice = await tx.getRepository(ArrivalNotice).save({
-      ...foundArrivalNotice,
-      status: anStatus,
-      acceptedBy: user,
-      acceptedAt: new Date(),
-      updater: user
-    })
-
-    return foundArrivalNotice
-  } catch (e) {
-    throw e
-  }
-}
-
-export async function checkArrivedNoticeFunction(
-  name: string,
-  context: any,
-  tx?: EntityManager
-): Promise<ArrivalNotice> {
-  const { user, domain } = context.state
-  try {
-    const foundArrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
-      where: { domain: { id: domain.id }, name, status: ORDER_STATUS.INTRANSIT },
-      relations: ['bizplace', 'collectionOrders', 'orderProducts', 'orderVass']
-    })
-
-    debug('ganNo', name, foundArrivalNotice)
-
-    if (!foundArrivalNotice) throw new Error(`Arrival notice doesn't exists.`)
-
-    // 1. Check wheter related collection order is done or not
-    const foundCOs: CollectionOrder[] = foundArrivalNotice.collectionOrders
-    if (foundCOs && foundCOs.length) {
-      foundCOs.map((co: CollectionOrder) => {
-        if (co.status !== ORDER_STATUS.DONE) {
-          throw new Error(`Collection Order: ${co.name} is not finished yet.`)
-        }
-      })
-    }
-
-    let foundOPs: OrderProduct[] = foundArrivalNotice.orderProducts
-    let foundOVs: OrderVas[] = foundArrivalNotice.orderVass
-
-    // 2. Update status of order products (INTRANSIT => ARRIVED)
-    foundOPs = foundOPs.map((op: OrderProduct) => {
-      return {
-        ...op,
-        status: ORDER_PRODUCT_STATUS.ARRIVED,
-        updater: user
-      }
-    })
-    await tx.getRepository(OrderProduct).save(foundOPs)
-
-    // 3. Update status of order vass if it exists (INTRANSIT => ARRIVED)
-    if (foundOVs && foundOVs.length) {
-      foundOVs = foundOVs.map((ov: OrderVas) => {
-        return {
-          ...ov,
-          status: ORDER_VAS_STATUS.ARRIVED,
-          updater: user
-        }
-      })
-      await tx.getRepository(OrderVas).save(foundOVs)
-    }
-
-    // 4. Update status of arrival notice (INTRANSIT => ARRIVED)
-    await tx.getRepository(ArrivalNotice).save({
-      ...foundArrivalNotice,
-      status: ORDER_STATUS.ARRIVED,
-      updater: user
-    })
-
-    // notification logics
-    const users: any[] = await getDomainUsers(foundArrivalNotice?.bizplace, tx)
-
-    if (users?.length && context.header?.referer) {
-      const receivers: any[] = users.map(user => user.id)
-      const msg = {
-        title: `Latest status for ${foundArrivalNotice.name}`,
-        body: `Your goods has safely arrived at ${domain.name}`,
-        url: context.header.referer,
-        data: { url: context.header.referer }
-      }
-
-      /**
-       * @notes Temporary off sendNotification due to suspect of causing wms down
-       */
-
-      // await sendNotification({
-      //   receivers,
-      //   message: { ...msg }
-      // })
-    }
-
-    return foundArrivalNotice
-  } catch (e) {
-    throw e
-  }
-}
-
-export async function rejectArrivalNotice(
-  tx: EntityManager,
-  name: string,
-  remark: string,
-  context: any
-): Promise<ArrivalNotice> {
-  const { user, domain } = context.state
-
-  const foundArrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
-    where: { domain: { id: domain.id }, name, status: ORDER_STATUS.PENDING_RECEIVE },
-    relations: ['bizplace', 'orderProducts', 'orderVass', 'collectionOrders']
-  })
-
-  if (!foundArrivalNotice) throw new Error(`Arrival notice doesn't exists.`)
-  if (!remark) throw new Error('Remark is not exist.')
-
-  let foundOPs: OrderProduct[] = foundArrivalNotice.orderProducts
-  let foundOVs: OrderVas[] = foundArrivalNotice.orderVass
-  let foundCOs: CollectionOrder[] = foundArrivalNotice.collectionOrders
-
-  // 1. Update status of order products (PENDING_RECEIVE => REJECTED)
-  foundOPs = foundOPs.map((op: OrderProduct) => {
-    op.status = ORDER_PRODUCT_STATUS.REJECTED
-    op.updater = user
-    return op
-  })
-  await tx.getRepository(OrderProduct).save(foundOPs)
-
-  // 2. Update status of order vass if it exists (PENDING_RECEIVE => REJECTED)
-  if (foundOVs && foundOVs.length) {
-    foundOVs = foundOVs.map((ov: OrderVas) => {
-      ov.status = ORDER_VAS_STATUS.REJECTED
-      ov.updater = user
-      return ov
-    })
-    await tx.getRepository(OrderVas).save(foundOVs)
-  }
-
-  // 3. If there's collection order, update status of collection order (PENDING_RECEIVE => REJECTED)
-  if (foundCOs) {
-    foundCOs = foundCOs.map((co: CollectionOrder) => {
-      co.status = ORDER_STATUS.REJECTED
-      co.updater = user
-      return co
-    })
-    await tx.getRepository(CollectionOrder).save(foundCOs)
-  }
-
-  foundArrivalNotice.remark = remark
-  foundArrivalNotice.status = ORDER_STATUS.REJECTED
-  foundArrivalNotice.updater = user
-  await tx.getRepository(ArrivalNotice).save(foundArrivalNotice)
-
-  // notification logics
-  const users: any[] = await getDomainUsers(foundArrivalNotice?.bizplace, tx)
-
-  // send notification to Customer Users
-  if (users?.length && context.header?.referer) {
-    const receivers: any[] = users.map(user => user.id)
-    const msg = {
-      title: `Latest status for ${foundArrivalNotice.name}`,
-      body: `Your GAN has been rejected.`,
-      url: context.header.referer,
-      data: { url: context.header.referer }
-    }
-
-    /**
-     * @notes Temporary off sendNotification due to suspect of causing wms down
-     */
-
-    // await sendNotification({
-    //   receivers,
-    //   message: { ...msg }
-    // })
-  }
-
-  return foundArrivalNotice
-}
-
-export async function addArrivalNoticeProducts(
-  domain: Domain,
-  arrivalNotice: ArrivalNotice,
-  newOrderProducts: any[],
-  user: User,
-  tx?: EntityManager
-): Promise<void> {
-  const productRepo: Repository<Product> = tx?.getRepository(Product) || getRepository(Product)
-  const orderProductRepo: Repository<OrderProduct> = tx?.getRepository(OrderProduct) || getRepository(OrderProduct)
-
-  if (!arrivalNotice?.bizplace || !arrivalNotice?.orderProducts?.length) {
-    arrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
-      where: { domain: { id: domain.id }, name: arrivalNotice.name },
-      relations: ['bizplace', 'orderProducts']
-    })
-  }
-
-  const createdOrderProducts: OrderProduct[] = await Promise.all(
-    newOrderProducts.map(async (op: OrderProduct) => {
-      return {
-        ...op,
-        domain,
-        bizplace: arrivalNotice.bizplace,
-        name: OrderNoGenerator.orderProduct(),
-        product: await productRepo.findOneBy({ id: op.product.id }),
-        arrivalNotice,
-        creator: user
-      }
-    })
-  )
-
-  debug('gan-created-order-products', createdOrderProducts)
-  await orderProductRepo.save(createdOrderProducts)
-}
-
-export async function editArrivalNoticeProducts(
-  existingOrderProducts: (OrderProduct | OrderProductPatch)[],
-  user: User,
-  tx?: EntityManager
-): Promise<void> {
-  const orderProductRepo: Repository<OrderProduct> = tx?.getRepository(OrderProduct) || getRepository(OrderProduct)
-
-  const updatedOrderProducts: OrderProduct[] = await Promise.all(
-    existingOrderProducts.map(async (op: OrderProduct) => {
-      return {
-        ...op,
-        status: ORDER_PRODUCT_STATUS.EDITED,
-        updater: user
-      }
-    })
-  )
-
-  debug('gan-updated-order-products', updatedOrderProducts)
-  await orderProductRepo.save(updatedOrderProducts)
-}
-
-function extractArrivalNotices(rawArrivalNotices): Partial<ArrivalNotice[]> {
-  return rawArrivalNotices.reduce((arrivalNotices, raw) => {
-    // discard the item that has no productId or productDetailId
-    if (!raw.productId || !raw.productDetailId) return
-
-    const idx: number = arrivalNotices.findIndex(an => {
-      // consider these attributes if they are exist in "item"
-      const comparison = [
-        'refNo2',
-        'refNo3',
-        'truckNo',
-        'ownTransport',
-        'container',
-        'containerNo',
-        'containerSize',
-        'looseItem',
-        'importCargo'
-      ]
-
-      let a: any = {},
-        b: any = {}
-
-      comparison.forEach(cc => {
-        if (raw[cc] !== null) {
-          a[cc] = raw[cc]
-          b[cc] = an[cc]
-        }
-      })
-
-      a = JSON.stringify(Object.fromEntries(Object.entries(a).sort()))
-      b = JSON.stringify(Object.fromEntries(Object.entries(b).sort()))
-
-      return an.refNo == raw.refNo && an.etaDate == raw.etaDate && a === b
-    })
-
-    const product: Product = Object.assign(new Product(), { id: raw.productId, sku: raw.sku })
-    const orderProduct: Partial<OrderProduct> = {
-      product,
-      batchId: raw.batchId,
-      batchIdRef: raw.batchIdRef,
-      packingType: raw.packingType,
-      packingSize: raw.packingSize,
-      packQty: raw.packQty,
-      uomValue: raw.uomValue,
-      uom: raw.uom,
-      totalUomValue: raw.totalUomValue,
-      palletQty: raw.palletQty,
-      unitPrice: raw.unitPrice,
-      manufactureDate: raw.manufactureDate
-    }
-
-    if (idx >= 0) {
-      const duplicateSkuIdx: number = arrivalNotices[idx].orderProducts.findIndex(
-        op =>
-          op.sku === raw.sku &&
-          op.packingType === raw.packingType &&
-          op.packingSize === raw.packingSize &&
-          op.batchId === raw.batchId
-      )
-
-      if (duplicateSkuIdx >= 0) arrivalNotices[idx].orderProducts[duplicateSkuIdx].packQty += raw.packQty
-      else arrivalNotices[idx].orderProducts.push(orderProduct)
-    } else {
-      arrivalNotices.push({
-        refNo: raw.refNo,
-        refNo2: raw.refNo2,
-        refNo3: raw.refNo3,
-        etaDate: raw.etaDate,
-        truckNo: raw.truckNo,
-        ownTransport: raw.ownTransport,
-        container: raw.container,
-        containerNo: raw.containerNo,
-        containerSize: raw.containerSize,
-        importCargo: raw.importCargo,
-        looseItem: raw.looseItem,
-        orderProducts: [orderProduct]
-      })
-    }
-
-    return arrivalNotices
-  }, [])
-}
-
-function formRawArrivalNotices(arrivalNotice, errorMsg) {
-  let rawArrivalNotices = []
-  for (let i = 0, l = arrivalNotice.orderProducts.length; i < l; i++) {
-    let rawArrivalNotice = {
-      ...arrivalNotice,
-      ...arrivalNotice.orderProducts[i],
-      sku: arrivalNotice.orderProducts[i].product.sku,
-      errorMsg
-    }
-
-    delete rawArrivalNotice.orderProducts
-    delete rawArrivalNotice.product
-
-    rawArrivalNotices.push(rawArrivalNotice)
-  }
-  return rawArrivalNotices
-}