@things-factory/sales-base 4.0.0-alpha.7 → 4.0.0-beta.1

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

@@ -0,0 +1,760 @@
+import { Attachment, createAttachments } from '@things-factory/attachment-base'
+import { Role, User } from '@things-factory/auth-base'
+import {
+  Bizplace,
+  getDomainUsers,
+  getMyBizplace,
+  getOutletBizplace,
+  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 { FileUpload, GraphQLUpload } from 'graphql-upload'
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager, getRepository, In, Repository } from 'typeorm'
+import {
+  ArrivalNoticePatch,
+  CollectionOrder,
+  JobSheet,
+  NewArrivalNotice,
+  NewOrderProduct,
+  OrderProduct,
+  OrderProductPatch,
+  OrderVas,
+  ReleaseGood,
+  Vas
+} from '../'
+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 { OrderNoGenerator } from '../../utils/order-no-generator'
+import { generateJobSheet } from '../job-sheet/job-sheet-mutation'
+import { confirmReleaseGood, deleteReleaseGood, rejectReleaseGood } from '../release-good/release-good-mutation'
+import { ArrivalNotice } from './arrival-notice'
+
+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: any): Promise<Boolean> {
+    const { tx, user, domain }: { tx: EntityManager; user: User; domain: Domain } = context.state
+
+    return await deleteArrivalNotice(tx, name, user, domain)
+  }
+
+  @Directive('@privilege(category: "order_customer", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => ArrivalNotice)
+  async generateArrivalNotice(
+    @Arg('arrivalNotice', type => NewArrivalNotice) arrivalNotice: NewArrivalNotice,
+    @Arg('files', type => GraphQLUpload) files: FileUpload,
+    @Ctx() context: any
+  ): Promise<ArrivalNotice> {
+    const { tx }: { tx: EntityManager } = context.state
+    const createdArrivalNotice: ArrivalNotice = await generateArrivalNoticeFunction(
+      null,
+      arrivalNotice,
+      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: any): Promise<ArrivalNotice> {
+    const { tx }: { tx: EntityManager } = 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, {
+        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: any): 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: any): Promise<ArrivalNotice> {
+    const { tx }: { tx: EntityManager } = 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: any
+  ): Promise<ArrivalNotice> {
+    const { tx }: { tx: EntityManager } = 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']
+        })
+
+      if (releaseGood.status !== ORDER_STATUS.REJECTED) {
+        await rejectReleaseGood(tx, releaseGood.name, patch.remark, context)
+      }
+    }
+
+    return arrivalNotice
+  }
+
+  @Directive('@privilege(category: "order_warehouse", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async addEditArrivalNoticeProducts(
+    @Ctx() context: any,
+    @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
+
+    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) {
+      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 }
+      }
+      await sendNotification({
+        receivers,
+        message: { ...msg }
+      })
+    }
+
+    return true
+  }
+
+  @Directive('@privilege(category: "order_customer", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => ArrivalNotice)
+  async addArrivalNotice(
+    @Ctx() context: any,
+    @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)
+
+    debug('createdGAN', createdGAN)
+
+    const confirmedGAN: ArrivalNotice = await confirmArrivalNoticeFunction(createdGAN.name, context, tx)
+
+    debug('confirmedGAN', confirmedGAN)
+
+    return confirmedGAN
+  }
+}
+
+export async function deleteArrivalNotice(
+  tx: EntityManager,
+  name: string,
+  user: User,
+  domain: Domain
+): Promise<boolean> {
+  let foundArrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
+    where: { domain, 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: foundArrivalNotice.bizplace,
+      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, name })
+    await deleteReleaseGood(tx, releaseGood.name, user, domain)
+  } else {
+    // 5. delete GAN
+    await tx.getRepository(ArrivalNotice).delete({ domain, name })
+  }
+  return true
+}
+
+export async function generateArrivalNoticeFunction(
+  _: any,
+  arrivalNotice: any,
+  files: FileUpload[],
+  context: any,
+  tx?: EntityManager
+): Promise<ArrivalNotice> {
+  const { domain, user }: { domain: Domain; user: 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.bizplaceId) myBizplace = context.state.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)
+
+  // find GAN number rule setting
+  const ganNoSetting: Setting = await settingRepo.findOne({
+    where: {
+      domain,
+      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: ORDER_STATUS.PENDING,
+    creator: user,
+    updater: user
+  })
+
+  // 2. Create arrival notice product
+  await addArrivalNoticeProducts(
+    domain,
+    createdArrivalNotice,
+    orderProducts.map((op: OrderProduct) => {
+      return { ...op, status: 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).findOne(ov.targetProduct.id)
+        }
+
+        return {
+          ...ov,
+          domain,
+          bizplace: myBizplace,
+          name: OrderNoGenerator.orderVas(),
+          vas: await tx.getRepository(Vas).findOne({ domain, id: ov.vas.id }),
+          type: ORDER_TYPES.ARRIVAL_NOTICE,
+          arrivalNotice: createdArrivalNotice,
+          status: ORDER_VAS_STATUS.PENDING,
+          creator: user,
+          updater: user
+        }
+      })
+    )
+    await tx.getRepository(OrderVas).save(orderVass)
+  }
+
+  if (files?.length) {
+    const attachments: Attachment[] = files.map(attachment => {
+      return {
+        file: attachment,
+        refBy: createdArrivalNotice.id,
+        category: ATTACHMENT_TYPE.GAN
+      }
+    })
+    await createAttachments(_, { attachments }, context)
+  }
+
+  return createdArrivalNotice
+}
+
+export async function confirmArrivalNoticeFunction(
+  name: string,
+  context: any,
+  tx?: EntityManager
+): Promise<ArrivalNotice> {
+  const { user, domain }: { user: User; domain: Domain } = context.state
+
+  const foundArrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
+    where: { domain, name, status: ORDER_STATUS.PENDING },
+    relations: [
+      'bizplace',
+      'releaseGood',
+      'orderProducts',
+      'orderProducts.product',
+      'orderVass',
+      'orderVass.vas',
+      'creator',
+      'updater'
+    ]
+  })
+
+  let foundOPs: OrderProduct[] = foundArrivalNotice.orderProducts
+  let foundOVs: OrderVas[] = foundArrivalNotice.orderVass
+  let customerBizplace: Bizplace = foundArrivalNotice.bizplace
+
+  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({
+    ...foundArrivalNotice,
+    status: ORDER_STATUS.PENDING_RECEIVE,
+    updater: user
+  })
+
+  foundOPs = foundOPs.map((op: OrderProduct) => {
+    return { ...op, status: ORDER_PRODUCT_STATUS.PENDING_RECEIVE }
+  })
+  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 }
+    })
+
+    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) {
+      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 }
+      }
+
+      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
+  try {
+    const foundArrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
+      where: { domain, name, status: ORDER_STATUS.PENDING_RECEIVE },
+      relations: ['bizplace', '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 }
+    })
+
+    // 1. Update status of order products (PENDING_RECEIVE => INTRANSIT)
+    foundOPs = foundOPs.map((op: OrderProduct) => {
+      return {
+        ...op,
+        status: ORDER_PRODUCT_STATUS.INTRANSIT,
+        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: ORDER_VAS_STATUS.INTRANSIT,
+          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: ORDER_STATUS.READY_TO_DISPATCH,
+          updater: user
+        }
+      })
+    }
+
+    // notification logics
+    const users: any[] = await getDomainUsers(foundArrivalNotice?.bizplace, tx)
+
+    // send notification to Customer Users
+    if (users?.length) {
+      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 }
+      }
+      await sendNotification({
+        receivers,
+        message: { ...msg }
+      })
+    }
+
+    // 4. Update status of arrival notice (PENDING_RECEIVE => INTRANSIT)
+    await tx.getRepository(ArrivalNotice).save({
+      ...foundArrivalNotice,
+      status: ORDER_STATUS.INTRANSIT,
+      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 }: { user: User; domain: Domain } = context.state
+  try {
+    const foundArrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
+      where: { domain, 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) {
+      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 }
+      }
+      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 }: { user: User; domain: Domain } = context.state
+
+  const foundArrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
+    where: { domain, 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) {
+    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 }
+    }
+
+    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, 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.findOne(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)
+}