@things-factory/sales-base 4.0.12 → 4.0.17

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

@@ -4,12 +4,19 @@ import { EntityManager, getRepository, In, Repository, SelectQueryBuilder } from
 
 import { Attachment } from '@things-factory/attachment-base'
 import { User } from '@things-factory/auth-base'
-import { Bizplace, getMyBizplace, getPermittedBizplaceIds } from '@things-factory/biz-base'
+import { Bizplace, getCompanyBizplace, getMyBizplace, getPermittedBizplaceIds } from '@things-factory/biz-base'
 import { Product } from '@things-factory/product-base'
 import { buildQuery, Domain, Filter, ListParam, Pagination, Sorting } from '@things-factory/shell'
 import { Inventory } from '@things-factory/warehouse-base'
 
-import { InventoryInfos, OrderInventory, ReleasableInventoryList, ReleaseGoodList, ShippingOrder } from '../'
+import {
+  InventoryInfos,
+  NewReleaseGood,
+  OrderInventory,
+  ReleasableInventoryList,
+  ReleaseGoodList,
+  ShippingOrder
+} from '../'
 import { ATTACHMENT_TYPE, ORDER_INVENTORY_STATUS, ORDER_STATUS } from '../../constants'
 import { ReleaseGood } from './release-good'
 
@@ -463,6 +470,129 @@ export class ReleaseGoodQuery {
     }
   }
 
+  @Directive('@transaction')
+  @Query(returns => [ReleaseGood])
+  async bulkReleaseGoodsAvailableItems(
+    @Ctx() context: any,
+    @Arg('rawReleaseGoods', type => [NewReleaseGood], { nullable: true }) rawReleaseGoods: NewReleaseGood[],
+    @Arg('bizplaceId', type => String) bizplaceId: string
+  ): Promise<ReleaseGood[]> {
+    const { domain, tx } = context.state
+    const companyBizplaceId: Bizplace = await getCompanyBizplace(null, null, bizplaceId)
+
+    if (!rawReleaseGoods) return
+
+    const json_oi = JSON.stringify(
+      rawReleaseGoods.map(raw => {
+        return {
+          sku: raw.sku,
+          packing_type: raw.packingType,
+          packing_size: raw.packingSize,
+          uom: raw.uom,
+          release_qty: raw.releaseQty
+        }
+      })
+    )
+
+    await tx.query(
+      `
+        CREATE TEMP TABLE temp_order_products(
+          product_id VARCHAR(50),
+          sku VARCHAR(150),
+          packing_type VARCHAR(50),
+          packing_size INT,
+          uom VARCHAR(10),
+          release_qty INT
+          );
+      `
+    )
+
+    await tx.query(
+      `
+        INSERT INTO temp_order_products
+        SELECT p.id AS product_id, js.sku,
+        CASE WHEN js.packing_type NOTNULL AND js.packing_size NOTNULL THEN js.packing_type ELSE pd.packing_type END,
+        CASE WHEN js.packing_type NOTNULL AND js.packing_size NOTNULL THEN js.packing_size ELSE pd.packing_size END,
+        CASE WHEN js.uom NOTNULL THEN js.uom ELSE pd.uom END,
+        js.release_qty
+        FROM JSON_POPULATE_RECORDSET(NULL::temp_order_products,'${json_oi}') js
+        LEFT JOIN products p ON js.sku = p.sku AND p.bizplace_id = $1
+        LEFT JOIN product_details pd ON p.id = pd.product_id AND pd.is_default = TRUE;
+      `,
+      [companyBizplaceId.id]
+    )
+
+    let availableItems = await tx.query(
+      `
+        SELECT i.product_id, foo.sku, i.batch_id, i.packing_type, i.packing_size, i.uom,
+          SUM(i.qty - COALESCE(i.locked_qty, 0)) - COALESCE(
+            (
+              SELECT SUM(oi.release_qty) FROM order_inventories oi 
+              WHERE (
+                oi.status = 'PENDING'
+                OR oi.status = 'PENDING_RECEIVE'
+                OR oi.status = 'PENDING_WORKSHEET'
+                OR oi.status = 'PENDING_SPLIT'
+              )
+              AND oi.inventory_id IS null
+              AND oi.product_id = i.product_id::uuid
+              AND oi.packing_type = i.packing_type
+              AND oi.uom = i.uom
+              AND oi.domain_id = $1
+              AND oi.bizplace_id = $2
+            ), 0) as "remain_qty",
+          SUM(i.uom_value - COALESCE(i.locked_uom_value, 0)) - COALESCE(
+            (
+              SELECT SUM(oi.release_uom_value) FROM order_inventories oi 
+              WHERE (
+                oi.status = 'PENDING'
+                OR oi.status = 'PENDING_RECEIVE'
+                OR oi.status = 'PENDING_WORKSHEET'
+                OR oi.status = 'PENDING_SPLIT'
+              )
+              AND oi.inventory_id IS null
+              AND oi.product_id = i.product_id::uuid
+              AND oi.packing_type = i.packing_type
+              AND oi.uom = i.uom
+              AND oi.domain_id = $1
+              AND oi.bizplace_id = $2
+            ), 0) as "remain_uom_value"
+        FROM inventories i
+        INNER JOIN (
+          SELECT top.product_id, top.sku, top.packing_type, top.packing_size, top.uom 
+          FROM temp_order_products top
+          GROUP BY top.product_id, top.sku, top.packing_type, top.packing_size, top.uom
+        ) AS foo
+        ON i.product_id = foo.product_id::uuid
+        AND i.packing_type = foo.packing_type
+        AND i.packing_size = foo.packing_size
+        AND i.uom = foo.uom
+        AND i.domain_id = $1
+        AND i.bizplace_id = $2
+        GROUP BY i.product_id, foo.sku, i.batch_id, i.packing_type, i.packing_size, i.uom
+        ORDER BY foo.sku, remain_qty
+      `,
+      [domain.id, bizplaceId]
+    )
+
+    await tx.query('DROP TABLE temp_order_products')
+
+    availableItems = availableItems.map(item => {
+      return {
+        productId: item.product_id,
+        sku: item.sku,
+        batchId: item.batch_id,
+        packingType: item.packing_type,
+        packingSize: item.packing_size,
+        uom: item.uom,
+        remainQty: item.remain_qty,
+        remainUomValue: item.remain_uom_value
+      }
+    })
+
+    return _extractData(rawReleaseGoods, availableItems)
+  }
+
   @FieldResolver(type => Domain)
   async domain(@Root() releaseGood: ReleaseGood): Promise<Domain> {
     return await getRepository(Domain).findOne(releaseGood.domainId)
@@ -559,6 +689,71 @@ async function dropOITempTable(domain: Domain, tx: EntityManager) {
   await tx.query(`DROP TABLE oi`)
 }
 
+function _extractData(rawData, validatedData) {
+  return rawData.map(raw => {
+    const idx = validatedData.findIndex(val => {
+      const comparison = ['packingType', 'packingSize', 'uom']
+
+      let a: any = {},
+        b: any = {}
+
+      comparison.forEach(cc => {
+        if (raw[cc]) {
+          a[cc] = raw[cc]
+          b[cc] = val[cc]
+        }
+      })
+
+      a = JSON.stringify(Object.fromEntries(Object.entries(a).sort()))
+      b = JSON.stringify(Object.fromEntries(Object.entries(b).sort()))
+
+      return val.sku == raw.sku && a === b
+    })
+
+    let releaseUomValue = 0
+
+    // if sku is matched, assign qty and product id
+    if (idx >= 0) {
+      // assign qty to rawData as much as possible
+      releaseUomValue =
+        (Math.round((validatedData[idx]?.remainUomValue / validatedData[idx]?.remainQty) * 100) / 100) * raw.releaseQty
+
+      raw.assignedQty =
+        validatedData[idx].remainQty >= raw.releaseQty
+          ? raw.releaseQty > 0
+            ? raw.releaseQty
+            : 0
+          : validatedData[idx].remainQty
+
+      raw.assignedUomValue =
+        validatedData[idx].remainUomValue >= releaseUomValue
+          ? releaseUomValue > 0
+            ? releaseUomValue
+            : 0
+          : validatedData[idx].remainUomValue
+
+      // deduct qty & uomValue from validateData
+      validatedData[idx].remainQty -= raw.assignedQty
+      validatedData[idx].remainUomValue -= raw.assignedUomValue
+
+      raw.productId = validatedData[idx].productId
+      raw.packingType = validatedData[idx].packingType
+      raw.packingSize = validatedData[idx].packingSize
+      raw.uom = validatedData[idx].uom
+      raw.batchId = validatedData[idx].batchId
+    } else {
+      raw.assignedQty = 0
+      raw.assignedUomValue = 0
+      raw.productId = null
+    }
+
+    return {
+      ...raw,
+      releaseUomValue
+    }
+  })
+}
+
 function getConditionValues(
   conditions: Filter[]
 ): {

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

@@ -121,10 +121,19 @@ export class InventoryInfos {
 
   @Field({ nullable: true })
   remark?: string
+
+  @Field({ nullable: true })
+  lockedQty?: number
+
+  @Field({ nullable: true })
+  lockedUomValue?: number
 }
 
 @ObjectType()
 export class ShippingOrderInfo {
+  @Field({ nullable: true })
+  id?: string
+
   @Field({ nullable: true })
   containerNo?: string
 
@@ -272,11 +281,11 @@ export class NewReleaseGood {
   @Field(type => ObjectRef, { nullable: true })
   shippingOrder: ObjectRef
 
-  @Field(type => NewOrderInventory, { nullable: true })
-  orderInventories: [NewOrderInventory]
+  @Field(type => [NewOrderInventory], { nullable: true })
+  orderInventories: NewOrderInventory[]
 
-  @Field(type => NewOrderVas, { nullable: true })
-  orderVass: [NewOrderVas]
+  @Field(type => [NewOrderVas], { nullable: true })
+  orderVass: NewOrderVas[]
 
   @Field({ nullable: true })
   status: string
@@ -295,6 +304,21 @@ export class NewReleaseGood {
 
   @Field({ nullable: true })
   partnerBizplaceId: string
+
+  @Field({ nullable: true })
+  sku: string
+
+  @Field({ nullable: true })
+  packingType: string
+
+  @Field({ nullable: true })
+  packingSize: string
+
+  @Field({ nullable: true })
+  uom: string
+
+  @Field({ nullable: true })
+  releaseQty: string
 }
 
 @InputType()
@@ -372,13 +396,13 @@ export class ReleaseGoodPatch {
   shippingOrder: ObjectRef
 
   @Field(type => [ObjectRef], { nullable: true })
-  deliveryOrders: [ObjectRef]
+  deliveryOrders: ObjectRef[]
 
   @Field(type => [ObjectRef], { nullable: true })
-  orderInventories: [ObjectRef]
+  orderInventories: ObjectRef[]
 
   @Field(type => [ObjectRef], { nullable: true })
-  orderVass: [ObjectRef]
+  orderVass: ObjectRef[]
 
   @Field({ nullable: true })
   status: string

package/server/service/reverse-kitting-order/reverse-kitting-order-mutation.ts

@@ -7,6 +7,7 @@ import {
   Inventory,
   INVENTORY_STATUS,
   INVENTORY_TRANSACTION_TYPE,
+  InventoryHistory,
   InventoryNoGenerator,
   InventoryPatch,
   InventoryUtil,
@@ -51,19 +52,19 @@ export class ReverseKittingOrderMutation {
 
     // 2. Create Reverse Kitting Order Items
     reverseKittingOrderOIs = await Promise.all(
-      reverseKittingOrderOIs.map(async (ork: any) => {
-        if (ork?.inventory?.id) {
-          const foundInv: Inventory = await tx.getRepository(Inventory).findOne(ork.inventory.id)
-          ork.inventory = foundInv
+      reverseKittingOrderOIs.map(async (reverseKittingOI: any) => {
+        if (reverseKittingOI?.inventory?.id) {
+          const foundInv: Inventory = await tx.getRepository(Inventory).findOne(reverseKittingOI.inventory.id)
+          reverseKittingOI.inventory = foundInv
 
-          foundInv.lockedQty = Number(foundInv.lockedQty) + ork.qty
-          foundInv.lockedUomValue = Number(foundInv.lockedUomValue) + ork.uomValue
+          foundInv.lockedQty = Number(foundInv.lockedQty) + reverseKittingOI.qty
+          foundInv.lockedUomValue = Number(foundInv.lockedUomValue) + reverseKittingOI.uomValue
           foundInv.updater = user
 
           await tx.getRepository(Inventory).save(foundInv)
         }
         return {
-          ...ork,
+          ...reverseKittingOI,
           domain,
           name: OrderNoGenerator.orderVas(),
           reverseKittingOrder: createdReverseKittingOrder,
@@ -130,8 +131,8 @@ export class ReverseKittingOrderMutation {
       updater: user
     })
 
-    reverseKittingOIs = reverseKittingOIs.map((ork: ReverseKittingOrderInventory) => {
-      return { ...ork, status: ORDER_VAS_STATUS.READY_TO_PROCESS }
+    reverseKittingOIs = reverseKittingOIs.map((reverseKittingOI: ReverseKittingOrderInventory) => {
+      return { ...reverseKittingOI, status: ORDER_VAS_STATUS.READY_TO_PROCESS }
     })
     await tx.getRepository(ReverseKittingOrderInventory).save(reverseKittingOIs)
 
@@ -244,6 +245,68 @@ export class ReverseKittingOrderMutation {
     return reverseKitting
   }
 
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To undo the execution of reverse kitting order' })
+  async undoReverseKittingInventory(
+    @Arg('reverseKittingOIName') reverseKittingOIName: string,
+    @Arg('palletId') palletId: string,
+    @Ctx() context: any
+  ): Promise<boolean> {
+    const { tx, domain, user } = context.state
+
+    //@sumjoekin please add stricter validation. It is dangerous without strict validation. Unexpected behaviour will cause accidental deletion of inventory.
+
+    const reverseKittingOI: ReverseKittingOrderInventory = await tx
+      .getRepository(ReverseKittingOrderInventory)
+      .findOne({
+        where: { domain, name: reverseKittingOIName },
+        relations: ['bizplace', 'reverseKittingOrder']
+      })
+
+    const bizplace: Bizplace = reverseKittingOI.bizplace
+    const reverseKittingOrder: ReverseKittingOrder = reverseKittingOI.reverseKittingOrder
+    let foundInventory: Inventory = await tx.getRepository(Inventory).findOne({
+      where: { domain, bizplace, orderVasId: reverseKittingOI.id, palletId },
+      relations: ['bizplace', 'product']
+    })
+    if (!foundInventory) throw new Error(`There's no results matched with condition ${foundInventory.palletId}`)
+
+    let operationGuide: any = JSON.parse(reverseKittingOI.operationGuide)
+    let productCombinationSets: any[] = operationGuide.data.productCombinationSets
+    productCombinationSets = productCombinationSets.map(item => {
+      if (foundInventory.product.id == item.productId) {
+        item.actualQty -= foundInventory.qty
+      }
+      return item
+    })
+    operationGuide.data.productCombinationSets = productCombinationSets
+
+    await tx
+      .getRepository(ReverseKittingOrderInventory)
+      .update({ id: reverseKittingOI.id }, { operationGuide: operationGuide })
+
+    foundInventory.lastSeq++
+    foundInventory.status = INVENTORY_STATUS.DELETED
+    foundInventory = await InventoryUtil.transactionInventory(
+      foundInventory,
+      reverseKittingOrder,
+      -foundInventory.qty,
+      -foundInventory.uomValue,
+      INVENTORY_TRANSACTION_TYPE.UNDO_REVERSE_KITTING,
+      user,
+      tx
+    )
+    foundInventory.qty = 0
+    foundInventory.uomValue = 0
+    foundInventory.updater = user
+
+    await tx.getRepository(InventoryHistory).update({ inventory: foundInventory }, { inventory: null })
+
+    await tx.getRepository(Inventory).delete({ id: foundInventory.id })
+
+    return true
+  }
+
   @Directive('@transaction')
   @Mutation(returns => ReverseKittingOrder, { description: 'To activate reverse kitting order' })
   async activateReverseKittingOrder(@Arg('name') name: string, @Ctx() context: any): Promise<ReverseKittingOrder> {
@@ -265,8 +328,8 @@ export class ReverseKittingOrderMutation {
       updater: user
     })
 
-    reverseKittingOIs = reverseKittingOIs.map((ork: ReverseKittingOrderInventory) => {
-      return { ...ork, status: ORDER_VAS_STATUS.PROCESSING }
+    reverseKittingOIs = reverseKittingOIs.map((reverseKittingOI: ReverseKittingOrderInventory) => {
+      return { ...reverseKittingOI, status: ORDER_VAS_STATUS.PROCESSING }
     })
     await tx.getRepository(ReverseKittingOrderInventory).save(reverseKittingOIs)
 
@@ -297,9 +360,7 @@ export class ReverseKittingOrderMutation {
     const customerBizplace: Bizplace = foundReverseKittingOrder.bizplace
 
     const productDetail: ProductDetail = await tx.getRepository(ProductDetail).findOne({
-      where: {
-        id: inventory.productDetailId
-      },
+      where: { id: inventory.productDetailId },
       relations: ['product']
     })
 
@@ -394,18 +455,18 @@ export class ReverseKittingOrderMutation {
 
     // Delete order reverse kittings by ids
     await Promise.all(
-      reverseKittingOIs.map(async (ork: ReverseKittingOrderInventory) => {
-        if (ork?.inventory?.id) {
-          ork.inventory = await tx.getRepository(Inventory).findOne(ork.inventory.id)
+      reverseKittingOIs.map(async (reverseKittingOI: ReverseKittingOrderInventory) => {
+        if (reverseKittingOI?.inventory?.id) {
+          reverseKittingOI.inventory = await tx.getRepository(Inventory).findOne(reverseKittingOI.inventory.id)
 
           await tx.getRepository(Inventory).save({
-            ...ork.inventory,
-            lockedQty: ork.inventory.lockedQty - ork.qty,
-            lockedUomValue: ork.inventory.lockedUomValue - ork.uomValue,
+            ...reverseKittingOI.inventory,
+            lockedQty: reverseKittingOI.inventory.lockedQty - reverseKittingOI.qty,
+            lockedUomValue: reverseKittingOI.inventory.lockedUomValue - reverseKittingOI.uomValue,
             updater: user
           })
         }
-        return ork
+        return reverseKittingOI
       })
     )
 

package/server/service/reverse-kitting-order/reverse-kitting-order-query.ts

@@ -3,13 +3,15 @@ import { getRepository, In } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
 import { Bizplace, getPermittedBizplaceIds } from '@things-factory/biz-base'
+import { generateId } from '@things-factory/id-rule-base'
+import { Product, ProductDetail } from '@things-factory/product-base'
 import { convertListParams, Domain, ListParam } from '@things-factory/shell'
 import { Inventory, INVENTORY_STATUS } from '@things-factory/warehouse-base'
 
 import { ORDER_VAS_STATUS } from '../../constants'
 import { ReverseKittingOrderInventory } from '../reverse-kitting-order-inventory/reverse-kitting-order-inventory'
 import { ReverseKittingOrder } from './reverse-kitting-order'
-import { ReverseKittingOrderList } from './reverse-kitting-order-type'
+import { LotInfo, ReverseKittingOrderList, ReverseKittingInventoryDetail } from './reverse-kitting-order-type'
 
 @Resolver(ReverseKittingOrder)
 export class ReverseKittingOrderQuery {
@@ -41,35 +43,119 @@ export class ReverseKittingOrderQuery {
 
   @Query(returns => ReverseKittingOrder, { description: 'To fetch a ReverseKittingOrder' })
   async reverseKittingInventories(
-    @Arg('orderReverseKittingName') orderReverseKittingName: string,
+    @Arg('reverseKittingOIName') reverseKittingOIName: string,
+    @Arg('productDetailId') productDetailId: string,
     @Ctx() context: any
   ): Promise<Inventory[]> {
     const { domain } = context.state
-    const reverseKittingOI: ReverseKittingOrderInventory = await getRepository(ReverseKittingOrderInventory).findOne({
+
+    const productDetail: ProductDetail = await getRepository(ProductDetail).findOne({
+      where: { id: productDetailId },
+      relations: ['product']
+    })
+
+    const product: Product = productDetail.product
+
+    const foundReverseKittingOI: ReverseKittingOrderInventory = await getRepository(
+      ReverseKittingOrderInventory
+    ).findOne({
       where: {
         domain,
-        name: orderReverseKittingName,
+        name: reverseKittingOIName,
         status: ORDER_VAS_STATUS.PROCESSING
       },
       relations: ['bizplace', 'reverseKittingOrder', 'inventory']
     })
 
-    if (!reverseKittingOI) return
+    if (!foundReverseKittingOI) return
 
-    const reverseKittingOrder: ReverseKittingOrder = reverseKittingOI.reverseKittingOrder
-    const customerBizplace: Bizplace = reverseKittingOI.bizplace
+    const reverseKittingOrder: ReverseKittingOrder = foundReverseKittingOI.reverseKittingOrder
+    const customerBizplace: Bizplace = foundReverseKittingOI.bizplace
     return await getRepository(Inventory).find({
       where: {
         domain,
         bizplace: customerBizplace,
         refOrderId: reverseKittingOrder.id,
-        orderVasId: reverseKittingOI.id,
+        orderVasId: foundReverseKittingOI.id,
+        product: product,
         status: INVENTORY_STATUS.STORED
       },
-      relations: ['product', 'bizplace']
+      relations: ['product', 'bizplace', 'location']
     })
   }
 
+  @Query(returns => [ReverseKittingInventoryDetail], {
+    description: 'To generate lot id and label for reverse kitting'
+  })
+  async generateReverseKittingLotId(
+    @Arg('targets', type => [LotInfo]) targets: LotInfo[],
+    @Arg('type') type: string,
+    @Ctx() context: any
+  ): Promise<ReverseKittingInventoryDetail[]> {
+    const { tx, domain } = context.state
+    // 1. get and set the date
+    const today = new Date()
+    const year = today.getFullYear()
+    const month = today.getMonth()
+    const day = today.getDate()
+
+    const yy = String(year).substr(String(year).length - 2)
+    const mm = String(month + 1).padStart(2, '0')
+    const dd = String(day).padStart(2, '0')
+
+    const date = yy + mm + dd
+    let results = []
+
+    // 2. get worksheet detail
+    let ids = targets.map(target => target.id)
+
+    // - getRepository using In(array) to pass the value to defined variable
+    const foundOrderReverseKittings: ReverseKittingOrderInventory[] = await tx
+      .getRepository(ReverseKittingOrderInventory)
+      .find({
+        where: {
+          domain,
+          id: In(ids)
+        },
+        relations: ['domain', 'bizplace']
+      })
+
+    // 3. from worksheet detail get product name, product type, batchid, packing type, bizplace
+
+    if (foundOrderReverseKittings.length <= 0) throw new Error('Unable to find order reverse kittings')
+    else {
+      for (let i = 0; i < foundOrderReverseKittings.length; i++) {
+        let foundORK = foundOrderReverseKittings[i]
+        for (let idx = 0; idx < targets.length; idx++) {
+          if (foundORK.id === targets[idx].id) {
+            // 4. generate pallet id based on print qty > call generateId resolver
+            for (let i = 0; i < targets[idx].printQty; i++) {
+              const generatedPalletId = await generateId({
+                domain,
+                type,
+                seed: {
+                  batchId: foundORK.inventory.batchId,
+                  date: date
+                }
+              })
+
+              // 5. map all data to be returned
+              if (foundORK != null) {
+                results.push({
+                  ...foundORK,
+                  palletId: generatedPalletId,
+                  bizplace: foundORK.bizplace
+                })
+              }
+            }
+          }
+        }
+      }
+    }
+
+    return results
+  }
+
   @Query(returns => ReverseKittingOrderList, { description: 'To fetch multiple ReverseKittingOrders' })
   async reverseKittingOrders(@Args() params: ListParam, @Ctx() context: any): Promise<ReverseKittingOrderList> {
     const { domain, user }: { domain: Domain; user: User } = context.state
@@ -92,76 +178,6 @@ export class ReverseKittingOrderQuery {
     return { items, total }
   }
 
-  // @Query(returns => [InventoryDetail], { description: 'To generate reverse kitting order lot id' })
-  // async generateReverseKittingPalletId(
-  //   @Arg('targets') targets: [PalletInfo],
-  //   @Arg('type') type: string,
-  //   @Ctx() context: any
-  // ): Promise<InventoryDetail[]> {
-  //   const { tx, domain } = context.state
-  //   // 1. get and set the date
-  //   const today = new Date()
-  //   const year = today.getFullYear()
-  //   const month = today.getMonth()
-  //   const day = today.getDate()
-
-  //   const yy = String(year).substr(String(year).length - 2)
-  //   const mm = String(month + 1).padStart(2, '0')
-  //   const dd = String(day).padStart(2, '0')
-
-  //   const date = yy + mm + dd
-  //   let results = []
-
-  //   // 2. get worksheet detail
-  //   let ids = targets.map(target => target.id)
-
-  //   // - getRepository using In(array) to pass the value to defined variable
-  //   const reverseKittingOIs: ReverseKittingOrderInventory[] = await tx
-  //     .getRepository(ReverseKittingOrderInventory)
-  //     .find({
-  //       where: {
-  //         domain,
-  //         id: In(ids)
-  //       },
-  //       relations: ['domain', 'bizplace']
-  //     })
-
-  //   // 3. from worksheet detail get product name, product type, batchid, packing type, bizplace
-
-  //   if (reverseKittingOIs.length <= 0) throw new Error('Unable to find order reverse kittings')
-  //   else {
-  //     for (let i = 0; i < reverseKittingOIs.length; i++) {
-  //       let reverseKittingOI = reverseKittingOIs[i]
-  //       for (let idx = 0; idx < targets.length; idx++) {
-  //         if (reverseKittingOI.id === targets[idx].id) {
-  //           // 4. generate pallet id based on print qty > call generateId resolver
-  //           for (let i = 0; i < targets[idx].printQty; i++) {
-  //             const generatedPalletId = await generateId({
-  //               domain,
-  //               type,
-  //               seed: {
-  //                 batchId: reverseKittingOI.inventory.batchId,
-  //                 date: date
-  //               }
-  //             })
-
-  //             // 5. map all data to be returned
-  //             if (reverseKittingOI != null) {
-  //               results.push({
-  //                 ...reverseKittingOI,
-  //                 palletId: generatedPalletId,
-  //                 bizplace: reverseKittingOI.bizplace
-  //               })
-  //             }
-  //           }
-  //         }
-  //       }
-  //     }
-  //   }
-
-  //   return results
-  // }
-
   @FieldResolver(type => Domain)
   async domain(@Root() reverseKittingOrder: ReverseKittingOrder): Promise<Domain> {
     return await getRepository(Domain).findOne(reverseKittingOrder.domainId)