@things-factory/worksheet-base 8.0.0-beta.1 → 8.0.0-beta.2

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

@@ -1,378 +0,0 @@
-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

@@ -1,142 +0,0 @@
-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)
-          // }
-        }
-      }
-    }
-  }
-}