@things-factory/sales-base 4.3.186 → 4.3.188

package/server/constants/order.ts

@@ -129,7 +129,8 @@ export const ORDER_INVENTORY_STATUS = {
   TERMINATED: 'TERMINATED',
   DONE: 'DONE',
   RECEIVED: 'RECEIVED',
-  NOT_RECEIVED: 'NOT_RECEIVED'
+  NOT_RECEIVED: 'NOT_RECEIVED',
+  PUTTING_AWAY: 'PUTTING_AWAY'
 }
 
 export const ORDER_VAS_STATUS = {
@@ -156,7 +157,8 @@ export const ORDER_TYPES = {
   VAS_ORDER: 'VAS_ORDER',
   CYCLE_COUNT: 'CYCLE_COUNT',
   STOCK_TAKE: 'STOCK_TAKE',
-  TRANSFER_ORDER: 'TRANSFER_ORDER'
+  TRANSFER_ORDER: 'TRANSFER_ORDER',
+  REPLENISHMENT: 'REPLENISHMENT'
 }
 
 export const GRN_STATUS = {
@@ -174,7 +176,8 @@ export const ORDER_NUMBER_SETTING_KEY = {
   DO_NUMBER_RULE: 'do-number-rule',
   RR_NUMBER_RULE: 'rr-number-rule',
   TO_NUMBER_RULE: 'to-number-rule',
-  DRO_NUMBER_RULE: 'dro-number-rule'
+  DRO_NUMBER_RULE: 'dro-number-rule',
+  RP_NUMBER_RULE: 'rp-number-rule'
 }
 
 export const ORDER_NUMBER_RULE_TYPE = {
@@ -185,7 +188,8 @@ export const ORDER_NUMBER_RULE_TYPE = {
   DO_NUMBER: 'do_number',
   RR_NUMBER: 'rr_number',
   TO_NUMBER: 'to_number',
-  DRO_NUMBER: 'dro_number'
+  DRO_NUMBER: 'dro_number',
+  RP_NUMBER: 'rp_number'
 }
 
 export const PURCHASE_ORDER_STATUS = {
@@ -200,7 +204,8 @@ export const DRAFT_RELEASE_ORDER_STATUS = {
   DRAFT: 'DRAFT',
   INSUFFICIENT: 'INSUFFICIENT',
   SUBMITTED: 'SUBMITTED',
-  CANCELLED: 'CANCELLED'
+  CANCELLED: 'CANCELLED',
+  TRANSFER: 'TRANSFER'
 }
 
 export const ORDER_SOURCE_TYPE = {

package/server/controllers/ecommerce/sellercraft-controller.ts

@@ -7,6 +7,7 @@ import { Inventory, INVENTORY_STATUS, LOCATION_TYPE } from '@things-factory/ware
 import { ORDER_PRODUCT_STATUS } from '../../constants'
 import { OrderProduct } from '../../service/order-product/order-product'
 import { ReleaseGood } from '../../service/release-good/release-good'
+import { DateTimeDifference } from '../../utils/datetime-util'
 import { OrderController } from '../order-controller'
 
 export class SellercraftController extends OrderController {
@@ -34,6 +35,14 @@ export class SellercraftController extends OrderController {
         orderId: releaseGood.refNo2,
         sellercraftOPs
       }
+
+      if (
+        releaseGood?.lastMarketPackCall &&
+        DateTimeDifference.timeDifferenceInSeconds(releaseGood.lastMarketPackCall, new Date()) <= 5
+      ) {
+        return
+      }
+
       const packageId: string = await SellercraftAPI.packMarketplaceOrder(sellercraft, {
         ...orderInformation,
         context: { state: { domain: this?.domain, user: this?.user } }

package/server/service/draft-release-good/draft-release-good-query.ts

@@ -120,14 +120,36 @@ export class DraftReleaseGoodQuery {
         [domain.id]
       )
 
+      tx.query(
+        `
+        create temp table temp_transfer_inv_calculation on commit drop as (
+          SELECT drg1.id from draft_release_goods drg1
+          left join order_products op on drg1.id = op.draft_release_good_id
+          where drg1.status ='DRAFT' AND drg1.domain_id = $1
+          AND EXISTS (
+            SELECT * FROM warehouse_bizplace_onhand_inventories wboi 
+            where (wboi."product_id" = op.product_id or wboi."product_bundle_id" = op.product_id) 
+            and wboi."domain_id" = op.domain_id
+            and wboi."bizplace_id" = op.bizplace_id
+            AND wboi."transfer_qty" > 0
+          ) GROUP BY drg1.id
+        )
+      `,
+        [domain.id]
+      )
+
       const qb: SelectQueryBuilder<DraftReleaseGood> = tx.getRepository(DraftReleaseGood).createQueryBuilder('drg')
       buildQuery(qb, params, context)
       qb.addSelect('COALESCE("cc".rank, 99999)', 'rank')
       qb.addSelect(
-        `CASE WHEN "drg".status = 'DRAFT' and tmp_calc.id IS NOT null then 'INSUFFICIENT' else "drg".status END`,
+        `CASE WHEN "drg".status = 'DRAFT' and (tmp_calc.id IS NOT null and tmp_transfer.id IS null) then 'INSUFFICIENT'
+         WHEN "drg".status = 'DRAFT' and (tmp_calc.id IS null and tmp_transfer.id IS NOT null) then 'TRANSFER'
+         WHEN "drg".status = 'DRAFT' and (tmp_calc.id IS NOT null and tmp_transfer.id IS NOT null) then 'INSUFFICIENT'
+         else "drg".status END`,
         'computed_status'
       )
       qb.leftJoin(`temp_op_calculation`, 'tmp_calc', 'tmp_calc.id = drg.id')
+      qb.leftJoin(`temp_transfer_inv_calculation`, 'tmp_transfer', 'tmp_transfer.id = drg.id')
       qb.leftJoinAndSelect('drg.domain', 'domain')
       qb.leftJoinAndSelect('drg.bizplace', 'bizplace')
       qb.leftJoinAndSelect('drg.creator', 'creator')
@@ -329,7 +351,12 @@ export async function getDraftReleaseGoodFunction(_: any, name: any, context: an
         groupType: foundProductInv ? foundProductInv.groupType : 'SINGLE',
         remainQty: foundProductInv ? foundProductInv.remainQty : 0,
         remainUomValue: foundProductInv ? foundProductInv.remainUomValue : 0,
-        remainUomValueWithUom: foundProductInv ? foundProductInv.remainUomValueWithUom : 0
+        remainUomValueWithUom: foundProductInv ? foundProductInv.remainUomValueWithUom : 0,
+        status: foundProductInv?.transferQty
+          ? DRAFT_RELEASE_ORDER_STATUS.TRANSFER
+          : foundProductInv?.remainQty <= itm.releaseQty
+          ? DRAFT_RELEASE_ORDER_STATUS.INSUFFICIENT
+          : DRAFT_RELEASE_ORDER_STATUS.DRAFT
       }
     })
     const foundAttachments: Attachment[] = await tx.getRepository(Attachment).find({

package/server/service/index.ts

@@ -1,4 +1,5 @@
 /* IMPORT ENTITIES AND RESOLVERS */
+import { entities as ReplenishmentEntities, resolvers as ReplenishmentResolvers } from './replenishment'
 import { entities as ArrivalNoticeEntity, resolvers as ArrivalNoticeResolvers } from './arrival-notice'
 import { entities as ClaimEntity, resolvers as ClaimResolvers } from './claim'
 import { entities as ClaimDetailEntity, resolvers as ClaimDetailResolvers } from './claim-detail'
@@ -46,6 +47,8 @@ import { entities as VasEntity, resolvers as VasResolvers } from './vas'
 import { entities as VasOrderEntity, resolvers as VasOrderResolvers } from './vas-order'
 
 /* EXPORT ENTITY TYPES */
+export * from './replenishment/replenishment'
+export * from './replenishment/replenishment'
 export * from './arrival-notice/arrival-notice'
 export * from './claim-detail/claim-detail'
 export * from './claim-order/claim-order'
@@ -176,6 +179,8 @@ export * from './vas/vas-query'
 
 export const entities = [
   /* ENTITIES */
+  ...ReplenishmentEntities,
+  ...ReplenishmentEntities,
   ...ArrivalNoticeEntity,
   ...ClaimDetailEntity,
   ...ClaimEntity,
@@ -213,6 +218,8 @@ export const entities = [
 export const schema = {
   resolverClasses: [
     /* RESOLVER CLASSES */
+    ...ReplenishmentResolvers,
+    ...ReplenishmentResolvers,
     ...ArrivalNoticeResolvers,
     ...ClaimDetailResolvers,
     ...ClaimOrderResolvers,

package/server/service/order-inventory/order-inventory.ts

@@ -13,7 +13,7 @@ import {
 
 import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
-import { Product, ProductDetail} from '@things-factory/product-base'
+import { Product, ProductDetail } from '@things-factory/product-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory, Location } from '@things-factory/warehouse-base'
 
@@ -25,6 +25,7 @@ import { OrderToteItem } from '../order-tote-item/order-tote-item'
 import { ReleaseGood } from '../release-good/release-good'
 import { ReturnOrder } from '../return-order/return-order'
 import { TransferOrder } from '../transfer-order/transfer-order'
+import { Replenishment } from '../replenishment/replenishment'
 
 @Entity()
 @Index('ix_order-inventory_0', (orderInventory: OrderInventory) => [orderInventory.domain, orderInventory.name], {
@@ -150,6 +151,13 @@ export class OrderInventory {
   @RelationId((orderInventory: OrderInventory) => orderInventory.releaseGood)
   releaseGoodId: string
 
+  @ManyToOne(type => Replenishment)
+  @Field(type => Replenishment, { nullable: true })
+  replenishment: Replenishment
+
+  @RelationId((orderInventory: OrderInventory) => orderInventory.replenishment)
+  replenishmentId: string
+
   @ManyToOne(type => InventoryCheck)
   @Field(type => InventoryCheck, { nullable: true })
   inventoryCheck: InventoryCheck
@@ -432,4 +440,7 @@ export class OrderInventory {
 
   @Field({ nullable: true })
   stopId: string
+
+  @Field({ nullable: true })
+  transferQty: number
 }

package/server/service/order-product/order-product.ts

@@ -26,6 +26,7 @@ import { OrderPackageItem } from '../order-package-item/order-package-item'
 import { PurchaseOrder } from '../purchase-order/purchase-order'
 import { ReleaseGood } from '../release-good/release-good'
 import { RetailReplenishmentOrder } from '../retail-replenishment-order/retail-replenishment-order'
+import { Replenishment } from '../replenishment/replenishment'
 
 @Entity()
 @Index('ix_order-product_0', (orderProduct: OrderProduct) => [orderProduct.domain, orderProduct.name], {
@@ -107,6 +108,13 @@ export class OrderProduct {
   @RelationId((orderProduct: OrderProduct) => orderProduct.releaseGood)
   releaseGoodId: string
 
+  @ManyToOne(type => Replenishment)
+  @Field(type => Replenishment, { nullable: true })
+  replenishment: Replenishment
+
+  @RelationId((orderInventory: OrderInventory) => orderInventory.replenishment)
+  replenishmentId: string
+
   @ManyToOne(type => DraftReleaseGood)
   @Field(type => DraftReleaseGood, { nullable: true })
   draftReleaseGood: DraftReleaseGood

package/server/service/release-good/release-good-query.ts

@@ -859,6 +859,9 @@ export async function bulkReleaseGoodsAvailableItemsFunction(
         AND i.domain_id = $1
         AND i.bizplace_id = $2
         WHERE l.type NOT IN ($3, $4)
+        AND i.obsolete = false
+        AND i.transfer_qty <= 0
+        AND i.transfer_uom_value <= 0
         GROUP BY i.product_id, foo.product_detail_id, foo.sku,foo.product_info, i.packing_type, i.packing_size, i.uom
         ORDER BY foo.sku, remain_qty
       ) SELECT * FROM inv WHERE remain_qty > 0

package/server/service/release-good/release-good.ts

@@ -17,8 +17,8 @@ import { Attachment } from '@things-factory/attachment-base'
 import { User } from '@things-factory/auth-base'
 import { Bizplace, ContactPoint } from '@things-factory/biz-base'
 import { config } from '@things-factory/env'
-import { Domain } from '@things-factory/shell'
 import { LastMileDelivery } from '@things-factory/integration-lmd'
+import { Domain } from '@things-factory/shell'
 
 import {
   ArrivalNotice,
@@ -508,6 +508,10 @@ export class ReleaseGood {
   @Field({ nullable: true })
   marketPackCallSuccess: Date
 
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  lastMarketPackCall: Date
+
   @ManyToOne(type => User)
   @Field(type => User, { nullable: true })
   manifestedBy: User
@@ -543,7 +547,7 @@ export class ReleaseGood {
   @Column({ nullable: true })
   @Field({ nullable: true })
   lmdOption: Boolean
-  
+
   @Column({ nullable: true })
   @Field({ nullable: true })
   parcelId: String

package/server/service/replenishment/index.ts

@@ -0,0 +1,6 @@
+import { Replenishment } from './replenishment'
+import { ReplenishmentQuery } from './replenishment-query'
+import { ReplenishmentMutation } from './replenishment-mutation'
+
+export const entities = [Replenishment]
+export const resolvers = [ReplenishmentQuery, ReplenishmentMutation]

package/server/service/replenishment/replenishment-mutation.ts

@@ -0,0 +1,309 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { getRepository, In, EntityManager, Repository } from 'typeorm'
+import { Replenishment } from './replenishment'
+import { NewReplenishment, ReplenishmentPatch, ReplenishmentInventoryPatch } from './replenishment-type'
+import { Domain } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { OrderInventory } from '../order-inventory/order-inventory'
+import { OrderProduct } from '../order-product/order-product'
+import { Inventory } from '@things-factory/warehouse-base'
+import { Setting } from '@things-factory/setting-base'
+import {
+  ORDER_INVENTORY_STATUS,
+  ORDER_NUMBER_RULE_TYPE,
+  ORDER_NUMBER_SETTING_KEY,
+  ORDER_PRODUCT_STATUS,
+  ORDER_STATUS,
+  ORDER_TYPES
+} from '../../constants'
+import { generateId } from '@things-factory/id-rule-base'
+import { InventoryUtil, OrderNoGenerator } from '../../utils'
+import { Product, ProductDetail } from '@things-factory/product-base'
+
+@Resolver(Replenishment)
+export class ReplenishmentMutation {
+  @Directive('@transaction')
+  @Mutation(returns => Replenishment, { description: 'To create new Replenishment' })
+  async createReplenishment(
+    @Arg('replenishInventories', type => [ReplenishmentInventoryPatch])
+    replenishmentInventories: ReplenishmentInventoryPatch,
+    @Ctx() context: any
+  ): Promise<Replenishment> {
+    const { tx } = context.state
+
+    const createdReplenishment: Replenishment = await generateReplenishmentFunction(
+      null,
+      replenishmentInventories,
+      context,
+      tx
+    )
+
+    return createdReplenishment
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Replenishment, { description: 'To modify Replenishment information' })
+  async updateReplenishment(
+    @Arg('id') id: string,
+    @Arg('patch') patch: ReplenishmentPatch,
+    @Ctx() context: any
+  ): Promise<Replenishment> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(Replenishment)
+    const replenishment = await repository.findOne({
+      where: { domain, id }
+    })
+
+    return await repository.save({
+      ...replenishment,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [Replenishment], { description: "To modify multiple Replenishments' information" })
+  async updateMultipleReplenishment(
+    @Arg('patches', type => [ReplenishmentPatch]) patches: ReplenishmentPatch[],
+    @Ctx() context: any
+  ): Promise<Replenishment[]> {
+    const { domain, user, tx } = context.state
+
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const replenishmentRepo = tx.getRepository(Replenishment)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await replenishmentRepo.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 replenishment = await replenishmentRepo.findOne(newRecord.id)
+
+        const result = await replenishmentRepo.save({
+          ...replenishment,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete Replenishment' })
+  async deleteReplenishment(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(Replenishment).delete({ domain, id })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple replenishments' })
+  async deleteReplenishments(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(Replenishment).delete({
+      domain,
+      id: In(ids)
+    })
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Replenishment)
+  async confirmReplenishment(@Arg('name') name: string, @Ctx() context: any): Promise<Replenishment> {
+    const { tx }: { tx: EntityManager } = context.state
+    const replenishment: Replenishment = await confirmReplenishment(name, context, tx)
+
+    return replenishment
+  }
+}
+
+export async function generateReplenishmentFunction(
+  _: any,
+  replenishment: any,
+  context: any,
+  tx?: EntityManager
+): Promise<Replenishment> {
+  try {
+    const { domain, user }: { domain: Domain; user: User } = context.state
+
+    const settingRepo: Repository<Setting> = tx?.getRepository(Setting) || getRepository(Setting)
+
+    let orderInventories: OrderInventory[] = replenishment
+
+    let finalOrderInventories: OrderInventory[] = []
+
+    let newReplenishment: Replenishment = new Replenishment()
+
+    // find RO number rule setting
+    const rpNoSetting: Setting = await settingRepo.findOne({
+      where: {
+        domain,
+        name: ORDER_NUMBER_SETTING_KEY.RP_NUMBER_RULE
+      }
+    })
+
+    newReplenishment = {
+      ...newReplenishment,
+      name: rpNoSetting
+        ? await generateId({ domain, type: ORDER_NUMBER_RULE_TYPE.RP_NUMBER, seed: {} })
+        : OrderNoGenerator.replenishment(),
+      domain,
+      status: ORDER_STATUS.PENDING,
+      creator: user,
+      updater: user
+    }
+
+    newReplenishment = await tx.getRepository(Replenishment).save(newReplenishment)
+
+    for (let oi of orderInventories) {
+      let productDetail: any = await tx
+        .getRepository(ProductDetail)
+        .findOne(oi.productDetailId, { relations: ['product'] })
+
+      let bizplace = oi.bizplaceId
+
+      let newOrderInv: OrderInventory = Object.assign({}, oi)
+      newOrderInv = {
+        ...newOrderInv,
+        domain,
+        bizplace: { id: bizplace },
+        status: ORDER_INVENTORY_STATUS.PENDING,
+        name: OrderNoGenerator.orderInventory(),
+        replenishment: newReplenishment,
+        product: productDetail.product,
+        productDetail,
+        creator: user,
+        updater: user
+      }
+
+      let newOrderProduct: OrderProduct = Object.assign(new OrderProduct(), newOrderInv)
+      newOrderProduct = {
+        ...newOrderProduct,
+        packQty: 0,
+        actualPackQty: 0,
+        palletQty: 0,
+        actualPalletQty: 0,
+        status: ORDER_PRODUCT_STATUS.ASSIGNED,
+        batchId: ''
+      }
+
+      newOrderProduct = await tx.getRepository(OrderProduct).save(newOrderProduct)
+
+      // Preassign Inventories
+      const inventoryAssignmentSetting: Setting = await tx.getRepository(Setting).findOne({
+        where: { domain, name: 'rule-for-inventory-assignment' }
+      })
+
+      let locationSortingRules = []
+      if (inventoryAssignmentSetting) {
+        let locationSetting = JSON.parse(inventoryAssignmentSetting.value)
+        for (const key in locationSetting) {
+          locationSortingRules.push({ name: key, desc: locationSetting[key] == 'ASC' ? false : true })
+        }
+      }
+
+      let assignedOrderInventories: OrderInventory[] = await InventoryUtil.autoAssignInventoryForRelease(
+        oi,
+        productDetail.product,
+        productDetail,
+        locationSortingRules,
+        { id: bizplace },
+        domain,
+        tx,
+        oi.batchId,
+        'STORAGE'
+      )
+
+      assignedOrderInventories = assignedOrderInventories.map(aoi => {
+        return {
+          ...aoi,
+          orderProduct: newOrderProduct,
+          bizplace: { id: bizplace }
+        }
+      })
+
+      finalOrderInventories.push(...assignedOrderInventories)
+    }
+
+    for (let oi of finalOrderInventories) {
+      let generatedOI: OrderInventory = Object.assign(new OrderInventory(), oi)
+      generatedOI = {
+        ...generatedOI,
+        domain,
+        status: ORDER_INVENTORY_STATUS.PENDING,
+        name: OrderNoGenerator.orderInventory(),
+        replenishment: newReplenishment,
+        creator: user,
+        updater: user
+      }
+
+      await tx.getRepository(OrderInventory).save({ ...generatedOI })
+
+      await tx.getRepository(Inventory).update(oi.inventory.id, {
+        transferQty: (oi.inventory?.lockedQty || 0) + generatedOI.releaseQty,
+        transferUomValue: (oi.inventory?.lockedUomValue || 0) + generatedOI.releaseUomValue,
+        updater: user
+      })
+    }
+
+    return newReplenishment
+  } catch (error) {
+    throw error
+  }
+}
+
+export async function confirmReplenishment(name: string, context: any, tx?: EntityManager): Promise<Replenishment> {
+  const { user, domain }: { user: User; domain: Domain } = context.state
+
+  let foundReplenishment: Replenishment = await tx.getRepository(Replenishment).findOne({
+    where: { name, status: ORDER_STATUS.PENDING }
+  })
+
+  if (!foundReplenishment) throw new Error(`Replenisment doesn't exists.`)
+
+  let foundOIs: OrderInventory[] = await tx.getRepository(OrderInventory).find({
+    where: { domain, replenishment: foundReplenishment }
+  })
+
+  // 1. RO Status change (PENDING => PENDING_RECEIVE)
+  const replenishment: Replenishment = await tx.getRepository(Replenishment).save({
+    ...foundReplenishment,
+    status: ORDER_STATUS.PENDING_WORKSHEET,
+    updater: user
+  })
+
+  // 1. Update status of order inventories
+  foundOIs = foundOIs.map((orderInventory: OrderInventory) => {
+    return {
+      ...orderInventory,
+      status: ORDER_INVENTORY_STATUS.PENDING_WORKSHEET,
+      updater: user
+    }
+  })
+  await tx.getRepository(OrderInventory).save(foundOIs)
+
+  return replenishment
+}

package/server/service/replenishment/replenishment-query.ts

@@ -0,0 +1,76 @@
+import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
+import { getRepository, EntityManager, SelectQueryBuilder } from 'typeorm'
+import { Domain, ListParam, convertListParams } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { Replenishment } from './replenishment'
+import { ReplenishmentList } from './replenishment-type'
+import { OrderInventory } from '../order-inventory/order-inventory'
+import { Inventory } from '@things-factory/warehouse-base'
+import { ORDER_INVENTORY_STATUS } from 'server/constants'
+
+@Resolver(Replenishment)
+export class ReplenishmentQuery {
+  @Query(returns => Replenishment, { description: 'To fetch a Replenishment' })
+  async replenishment(@Arg('id') id: string, @Ctx() context: any): Promise<Replenishment> {
+    const { domain } = context.state
+
+    return await getRepository(Replenishment).findOne({
+      where: { domain, id }
+    })
+  }
+
+  @Query(returns => ReplenishmentList, { description: 'To fetch multiple Replenishments' })
+  async replenishments(@Args() params: ListParam, @Ctx() context: any): Promise<ReplenishmentList> {
+    const { domain } = context.state
+
+    const convertedParams = convertListParams(params, domain.id)
+    const [items, total] = await getRepository(Replenishment).findAndCount(convertedParams)
+
+    return { items, total }
+  }
+
+  @Query(returns => Replenishment)
+  async replenishmentDetail(
+    @Ctx() context: any,
+    @Arg('name', { nullable: true }) name?: string
+  ): Promise<Replenishment> {
+    try {
+      const { domain }: { domain: Domain } = context.state
+      let param: any
+
+      if (name) param = { domain, name }
+
+      let replenishment: Replenishment = await getRepository(Replenishment).findOne({
+        where: { ...param },
+        relations: ['domain', 'orderInventories', 'orderInventories.product', 'orderInventories.bizplace']
+      })
+
+      replenishment.orderInventories = replenishment.orderInventories.map((oi: OrderInventory) => {
+        return {
+          ...oi,
+          transferQty: oi.releaseQty,
+          productSKU: oi.product.sku
+        }
+      })
+
+      return replenishment
+    } catch (error) {
+      throw new Error(error)
+    }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() replenishment: Replenishment): Promise<Domain> {
+    return await getRepository(Domain).findOne(replenishment.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() replenishment: Replenishment): Promise<User> {
+    return await getRepository(User).findOne(replenishment.updaterId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() replenishment: Replenishment): Promise<User> {
+    return await getRepository(User).findOne(replenishment.creatorId)
+  }
+}