@things-factory/sales-base 8.0.2 → 8.0.5

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

@@ -1,516 +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, 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
-}