@things-factory/sales-base 4.0.0-y.0 → 4.0.4

package/server/graphql/resolvers/retail-replenishment-order/create-retail-replenishment-order.ts

@@ -1,107 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Bizplace, getOutletBizplace } from '@things-factory/biz-base'
-import { generateId } from '@things-factory/id-rule-base'
-import { Setting } from '@things-factory/setting-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager, getRepository, Repository } from 'typeorm'
-import {
-  ORDER_NUMBER_RULE_TYPE,
-  ORDER_NUMBER_SETTING_KEY,
-  ORDER_PRODUCT_STATUS,
-  ORDER_STATUS,
-  TRANSFER_ORDER_TYPE
-} from '../../..//constants'
-import { OrderProduct, OrderVas, RetailReplenishmentOrder } from '../../../entities'
-import { OrderNoGenerator } from '../../../utils/order-no-generator'
-import { generateTransferOrder } from '../transfer-order/generate-transfer-order'
-import { addRetailReplenishmentOrderProducts } from './add-retail-replenishment-order-products'
-
-export const createRetailReplenishmentOrder = {
-  async createRetailReplenishmentOrder(_: any, { retailReplenishmentOrder }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    const settingRepo: Repository<Setting> = tx?.getRepository(Setting) || getRepository(Setting)
-
-    let orderVass: OrderVas[] = retailReplenishmentOrder.orderVass
-    const myBizplace: Bizplace = await getOutletBizplace(retailReplenishmentOrder.warehouseId)
-
-    // #1 check for allocated qty to identify the status: APPROVED or PENDING
-    const allocatedQty: number = null
-    let status = allocatedQty ? ORDER_STATUS.PENDING : ORDER_STATUS.APPROVED
-    let remark = allocatedQty ? 'INSUFFICIENT QTY' : ''
-
-    let orderProducts: OrderProduct[] = retailReplenishmentOrder.orderProducts
-    orderProducts = orderProducts.map((op: OrderProduct) => {
-      return {
-        ...op,
-        status: allocatedQty ? ORDER_PRODUCT_STATUS.PENDING : ORDER_PRODUCT_STATUS.APPROVED,
-        remark
-      }
-    })
-
-    const rrNoSetting: Setting = await settingRepo.findOne({
-      where: {
-        domain,
-        name: ORDER_NUMBER_SETTING_KEY.RR_NUMBER_RULE
-      }
-    })
-
-    let orderNo: string = ''
-
-    if (rrNoSetting) {
-      orderNo = await generateId({ domain, type: ORDER_NUMBER_RULE_TYPE.RR_NUMBER, seed: {} })
-    } else {
-      orderNo = OrderNoGenerator.retailReplenishmentOrder()
-    }
-
-    // #2 Create Retail Replenishment Order
-    const createdRetailReplenishmentOrder: RetailReplenishmentOrder = await tx
-      .getRepository(RetailReplenishmentOrder)
-      .save({
-        ...retailReplenishmentOrder,
-        name: orderNo,
-        bizplace: myBizplace,
-        status,
-        domain,
-        creator: user,
-        updater: user
-      })
-
-    // #3 Create retail replenishment order products
-    await addRetailReplenishmentOrderProducts(domain, createdRetailReplenishmentOrder, orderProducts, user, tx)
-
-    // #4 generate transfer order if status is APPROVED
-    if (createdRetailReplenishmentOrder.status === ORDER_STATUS.APPROVED) {
-      const issuedDate: string = retailReplenishmentOrder.issuedDate
-      const remark: string = retailReplenishmentOrder.remark
-      const refNo: string = retailReplenishmentOrder.refNo
-      const ownTransport: string = retailReplenishmentOrder.ownTransport
-      const orderInventories: any[] = orderProducts.map((op: OrderProduct) => {
-        return {
-          batchId: op.batchId,
-          releaseQty: op.packQty,
-          product: op.product,
-          packingType: op.packingType
-        }
-      })
-
-      await generateTransferOrder(
-        {
-          issuedDate,
-          remark,
-          refNo,
-          type: TRANSFER_ORDER_TYPE.NORMAL,
-          ownTransport,
-          orderInventories,
-          orderVass,
-          bizplace: myBizplace,
-          retailReplenishmentOrder: createdRetailReplenishmentOrder
-        },
-        domain,
-        user,
-        tx
-      )
-    }
-
-    return createdRetailReplenishmentOrder
-  }
-}

package/server/graphql/resolvers/retail-replenishment-order/delete-retail-replenishment-order.ts

@@ -1,11 +0,0 @@
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { RetailReplenishmentOrder } from '../../../entities'
-
-export const deleteRetailReplenishmentOrder = {
-  async deleteRetailReplenishmentOrder(_: any, { name }, context: any) {
-    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
-    await tx.getRepository(RetailReplenishmentOrder).delete({ domain, name })
-    return true
-  }
-}

package/server/graphql/resolvers/retail-replenishment-order/delete-retail-replenishment-orders.ts

@@ -1,14 +0,0 @@
-import { Domain } from '@things-factory/shell'
-import { EntityManager, In } from 'typeorm'
-import { RetailReplenishmentOrder } from '../../../entities'
-
-export const deleteRetailReplenishmentOrders = {
-  async deleteRetailReplenishmentOrders(_: any, { names }, context: any) {
-    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
-    await tx.getRepository(RetailReplenishmentOrder).delete({
-      domain,
-      name: In(names)
-    })
-    return true
-  }
-}

package/server/graphql/resolvers/retail-replenishment-order/index.ts

@@ -1,27 +0,0 @@
-import { retailReplenishmentOrderResolver } from './retail-replenishment-order'
-import { retailReplenishmentOrdersResolver } from './retail-replenishment-orders'
-
-import { addRetailReplenishmentOrderProductsResolver } from './add-retail-replenishment-order-products'
-import { cancelRetailReplenishmentOrderResolver } from './cancel-retail-replenishment-order'
-import { updateRetailReplenishmentOrder } from './update-retail-replenishment-order'
-import { updateMultipleRetailReplenishmentOrder } from './update-multiple-retail-replenishment-order'
-import { createRetailReplenishmentOrder } from './create-retail-replenishment-order'
-import { completeRetailReplenishmentOrderResolver } from './complete-retail-replenishment-order'
-import { deleteRetailReplenishmentOrder } from './delete-retail-replenishment-order'
-import { deleteRetailReplenishmentOrders } from './delete-retail-replenishment-orders'
-
-export const Query = {
-  ...retailReplenishmentOrdersResolver,
-  ...retailReplenishmentOrderResolver
-}
-
-export const Mutation = {
-  ...addRetailReplenishmentOrderProductsResolver,
-  ...cancelRetailReplenishmentOrderResolver,
-  ...completeRetailReplenishmentOrderResolver,
-  ...updateRetailReplenishmentOrder,
-  ...updateMultipleRetailReplenishmentOrder,
-  ...createRetailReplenishmentOrder,
-  ...deleteRetailReplenishmentOrder,
-  ...deleteRetailReplenishmentOrders
-}

package/server/graphql/resolvers/retail-replenishment-order/retail-replenishment-order.ts

@@ -1,16 +0,0 @@
-import { Domain } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
-import { RetailReplenishmentOrder } from '../../../entities'
-
-export const retailReplenishmentOrderResolver = {
-  async retailReplenishmentOrder(_: any, { name }, context: any) {
-    const { domain }: { domain: Domain } = context.state
-
-    const repository = getRepository(RetailReplenishmentOrder)
-
-    return await repository.findOne({
-      where: { domain, name },
-      relations: ['domain', 'orderProducts', 'orderProducts.product', 'creator', 'updater']
-    })
-  }
-}

package/server/graphql/resolvers/retail-replenishment-order/retail-replenishment-orders.ts

@@ -1,14 +0,0 @@
-import { convertListParams, ListParam } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
-import { RetailReplenishmentOrder } from '../../../entities'
-
-export const retailReplenishmentOrdersResolver = {
-  async retailReplenishmentOrders(_: any, params: ListParam, context: any) {
-    const convertedParams = convertListParams(params)
-    const [items, total] = await getRepository(RetailReplenishmentOrder).findAndCount({
-      ...convertedParams,
-      relations: ['domain', 'orderProducts', 'orderProducts.product', 'creator', 'updater']
-    })
-    return { items, total }
-  }
-}

package/server/graphql/resolvers/retail-replenishment-order/update-multiple-retail-replenishment-order.ts

@@ -1,47 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { RetailReplenishmentOrder } from '../../../entities'
-
-export const updateMultipleRetailReplenishmentOrder = {
-  async updateMultipleRetailReplenishmentOrder(_: any, { patches }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-
-    let results = []
-    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
-    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-    const retailReplenishmentOrderRepo = tx.getRepository(RetailReplenishmentOrder)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await retailReplenishmentOrderRepo.save({
-          ...newRecord,
-          domain,
-          creator: user,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const newRecord = _updateRecords[i]
-        const retailReplenishmentOrder = await retailReplenishmentOrderRepo.findOne(newRecord.id)
-
-        const result = await retailReplenishmentOrderRepo.save({
-          ...retailReplenishmentOrder,
-          ...newRecord,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-}

package/server/graphql/resolvers/retail-replenishment-order/update-retail-replenishment-order-products.ts

@@ -1,64 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Product } from '@things-factory/product-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager, getRepository, Repository } from 'typeorm'
-import { OrderProduct, RetailReplenishmentOrder } from '../../../entities'
-import { OrderNoGenerator } from '../../../utils'
-
-export const updateRetailReplenishmentOrderProductsResolver = {
-  async updateRetailReplenishmentOrderProducts(_: any, { sroNo, orderProducts }, context: any): Promise<void> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-
-    const retailReplenishmentOrder: RetailReplenishmentOrder = await tx
-      .getRepository(RetailReplenishmentOrder)
-      .findOne({
-        where: { name: sroNo },
-        relations: ['bizplace', 'orderProducts']
-      })
-
-    await updateRetailReplenishmentOrderProducts(domain, retailReplenishmentOrder, orderProducts, user, tx)
-  }
-}
-
-export async function updateRetailReplenishmentOrderProducts(
-  domain: Domain,
-  retailReplenishmentOrder: RetailReplenishmentOrder,
-  orderProducts: OrderProduct[],
-  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 (!retailReplenishmentOrder?.bizplace || !retailReplenishmentOrder?.orderProducts?.length) {
-    retailReplenishmentOrder = await tx.getRepository(RetailReplenishmentOrder).findOne({
-      where: { ...retailReplenishmentOrder },
-      relations: ['bizplace', 'orderProducts']
-    })
-  }
-
-  orderProducts = await Promise.all(
-    orderProducts.map(async (op: OrderProduct) => {
-      const foundProduct = await productRepo.findOne({ domain, sku: op.product.sku, name: op.product.name })
-      if (!foundProduct) throw new Error(`Product not found.`)
-
-      return {
-        ...op,
-        domain,
-        bizplace: retailReplenishmentOrder.bizplace,
-        name: OrderNoGenerator.orderProduct(),
-        product: foundProduct,
-        retailReplenishmentOrder,
-        //========= need to revise ===========
-        packingType: foundProduct.packingType,
-        uom: foundProduct.weightUnit,
-        uomValue: foundProduct.weight,
-        //====================================
-        creator: user,
-        updater: user
-      }
-    })
-  )
-
-  await orderProductRepo.save(orderProducts)
-}

package/server/graphql/resolvers/retail-replenishment-order/update-retail-replenishment-order.ts

@@ -1,33 +0,0 @@
-import { Bizplace, getOutletBizplace } from '@things-factory/biz-base'
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { RetailReplenishmentOrder } from '../../../entities'
-import { ORDER_STATUS } from '../../../constants'
-
-export const updateRetailReplenishmentOrder = {
-  async updateRetailReplenishmentOrder(_: any, { name, patch }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-
-    const bizplace: Bizplace = await getOutletBizplace(patch.warehouseId)
-    const repository = tx.getRepository(RetailReplenishmentOrder)
-
-    delete patch.warehouseId //exclude warehouse Id from patch
-
-    const retailReplenishmentOrder = await repository.findOne({
-      where: { domain, name, bizplace },
-      relations: ['orderProducts', 'orderProducts.product']
-    })
-
-    if (!retailReplenishmentOrder) throw new Error(`Retail replenishment order is not found.`)
-    if (retailReplenishmentOrder && retailReplenishmentOrder.status !== ORDER_STATUS.REJECTED)
-      throw new Error(`You are not allowed to update this order with status: ${retailReplenishmentOrder.status}`)
-
-    return await repository.save({
-      ...retailReplenishmentOrder,
-      ...patch,
-      status: ORDER_STATUS.PENDING_RECEIVE,
-      updater: user
-    })
-  }
-}

package/server/graphql/resolvers/return-order/check-return-order.ts

@@ -1,76 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { getDomainUsers } from '@things-factory/biz-base'
-import { sendNotification } from '@things-factory/notification'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { ORDER_INVENTORY_STATUS, ORDER_STATUS, ORDER_VAS_STATUS } from '../../../constants'
-import { OrderInventory, OrderVas, ReturnOrder } from '../../../entities'
-
-export const checkReturnOrderResolver = {
-  async checkReturnOrder(_: any, { name }, context: any) {
-    const { tx }: { tx: EntityManager } = context.state
-    const returnOrder: ReturnOrder = await checkReturnOrder(tx, name, context)
-
-    return returnOrder
-  }
-}
-
-export async function checkReturnOrder(tx: EntityManager, name: string, context: any): Promise<ReturnOrder> {
-  const { domain, user }: { domain: Domain; user: User } = context.state
-
-  const foundReturnOrder: ReturnOrder = await tx.getRepository(ReturnOrder).findOne({
-    where: { domain, 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) {
-    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 }
-    }
-
-    await sendNotification({
-      receivers,
-      message: { ...msg }
-    })
-  }
-
-  return foundReturnOrder
-}

package/server/graphql/resolvers/return-order/confirm-return-order.ts

@@ -1,96 +0,0 @@
-import { Role, User } from '@things-factory/auth-base'
-import { Bizplace } from '@things-factory/biz-base'
-import { sendNotification } from '@things-factory/notification'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { ORDER_INVENTORY_STATUS, ORDER_STATUS, ORDER_VAS_STATUS } from '../../../constants'
-import { OrderInventory, OrderVas, ReturnOrder } from '../../../entities'
-
-export const confirmReturnOrderResolver = {
-  async confirmReturnOrder(_: any, { name }, context: any) {
-    const { tx }: { tx: EntityManager } = context.state
-
-    const returnOrder: ReturnOrder = await confirmReturnOrder(tx, name, context)
-
-    return returnOrder
-  }
-}
-
-export async function confirmReturnOrder(tx: EntityManager, name: string, context: any): Promise<ReturnOrder> {
-  const { domain, user }: { domain: Domain; user: User } = context.state
-
-  const foundReturnOrder: ReturnOrder = await tx.getRepository(ReturnOrder).findOne({
-    where: { domain, 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) {
-    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 }
-    }
-
-    await sendNotification({
-      receivers,
-      message: { ...msg }
-    })
-  }
-
-  return returnOrder
-}

package/server/graphql/resolvers/return-order/delete-return-order.ts

@@ -1,57 +0,0 @@
-import { Attachment } from '@things-factory/attachment-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager, In } from 'typeorm'
-import { ATTACHMENT_TYPE } from '../../../constants/attachment-type'
-import { OrderInventory, OrderVas, ReturnOrder } from '../../../entities'
-
-export const deleteReturnOrderResolver = {
-  async deleteReturnOrder(_: any, { name }, context: any) {
-    const { tx }: { tx: EntityManager } = context.state
-
-    return await deleteReturnOrder(tx, name, context)
-  }
-}
-export async function deleteReturnOrder(tx: EntityManager, name: string, context: any): Promise<boolean> {
-  const { domain }: { domain: Domain } = context.state
-
-  let foundReturnOrder: ReturnOrder = await tx.getRepository(ReturnOrder).findOne({
-    where: { domain, 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,
-        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: foundAttachment.id })
-  }
-
-  await tx.getRepository(ReturnOrder).delete({ domain, name })
-  return true
-}

package/server/graphql/resolvers/return-order/delete-return-orders.ts

@@ -1,15 +0,0 @@
-import { EntityManager, In } from 'typeorm'
-import { Domain } from '@things-factory/shell'
-import { ReturnOrder } from '../../../entities'
-
-export const deleteReturnOrders = {
-  async deleteReturnOrders(_: any, { names }, context: any) {
-    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
-
-    await tx.getRepository(ReturnOrder).delete({
-      domain,
-      name: In(names)
-    })
-    return true
-  }
-}

package/server/graphql/resolvers/return-order/generate-return-order.ts

@@ -1,70 +0,0 @@
-import { Attachment, createAttachments } from '@things-factory/attachment-base'
-import { User } from '@things-factory/auth-base'
-import { Bizplace, getMyBizplace } from '@things-factory/biz-base'
-import { Product } from '@things-factory/product-base'
-import { Domain } from '@things-factory/shell'
-import { Inventory } from '@things-factory/warehouse-base'
-import { EntityManager } from 'typeorm'
-import { ORDER_STATUS } from '../../../constants'
-import { ATTACHMENT_TYPE } from '../../../constants/attachment-type'
-import { ORDER_INVENTORY_STATUS } from '../../../constants/order'
-import { OrderInventory, ReturnOrder } from '../../../entities'
-import { OrderNoGenerator } from '../../../utils/order-no-generator'
-
-export const generateReturnOrder = {
-  async generateReturnOrder(_: any, { returnOrder, file }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-
-    const bizplace: Bizplace = await tx.getRepository(Bizplace).findOne(returnOrder.customerBizplaceId)
-    let orderInventories: OrderInventory[] = returnOrder.orderInventories
-    let foundInv = Inventory
-
-    let newReturnOrder: ReturnOrder = {
-      ...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)
-
-    for (let oi of orderInventories) {
-      let newOrderInv: OrderInventory = Object.assign({}, oi)
-      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).findOne(oi.product.id)
-      newOrderInv.creator = user
-      newOrderInv.updater = user
-
-      if (newOrderInv.inventory?.id) {
-        foundInv = await tx.getRepository(Inventory).findOne(newOrderInv.inventory.id)
-        newOrderInv.inventory = foundInv
-      }
-
-      await tx.getRepository(OrderInventory).save(newOrderInv)
-    }
-
-    if (file?.length > 0) {
-      const attachments: Attachment[] = file.map(attachment => {
-        return {
-          file: attachment,
-          refBy: createdReturnOrder.id,
-          category: ATTACHMENT_TYPE.RETURN_ORDER
-        }
-      })
-      await createAttachments(_, { attachments }, context)
-    }
-
-    return createdReturnOrder
-  }
-}