@things-factory/sales-base 8.0.0-beta.8 → 8.0.0

package/server/service/return-order/return-order-mutation.ts

@@ -0,0 +1,516 @@
+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, In } from 'typeorm'
+
+import { Attachment, createAttachments } from '@things-factory/attachment-base'
+import { Role } from '@things-factory/auth-base'
+import { Bizplace, getDomainUsers } from '@things-factory/biz-base'
+import { Product } from '@things-factory/product-base'
+import { Inventory } from '@things-factory/warehouse-base'
+
+import { NewOrderInventory, NewReturnOrder, OrderInventory, OrderVas, ReturnOrderPatch } from '../'
+import { ATTACHMENT_TYPE, ORDER_INVENTORY_STATUS, ORDER_STATUS, ORDER_VAS_STATUS } from '../../constants'
+import { OrderNoGenerator } from '../../utils'
+import { ReturnOrder } from './return-order'
+
+@Resolver(ReturnOrder)
+export class ReturnOrderMutation {
+  @Directive('@privilege(category: "order_customer", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteReturnOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { tx } = context.state
+
+    return await deleteReturnOrder(tx, name, context)
+  }
+
+  @Directive('@privilege(category: "order_customer", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteReturnOrders(
+    @Arg('names', type => [String]) names: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { tx, domain } = context.state
+
+    await tx.getRepository(ReturnOrder).delete({
+      domain: { id: domain.id },
+      name: In(names)
+    })
+    return true
+  }
+
+  @Directive('@privilege(category: "order_customer", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => ReturnOrder)
+  async generateReturnOrder(
+    @Ctx() context: ResolverContext,
+    @Arg('file', type => [GraphQLUpload], { nullable: true }) file: FileUpload[],
+    @Arg('returnOrder', type => NewReturnOrder, { nullable: true }) returnOrder: NewReturnOrder
+  ): Promise<ReturnOrder> {
+    const { tx, domain, user } = context.state
+
+    const bizplace: Bizplace = await tx.getRepository(Bizplace).findOneBy({ id: returnOrder.customerBizplaceId })
+
+    let orderInventories: NewOrderInventory[] = returnOrder.orderInventories
+    let foundInv = Inventory
+
+    const mergedOrderInventories = orderInventories.reduce((acc, curr) => {
+      let existingItem = acc.find(
+        itm =>
+          itm.product.id === curr.product.id &&
+          itm.packingType === curr.packingType &&
+          itm.batchId === curr.batchId &&
+          itm.packingSize === curr.packingSize
+      )
+
+      if (!existingItem) {
+        acc.push(curr)
+      } else {
+        existingItem.returnQty = existingItem.returnQty + curr.returnQty
+        existingItem.returnUomValue = existingItem.returnUomValue + curr.returnUomValue
+      }
+
+      return acc
+    }, [])
+
+    returnOrder.orderInventories = mergedOrderInventories
+
+    let newReturnOrder: NewReturnOrder = {
+      ...returnOrder,
+      name: OrderNoGenerator.returnOrder(),
+      domain,
+      bizplace,
+      status: ORDER_STATUS.PENDING,
+      creator: user,
+      updater: user
+    }
+
+    if (newReturnOrder.orderInventories[0].returnQty < 0) {
+      throw new Error('invalid return quantity')
+    }
+
+    let createdReturnOrder: ReturnOrder = await tx.getRepository(ReturnOrder).save(newReturnOrder as any)
+
+    for (let moi of mergedOrderInventories) {
+      let newOrderInv: OrderInventory = Object.assign({}, moi) as any
+      newOrderInv.domain = domain
+      newOrderInv.bizplace = bizplace
+      newOrderInv.status = ORDER_INVENTORY_STATUS.PENDING
+      newOrderInv.name = OrderNoGenerator.orderInventory()
+      newOrderInv.returnOrder = createdReturnOrder
+      newOrderInv.product = await tx.getRepository(Product).findOneBy({ id: moi.product.id })
+      newOrderInv.creator = user
+      newOrderInv.updater = user
+
+      if (newOrderInv.inventory?.id) {
+        foundInv = (await tx.getRepository(Inventory).findOneBy({ id: newOrderInv.inventory.id })) as any
+        newOrderInv.inventory = foundInv as any
+      }
+
+      await tx.getRepository(OrderInventory).save(newOrderInv)
+    }
+
+    if (file?.length > 0) {
+      const attachments: Partial<Attachment>[] = file.map(attachment => {
+        return {
+          file: attachment,
+          refType: ATTACHMENT_TYPE.RETURN_ORDER,
+          refBy: createdReturnOrder.id,
+          category: ATTACHMENT_TYPE.RETURN_ORDER /* TODO use refType */
+        }
+      })
+      await createAttachments(null, { attachments }, context)
+    }
+
+    return createdReturnOrder
+  }
+
+  @Directive('@privilege(category: "order_customer", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => ReturnOrder)
+  async confirmReturnOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<ReturnOrder> {
+    const { tx } = context.state
+
+    const returnOrder: ReturnOrder = await confirmReturnOrder(tx, name, context)
+
+    return returnOrder
+  }
+
+  @Directive('@privilege(category: "order_customer", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => ReturnOrder)
+  async receiveReturnOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<ReturnOrder> {
+    const { tx } = context.state
+    const returnOrder: ReturnOrder = await receiveReturnOrder(tx, name, context)
+
+    return returnOrder
+  }
+
+  @Directive('@privilege(category: "order_customer", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => ReturnOrder)
+  async rejectReturnOrder(
+    @Arg('name') name: string,
+    @Arg('patch', type => ReturnOrderPatch) patch: ReturnOrderPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<ReturnOrder> {
+    const { tx } = context.state
+    const returnOrder: ReturnOrder = await rejectReturnOrder(tx, name, patch.remark, context)
+
+    return returnOrder
+  }
+
+  @Directive('@privilege(category: "order_customer", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => ReturnOrder)
+  async checkReturnOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<ReturnOrder> {
+    const { tx } = context.state
+    const returnOrder: ReturnOrder = await checkReturnOrder(tx, name, context)
+
+    return returnOrder
+  }
+}
+
+export async function deleteReturnOrder(tx: EntityManager, name: string, context: ResolverContext): Promise<boolean> {
+  const { domain } = context.state
+
+  let foundReturnOrder: ReturnOrder = await tx.getRepository(ReturnOrder).findOne({
+    where: { domain: { id: domain.id }, name },
+    relations: ['orderInventories', 'orderInventories.inventory', 'orderVass', 'creator', 'updater']
+  })
+
+  if (!foundReturnOrder) throw new Error(`Return Order doesn't exists.`)
+  const foundOIs: OrderInventory[] = foundReturnOrder.orderInventories
+  const foundOVs: OrderVas[] = foundReturnOrder.orderVass
+
+  let foundAttachment: Attachment
+  if (foundReturnOrder?.ownTransport) {
+    foundAttachment = await tx.getRepository(Attachment).findOne({
+      where: {
+        domain: { id: domain.id },
+        refBy: foundReturnOrder.id,
+        category: ATTACHMENT_TYPE.RETURN_ORDER
+      }
+    })
+  }
+
+  // Update locked qty and locked weight of inventories and return id list of order inventories
+  const inventoryIds: string[] = foundOIs.map((oi: OrderInventory) => oi.id)
+
+  // Delete order inventories by ids
+  if (inventoryIds.length) {
+    await tx.getRepository(OrderInventory).delete({ id: In(inventoryIds) })
+  }
+
+  // 2. delete order vass
+  const vasIds = foundOVs.map((vas: OrderVas) => vas.id)
+  if (vasIds.length) {
+    await tx.getRepository(OrderVas).delete({ id: In(vasIds) })
+  }
+
+  if (foundAttachment) {
+    await tx.getRepository(Attachment).delete({ domain: { id: domain.id }, id: foundAttachment.id })
+  }
+
+  await tx.getRepository(ReturnOrder).delete({ domain: { id: domain.id }, name })
+  return true
+}
+
+export async function confirmReturnOrder(
+  tx: EntityManager,
+  name: string,
+  context: ResolverContext
+): Promise<ReturnOrder> {
+  const { domain, user } = context.state
+
+  const foundReturnOrder: ReturnOrder = await tx.getRepository(ReturnOrder).findOne({
+    where: { domain: { id: domain.id }, name, status: ORDER_STATUS.PENDING },
+    relations: ['bizplace', 'orderInventories', 'orderVass']
+  })
+
+  if (!foundReturnOrder) throw new Error(`Return order doesn't exists.`)
+  let foundOIs: OrderInventory[] = foundReturnOrder.orderInventories
+  let foundOVs: OrderVas[] = foundReturnOrder.orderVass
+  let customerBizplace: Bizplace = foundReturnOrder.bizplace
+
+  // 1. RO Status change (PENDING => PENDING_RECEIVE)
+  const returnOrder: ReturnOrder = await tx.getRepository(ReturnOrder).save({
+    ...foundReturnOrder,
+    status: ORDER_STATUS.PENDING_RECEIVE,
+    updater: user
+  })
+
+  // 1. Update status of order inventories
+  foundOIs = foundOIs.map((orderInventory: OrderInventory) => {
+    return {
+      ...orderInventory,
+      status: ORDER_INVENTORY_STATUS.PENDING_RECEIVE,
+      updater: user
+    }
+  })
+  await tx.getRepository(OrderInventory).save(foundOIs)
+
+  // 2. Update status of order vass
+  if (foundOVs && foundOVs.length) {
+    foundOVs = foundOVs.map((orderVas: OrderVas) => {
+      return {
+        ...orderVas,
+        status: ORDER_VAS_STATUS.PENDING_RECEIVE,
+        updater: user
+      }
+    })
+    await tx.getRepository(OrderVas).save(foundOVs)
+  }
+
+  // notification logics
+  // get Office Admin Users
+  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 Return Order from ${customerBizplace.name}`,
+      body: `New incoming order, ${foundReturnOrder.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 returnOrder
+}
+
+export async function receiveReturnOrder(
+  tx: EntityManager,
+  name: string,
+  context: ResolverContext
+): Promise<ReturnOrder> {
+  const { domain, user } = context.state
+
+  const foundReturnOrder: ReturnOrder = await tx.getRepository(ReturnOrder).findOne({
+    where: { domain: { id: domain.id }, name, status: ORDER_STATUS.PENDING_RECEIVE },
+    relations: ['bizplace', 'orderInventories', 'orderVass']
+  })
+
+  if (!foundReturnOrder) throw new Error(`Return order doesn't exists.`)
+  let foundOIs: OrderInventory[] = foundReturnOrder.orderInventories
+  let foundOVs: OrderVas[] = foundReturnOrder.orderVass
+
+  // 1. RO Status change (PENDING_RECEIVE => INTRANSIT)
+  const returnOrder: ReturnOrder = await tx.getRepository(ReturnOrder).save({
+    ...foundReturnOrder,
+    status: ORDER_STATUS.INTRANSIT,
+    updater: user,
+    acceptedBy: user,
+    acceptedAt: new Date()
+  })
+
+  // 1. Update status of order inventories
+  foundOIs = foundOIs.map((orderInventory: OrderInventory) => {
+    return {
+      ...orderInventory,
+      status: ORDER_INVENTORY_STATUS.INTRANSIT,
+      updater: user
+    }
+  })
+  await tx.getRepository(OrderInventory).save(foundOIs)
+
+  // 2. Update status of order vass
+  if (foundOVs && foundOVs.length) {
+    foundOVs = foundOVs.map((orderVas: OrderVas) => {
+      return {
+        ...orderVas,
+        status: ORDER_VAS_STATUS.INTRANSIT,
+        updater: user
+      }
+    })
+    await tx.getRepository(OrderVas).save(foundOVs)
+  }
+
+  // notification logics
+  const users: any[] = await getDomainUsers(foundReturnOrder?.bizplace, tx)
+
+  if (users?.length && context.header?.referer) {
+    const receivers: any[] = users.map(user => user.id)
+    const msg = {
+      title: `Latest status for ${foundReturnOrder.name}`,
+      body: `Your Return Order 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 }
+    // })
+  }
+
+  return returnOrder
+}
+
+export async function rejectReturnOrder(
+  tx: EntityManager,
+  name: string,
+  remark: string,
+  context: any
+): Promise<ReturnOrder> {
+  const { domain, user } = context.state
+
+  const foundReturnOrder: ReturnOrder = await tx.getRepository(ReturnOrder).findOne({
+    where: { domain: { id: domain.id }, name, status: ORDER_STATUS.PENDING_RECEIVE },
+    relations: ['bizplace', 'orderInventories', 'orderVass']
+  })
+
+  if (!foundReturnOrder) throw new Error(`Return order doesn't exists.`)
+  if (!remark) throw new Error('Remark is not exist.')
+
+  let foundOIs: OrderInventory[] = foundReturnOrder.orderInventories
+  let foundOVs: OrderVas[] = foundReturnOrder.orderVass
+
+  foundReturnOrder.remark = remark
+  foundReturnOrder.status = ORDER_STATUS.REJECTED
+  foundReturnOrder.updater = user
+  await tx.getRepository(ReturnOrder).save(foundReturnOrder)
+
+  // 1. Update status of order inventories
+  foundOIs = foundOIs.map((orderInventory: OrderInventory) => {
+    return {
+      ...orderInventory,
+      status: ORDER_INVENTORY_STATUS.REJECTED,
+      updater: user
+    }
+  })
+  await tx.getRepository(OrderInventory).save(foundOIs)
+
+  // 2. Update status of order vass
+  if (foundOVs && foundOVs.length) {
+    foundOVs = foundOVs.map((orderVas: OrderVas) => {
+      return {
+        ...orderVas,
+        status: ORDER_VAS_STATUS.REJECTED,
+        updater: user
+      }
+    })
+    await tx.getRepository(OrderVas).save(foundOVs)
+  }
+
+  // notification logics
+  const users: any[] = await getDomainUsers(foundReturnOrder?.bizplace, tx)
+
+  if (users?.length && context.header?.referer) {
+    const receivers: any[] = users.map(user => user.id)
+    const msg = {
+      title: `Latest status for ${foundReturnOrder.name}`,
+      body: `Your Return Order 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 foundReturnOrder
+}
+
+export async function checkReturnOrder(
+  tx: EntityManager,
+  name: string,
+  context: ResolverContext
+): Promise<ReturnOrder> {
+  const { domain, user } = context.state
+
+  const foundReturnOrder: ReturnOrder = await tx.getRepository(ReturnOrder).findOne({
+    where: { domain: { id: domain.id }, name, status: ORDER_STATUS.INTRANSIT },
+    relations: ['bizplace', 'orderInventories', 'orderVass']
+  })
+
+  if (!foundReturnOrder) throw new Error(`Return order doesn't exists.`)
+
+  let foundOIs: OrderInventory[] = foundReturnOrder.orderInventories
+  let foundOVs: OrderVas[] = foundReturnOrder.orderVass
+
+  foundReturnOrder.status = ORDER_STATUS.ARRIVED
+  foundReturnOrder.updater = user
+  await tx.getRepository(ReturnOrder).save(foundReturnOrder)
+
+  // 1. Update status of order inventories
+  foundOIs = foundOIs.map((orderInventory: OrderInventory) => {
+    return {
+      ...orderInventory,
+      status: ORDER_INVENTORY_STATUS.ARRIVED,
+      updater: user
+    }
+  })
+  await tx.getRepository(OrderInventory).save(foundOIs)
+
+  // 2. Update status of order vass
+  if (foundOVs && foundOVs.length) {
+    foundOVs = foundOVs.map((orderVas: OrderVas) => {
+      return {
+        ...orderVas,
+        status: ORDER_VAS_STATUS.ARRIVED,
+        updater: user
+      }
+    })
+    await tx.getRepository(OrderVas).save(foundOVs)
+  }
+
+  // notification logics
+  const users: any[] = await getDomainUsers(foundReturnOrder?.bizplace, tx)
+
+  if (users?.length && context.header?.referer) {
+    const receivers: any[] = users.map(user => user.id)
+    const msg = {
+      title: `Latest status for ${foundReturnOrder.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 foundReturnOrder
+}