@things-factory/worksheet-base 4.3.243 → 4.3.246

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

@@ -1,272 +0,0 @@
-import { getRepository } from 'typeorm'
-
-import { Bizplace } from '@things-factory/biz-base'
-import { logger } from '@things-factory/env'
-import { Powrup, PowrupAPI } from '@things-factory/integration-powrup'
-import { Product, ProductDetail } from '@things-factory/product-base'
-import {
-  ORDER_STATUS,
-  OrderNoGenerator,
-  OrderPackage,
-  OrderPackageItem,
-  OrderProduct,
-  ReleaseGood
-} from '@things-factory/sales-base'
-import { Inventory, INVENTORY_STATUS, LOCATION_TYPE } from '@things-factory/warehouse-base'
-
-import { DateTimeDifference } from '../../utils/datetime-util'
-import { WorksheetController } from '../worksheet-controller'
-
-export class PowrupController extends WorksheetController {
-  async packOrder(powrup: Powrup, releaseGood: ReleaseGood): Promise<ReleaseGood> {
-    try {
-      const orderProducts: OrderProduct[] = releaseGood.orderProducts
-      const orderInformation: any = {
-        refOrderId: releaseGood.refOrderId
-      }
-
-      if (
-        releaseGood?.lastMarketPackCall &&
-        DateTimeDifference.timeDifferenceInSeconds(releaseGood.lastMarketPackCall, new Date()) <= 5
-      ) {
-        return false
-      }
-
-      await getRepository(ReleaseGood).update(
-        { id: releaseGood.id },
-        {
-          lastMarketPackCall: new Date()
-        }
-      )
-
-      const orderPack: any = await PowrupAPI.packOrder(powrup, {
-        ...orderInformation,
-        context: { state: { domain: this?.domain, user: this?.user } }
-      })
-
-      if (orderPack?.packages) {
-        const packages: any[] = orderPack.packages
-
-        await Promise.all(
-          packages.map(async pkg => {
-            const items = pkg.items
-            const orderPackage: OrderPackage = {
-              name: OrderNoGenerator.orderPackage(),
-              packageId: pkg.packageId,
-              status: ORDER_STATUS.PROCESSING,
-              releaseGood,
-              domain: releaseGood.domain,
-              bizplace: releaseGood.bizplace,
-              creator: releaseGood.creator,
-              updater: releaseGood.updater
-            }
-
-            let savedOrderPackage: OrderPackage = await this.trxMgr.getRepository(OrderPackage).save(orderPackage)
-
-            const orderPackageItems: OrderPackageItem[] = items.map(itm => {
-              const { refCode, qty } = itm
-              const matchedOrderProduct: OrderProduct = orderProducts.find(op => op.productDetail.refCode == refCode)
-
-              return {
-                name: OrderNoGenerator.orderPackageItem(),
-                orderProduct: matchedOrderProduct,
-                status: ORDER_STATUS.PROCESSING,
-                releaseQty: qty,
-                orderPackage: savedOrderPackage,
-                domain: releaseGood.domain,
-                bizplace: releaseGood.bizplace,
-                creator: releaseGood.creator,
-                updater: releaseGood.updater
-              }
-            })
-
-            await this.trxMgr.getRepository(OrderPackageItem).save(orderPackageItems)
-          })
-        )
-
-        await this.trxMgr.getRepository(ReleaseGood).update(
-          { id: releaseGood.id },
-          {
-            packageId: packages[0].packageId,
-            marketPackCallSuccess: new Date(),
-            lastMarketPackCall: new Date(),
-            updatedAt: new Date()
-          }
-        )
-      }
-    } catch (error) {
-      logger.error(`powrup-controller[packOrder]: ${error}`)
-      throw error
-    }
-
-    return releaseGood
-  }
-
-  async updateStock(powrup: Powrup, inventory: Inventory): Promise<void> {
-    const bizplace: Bizplace = await this.trxMgr.getRepository(Bizplace).findOne({ domain: powrup.domain })
-    let product: Product = inventory.product
-    const productDetail: ProductDetail = inventory.productDetail
-    let qb = await this.trxMgr.getRepository(Inventory).createQueryBuilder('inv')
-    qb.leftJoinAndSelect('inv.location', 'loc')
-      .andWhere('"inv"."domain_id" = :domainId')
-      .andWhere('"inv"."bizplace_id" = :bizplaceId')
-      .andWhere('"inv"."product_id" = :productId')
-      .andWhere('"inv"."product_detail_id" = :productDetailId')
-      .andWhere('"inv"."status" = :status')
-      .andWhere('"loc"."type" NOT IN (:...locationTypes)')
-      .setParameters({
-        domainId: this.domain.id,
-        bizplaceId: bizplace.id,
-        productId: product.id,
-        productDetailId: productDetail.id,
-        status: INVENTORY_STATUS.STORED,
-        locationTypes: [LOCATION_TYPE.QUARANTINE]
-      })
-
-    const warehouseDomainId = this.domain.id
-    let inventories: Inventory[] = await qb.getMany()
-    let inventoryTotalQty: number = 0
-    let inventoryTotalLockedQty: number = 0
-    let inventoryBufferQty: number = 0
-
-    inventories.forEach((inventory: Inventory) => {
-      const { qty, lockedQty } = inventory
-      inventoryTotalQty += qty
-      inventoryTotalLockedQty += lockedQty
-      if (inventory.location.type === LOCATION_TYPE.RESERVE) {
-        inventoryBufferQty += qty
-      }
-    })
-
-    const powrupInvs: any[] = [
-      {
-        refCode: productDetail.refCode,
-        stock: {
-          quantityTotal: inventoryTotalQty - inventoryTotalLockedQty - inventoryBufferQty,
-          quantityReserved: inventoryTotalLockedQty - inventoryBufferQty,
-          quantityBuffer: inventoryBufferQty
-        }
-      }
-    ]
-
-    await PowrupAPI.updateStock(powrup, {
-      context: { state: { domain: this?.domain, user: this?.user } },
-      warehouseDomainId,
-      powrupInvs
-    })
-  }
-
-  async initiateShipment(powrup: Powrup, releaseGood: ReleaseGood): Promise<void> {
-    try {
-      let orderPackages: OrderPackage[] = await this.trxMgr
-        .getRepository(OrderPackage)
-        .find({ where: { releaseGood, bizplace: releaseGood.bizplace } })
-
-      if (orderPackages?.length) {
-        await Promise.all(
-          orderPackages
-            .filter(op => op?.marketRtsCallSuccess == undefined)
-            .map(async op => {
-              if (!op?.packageId) throw new Error('Order package id is not found')
-              if (releaseGood.lmdOption && !op?.parcelId) return
-
-              let orderInformation: any = {
-                refOrderId: releaseGood.refOrderId,
-                packageId: op.packageId
-              }
-              if (releaseGood.lmdOption) {
-                let releaseGoodQuery: ReleaseGood = await getRepository(ReleaseGood).findOne({
-                  where: { id: releaseGood.id },
-                  relations: ['lastMileDelivery']
-                })
-                orderInformation = {
-                  ...orderInformation,
-                  awb: op.airwayBill,
-                  trackingNo: op.trackingNo,
-                  lmdOption: releaseGood.lmdOption,
-                  shipperName: releaseGoodQuery.lastMileDelivery.platform
-                }
-              }
-
-              try {
-                await PowrupAPI.initiateShipment(powrup, {
-                  ...orderInformation,
-                  context: { state: { domain: this?.domain, user: this?.user } }
-                })
-                await getRepository(OrderPackage).update({ id: op.id }, { marketRtsCallSuccess: new Date() })
-              } catch (error) {
-                logger.error(
-                  `powrup-controller[initiateShipment]: ${JSON.stringify({
-                    ...orderInformation,
-                    context: { state: { domain: this?.domain, user: this?.user } },
-                    error: error
-                  })}`
-                )
-              }
-            })
-        )
-      }
-    } catch (error) {
-      throw error
-    }
-  }
-
-  async fetchDocument(powrup: Powrup, releaseGood: ReleaseGood): Promise<ReleaseGood> {
-    if (releaseGood?.ownTransport && releaseGood?.lmdOption) {
-      return
-    }
-    try {
-      let orderPackages: OrderPackage[] = await this.trxMgr
-        .getRepository(OrderPackage)
-        .find({ where: { releaseGood, bizplace: releaseGood.bizplace } })
-
-      if (orderPackages?.length) {
-        await Promise.all(
-          orderPackages.map(async op => {
-            if (!op?.packageId) throw new Error('Order package id is not found')
-
-            const orderInformation: any = {
-              refOrderId: releaseGood.refOrderId,
-              packageId: op.packageId
-            }
-
-            const {
-              documents,
-              trackingNo,
-              transporter
-            }: { documents: any[]; trackingNo: string; transporter: string } = await PowrupAPI.fetchDocument(powrup, {
-              ...orderInformation,
-              context: { state: { domain: this?.domain, user: this?.user } }
-            })
-
-            let updateInfo: any
-            if (documents?.length) {
-              documents.map(document => {
-                if (document.type === 'invoice') {
-                  updateInfo = { ...updateInfo, invoice: document.download_url }
-                } else if (document.type === 'airway_bill') {
-                  updateInfo = { ...updateInfo, airwayBill: document.download_url }
-                }
-              })
-
-              updateInfo = {
-                ...updateInfo,
-                trackingNo: trackingNo,
-                transporter: transporter,
-                updater: this.user
-              }
-
-              await this.trxMgr.getRepository(OrderPackage).update({ id: op.id }, { ...updateInfo })
-            }
-          })
-        )
-
-        releaseGood = await this.trxMgr.getRepository(ReleaseGood).findOne({ id: releaseGood.id })
-      }
-
-      return releaseGood
-    } catch (error) {
-      throw error
-    }
-  }
-}