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

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

@@ -0,0 +1,462 @@
+import { Attachment, createAttachments } from '@things-factory/attachment-base'
+import { Role, User } from '@things-factory/auth-base'
+import { Bizplace, getDomainUsers } from '@things-factory/biz-base'
+import { sendNotification } from '@things-factory/notification'
+import { Product } from '@things-factory/product-base'
+import { Domain } from '@things-factory/shell'
+import { Inventory } from '@things-factory/warehouse-base'
+import { FileUpload, GraphQLUpload } from 'graphql-upload'
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager, In } from 'typeorm'
+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: any): Promise<boolean> {
+    const { tx }: { tx: EntityManager } = 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: any): Promise<boolean> {
+    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+
+    await tx.getRepository(ReturnOrder).delete({
+      domain,
+      name: In(names)
+    })
+    return true
+  }
+
+  @Directive('@privilege(category: "order_customer", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => ReturnOrder)
+  async generateReturnOrder(
+    @Ctx() context: any,
+    @Arg('file', type => [GraphQLUpload]) file: FileUpload[],
+    @Arg('returnOrder', type => NewReturnOrder, { nullable: true }) returnOrder: NewReturnOrder
+  ): Promise<ReturnOrder> {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+
+    const bizplace: Bizplace = await tx.getRepository(Bizplace).findOne(returnOrder.customerBizplaceId)
+    let orderInventories: NewOrderInventory[] = returnOrder.orderInventories
+    let foundInv = Inventory
+
+    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)
+
+    for (let oi of orderInventories) {
+      let newOrderInv: OrderInventory = Object.assign({}, oi) 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).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(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: any): Promise<ReturnOrder> {
+    const { tx }: { tx: EntityManager } = 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: any): Promise<ReturnOrder> {
+    const { tx }: { tx: EntityManager } = 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: any
+  ): Promise<ReturnOrder> {
+    const { tx }: { tx: EntityManager } = 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: any): Promise<ReturnOrder> {
+    const { tx }: { tx: EntityManager } = context.state
+    const returnOrder: ReturnOrder = await checkReturnOrder(tx, name, context)
+
+    return returnOrder
+  }
+}
+
+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
+}
+
+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
+}
+
+export async function receiveReturnOrder(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_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) {
+    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 }
+    }
+
+    await sendNotification({
+      receivers,
+      message: { ...msg }
+    })
+  }
+
+  return returnOrder
+}
+
+export async function rejectReturnOrder(
+  tx: EntityManager,
+  name: string,
+  remark: 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_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) {
+    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 }
+    }
+
+    await sendNotification({
+      receivers,
+      message: { ...msg }
+    })
+  }
+
+  return foundReturnOrder
+}
+
+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/service/return-order/return-order-query.ts

@@ -0,0 +1,224 @@
+import { Attachment } from '@things-factory/attachment-base'
+import { User } from '@things-factory/auth-base'
+import { getPermittedBizplaceIds } from '@things-factory/biz-base'
+import { buildQuery, Domain, Filter, Pagination, Sorting } from '@things-factory/shell'
+import { Inventory } from '@things-factory/warehouse-base'
+import { Arg, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { getRepository, SelectQueryBuilder } from 'typeorm'
+import { OrderInventory, ReturnOrderDetail, ReturnOrderList } from '../'
+import { ATTACHMENT_TYPE, ORDER_INVENTORY_TYPE, ORDER_STATUS } from '../../constants'
+import { ReturnOrder } from './return-order'
+
+@Resolver(ReturnOrder)
+export class ReturnOrderQuery {
+  @Query(returns => ReturnOrderList)
+  async returnOrders(
+    @Ctx() context: any,
+    @Arg('filters', type => [Filter], { nullable: true }) filters?: Filter[],
+    @Arg('pagination', type => Pagination, { nullable: true }) pagination?: Pagination,
+    @Arg('sortings', type => [Sorting], { nullable: true }) sortings?: Sorting[]
+  ): Promise<ReturnOrderList> {
+    try {
+      const { domain, user }: { domain: Domain; user: User } = context.state
+
+      filters.push({
+        name: 'bizplaceId',
+        operator: 'in',
+        value: await getPermittedBizplaceIds(domain, user),
+        relation: false
+      })
+
+      const qb: SelectQueryBuilder<ReturnOrder> = getRepository(ReturnOrder).createQueryBuilder('ro')
+      buildQuery(qb, { filters, pagination, sortings }, context)
+      qb.addSelect(subQuery => {
+        return subQuery
+          .select('COALESCE("ccd".rank, 99999)', 'rank')
+          .from('common_code_details', 'ccd')
+          .innerJoin('ccd.commonCode', 'cc')
+          .where('"ccd"."name" = "ro"."status"')
+          .andWhere('"ccd"."domain_id" = "ro"."domain_id"')
+          .andWhere('"cc"."name" = \'RETURN_LIST_STATUS\'')
+      }, 'rank')
+      qb.leftJoinAndSelect('ro.domain', 'domain')
+      qb.leftJoinAndSelect('ro.bizplace', 'bizplace')
+      qb.leftJoinAndSelect('ro.creator', 'creator')
+      qb.leftJoinAndSelect('ro.updater', 'updater')
+      qb.leftJoinAndSelect('ro.acceptedBy', 'acceptedBy')
+
+      const arrChildSortData = ['bizplace']
+      const sort = (sortings || []).reduce(
+        (acc, sort) => ({
+          ...acc,
+          [arrChildSortData.indexOf(sort.name) >= 0 ? sort.name + '.name' : 'ro.' + sort.name]: sort.desc
+            ? 'DESC'
+            : 'ASC'
+        }),
+        !sortings.some(e => e.name === 'status') ? { rank: 'ASC' } : {}
+      )
+
+      qb.orderBy(sort)
+
+      const [items, total] = await qb.getManyAndCount()
+
+      return { items, total }
+    } catch (error) {
+      throw error
+    }
+  }
+
+  @Query(returns => ReturnOrder)
+  async returnOrder(@Arg('name') name: string, @Ctx() context: any): Promise<ReturnOrder> {
+    const { domain }: { domain: Domain } = context.state
+
+    const repository = getRepository(ReturnOrder)
+
+    return await repository.findOne({
+      where: { domain, name },
+      relations: ['domain', 'creator', 'updater']
+    })
+  }
+
+  @Query(returns => ReturnOrderDetail)
+  async returnOrderDetail(@Arg('name') name: string, @Ctx() context: any): Promise<ReturnOrderDetail> {
+    const { domain, user }: { domain: Domain; user: User } = context.state
+
+    const returnOrder: ReturnOrder = await getRepository(ReturnOrder).findOne({
+      where: {
+        domain,
+        name
+      },
+      relations: [
+        'domain',
+        'bizplace',
+        'orderInventories',
+        'orderInventories.inventory',
+        'orderInventories.product',
+        'orderInventories.inventory.product',
+        'orderInventories.inventory.location',
+        'orderVass',
+        'orderVass.vas',
+        'orderVass.targetProduct',
+        'orderVass.inventory',
+        'creator',
+        'updater'
+      ]
+    })
+
+    const foundAttachments: Attachment[] = await getRepository(Attachment).find({
+      where: {
+        domain,
+        refBy: returnOrder.id,
+        category: ATTACHMENT_TYPE.RETURN_ORDER
+      }
+    })
+
+    return {
+      ...(returnOrder as any),
+      attachment: foundAttachments,
+      inventoryInfos: returnOrder.orderInventories
+        .filter(orderInv => orderInv.type === ORDER_INVENTORY_TYPE.RETURN_ORDER)
+        .map((orderInv: OrderInventory) => {
+          const inventory: Inventory = orderInv.inventory
+          return {
+            id: inventory.id,
+            name: inventory.name,
+            batchId: inventory.batchId,
+            palletId: inventory.palletId,
+            product: inventory.product,
+            productName: `${inventory.product.name} (${inventory.product.description})`,
+            packingType: inventory.packingType,
+            packingSize: inventory.packingSize,
+            returnQty: orderInv.returnQty,
+            returnUomValue: orderInv.returnUomValue,
+            status: orderInv.status,
+            remark: orderInv.remark
+          }
+        })
+    }
+  }
+
+  @Directive('@privilege(category: "order_warehouse", privilege: "query")')
+  @Query(returns => ReturnOrderList)
+  async returnOrderRequests(
+    @Ctx() context: any,
+    @Arg('filters', type => [Filter], { nullable: true }) filters?: Filter[],
+    @Arg('pagination', type => Pagination, { nullable: true }) pagination?: Pagination,
+    @Arg('sortings', type => [Sorting], { nullable: true }) sortings?: Sorting[]
+  ): Promise<ReturnOrderList> {
+    try {
+      const { domain, user }: { domain: Domain; user: User } = context.state
+
+      const statusFilter = filters.some(e => e.name === 'status')
+      const bizplaceFilter = filters.find(param => param.name === 'bizplaceId')
+
+      if (!statusFilter) {
+        filters.push({
+          name: 'status',
+          operator: 'notin',
+          value: [ORDER_STATUS.PENDING, ORDER_STATUS.EDITING],
+          relation: false
+        })
+      }
+
+      if (!bizplaceFilter) {
+        filters.push({
+          name: 'bizplaceId',
+          operator: 'in',
+          value: await getPermittedBizplaceIds(domain, user),
+          relation: false
+        })
+      }
+
+      const qb: SelectQueryBuilder<ReturnOrder> = getRepository(ReturnOrder).createQueryBuilder('ro')
+      buildQuery(qb, { filters, pagination, sortings }, context)
+      qb.addSelect(subQuery => {
+        return subQuery
+          .select('COALESCE("ccd".rank, 99999)', 'rank')
+          .from('common_code_details', 'ccd')
+          .innerJoin('ccd.commonCode', 'cc')
+          .where('"ccd"."name" = "ro"."status"')
+          .andWhere('"ccd"."domain_id" = "ro"."domain_id"')
+          .andWhere('"cc"."name" = \'RETURN_LIST_STATUS\'')
+      }, 'rank')
+      qb.leftJoinAndSelect('ro.domain', 'domain')
+      qb.leftJoinAndSelect('ro.bizplace', 'bizplace')
+      qb.leftJoinAndSelect('ro.creator', 'creator')
+      qb.leftJoinAndSelect('ro.updater', 'updater')
+      qb.leftJoinAndSelect('ro.acceptedBy', 'acceptedBy')
+
+      const arrChildSortData = ['bizplace']
+      const sort = (sortings || []).reduce(
+        (acc, sort) => ({
+          ...acc,
+          [arrChildSortData.indexOf(sort.name) >= 0 ? sort.name + '.name' : 'ro.' + sort.name]: sort.desc
+            ? 'DESC'
+            : 'ASC'
+        }),
+        !sortings.some(e => e.name === 'status') ? { rank: 'ASC' } : {}
+      )
+
+      qb.orderBy(sort)
+
+      const [items, total] = await qb.getManyAndCount()
+
+      return { items, total }
+    } catch (error) {
+      throw error
+    }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() returnOrder: ReturnOrder): Promise<Domain> {
+    return await getRepository(Domain).findOne(returnOrder.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() returnOrder: ReturnOrder): Promise<User> {
+    return await getRepository(User).findOne(returnOrder.creatorId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() returnOrder: ReturnOrder): Promise<User> {
+    return await getRepository(User).findOne(returnOrder.updaterId)
+  }
+}