@things-factory/worksheet-base 8.0.0-beta.8 → 8.0.0

package/server/graphql/resolvers/worksheet/packing-worksheet.ts

@@ -0,0 +1,378 @@
+import { EntityManager, getManager, SelectQueryBuilder } from 'typeorm'
+
+import { ApplicationType, User } from '@things-factory/auth-base'
+import { logger } from '@things-factory/env'
+import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
+import {
+  MarketplaceOrder,
+  MarketplaceOrderItem,
+  MarketplaceOrderShipping,
+  MarketplaceOrderShippingItem
+} from '@things-factory/marketplace-base'
+import { ORDER_INVENTORY_STATUS, ORDER_STATUS, OrderInventory, ReleaseGood } from '@things-factory/sales-base'
+import { PartnerSetting, Setting } from '@things-factory/setting-base'
+import { Domain } from '@things-factory/shell'
+import { Inventory, Location } from '@things-factory/warehouse-base'
+
+import { WORKSHEET_TYPE } from '../../../constants'
+import { PackingWorksheetController, SellercraftController } from '../../../controllers'
+import { Worksheet, WorksheetDetail } from '../../../entities'
+import { fetchExecutingWorksheet } from '../../../utils'
+
+export const packingWorksheetResolver = {
+  async packingWorksheet(_: any, { releaseGoodNo }, context: ResolverContext) {
+    try {
+      const { tx, domain, user } = context.state
+      let releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
+        where: {
+          domain: { id: domain.id },
+          name: releaseGoodNo
+        },
+        relations: ['bizplace', 'bizplace.domain']
+      })
+
+      // Find Release Order based on Bin
+      if (!releaseGood) {
+        const binLocation: Location = await tx.getRepository(Location).findOne({
+          where: { domain: { id: domain.id }, name: releaseGoodNo }
+        })
+
+        if (binLocation) {
+          const qb: SelectQueryBuilder<OrderInventory> = tx
+            .getRepository(OrderInventory)
+            .createQueryBuilder('orderInventory')
+
+          qb.innerJoinAndSelect('orderInventory.releaseGood', 'releaseGood')
+            .innerJoinAndSelect('releaseGood.bizplace', 'bizplace')
+            .innerJoinAndSelect('bizplace.domain', 'domain')
+            .innerJoinAndSelect(
+              'worksheets',
+              'ws',
+              `orderInventory.release_good_id = ws.release_good_id AND ws.type = 'PACKING' AND (ws.status = 'EXECUTING' OR ws.status = 'DEACTIVATED')`
+            )
+            .where('orderInventory.domain_id = :domainId', { domainId: domain.id })
+            .andWhere('orderInventory.status IN (:...orderInventoryStatus)', {
+              orderInventoryStatus: [
+                ORDER_INVENTORY_STATUS.READY_TO_PACK,
+                ORDER_INVENTORY_STATUS.PACKING,
+                ORDER_INVENTORY_STATUS.PACKED
+              ]
+            })
+            .andWhere('orderInventory.bin_location_id = :locationId', { locationId: binLocation.id })
+            .andWhere('releaseGood.status IN (:...status)', {
+              status: [ORDER_STATUS.READY_TO_PACK, ORDER_STATUS.PACKING]
+            })
+            .orderBy(`case when orderInventory.status = '${ORDER_INVENTORY_STATUS.PACKED}' then 1 end`)
+            .addOrderBy('ws.created_at', 'ASC')
+
+          const [orderInventoriesByBin, totalInventoriesByBin] = await qb.getManyAndCount()
+          // @oscarchuaweiwen-fsd @chrislim I suggest using getMany() instead since the total is redundant here
+
+          // remove duplicated count of release good
+          const filteredRO = orderInventoriesByBin.map(oiBin => {
+            return oiBin.releaseGood.name
+          })
+
+          if (orderInventoriesByBin.length > 0) {
+            releaseGoodNo = orderInventoriesByBin[0].releaseGood.name
+            releaseGood = orderInventoriesByBin[0].releaseGood
+            releaseGood.totalInventoriesByBin = [...new Set(filteredRO)].length
+            releaseGood.isOrderInventoryBin = true
+          } else {
+            throw new Error(`Bin do not have any existing order.`)
+          }
+        }
+      }
+
+      if (!releaseGood) throw new Error(`Release good do not exist.`)
+
+      const worksheet: Worksheet = await fetchExecutingWorksheet(
+        domain,
+        releaseGood.bizplace,
+        [
+          'bizplace',
+          'bizplace.domain',
+          'releaseGood',
+          'releaseGood.domain',
+          'worksheetDetails',
+          'worksheetDetails.targetInventory',
+          'worksheetDetails.targetInventory.binLocation',
+          'worksheetDetails.targetInventory.inventory',
+          'worksheetDetails.targetInventory.inventory.location',
+          'worksheetDetails.targetInventory.inventory.product',
+          'worksheetDetails.targetInventory.inventory.product.productDetails',
+          'worksheetDetails.toLocation'
+        ],
+        WORKSHEET_TYPE.PACKING,
+        releaseGood
+      )
+
+      if (worksheet.status === 'DEACTIVATED') {
+        const packingWSCtrl: PackingWorksheetController = new PackingWorksheetController(tx, domain, user)
+
+        const directActivatePackingWorksheet: Setting = await tx.getRepository(Setting).findOne({
+          where: { domain: { id: domain.id }, category: 'id-rule', name: 'enable-direct-activate-packing-worksheet' }
+        })
+
+        const partnerDirectActivatePackingWorksheetSetting: PartnerSetting = await tx
+          .getRepository(PartnerSetting)
+          .findOne({
+            where: {
+              setting: { id: directActivatePackingWorksheet.id },
+              domain: { id: domain.id },
+              partnerDomain: { id: releaseGood.bizplace?.domain.id }
+            }
+          })
+
+        if (
+          directActivatePackingWorksheet != undefined &&
+          directActivatePackingWorksheet.value.toLowerCase() == 'true'
+        ) {
+          if (partnerDirectActivatePackingWorksheetSetting != undefined) {
+            if (partnerDirectActivatePackingWorksheetSetting.value.toLowerCase() == 'true')
+              await packingWSCtrl.activatePacking(worksheet.name)
+          } else {
+            await packingWSCtrl.activatePacking(worksheet.name)
+          }
+        } else {
+          throw new Error('Kindly go to packing worksheet page to activate the packing worksheet')
+        }
+      }
+
+      //@ts-ignore
+      let marketplaceOrder: MarketplaceOrder = {}
+      let marketplaceOrderItems: MarketplaceOrderItem[] = []
+      let marketplaceStore
+      let trackingNo: string
+      let shippingProvider: string
+      let marketplaceStatus: string
+
+      const orderSource: string = releaseGood.source
+      switch (orderSource) {
+        case ApplicationType.SELLERCRAFT:
+          const sellercraft: Sellercraft = await tx.getRepository(Sellercraft).findOneBy({
+            domain: { id: worksheet.bizplace.domain.id },
+            status: SellercraftStatus.ACTIVE
+          })
+
+          if (sellercraft) {
+            // asynchronously get document from sellercraft
+            getSellercraftDocument(sellercraft, releaseGood, domain, user)
+          }
+          break
+
+        case ApplicationType.MMS:
+          marketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+            where: { orderNo: releaseGood.refNo },
+            relations: [
+              'domain',
+              'marketplaceStore',
+              'marketplaceOrderItems',
+              'marketplaceOrderItems.marketplaceOrderShippingItems',
+              'marketplaceOrderItems.marketplaceOrderShippingItems.marketplaceOrderShipping'
+            ]
+          })
+
+          if (!marketplaceOrder) {
+            throw new Error('Failed to retrieve ecommerce information, kindly contact our support team for this issue.')
+          }
+
+          let marketplaceOrderShipping: MarketplaceOrderShipping
+          if (marketplaceOrder.isSplitted) {
+            marketplaceOrderShipping = await tx.getRepository(MarketplaceOrderShipping).findOne({
+              where: { subOrderNoRef: worksheet.releaseGood.refNo2 }
+            })
+          } else {
+            marketplaceOrderShipping = await tx.getRepository(MarketplaceOrderShipping).findOne({
+              where: { orderNoRef: worksheet.releaseGood.refNo }
+            })
+          }
+
+          trackingNo = marketplaceOrderShipping.ownTrackingNo
+            ? marketplaceOrderShipping.ownTrackingNo
+            : marketplaceOrderShipping.trackingNo
+          shippingProvider = marketplaceOrderShipping.ownTransporter
+            ? marketplaceOrderShipping.ownTransporter
+            : marketplaceOrderShipping.transporter
+
+          marketplaceStore = marketplaceOrder?.marketplaceStore
+          marketplaceStatus = marketplaceOrder?.status
+          break
+
+        default:
+          break
+      }
+
+      // if (releaseGood.type === 'b2c') {
+      //   const sellercraft: Sellercraft = await tx.getRepository(Sellercraft).findOne({
+      //     domain: worksheet.bizplace.domain,
+      //     status: SellercraftStatus.ACTIVE
+      //   })
+
+      //   if (sellercraft) {
+      //     // asynchronously get document from sellercraft
+      //     getSellercraftDocument(sellercraft, releaseGood, domain, user)
+      //   } else {
+      //     marketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+      //       where: { orderNo: releaseGood.refNo },
+      //       relations: [
+      //         'domain',
+      //         'marketplaceStore',
+      //         'marketplaceOrderItems',
+      //         'marketplaceOrderItems.marketplaceOrderShippingItems',
+      //         'marketplaceOrderItems.marketplaceOrderShippingItems.marketplaceOrderShipping'
+      //       ]
+      //     })
+
+      //     if (!marketplaceOrder) {
+      //       throw new Error('Failed to retrieve ecommerce information, kindly contact our support team for this issue.')
+      //     }
+
+      //     let marketplaceOrderShipping: MarketplaceOrderShipping
+      //     if (marketplaceOrder.isSplitted) {
+      //       marketplaceOrderShipping = await tx.getRepository(MarketplaceOrderShipping).findOne({
+      //         where: { subOrderNoRef: worksheet.releaseGood.refNo2 }
+      //       })
+      //     } else {
+      //       marketplaceOrderShipping = await tx.getRepository(MarketplaceOrderShipping).findOne({
+      //         where: { orderNoRef: worksheet.releaseGood.refNo }
+      //       })
+      //     }
+
+      //     trackingNo = marketplaceOrderShipping.ownTrackingNo
+      //       ? marketplaceOrderShipping.ownTrackingNo
+      //       : marketplaceOrderShipping.trackingNo
+      //     shippingProvider = marketplaceOrderShipping.ownTransporter
+      //       ? marketplaceOrderShipping.ownTransporter
+      //       : marketplaceOrderShipping.transporter
+
+      //     marketplaceStore = marketplaceOrder?.marketplaceStore
+      //     marketplaceStatus = marketplaceOrder?.status
+      //   }
+      // }
+
+      return {
+        worksheetInfo: {
+          releaseGood,
+          bizplaceName: releaseGood.bizplace.name,
+          refNo: releaseGood.refNo,
+          refNo2: releaseGood.refNo2,
+          refNo3: releaseGood.refNo3,
+          partnerDomainId: releaseGood.bizplace?.domain.id,
+          startedAt: worksheet.startedAt,
+          shippingProvider: shippingProvider ? shippingProvider : '',
+          trackingNo: trackingNo ? trackingNo : '',
+          airwayBill: releaseGood?.airwayBill,
+          checkedRemarkBy: releaseGood?.checkedRemarkBy,
+          invoice: releaseGood?.invoice,
+          platform: Object.keys(marketplaceOrder).length > 0 ? marketplaceOrder.marketplaceStore?.platform : 'operato',
+          marketplaceStoreId: Object.keys(marketplaceOrder).length > 0 ? marketplaceOrder.marketplaceStore?.id : '',
+          marketplaceStatus: marketplaceStatus ? marketplaceStatus : '',
+          marketplaceOrder: marketplaceOrder ? marketplaceOrder : ''
+        },
+        worksheetDetailInfos: worksheet.worksheetDetails.map((packingWSD: WorksheetDetail) => {
+          const targetInventory: OrderInventory = packingWSD.targetInventory
+          const inventory: Inventory = targetInventory.inventory
+          return {
+            name: packingWSD.name,
+            palletId: inventory.palletId,
+            cartonId: inventory.cartonId,
+            batchId: inventory.batchId,
+            batchIdRef: inventory.batchIdRef,
+            product: inventory.product,
+            sku: inventory.product.sku,
+            releaseQty: targetInventory.releaseQty,
+            packedQty: targetInventory.packedQty,
+            status: packingWSD.status,
+            description: packingWSD.description,
+            targetName: targetInventory.name,
+            packingType: inventory.packingType,
+            packingSize: inventory.packingSize,
+            binLocation: targetInventory?.binLocation,
+            location: inventory.location,
+            relatedOrderInv: targetInventory
+          }
+        })
+      }
+    } catch (error) {
+      console.error(error)
+      throw error
+    }
+  }
+}
+
+export async function getTrackingNo(marketplaceStore, marketplaceOrderItems): Promise<string> {
+  let trackingNo = ''
+  let marketplaceOrderShippings = []
+
+  marketplaceOrderItems.map(item => {
+    const marketplaceOrderShippingItems: MarketplaceOrderShippingItem[] = item.marketplaceOrderShippingItems
+    marketplaceOrderShippingItems.map(marketplaceOrderShippingItem => {
+      const marketplaceOrderShipping = marketplaceOrderShippingItem.marketplaceOrderShipping
+
+      if (marketplaceOrderShipping) {
+        marketplaceOrderShippings.push(marketplaceOrderShipping)
+      }
+    })
+  })
+
+  const uniqueMarketplaceOrderShippings = Array.from(new Set(marketplaceOrderShippings.map(a => a.id))).map(id => {
+    return marketplaceOrderShippings.find(a => a.id === id)
+  })
+
+  if (uniqueMarketplaceOrderShippings) {
+    uniqueMarketplaceOrderShippings.map(marketplaceOrderShipping => {
+      if (marketplaceStore.platform === 'lazada') {
+        var newTrackingNo = []
+        if (marketplaceOrderShipping?.trackingNo) {
+          const trackingNos = JSON.parse(marketplaceOrderShipping.trackingNo)
+          newTrackingNo = trackingNos.map(item => item.tracking_code)
+        }
+        let uniqueTrackingNos = [...new Set(newTrackingNo)]
+        trackingNo = uniqueTrackingNos.join(', ')
+      } else {
+        trackingNo = marketplaceOrderShipping.trackingNo
+      }
+    })
+  }
+
+  return trackingNo
+}
+
+//trigger RTS, init document, and fetch sellercraft document in separated transaction
+async function getSellercraftDocument(sellercraft: Sellercraft, releaseGood: ReleaseGood, domain: Domain, user: User) {
+  await getManager().transaction(async txMgr => {
+    const sellercraftCtrl: SellercraftController = new SellercraftController(txMgr, domain, user)
+    try {
+      if (!releaseGood?.airwayBill) {
+        try {
+          // try fetch order document / AWB
+          releaseGood = await sellercraftCtrl.fetchOrderDocument(sellercraft, releaseGood)
+        } catch (error) {
+          try {
+            // retry initiate order document
+            await sellercraftCtrl.initiateOrderDocument(sellercraft, releaseGood)
+          } catch (error) {
+            try {
+              // retry initiate order shipment / RTS
+              await sellercraftCtrl.initiateOrderShipment(sellercraft, releaseGood)
+            } catch (error) {
+              throw new Error(`initiateOrderShipment: ${error}`)
+            }
+            throw new Error(`initiateOrderDocument: ${error}`)
+          }
+          throw new Error(`fetchOrderDocument: ${error}`)
+        }
+      }
+    } catch (error) {
+      logger.error(
+        `packing-worksheet[getSellercraftDocument]:(data:${JSON.stringify({
+          sellercraft,
+          releaseGood,
+          domain,
+          user
+        })}) ${error} `
+      )
+    }
+  })
+}

package/server/graphql/resolvers/worksheet/palletizing-pallets.ts

@@ -0,0 +1,142 @@
+import { EntityManager, Equal, Not } from 'typeorm'
+import { v4 as uuidv4 } from 'uuid'
+
+import { User } from '@things-factory/auth-base'
+import { ArrivalNotice, ORDER_STATUS, ORDER_TYPES, OrderVas, Vas } from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+
+import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
+import { VasWorksheetController, WorksheetController } from '../../../controllers'
+import { Worksheet, WorksheetDetail } from '../../../entities'
+
+export const palletizingPallets = {
+  async palletizingPallets(_: any, { refOrderNo, patches }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    let arrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
+      where: { domain: { id: context.state.domain.id }, name: refOrderNo, status: Not(Equal(ORDER_STATUS.DONE)) },
+      relations: ['bizplace']
+    })
+
+    if (!arrivalNotice) throw new Error(`Couldn't find VAS worksheet by order no (${refOrderNo})`)
+
+    const vasWorksheetController: VasWorksheetController = new VasWorksheetController(tx, domain, user)
+    const worksheetController: WorksheetController = new WorksheetController(tx, domain, user)
+
+    for (let patch of patches) {
+      let orderVass: OrderVas
+
+      const foundOV: OrderVas = await tx.getRepository(OrderVas).findOne({
+        where: {
+          id: patch.id
+        }
+      })
+
+      const palletizingVAS: Vas = await tx.getRepository(Vas).findOne({
+        where: { domain: { id: domain.id }, id: patch.vas.id }
+      })
+
+      if (foundOV) {
+        orderVass = {
+          ...foundOV,
+          set: patch.set,
+          vas: palletizingVAS,
+          qty: patch.qty,
+          remark: patch.remark
+        }
+
+        let savedOrderVass: OrderVas = await tx.getRepository(OrderVas).save(orderVass)
+        let newOrderVass: OrderVas = new OrderVas()
+        //@ts-ignore
+        ;(newOrderVass.id = savedOrderVass.id),
+          (newOrderVass.name = savedOrderVass.name),
+          (newOrderVass.set = savedOrderVass.set),
+          (newOrderVass.vas = savedOrderVass.vas),
+          (newOrderVass.qty = savedOrderVass.qty),
+          (newOrderVass.remark = savedOrderVass.remark),
+          (newOrderVass.targetType = savedOrderVass.targetType),
+          (newOrderVass.type = savedOrderVass.type),
+          (newOrderVass.status = savedOrderVass.status),
+          (newOrderVass.domain = savedOrderVass.domain),
+          (newOrderVass.bizplace = savedOrderVass.bizplace),
+          (newOrderVass.arrivalNotice = savedOrderVass.arrivalNotice),
+          (newOrderVass.creator = savedOrderVass.creator),
+          (newOrderVass.updater = savedOrderVass.updater)
+
+        let vasWorksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
+          where: {
+            arrivalNotice: { id: arrivalNotice.id },
+            type: WORKSHEET_TYPE.VAS
+          },
+          relations: ['domain', 'bizplace', 'worksheetDetails', 'worksheetDetails.targetVas']
+        })
+        if (!vasWorksheet) {
+          vasWorksheet = await vasWorksheetController.generateVasWorksheet(arrivalNotice)
+          let vasWorksheetDetails: WorksheetDetail[] = vasWorksheet.worksheetDetails
+
+          await vasWorksheetController.activateVAS(vasWorksheet.name, vasWorksheetDetails)
+        }
+      } else {
+        //@ts-ignore
+        orderVass = {
+          name: uuidv4(),
+          set: patch.set,
+          vas: palletizingVAS,
+          qty: patch.qty,
+          remark: patch.remark,
+          targetType: patch.targetType,
+          type: ORDER_TYPES.ARRIVAL_NOTICE,
+          status: WORKSHEET_STATUS.EXECUTING,
+          domain: context.state.domain,
+          bizplace: arrivalNotice.bizplace,
+          arrivalNotice: arrivalNotice,
+          creator: context.state.user,
+          updater: context.state.user
+        }
+
+        let savedOrderVass: OrderVas = await tx.getRepository(OrderVas).save(orderVass)
+        let newOrderVass: OrderVas = new OrderVas()
+        //@ts-ignore
+        ;(newOrderVass.id = savedOrderVass.id),
+          (newOrderVass.name = savedOrderVass.name),
+          (newOrderVass.set = savedOrderVass.set),
+          (newOrderVass.vas = savedOrderVass.vas),
+          (newOrderVass.qty = savedOrderVass.qty),
+          (newOrderVass.remark = savedOrderVass.remark),
+          (newOrderVass.targetType = savedOrderVass.targetType),
+          (newOrderVass.type = savedOrderVass.type),
+          (newOrderVass.status = savedOrderVass.status),
+          (newOrderVass.domain = savedOrderVass.domain),
+          (newOrderVass.bizplace = savedOrderVass.bizplace),
+          (newOrderVass.arrivalNotice = savedOrderVass.arrivalNotice),
+          (newOrderVass.creator = savedOrderVass.creator),
+          (newOrderVass.updater = savedOrderVass.updater)
+
+        let vasWorksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
+          where: {
+            arrivalNotice: { id: arrivalNotice.id },
+            type: WORKSHEET_TYPE.VAS
+          },
+          relations: ['domain', 'bizplace', 'worksheetDetails', 'worksheetDetails.targetVas']
+        })
+        if (!vasWorksheet) {
+          vasWorksheet = await vasWorksheetController.generateVasWorksheet(arrivalNotice)
+          let vasWorksheetDetails: WorksheetDetail[] = vasWorksheet.worksheetDetails
+
+          await vasWorksheetController.activateVAS(vasWorksheet.name, vasWorksheetDetails)
+        } else {
+          await worksheetController.createWorksheetDetails(vasWorksheet, WORKSHEET_TYPE.VAS, [newOrderVass])
+
+          // if(vasWorksheetDetails) {
+          //   vasWorksheetDetails = vasWorksheetDetails.map(wsd => {
+          //     return {
+          //       ...wsd,
+          //       status: WORKSHEET_STATUS.EXECUTING
+          //     }
+          //   })
+          //   await trxMgr.getRepository(WorksheetDetail).save(vasWorksheetDetails)
+          // }
+        }
+      }
+    }
+  }
+}