@things-factory/worksheet-base 4.1.33 → 4.1.34

package/server/controllers/outbound/picking-worksheet-controller.ts

@@ -1,4 +1,4 @@
-import { In } from 'typeorm'
+import { Equal, In, Not } from 'typeorm'
 
 import { Bizplace } from '@things-factory/biz-base'
 import { generateId } from '@things-factory/id-rule-base'
@@ -14,8 +14,11 @@ import {
 import { Setting } from '@things-factory/setting-base'
 import {
   Inventory,
+  INVENTORY_ITEM_SOURCE,
   INVENTORY_STATUS,
   INVENTORY_TRANSACTION_TYPE,
+  InventoryItem,
+  InventoryNoGenerator,
   Location,
   LOCATION_TYPE
 } from '@things-factory/warehouse-base'
@@ -190,7 +193,7 @@ export class PickingWorksheetController extends VasWorksheetController {
       if (vasWorksheet) {
         await this.activateVAS(vasWorksheet.name, vasWorksheet.worksheetDetails)
       }
-    } catch (e) { }
+    } catch (e) {}
 
     const pendingSplitOIs: OrderInventory[] = await this.trxMgr.getRepository(OrderInventory).find({
       where: { domain: this.domain, releaseGood, status: ORDER_INVENTORY_STATUS.PENDING_SPLIT }
@@ -443,7 +446,7 @@ export class PickingWorksheetController extends VasWorksheetController {
           detail.product?.id === product.id
       )
 
-      if (!foundProductDetail) {
+      if (!foundProductDetail && !product?.isRequireSerialNumberScanningOutbound) {
         const roProductDetail: ProductDetail = productDetails.find(
           (parentDetail: ProductDetail) =>
             parentDetail.packingType === packingType && parentDetail.packingSize == packingSize
@@ -453,26 +456,56 @@ export class PickingWorksheetController extends VasWorksheetController {
         if (pickedQty > releaseQty) {
           throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `over release`))
         }
+      } else if (!foundProductDetail) {
+        throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode))
       }
 
-      if (product?.isRequireSerialNumberScanning) {
-        if (!serialNumber || serialNumber == '')
+      if (product?.isRequireSerialNumberScanningOutbound) {
+        if (!serialNumber || serialNumber == '') {
           throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `require serial number`))
-
-        if (serialNumber) {
-          targetInventory.serialNumber = JSON.stringify(
-            targetInventory.serialNumber ? [...JSON.parse(targetInventory.serialNumber), serialNumber] : [serialNumber]
-          )
         }
-      }
 
-      targetInventory.pickedAt = new Date()
-      targetInventory.pickedByUser = this.user
+        let totalInventoryItems = await this.trxMgr.getRepository(InventoryItem).count({
+          where: {
+            inventory
+          }
+        })
+
+        let foundSerialNumber: InventoryItem = await this.trxMgr
+          .getRepository(InventoryItem)
+          .findOne({ where: { domain: this.domain, serialNumber: serialNumber, product } })
+
+        if (foundSerialNumber) {
+          if (foundSerialNumber.inventoryId !== inventory.id) {
+            throw new Error('Serial Number scanned is in another inventory')
+          }
+
+          if (foundSerialNumber.status !== INVENTORY_STATUS.STORED || foundSerialNumber.outboundOrderId) {
+            throw new Error('Inventory Item is not available')
+          }
+
+          foundSerialNumber.status = INVENTORY_STATUS.PICKED
+          foundSerialNumber.updater = this.user
+          foundSerialNumber.outboundOrderId = releaseGood.id
+
+          await this.trxMgr.getRepository(InventoryItem).save(foundSerialNumber)
+        } else {
+          if (totalInventoryItems >= inventory.qty) {
+            throw new Error('Insufficient inventory quantity to scan new serial number')
+          }
 
-      let pickedBy: string[] = targetInventory.pickedBy ? (targetInventory.pickedBy).split(',') : []
-      if (!pickedBy.find(x => x == this.user.name)) {
-        pickedBy.push(this.user.name)
-        targetInventory.pickedBy = pickedBy.join(',')
+          let inventoryItem: InventoryItem = new InventoryItem()
+          inventoryItem.name = InventoryNoGenerator.inventoryItemName()
+          inventoryItem.serialNumber = serialNumber
+          inventoryItem.status = INVENTORY_STATUS.PICKED
+          inventoryItem.outboundOrderId = releaseGood.id
+          inventoryItem.source = INVENTORY_ITEM_SOURCE.OUTBOUND
+          inventoryItem.product = product
+          inventoryItem.inventory = inventory
+          inventoryItem.domain = this.domain
+
+          await this.trxMgr.getRepository(InventoryItem).save(inventoryItem)
+        }
       }
 
       await this.updatePickingTransaction(releaseGood, targetInventory, worksheetDetail, inventory, pickedQty)
@@ -518,32 +551,103 @@ export class PickingWorksheetController extends VasWorksheetController {
       //validation to prevent over release
       if (inventory.qty <= 0) throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `over release`))
 
-      if (inventory.palletId !== palletId)
+      if (inventory.palletId !== palletId /*&& !product?.isRequireSerialNumberScanningOutbound*/)
+        //to be changed
         throw new Error(this.ERROR_MSG.VALIDITY.UNEXPECTED_FIELD_VALUE('Pallet ID', palletId, inventory.palletId))
 
-      if (product?.isRequireSerialNumberScanning) {
-        if (!serialNumber || serialNumber == '')
+      if (product?.isRequireSerialNumberScanningOutbound) {
+        if (!serialNumber || serialNumber == '') {
           throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `require serial number`))
+        }
 
-        if (serialNumber) {
-          targetInventory.serialNumber = JSON.stringify(
-            targetInventory.serialNumber ? [...JSON.parse(targetInventory.serialNumber), serialNumber] : [serialNumber]
-          )
+        let totalInventoryItems = await this.trxMgr.getRepository(InventoryItem).count({
+          where: {
+            inventory
+          }
+        })
+
+        let foundSerialNumber: InventoryItem = await this.trxMgr.getRepository(InventoryItem).findOne({
+          where: { domain: this.domain, serialNumber: serialNumber, product },
+          relations: ['product', 'inventory']
+        })
+
+        let scannedPalletIdInventory: Inventory = await this.trxMgr
+          .getRepository(Inventory)
+          .findOne({ where: { domain: this.domain, palletId }, relations: ['product'] })
+
+        if (foundSerialNumber) {
+          if (
+            foundSerialNumber.status !== INVENTORY_STATUS.STORED ||
+            foundSerialNumber.outboundOrderId ||
+            foundSerialNumber.inventory !== inventory
+            /*to be changed for replacement && inventory.palletId == palletId*/
+          ) {
+            throw new Error('Inventory Item is not available')
+          }
+
+          foundSerialNumber.status = INVENTORY_STATUS.PICKED
+          foundSerialNumber.updater = this.user
+          foundSerialNumber.outboundOrderId = releaseGood.id
+
+          await this.trxMgr.getRepository(InventoryItem).save(foundSerialNumber)
+        } else {
+          if (totalInventoryItems >= inventory.qty) {
+            throw new Error('Insufficient inventory quantity to scan new serial number')
+          }
+
+          let inventoryItem: InventoryItem = new InventoryItem()
+          inventoryItem.name = InventoryNoGenerator.inventoryItemName()
+          inventoryItem.serialNumber = serialNumber
+          inventoryItem.status = INVENTORY_STATUS.PICKED
+          inventoryItem.outboundOrderId = releaseGood.id
+          inventoryItem.product = product
+          inventoryItem.inventory = scannedPalletIdInventory
+          inventoryItem.domain = this.domain
+
+          await this.trxMgr.getRepository(InventoryItem).save(inventoryItem)
         }
-      }
-      targetInventory.pickedAt = new Date()
-      targetInventory.pickedByUser = this.user;
 
-      let pickedBy: string[] = targetInventory.pickedBy ? (targetInventory.pickedBy).split(',') : []
-      if (!pickedBy.find(x => x == this.user.name)) {
-        pickedBy.push(this.user.name)
-        targetInventory.pickedBy = pickedBy.join(',')
-      }
+        if (inventory.palletId !== palletId) {
+          let existingOrderInv = await this.trxMgr.getRepository(OrderInventory).findOne({
+            where: {
+              domain: this.domain,
+              inventory: scannedPalletIdInventory,
+              releaseGood: releaseGood
+            }
+          })
 
-      targetInventory = await this.checkAndSetBinPicking(targetInventory, binLocation)
+          if (existingOrderInv) {
+            //if replacement order inventory already existed in worksheet detail
+            await this.serialNumberReplacementForExistingOrderInv(
+              existingOrderInv,
+              targetInventory,
+              worksheetDetail,
+              foundSerialNumber
+            )
+          } else if (
+            scannedPalletIdInventory.batchId == inventory.batchId &&
+            scannedPalletIdInventory.product.id == product.id &&
+            scannedPalletIdInventory.product.packingType == product.packingType
+          ) {
+            //if replacement order inventory does not exist
+            await this.serialNumberReplacement(
+              targetInventory,
+              scannedPalletIdInventory,
+              releaseGood,
+              product,
+              worksheetDetail,
+              foundSerialNumber
+            )
+          } else {
+            throw new Error(this.ERROR_MSG.VALIDITY.UNEXPECTED_FIELD_VALUE('Pallet ID', palletId, inventory.palletId))
+          }
+        }
+      }
 
       await this.updatePickingTransaction(releaseGood, targetInventory, worksheetDetail, inventory, pickedQty)
 
+      targetInventory = await this.checkAndSetBinPicking(targetInventory, binLocation)
+
       const fromLocation: Location = targetInventory.inventory.location
       if (locationName) {
         const toLocation: Location = await this.trxMgr.getRepository(Location).findOne({
@@ -638,16 +742,6 @@ export class PickingWorksheetController extends VasWorksheetController {
 
       targetInventory.pickedQty = targetInventory.releaseQty
       targetInventory.status = ORDER_INVENTORY_STATUS.PICKED
-
-      targetInventory.pickedAt = new Date()
-      targetInventory.pickedByUser = this.user;
-
-      let pickedBy: string[] = targetInventory.pickedBy ? (targetInventory.pickedBy).split(',') : []
-      if (!pickedBy.find(x => x == this.user.name)) {
-        pickedBy.push(this.user.name)
-        targetInventory.pickedBy = pickedBy.join(',')
-      }
-
       await this.updateOrderTargets([targetInventory])
 
       inventory.qty -= targetInventory.releaseQty
@@ -802,15 +896,6 @@ export class PickingWorksheetController extends VasWorksheetController {
         targetInventory.pickedQty += pickedQty > gapQtyRemaining ? gapQtyRemaining : pickedQty
         remainingAssignedQty = remainingAssignedQty < 0 ? 0 : remainingAssignedQty
 
-        targetInventory.pickedAt = new Date()
-        targetInventory.pickedByUser = this.user;
-
-        let pickedBy: string[] = targetInventory.pickedBy ? (targetInventory.pickedBy).split(',') : []
-        if (!pickedBy.find(x => x == this.user.name)) {
-          pickedBy.push(this.user.name)
-          targetInventory.pickedBy = pickedBy.join(',')
-        }
-
         if (targetInventory.pickedQty == targetReleaseQty) {
           const leftQty: number = inventory.qty - targetInventory.releaseQty
           if (leftQty < 0) {
@@ -865,6 +950,28 @@ export class PickingWorksheetController extends VasWorksheetController {
     ])
     await this.checkRecordValidity(worksheet, { status: WORKSHEET_STATUS.EXECUTING })
 
+    let InventoryItems: InventoryItem = await this.trxMgr
+      .getRepository(InventoryItem)
+      .find({ where: { outboundOrderId: releaseGood.id } })
+
+    if (InventoryItems.length > 0) {
+      InventoryItems.forEach((itm: InventoryItem) => {
+        itm.status = INVENTORY_STATUS.TERMINATED
+        itm.updater = this.user
+      })
+
+      // let inventoryLists = InventoryItems.filter(
+      //   (value, index, self) => index === self.findIndex(itm => itm.inventory.id === value.inventory.id)
+      // )
+
+      // inventoryLists.forEach((itm: Inventory) => {
+      //   if (itm.inventory.qty - itm.releaseQty == 0)
+      //     this.transactionInventory(itm, releaseGood, 0, 0, INVENTORY_TRANSACTION_TYPE.TERMINATED)
+      // })
+
+      await this.trxMgr.getRepository(InventoryItem).save(InventoryItems)
+    }
+
     let orderStatus: string
     if (releaseGood?.packingOption) {
       orderStatus = ORDER_STATUS.READY_TO_PACK
@@ -1025,4 +1132,269 @@ export class PickingWorksheetController extends VasWorksheetController {
 
     return orderInventory
   }
+
+  private async serialNumberReplacementForExistingOrderInv(
+    existingOrderInv,
+    targetInventory,
+    worksheetDetail,
+    foundSerialNumber
+  ) {
+    try {
+      //1. update replacement inventory, order inventory, old inventory, old order inventory quantity
+      let newInventory: Inventory = await this.trxMgr
+        .getRepository(Inventory)
+        .findOne({ where: { domain: this.domain, id: existingOrderInv?.inventoryId } })
+
+      let newOrderInventory: OrderInventory = await this.trxMgr
+        .getRepository(OrderInventory)
+        .findOne({ where: { domain: this.domain, id: existingOrderInv?.id } })
+
+      let oldInventory: Inventory = await this.trxMgr
+        .getRepository(Inventory)
+        .findOne({ where: { domain: this.domain, id: targetInventory?.inventory.id } })
+
+      let oldOrderInventory: OrderInventory = await this.trxMgr
+        .getRepository(OrderInventory)
+        .findOne({ where: { domain: this.domain, id: targetInventory?.id } })
+
+      //if replacement inventory quantity insufficient
+      if (newInventory.qty - newInventory.lockedQty < targetInventory.releaseQty - targetInventory.pickedQty) {
+        newOrderInventory.releaseQty += newInventory.qty - newInventory.lockedQty
+        newOrderInventory.releaseUomValue += newInventory.uomValue - newInventory.lockedUomValue
+
+        oldOrderInventory.releaseQty -= newOrderInventory.releaseQty
+        oldOrderInventory.releaseUomValue -= newOrderInventory.releaseUomValue
+
+        oldInventory.lockedQty -= newOrderInventory.releaseQty
+        oldInventory.lockedUomValue -= newOrderInventory.releaseUomValue
+
+        newInventory.lockedQty = newInventory.qty
+        newInventory.lockedUomValue = newInventory.uomValue
+      } else {
+        newOrderInventory.releaseQty += targetInventory.releaseQty - targetInventory.pickedQty
+        newOrderInventory.releaseUomValue +=
+          newOrderInventory.releaseQty * (targetInventory.releaseUomValue / targetInventory.releaseQty)
+
+        oldOrderInventory.releaseQty = targetInventory.pickedQty
+        oldOrderInventory.status = INVENTORY_STATUS.PICKED
+        oldOrderInventory.releaseUomValue =
+          (targetInventory.releaseUomValue / targetInventory.releaseQty) * oldOrderInventory.releaseQty
+
+        oldInventory.lockedQty -= targetInventory.releaseQty - targetInventory.pickedQty
+        oldInventory.lockedUomValue =
+          oldInventory.lockedQty * (targetInventory.releaseUomValue / targetInventory.releaseQty)
+
+        newInventory.lockedQty = newInventory.lockedQty + (targetInventory.releaseQty - targetInventory.pickedQty)
+        newInventory.lockedUomValue =
+          (targetInventory.releaseUomValue / targetInventory.releaseQty) * newInventory.lockedQty
+      }
+
+      newInventory = await this.trxMgr.getRepository(Inventory).save({ ...newInventory, updater: this.user })
+
+      newOrderInventory = await this.trxMgr.getRepository(OrderInventory).save({
+        ...newOrderInventory,
+        status: INVENTORY_STATUS.PICKING,
+        pickedQty: existingOrderInv.pickedQty++,
+        updater: this.user
+      })
+
+      oldInventory = await this.trxMgr.getRepository(Inventory).save({ ...oldInventory, updater: this.user })
+
+      foundSerialNumber = await this.trxMgr
+        .getRepository(InventoryItem)
+        .save({ ...foundSerialNumber, inventory: newInventory })
+
+      //2. update replacement worksheet detail
+      await this.trxMgr.getRepository(WorksheetDetail).update(
+        {
+          targetInventory: existingOrderInv
+        },
+        {
+          status: WORKSHEET_STATUS.EXECUTING,
+          updater: this.user
+        }
+      )
+
+      if (oldOrderInventory.releaseQty !== 0) {
+        oldOrderInventory = await this.trxMgr
+          .getRepository(OrderInventory)
+          .save({ ...oldOrderInventory, updater: this.user })
+
+        await this.trxMgr.getRepository(WorksheetDetail).update(
+          {
+            name: worksheetDetail.name
+          },
+          {
+            status: WORKSHEET_STATUS.DONE,
+            updater: this.user
+          }
+        )
+      } else {
+        await this.trxMgr.getRepository(OrderInventory).delete(targetInventory.id)
+        await this.trxMgr.getRepository(WorksheetDetail).delete(worksheetDetail.ild)
+      }
+    } catch (e) {}
+  }
+
+  private async serialNumberReplacement(
+    targetInventory,
+    scannedPalletIdInventory,
+    releaseGood,
+    product,
+    worksheetDetail,
+    foundSerialNumber
+  ) {
+    try {
+      //1. create new inventory, new order inventory, update old inventory, old order inventory quantity
+      let newInventory: Inventory = await this.trxMgr
+        .getRepository(Inventory)
+        .findOne({ where: { id: scannedPalletIdInventory?.id } })
+
+      let oldInventory: Inventory = await this.trxMgr
+        .getRepository(Inventory)
+        .findOne({ where: { domain: this.domain, id: targetInventory?.inventory.id } })
+
+      let oldOrderInventory: OrderInventory = await this.trxMgr
+        .getRepository(OrderInventory)
+        .findOne({ where: { domain: this.domain, id: targetInventory?.id } })
+
+      let newOrderInventoryReleaseQty = 0
+      let newOrderInventoryReleaseUomValue = 0
+
+      //if replacement inventory quantity insufficient
+      if (newInventory.qty - newInventory.lockedQty < targetInventory.releaseQty - targetInventory.pickedQty) {
+        newOrderInventoryReleaseQty = newInventory.qty - newInventory.lockedQty
+        newOrderInventoryReleaseUomValue = newInventory.uomValue - newInventory.lockedUomValue
+
+        oldOrderInventory.releaseQty -= newOrderInventoryReleaseQty
+        oldOrderInventory.releaseUomValue -= newOrderInventoryReleaseUomValue
+
+        oldInventory.lockedQty -= newOrderInventoryReleaseQty
+        oldInventory.lockedUomValue -= newOrderInventoryReleaseUomValue
+
+        newInventory.lockedQty = newInventory.qty
+        newInventory.lockedUomValue = newInventory.uomValue
+      } else {
+        newOrderInventoryReleaseQty = targetInventory.releaseQty - targetInventory.pickedQty
+        newOrderInventoryReleaseUomValue =
+          newOrderInventoryReleaseQty * (targetInventory.releaseUomValue / targetInventory.releaseQty)
+
+        oldOrderInventory.releaseQty = targetInventory.pickedQty
+        oldOrderInventory.status = INVENTORY_STATUS.PICKED
+        oldOrderInventory.releaseUomValue =
+          (targetInventory.releaseUomValue / targetInventory.releaseQty) * oldOrderInventory.releaseQty
+
+        oldInventory.lockedQty -= newOrderInventoryReleaseQty
+        oldInventory.lockedUomValue -= newOrderInventoryReleaseUomValue
+
+        newInventory.lockedQty = newInventory.lockedQty + (targetInventory.releaseQty - targetInventory.pickedQty)
+        newInventory.lockedUomValue =
+          (targetInventory.releaseUomValue / targetInventory.releaseQty) * newInventory.lockedQty
+      }
+
+      newInventory = await this.trxMgr.getRepository(Inventory).save({ ...newInventory, updater: this.user })
+
+      let newTargetInventory = (({ id, ...targetInventory }) => targetInventory)(targetInventory)
+
+      let newOrderInventory = await this.trxMgr.getRepository(OrderInventory).save({
+        ...newTargetInventory,
+        domain: this.domain,
+        name: OrderNoGenerator.orderInventory(),
+        releaseGood,
+        releaseQty: newOrderInventoryReleaseQty,
+        releaseUomValue: newOrderInventoryReleaseUomValue,
+        pickedQty: 1,
+        product,
+        inventory: scannedPalletIdInventory,
+        creator: this.user,
+        updater: this.user
+      })
+
+      oldInventory = await this.trxMgr.getRepository(Inventory).save({ ...oldInventory, updater: this.user })
+
+      foundSerialNumber = await this.trxMgr
+        .getRepository(InventoryItem)
+        .save({ ...foundSerialNumber, inventory: newInventory })
+
+      //3. create new worksheet detail
+      let NewWorksheetDetail = (({ id, ...worksheetDetail }) => worksheetDetail)(worksheetDetail)
+      await this.trxMgr.getRepository(WorksheetDetail).save({
+        ...NewWorksheetDetail,
+        domain: this.domain,
+        name: WorksheetNoGenerator.pickingDetail(),
+        targetInventory: newOrderInventory,
+        status: WORKSHEET_STATUS.EXECUTING,
+        creator: this.user,
+        updater: this.user
+      })
+
+      //if old order inventory release quantity is 0 then delete
+      if (oldOrderInventory.releaseQty !== 0) {
+        oldOrderInventory = await this.trxMgr
+          .getRepository(OrderInventory)
+          .save({ ...oldOrderInventory, updater: this.user })
+
+        //4. update old worksheet detail
+        worksheetDetail = await this.trxMgr.getRepository(WorksheetDetail).update(
+          {
+            name: worksheetDetail.name
+          },
+          {
+            status: WORKSHEET_STATUS.DONE,
+            updater: this.user
+          }
+        )
+      } else {
+        await this.trxMgr.getRepository(OrderInventory).delete(targetInventory.id)
+        await this.trxMgr.getRepository(WorksheetDetail).delete(worksheetDetail.id)
+      }
+    } catch (e) {}
+  }
+
+  async undoSerialNumberPicking(worksheetDetailName: string, inventoryItemId: string): Promise<void> {
+    const worksheetDetail: WorksheetDetail = await this.trxMgr.getRepository(WorksheetDetail).findOne({
+      where: { name: worksheetDetailName, domain: this.domain, status: Not(Equal(WORKSHEET_STATUS.DEACTIVATED)) },
+      relations: [
+        'worksheet',
+        'worksheet.releaseGood',
+        'targetInventory',
+        'targetInventory.product',
+        'targetInventory.inventory'
+      ]
+    })
+
+    let targetInventory: OrderInventory = worksheetDetail.targetInventory
+
+    if (targetInventory.releaseQty == targetInventory.pickedQty && targetInventory.status == INVENTORY_STATUS.PICKED) {
+      targetInventory.status = INVENTORY_STATUS.PICKING
+
+      await this.trxMgr
+        .getRepository(WorksheetDetail)
+        .update({ id: worksheetDetail.id }, { status: WORKSHEET_STATUS.EXECUTING })
+
+      targetInventory.inventory.qty += targetInventory.releaseQty
+      targetInventory.inventory.uomValue =
+        Math.round((targetInventory.inventory.uomValue + targetInventory.releaseUomValue) * 100) / 100
+      targetInventory.inventory.lockedQty = targetInventory.inventory.lockedQty + targetInventory.releaseQty
+      targetInventory.inventory.lockedUomValue =
+        Math.round((targetInventory.inventory.lockedUomValue + targetInventory.releaseUomValue) * 100) / 100
+
+      await this.trxMgr.getRepository(Inventory).save(targetInventory.inventory)
+    }
+
+    await this.trxMgr.getRepository(InventoryItem).update(
+      {
+        id: inventoryItemId
+      },
+      {
+        status: INVENTORY_STATUS.STORED,
+        outboundOrderId: null,
+        updater: this.user
+      }
+    )
+
+    targetInventory.pickedQty--
+    targetInventory.updater = this.user
+    await this.updateOrderTargets([targetInventory])
+  }
 }

package/server/controllers/render-invoices.ts

@@ -1,17 +1,9 @@
-import FormData from 'form-data'
-import fetch from 'node-fetch'
-import {
-  getRepository,
-  SelectQueryBuilder
-} from 'typeorm'
-
-import {
-  Attachment,
-  STORAGE
-} from '@things-factory/attachment-base'
+import { getRepository, SelectQueryBuilder } from 'typeorm'
+
+import { Attachment, STORAGE } from '@things-factory/attachment-base'
 import { Bizplace } from '@things-factory/biz-base'
 import { config } from '@things-factory/env'
-import { ReleaseGood } from '@things-factory/sales-base'
+import { InvoiceProduct, ReleaseGood } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 
 import { TEMPLATE_TYPE } from '../constants'
@@ -28,31 +20,24 @@ export async function renderInvoices({ req, timezoneOffSet }, context: any) {
     let result = await Promise.all(
       req.roIds.map(async roId => {
         try {
-          const qb: SelectQueryBuilder<ReleaseGood> = getRepository(ReleaseGood)
+          const qb: SelectQueryBuilder<ReleaseGood> = await getRepository(ReleaseGood)
             .createQueryBuilder('rg')
             .innerJoinAndSelect('rg.domain', 'domain')
             .innerJoinAndSelect('rg.bizplace', 'bizplace')
             .innerJoinAndSelect('bizplace.domain', 'bizplace_domain')
             .innerJoinAndSelect('bizplace.company', 'company')
             .innerJoinAndSelect('company.domain', 'company_domain')
-            .innerJoinAndSelect('invoices', 'iv', 'rg.id = iv.release_good_id')
-            .innerJoinAndSelect('iv.invoiceProducts', 'ip')
+            .innerJoinAndSelect('invoices', 'iv', 'rg.ref_no = iv.ref_no_1')
             .leftJoinAndSelect('marketplace_orders', 'mo', 'rg.id = mo.release_order_id::uuid')
-            .leftJoinAndSelect('mo.marketplaceOrderItems', 'moi')
-            .leftJoinAndSelect('marketplace_product_variations', 'mpv', 'moi.marketplace_product_variation_id = mpv.id')
-            .leftJoinAndSelect('products', 'p', 'mpv.sku = p.sku and p.domain_id = company.domain_id')
             .leftJoinAndSelect('marketplace_order_shippings', 'mos', 'rg.id = mos.release_order_id::uuid')
             .leftJoinAndSelect('mo.fulfillmentCenter', 'fc')
             .where('rg.id = :roId')
-            .andWhere('ip.sku = p.sku')
             .andWhere('rg.domain = :domainId')
             .setParameters({ roId, domainId: domain.id })
 
-          let items: any[] = await qb.getRawMany()
-
-          if (items.length) {
-            let record: any = items[0]
+          let record: any = await qb.getRawOne()
 
+          if (record) {
             const partnerBiz: Partial<Bizplace> = {
               id: record.bizplace_id,
               name: record.bizplace_name,
@@ -86,6 +71,16 @@ export async function renderInvoices({ req, timezoneOffSet }, context: any) {
               record.iv_delivery_address_5
             ]
 
+            const qb: SelectQueryBuilder<InvoiceProduct> = await getRepository(InvoiceProduct)
+              .createQueryBuilder('ip')
+              .innerJoin('invoices', 'iv', 'iv.id = ip.invoice_id')
+              .leftJoin('release_goods', 'rg', 'rg.ref_no = iv.ref_no_1')
+              .where('rg.id = :roId')
+              .andWhere('rg.domain = :domainId')
+              .setParameters({ roId, domainId: domain.id })
+
+            let items: any[] = await qb.getRawMany()
+
             const product_list = items.map((item, idx) => {
               return {
                 list_no: idx + 1,
@@ -100,9 +95,9 @@ export async function renderInvoices({ req, timezoneOffSet }, context: any) {
                   (item.ip_paid_price || item.ip_unit_price) * parseInt(item.ip_qty || 0)
                 ),
                 product_total_unit_price: getRoundedValue(item.ip_unit_price * parseInt(item.ip_qty || 0)),
-                original_price: getRoundedValue(parseFloat(item.moi_original_price || 0)),
-                product_discount: getRoundedValue(parseFloat(item.moi_discount || 0)),
-                shipping_fee_paid_by_customer: getRoundedValue(parseFloat(item.moi_shipping_fee_paid_by_customer || 0))
+                original_price: getRoundedValue(parseFloat(item.ip_unit_price || 0)),
+                product_discount: getRoundedValue(parseFloat(item.ip_discount || 0)),
+                shipping_fee_paid_by_customer: getRoundedValue(parseFloat(item.ip_shipping_fee_paid_by_customer || 0))
               }
             })
 
@@ -161,12 +156,14 @@ export async function renderInvoices({ req, timezoneOffSet }, context: any) {
                 .join(' '),
               fulfillment_center: record.fc_name,
               voucher_amount: getRoundedValue(parseFloat(record.mo_voucher_amount || 0)),
-              actual_shipping_fee: getRoundedValue(parseFloat(record.mos_actual_shipping_fee || record.mos_shipping_fee || 0)),
+              actual_shipping_fee: getRoundedValue(
+                parseFloat(record.mos_actual_shipping_fee || record.mos_shipping_fee || 0)
+              ),
               sub_total: sumProductTotalPaidPrice,
               grand_total: getRoundedValue(
                 sumProductTotalPaidPrice -
-                parseFloat(record.mo_voucher_amount || 0) +
-                parseFloat(record.mos_actual_shipping_fee || 0)
+                  parseFloat(record.mo_voucher_amount || 0) +
+                  parseFloat(record.mos_actual_shipping_fee || 0)
               ),
               product_list
             }