@things-factory/sales-base 4.3.239 → 4.3.244

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

@@ -0,0 +1,301 @@
+import { getRepository, EntityManager } from 'typeorm'
+
+import { Bizplace } from '@things-factory/biz-base'
+import { logger } from '@things-factory/env'
+import { Powrup, PowrupAPI, Platform } from '@things-factory/integration-powrup'
+import { Product, ProductDetail } from '@things-factory/product-base'
+import { Inventory, INVENTORY_STATUS, LOCATION_TYPE } from '@things-factory/warehouse-base'
+import { Domain, User } from '@things-factory/shell'
+
+import { DateTimeDifference } from '../../utils/datetime-util'
+import { ORDER_STATUS } from '../../constants'
+import { OrderNoGenerator } from '../../utils'
+import { OrderPackage } from '../../service/order-package/order-package'
+import { OrderPackageItem } from '../../service/order-package-item/order-package-item'
+import { OrderProduct } from '../../service/order-product/order-product'
+import { ReleaseGood } from '../../service/release-good/release-good'
+
+export class PowrupController {
+  async packOrder(
+    powrup: Powrup,
+    releaseGood: ReleaseGood,
+    domain?: Domain,
+    user?: User,
+    trxMgr?: EntityManager
+  ): 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
+      }
+
+      await getRepository(ReleaseGood).update(
+        { id: releaseGood.id },
+        {
+          lastMarketPackCall: new Date()
+        }
+      )
+
+      const orderPack: any = await PowrupAPI.packOrder(powrup, {
+        ...orderInformation,
+        context: { state: { domain: domain || null, user: user || null } }
+      })
+
+      if (orderPack?.packages) {
+        const packages: any[] = orderPack.packages
+
+        await Promise.all(
+          packages.map(async pkg => {
+            const items = pkg.items
+            const orderPackage: any = {
+              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 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 trxMgr.getRepository(OrderPackageItem).save(orderPackageItems)
+          })
+        )
+
+        await 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(
+    inventories: Inventory[],
+    customerDomain: Domain,
+    user?: User,
+    trxMgr?: EntityManager
+  ): Promise<void> {
+    const bizplace: Bizplace = await trxMgr.getRepository(Bizplace).findOne({ domain: customerDomain })
+    const powrup: Powrup = await trxMgr
+      .getRepository(Powrup)
+      .findOne({ where: { platform: Platform.POWRUP, active: true } })
+
+    if (powrup) {
+      for (let inventory of inventories) {
+        let product: Product = inventory.product
+        const productDetail: ProductDetail = inventory.productDetail
+        const warehouseDomainId: string = inventory.domainId
+        let qb = await 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: warehouseDomainId,
+            bizplaceId: bizplace.id,
+            productId: product.id,
+            productDetailId: productDetail.id,
+            status: INVENTORY_STATUS.STORED,
+            locationTypes: [LOCATION_TYPE.QUARANTINE]
+          })
+
+        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 || 0,
+              quantityReserved: inventoryTotalLockedQty - inventoryBufferQty || 0,
+              quantityBuffer: inventoryBufferQty || 0
+            }
+          }
+        ]
+
+        await PowrupAPI.updateStock(powrup, {
+          context: { state: { domain: customerDomain || null, user: user || user } },
+          warehouseDomainId,
+          powrupInvs
+        })
+      }
+    }
+  }
+
+  async initiateShipment(
+    powrup: Powrup,
+    releaseGood: ReleaseGood,
+    domain?: Domain,
+    user?: User,
+    trxMgr?: EntityManager
+  ): Promise<void> {
+    try {
+      let orderPackages: OrderPackage[] = await 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, user } }
+                })
+                await getRepository(OrderPackage).update({ id: op.id }, { marketRtsCallSuccess: new Date() })
+              } catch (error) {
+                logger.error(
+                  `powrup-controller[initiateShipment]: ${JSON.stringify({
+                    ...orderInformation,
+                    context: { state: { domain: domain || null, user: user || null } },
+                    error: error
+                  })}`
+                )
+              }
+            })
+        )
+      }
+    } catch (error) {
+      throw error
+    }
+  }
+
+  async fetchDocument(
+    powrup: Powrup,
+    releaseGood: ReleaseGood,
+    domain?: Domain,
+    user?: User,
+    trxMgr?: EntityManager
+  ): Promise<ReleaseGood> {
+    if (releaseGood?.ownTransport && releaseGood?.lmdOption) {
+      return
+    }
+    try {
+      let orderPackages: OrderPackage[] = await 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: domain || null, user: user || null } }
+            })
+
+            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: user
+              }
+
+              await trxMgr.getRepository(OrderPackage).update({ id: op.id }, { ...updateInfo })
+            }
+          })
+        )
+
+        releaseGood = await trxMgr.getRepository(ReleaseGood).findOne({ id: releaseGood.id })
+      }
+
+      return releaseGood
+    } catch (error) {
+      throw error
+    }
+  }
+}

package/server/index.ts

@@ -3,3 +3,4 @@ export * from './migrations'
 export * from './utils'
 export * from './constants'
 export * from './controllers/ecommerce/sellercraft-controller'
+export * from './controllers/ecommerce/powrup-controller'

package/server/service/delivery-order/delivery-order-query.ts

@@ -143,8 +143,8 @@ export class DeliveryOrderQuery {
           [arrChildSortData.indexOf(sort.name) >= 0
             ? 'releaseGood.' + sort.name
             : arrNameSortData.indexOf(sort.name) >= 0
-              ? sort.name + '.name'
-              : 'do.' + sort.name]: sort.desc ? 'DESC' : 'ASC'
+            ? sort.name + '.name'
+            : 'do.' + sort.name]: sort.desc ? 'DESC' : 'ASC'
         }),
         params.sortings.length < 1 ? { rank: 'ASC', 'do.createdAt': 'DESC' } : {}
       )
@@ -251,13 +251,13 @@ export class DeliveryOrderQuery {
 
     let [items, total] = await getRepository(OrderInventory).findAndCount({
       where: { domain, deliveryOrder },
-      relations: ['inventory', 'inventory.product', 'inventory.reusablePallet']
+      relations: ['product', 'productDetail', 'inventory', 'inventory.product', 'inventory.reusablePallet']
     })
 
     items = items
       .map((oi: OrderInventory) => {
         const inventory: Inventory = oi.inventory
-        const product: Product = inventory.product
+        const product: Product = oi.product
         return {
           inventory: inventory,
           productName: `${product.name} (${product.description})`,
@@ -321,12 +321,12 @@ export class DeliveryOrderQuery {
         systemRemark: prod?.remark
           ? prod.remark
           : prod.crossDocking
-            ? prod.pallet === ''
-              ? `${prod.palletQty} PALLET(S) [C/D]`
-              : `${prod.palletQty} PALLET(S) (${prod.pallet}) [C/D]`
-            : prod.pallet === ''
-              ? `${prod.palletQty} PALLET(S)`
-              : `${prod.palletQty} PALLET(S) (${prod.pallet})`
+          ? prod.pallet === ''
+            ? `${prod.palletQty} PALLET(S) [C/D]`
+            : `${prod.palletQty} PALLET(S) (${prod.pallet}) [C/D]`
+          : prod.pallet === ''
+          ? `${prod.palletQty} PALLET(S)`
+          : `${prod.palletQty} PALLET(S) (${prod.pallet})`
       }
     })
 
@@ -413,12 +413,12 @@ export class DeliveryOrderQuery {
         systemRemark: prod?.remark
           ? prod.remark
           : prod.crossDocking
-            ? prod.pallet === ''
-              ? `${prod.palletQty} PALLET(S) [C/D]`
-              : `${prod.palletQty} PALLET(S) (${prod.pallet}) [C/D]`
-            : prod.pallet === ''
-              ? `${prod.palletQty} PALLET(S)`
-              : `${prod.palletQty} PALLET(S) (${prod.pallet})`
+          ? prod.pallet === ''
+            ? `${prod.palletQty} PALLET(S) [C/D]`
+            : `${prod.palletQty} PALLET(S) (${prod.pallet}) [C/D]`
+          : prod.pallet === ''
+          ? `${prod.palletQty} PALLET(S)`
+          : `${prod.palletQty} PALLET(S) (${prod.pallet})`
       }
     })
 
@@ -442,7 +442,7 @@ export class DeliveryOrderQuery {
 
       const releaseGoodParam = params.filters.find(param => param.name === 'releaseGoodNo')
       if (releaseGoodParam) {
-        let arrFilters = []          
+        let arrFilters = []
         params.filters.splice(
           params.filters.findIndex(item => item.name == 'releaseGoodNo'),
           1
@@ -546,8 +546,8 @@ export class DeliveryOrderQuery {
           [arrChildSortData.indexOf(sort.name) >= 0
             ? 'releaseGood.' + sort.name
             : arrNameSortData.indexOf(sort.name) >= 0
-              ? sort.name + '.name'
-              : 'do.' + sort.name]: sort.desc ? 'DESC' : 'ASC'
+            ? sort.name + '.name'
+            : 'do.' + sort.name]: sort.desc ? 'DESC' : 'ASC'
         }),
         params.sortings.length < 1 ? { rank: 'ASC', 'do.createdAt': 'DESC' } : {}
       )

package/server/service/index.ts

@@ -1,4 +1,5 @@
 /* IMPORT ENTITIES AND RESOLVERS */
+import { entities as OrderVasItemEntities, resolvers as OrderVasItemResolvers } from './order-vas-item'
 import { entities as ReplenishmentEntities, resolvers as ReplenishmentResolvers } from './replenishment'
 import { entities as ArrivalNoticeEntity, resolvers as ArrivalNoticeResolvers } from './arrival-notice'
 import { entities as ClaimEntity, resolvers as ClaimResolvers } from './claim'
@@ -47,6 +48,7 @@ import { entities as VasEntity, resolvers as VasResolvers } from './vas'
 import { entities as VasOrderEntity, resolvers as VasOrderResolvers } from './vas-order'
 
 /* EXPORT ENTITY TYPES */
+export * from './order-vas-item/order-vas-item'
 export * from './replenishment/replenishment'
 export * from './replenishment/replenishment'
 export * from './arrival-notice/arrival-notice'
@@ -179,6 +181,7 @@ export * from './vas/vas-query'
 
 export const entities = [
   /* ENTITIES */
+	...OrderVasItemEntities,
   ...ReplenishmentEntities,
   ...ReplenishmentEntities,
   ...ArrivalNoticeEntity,
@@ -218,6 +221,7 @@ export const entities = [
 export const schema = {
   resolverClasses: [
     /* RESOLVER CLASSES */
+		...OrderVasItemResolvers,
     ...ReplenishmentResolvers,
     ...ReplenishmentResolvers,
     ...ArrivalNoticeResolvers,

package/server/service/order-inventory/order-inventory-query.ts

@@ -71,7 +71,8 @@ export class OrderInventoryQuery {
     qb.leftJoinAndSelect('oi.arrivalNotice', 'arrivalNotice')
     qb.leftJoinAndSelect('oi.orderProduct', 'orderProduct')
     qb.leftJoinAndSelect('oi.inventory', 'inventory')
-    qb.leftJoinAndSelect('inventory.product', 'product')
+    qb.leftJoinAndSelect('oi.product', 'product')
+    qb.leftJoinAndSelect('inventory.product', 'inventoryProduct')
     qb.leftJoinAndSelect('inventory.location', 'location')
     qb.leftJoinAndSelect('oi.releaseGood', 'releaseGood')
     qb.leftJoinAndSelect('oi.deliveryOrder', 'deliveryOrder')

package/server/service/order-vas/order-vas-mutation.ts

@@ -1,8 +1,9 @@
 import { Domain } from '@things-factory/shell'
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager } from 'typeorm'
+import { EntityManager, getRepository } from 'typeorm'
 import { OrderVasPatch } from '../'
 import { OrderVas } from './order-vas'
+// import { WorksheetDetail } from '@things-factory/worksheet-base'
 
 @Resolver(OrderVas)
 export class OrderVasMutation {
@@ -18,4 +19,96 @@ export class OrderVasMutation {
     let orderVas = await tx.getRepository(OrderVas).findOne(id)
     return await tx.getRepository(OrderVas).save({ orderVas, ...patch })
   }
+
+  @Directive('@transaction')
+  @Mutation(returns => [OrderVas])
+  async updateMultipleOrderVas(
+    @Arg('patches', type => [OrderVasPatch]) patches: OrderVasPatch[],
+    @Ctx() context: any
+  ): Promise<OrderVasPatch[]> {
+    const { domain, user } = context.state
+
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const orderVasRepo = getRepository(OrderVas)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await orderVasRepo.save({
+          ...newRecord,
+          domain: domain,
+          creator: user,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const newRecord = _updateRecords[i]
+        const orderVas = await orderVasRepo.findOne({
+          where: { domain, id: newRecord.id },
+          relations: ['product', 'productDetail', 'newProduct', 'newProductDetail', 'releaseGood', 'orderVasItems']
+        })
+
+        const result = await orderVasRepo.save({
+          ...orderVas,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@privilege(category: "vas", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteOrderVas(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+    const { tx }: { tx: EntityManager } = context.state
+    await tx.getRepository(OrderVas).delete(id)
+    return true
+  }
+
+  @Directive('@privilege(category: "vas", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteOrderVass(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
+    const { tx }: { tx: EntityManager } = context.state
+    // const foundWDs = await tx.getRepository(WorksheetDetail)
+    //   .createQueryBuilder('wd')
+    //   .innerJoinAndSelect('wd.targetVas', 'tv')
+    //   .where('tv.id IN (:...ids)', { ids })
+    //   .getMany();
+
+    const foundWDs = await tx.query(
+      `
+      select wd.*, ov.*
+      from worksheet_details wd
+      left join order_vass ov on wd.target_vas_id = ov.id
+      where ov.id IN ('${ ids }');
+      `
+    )
+      
+    if (foundWDs.length > 0) {
+      await tx.query(
+        `
+        delete from worksheet_details wd
+        left join order_vass or on wd.target_vas_id = ov.id
+        where ov.id IN ('${ ids }')
+        `
+      )
+    }
+  
+    await tx.getRepository(OrderVas).delete(ids)
+    return true
+  }
 }

package/server/service/order-vas/order-vas-query.ts

@@ -22,7 +22,10 @@ export class OrderVasQuery {
         'releaseGood',
         'vasOrder',
         'shippingOrder',
-        'vas',
+        'product',
+        'newProduct',
+        'orderVasItems',
+        'orderVasItems.vas',
         'inventory',
         'creator',
         'updater'

package/server/service/order-vas/order-vas-types.ts

@@ -26,7 +26,7 @@ export class NewOrderVas {
   targetBatchId: string
 
   @Field(type => ObjectRef, { nullable: true })
-  targetProduct: ObjectRef
+  product: ObjectRef
 
   @Field({ nullable: true })
   otherTarget: string
@@ -88,6 +88,9 @@ export class OrderVasPatch {
   @Field({ nullable: true })
   id: string
 
+  @Field(type => ObjectRef, { nullable: true })
+  bizplace: ObjectRef
+
   @Field({ nullable: true })
   name: string
 
@@ -103,12 +106,21 @@ export class OrderVasPatch {
   @Field(type => ObjectRef, { nullable: true })
   targetProduct: ObjectRef
 
+  @Field(type => ObjectRef, { nullable: true })
+  product: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  productDetail: ObjectRef
+
   @Field({ nullable: true })
   otherTarget: string
 
   @Field(type => Int, { nullable: true })
   qty: number
 
+  @Field({ nullable: true })
+  uom: string
+
   @Field(type => Float, { nullable: true })
   uomValue: number
 
@@ -145,6 +157,24 @@ export class OrderVasPatch {
   @Field({ nullable: true })
   operationGuide: string
 
+  @Field({ nullable: true })
+  newProduct: string
+
+  @Field({ nullable: true })
+  newProductDetail: string
+
+  @Field({ nullable: true })
+  newPackingType: string
+
+  @Field({ nullable: true })
+  newUom: string
+
+  @Field({ nullable: true })
+  newUomValue: number
+
+  @Field({ nullable: true })
+  outputQty: number
+
   @Field({ nullable: true })
   remark: string
 
@@ -154,6 +184,9 @@ export class OrderVasPatch {
   @Field({ nullable: true })
   status: string
 
+  @Field({ nullable: true })
+  domain: string
+
   @Field({ nullable: true })
   cuFlag: string
 }