@things-factory/sales-base 4.3.131 → 4.3.135

package/server/service/draft-release-good/draft-release-good-mutation.ts

@@ -1,6 +1,7 @@
 import { FileUpload, GraphQLUpload } from 'graphql-upload'
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
 import { EntityManager, getConnection, getRepository, In, IsNull, Repository } from 'typeorm'
+import { logger } from '@things-factory/env'
 
 import { Attachment, createAttachments, deleteAttachmentsByRef } from '@things-factory/attachment-base'
 import { User } from '@things-factory/auth-base'
@@ -185,240 +186,250 @@ export class DraftReleaseGoodMutation {
     // @Arg('bizplaceId', type => String) bizplaceId: string
   ): Promise<boolean> {
     const { domain, user, tx } = context.state
-
-    const updatableDraftOrders = await tx.getRepository(DraftReleaseGood).find({
-      where: {
-        domain,
-        id: In(ids),
-        status: DRAFT_RELEASE_ORDER_STATUS.DRAFT
-      },
-      relations: [
-        'orderProducts',
-        'orderProducts.product',
-        'orderProducts.productBundle',
-        'shippingOrder',
-        'bizplace',
-        'bizplace.domain',
-        'domain',
-        'creator',
-        'updater'
-      ]
-    })
-    if (updatableDraftOrders.length > 0) {
-      let createdReleaseGoods: ReleaseGood[] = []
-      const settingRepo: Repository<Setting> = tx?.getRepository(Setting) || getRepository(Setting)
-
-      const roNoSetting: Setting = await settingRepo.findOne({
+    try {
+      const updatableDraftOrders = await tx.getRepository(DraftReleaseGood).find({
         where: {
           domain,
-          name: ORDER_NUMBER_SETTING_KEY.RO_NUMBER_RULE
-        }
+          id: In(ids),
+          status: DRAFT_RELEASE_ORDER_STATUS.DRAFT
+        },
+        relations: [
+          'orderProducts',
+          'orderProducts.product',
+          'orderProducts.productBundle',
+          'shippingOrder',
+          'bizplace',
+          'bizplace.domain',
+          'domain',
+          'creator',
+          'updater'
+        ]
       })
 
-      for (let index = 0; index < updatableDraftOrders.length; index++) {
-        await getConnection().transaction(async (parentTx: EntityManager) => {
-          const draftOrder = updatableDraftOrders[index]
-
-          let foundPermittedBizplace: Bizplace
-          let companyBizplace: Bizplace
+      if (updatableDraftOrders.length > 0) {
+        let createdReleaseGoods: ReleaseGood[] = []
+        const settingRepo: Repository<Setting> = tx?.getRepository(Setting) || getRepository(Setting)
 
-          if (draftOrder?.bizplace?.id) {
-            foundPermittedBizplace = await parentTx.getRepository(Bizplace).findOne(draftOrder.bizplace.id, {
-              relations: ['company', 'company.domain']
-            })
-            const companyDomain: Domain = foundPermittedBizplace.company.domain
-            companyBizplace = await parentTx.getRepository(Bizplace).findOne({ where: { domain: companyDomain } })
-          } else {
-            return false
+        const roNoSetting: Setting = await settingRepo.findOne({
+          where: {
+            domain,
+            name: ORDER_NUMBER_SETTING_KEY.RO_NUMBER_RULE
           }
+        })
 
-          const bizplaces: Bizplace[] = [foundPermittedBizplace, companyBizplace]
+        for (let index = 0; index < updatableDraftOrders.length; index++) {
+          await getConnection().transaction(async (parentTx: EntityManager) => {
+            const draftOrder = updatableDraftOrders[index]
 
-          let productInventory = await InventoryUtil.bizplaceProductInventory(
-            bizplaces,
-            {
-              filters: [
-                {
-                  name: 'productId',
-                  operator: 'in',
-                  value: [
-                    ...draftOrder.orderProducts
-                      .filter(itm => itm?.product)
-                      .map(itm => {
-                        return itm.product.id
-                      }),
-                    ...draftOrder.orderProducts
-                      .filter(itm => itm?.productBundle)
-                      .map(itm => {
-                        return itm.productBundle.id
-                      })
-                  ]
-                }
-              ]
-            },
-            context,
-            parentTx
-          )
-
-          draftOrder.orderProducts = draftOrder.orderProducts.map(itm => {
-            let foundProductInv = productInventory.items.find(
-              i =>
-                (i.productId == itm?.product?.id || i.productId == itm?.productBundle?.id) &&
-                i.packingType == itm.packingType &&
-                i.packingSize == itm.packingSize &&
-                i.uom == itm.uom &&
-                itm.releaseQty <= i.remainQty
-            )
-            return {
-              ...itm,
-              releaseUomValue: (foundProductInv.remainUomValue / foundProductInv.remainQty) * itm.releaseQty,
-              status: foundProductInv ? 'suffice' : 'insufficient'
+            let foundPermittedBizplace: Bizplace
+            let companyBizplace: Bizplace
+
+            if (draftOrder?.bizplace?.id) {
+              foundPermittedBizplace = await parentTx.getRepository(Bizplace).findOne(draftOrder.bizplace.id, {
+                relations: ['company', 'company.domain']
+              })
+              const companyDomain: Domain = foundPermittedBizplace.company.domain
+              companyBizplace = await parentTx.getRepository(Bizplace).findOne({ where: { domain: companyDomain } })
+            } else {
+              return false
             }
-          })
 
-          let insufficient = draftOrder.orderProducts.find(op => op.status == 'insufficient')
-          if (!insufficient) {
-            //create RO
-            let releaseGood = { ...draftOrder }
-            delete releaseGood.id
-            delete releaseGood.name
-            delete releaseGood.createdAt
-            delete releaseGood.createdBy
-            delete releaseGood.updatedAt
-            delete releaseGood.updatedBy
-
-            let orderInventories = []
-
-            for (let index = 0; index < draftOrder.orderProducts.length; index++) {
-              const itm: Partial<OrderProduct> = draftOrder.orderProducts[index]
-              let data = []
-              if (itm.productBundle) {
-                let bundle: ProductBundle = await parentTx.getRepository(ProductBundle).findOne({
-                  where: { id: itm.productBundle.id },
-                  relations: [
-                    'productBundleSettings',
-                    'productBundleSettings.productDetail',
-                    'productBundleSettings.product'
-                  ]
-                })
+            const bizplaces: Bizplace[] = [foundPermittedBizplace, companyBizplace]
 
-                for (let index2 = 0; index2 < bundle.productBundleSettings.length; index2++) {
-                  const objProductBundleSetting = bundle.productBundleSettings[index2]
-                  data.push({
-                    sku: objProductBundleSetting.product.sku,
-                    packingType: objProductBundleSetting.productDetail.packingType,
-                    packingSize: objProductBundleSetting.productDetail.packingSize,
-                    uom: objProductBundleSetting.productDetail.uom,
-                    releaseQty: objProductBundleSetting.bundleQty * itm.releaseQty,
-                    assignedQty: undefined,
-                    assignedUomValue: undefined,
-                    releaseUomValue: objProductBundleSetting.bundleQty * itm.releaseQty * itm.releaseUomValue
-                  })
-                }
-              } else {
-                data = [
-                  {
-                    sku: itm.product.sku,
-                    packingType: itm.packingType,
-                    packingSize: itm.packingSize,
-                    uom: itm.uom,
-                    releaseQty: itm.releaseQty,
-                    assignedQty: undefined,
-                    assignedUomValue: undefined,
-                    releaseUomValue: itm.releaseUomValue
-                  }
-                ]
-              }
+            let loggerJson = JSON.stringify({ refNo: draftOrder.refNo, bizplaceId: draftOrder.bizplace.id, domain })
+            try {
+              console.time(`creating_order:${loggerJson}`)
 
-              data.forEach(data => {
-                let existingOI = orderInventories.find(
-                  itm =>
-                    itm.sku == data.sku &&
-                    itm.packingType == data.packingType &&
-                    itm.packingSize == data.packingSize &&
-                    itm.uom == data.uom
+              let productInventory = await InventoryUtil.bizplaceProductInventory(
+                bizplaces,
+                {
+                  filters: [
+                    {
+                      name: 'productId',
+                      operator: 'in',
+                      value: [
+                        ...draftOrder.orderProducts
+                          .filter(itm => itm?.product)
+                          .map(itm => {
+                            return itm.product.id
+                          }),
+                        ...draftOrder.orderProducts
+                          .filter(itm => itm?.productBundle)
+                          .map(itm => {
+                            return itm.productBundle.id
+                          })
+                      ]
+                    }
+                  ]
+                },
+                context,
+                parentTx
+              )
+
+              draftOrder.orderProducts = draftOrder.orderProducts.map(itm => {
+                let foundProductInv = productInventory.items.find(
+                  i =>
+                    (i.productId == itm?.product?.id || i.productId == itm?.productBundle?.id) &&
+                    i.packingType == itm.packingType &&
+                    i.packingSize == itm.packingSize &&
+                    i.uom == itm.uom &&
+                    itm.releaseQty <= i.remainQty
                 )
-
-                if (existingOI) {
-                  existingOI.releaseQty = existingOI.releaseQty + data.releaseQty
-                  existingOI.releaseUomValue = existingOI.releaseUomValue + data.uomValue
-                  existingOI.uomValue = existingOI.uomValue + data.uomValue
-                } else {
-                  orderInventories.push({ ...data, orderProduct: itm })
+                return {
+                  ...itm,
+                  releaseUomValue: (foundProductInv.remainUomValue / foundProductInv.remainQty) * itm.releaseQty,
+                  status: foundProductInv ? 'suffice' : 'insufficient'
                 }
               })
-            }
-            try {
-              await getConnection().transaction(async (childTx: EntityManager) => {
-                let availableItems: any[] = await bulkReleaseGoodsAvailableItemsFunction(
-                  orderInventories,
-                  draftOrder.bizplace.id,
-                  context,
-                  childTx
-                )
-                if (availableItems.some(item => !item.releaseQty || item.releaseQty > item.assignedQty))
-                  throw new ValidationError({
-                    ...ValidationError.ERROR_CODES.INSUFFICIENT_STOCK,
-                    detail: { data: JSON.stringify(availableItems) }
-                  })
-                // update orderInventories if availableItems are valid
-                releaseGood.orderInventories = availableItems.map(itm => {
-                  return {
-                    ...itm,
-                    releaseQty: itm.releaseQty,
-                    releaseUomValue: itm.releaseUomValue,
-                    uomValue: itm.uomValue
+
+              let insufficient = draftOrder.orderProducts.find(op => op.status == 'insufficient')
+              if (!insufficient) {
+                //create RO
+                let releaseGood = { ...draftOrder }
+                delete releaseGood.id
+                delete releaseGood.name
+                delete releaseGood.createdAt
+                delete releaseGood.createdBy
+                delete releaseGood.updatedAt
+                delete releaseGood.updatedBy
+
+                let orderInventories = []
+
+                for (let index = 0; index < draftOrder.orderProducts.length; index++) {
+                  const itm: Partial<OrderProduct> = draftOrder.orderProducts[index]
+                  let data = []
+                  if (itm.productBundle) {
+                    let bundle: ProductBundle = await parentTx.getRepository(ProductBundle).findOne({
+                      where: { id: itm.productBundle.id },
+                      relations: [
+                        'productBundleSettings',
+                        'productBundleSettings.productDetail',
+                        'productBundleSettings.product'
+                      ]
+                    })
+
+                    for (let index2 = 0; index2 < bundle.productBundleSettings.length; index2++) {
+                      const objProductBundleSetting = bundle.productBundleSettings[index2]
+                      data.push({
+                        sku: objProductBundleSetting.product.sku,
+                        packingType: objProductBundleSetting.productDetail.packingType,
+                        packingSize: objProductBundleSetting.productDetail.packingSize,
+                        uom: objProductBundleSetting.productDetail.uom,
+                        releaseQty: objProductBundleSetting.bundleQty * itm.releaseQty,
+                        assignedQty: undefined,
+                        assignedUomValue: undefined,
+                        releaseUomValue: objProductBundleSetting.bundleQty * itm.releaseQty * itm.releaseUomValue
+                      })
+                    }
+                  } else {
+                    data = [
+                      {
+                        sku: itm.product.sku,
+                        packingType: itm.packingType,
+                        packingSize: itm.packingSize,
+                        uom: itm.uom,
+                        releaseQty: itm.releaseQty,
+                        assignedQty: undefined,
+                        assignedUomValue: undefined,
+                        releaseUomValue: itm.releaseUomValue
+                      }
+                    ]
                   }
-                })
-                let createdReleaseGood: ReleaseGood = await bulkGenerateReleaseGood(
-                  releaseGood,
-                  releaseGood.bizplace.id,
-                  roNoSetting,
-                  domain,
-                  user,
-                  childTx
-                )
-                await childTx
-                  .getRepository(DraftReleaseGood)
-                  .update(
-                    { id: draftOrder.id },
-                    { releaseGood: createdReleaseGood, status: DRAFT_RELEASE_ORDER_STATUS.SUBMITTED }
-                  )
 
-                const directReceiveSetting: Setting = await tx.getRepository(Setting).findOne({
-                  where: { domain, category: 'id-rule', name: 'enable-direct-receive-release-order' }
-                })
+                  data.forEach(data => {
+                    let existingOI = orderInventories.find(
+                      itm =>
+                        itm.sku == data.sku &&
+                        itm.packingType == data.packingType &&
+                        itm.packingSize == data.packingSize &&
+                        itm.uom == data.uom
+                    )
+
+                    if (existingOI) {
+                      existingOI.releaseQty = existingOI.releaseQty + data.releaseQty
+                      existingOI.releaseUomValue = existingOI.releaseUomValue + data.uomValue
+                      existingOI.uomValue = existingOI.uomValue + data.uomValue
+                    } else {
+                      orderInventories.push({ ...data, orderProduct: itm })
+                    }
+                  })
+                }
+                await getConnection().transaction(async (childTx: EntityManager) => {
+                  let availableItems: any[] = await bulkReleaseGoodsAvailableItemsFunction(
+                    orderInventories,
+                    draftOrder.bizplace.id,
+                    context,
+                    childTx
+                  )
+                  if (availableItems.some(item => !item.releaseQty || item.releaseQty > item.assignedQty))
+                    throw new ValidationError({
+                      ...ValidationError.ERROR_CODES.INSUFFICIENT_STOCK,
+                      detail: { data: JSON.stringify(availableItems) }
+                    })
+                  // update orderInventories if availableItems are valid
+                  releaseGood.orderInventories = availableItems.map(itm => {
+                    return {
+                      ...itm,
+                      releaseQty: itm.releaseQty,
+                      releaseUomValue: itm.releaseUomValue,
+                      uomValue: itm.uomValue
+                    }
+                  })
+                  let createdReleaseGood: ReleaseGood = await bulkGenerateReleaseGood(
+                    releaseGood,
+                    releaseGood.bizplace.id,
+                    roNoSetting,
+                    domain,
+                    user,
+                    childTx
+                  )
+                  await childTx
+                    .getRepository(DraftReleaseGood)
+                    .update(
+                      { id: draftOrder.id },
+                      { releaseGood: createdReleaseGood, status: DRAFT_RELEASE_ORDER_STATUS.SUBMITTED }
+                    )
+
+                  const directReceiveSetting: Setting = await tx.getRepository(Setting).findOne({
+                    where: { domain, category: 'id-rule', name: 'enable-direct-receive-release-order' }
+                  })
 
-                const partnerDirectReceiveSetting: PartnerSetting = await tx.getRepository(PartnerSetting).findOne({
-                  where: { setting: directReceiveSetting, domain, partnerDomain: draftOrder.bizplace?.domain }
-                })
+                  const partnerDirectReceiveSetting: PartnerSetting = await tx.getRepository(PartnerSetting).findOne({
+                    where: { setting: directReceiveSetting, domain, partnerDomain: draftOrder.bizplace?.domain }
+                  })
 
-                let settingValue
+                  let settingValue
 
-                if (
-                  !isNaN(partnerDirectReceiveSetting?.value) &&
-                  !isNaN(parseFloat(partnerDirectReceiveSetting?.value))
-                ) {
-                  settingValue = parseFloat(partnerDirectReceiveSetting.value)
-                } else {
-                  settingValue = parseFloat(directReceiveSetting.value)
-                }
+                  if (
+                    !isNaN(partnerDirectReceiveSetting?.value) &&
+                    !isNaN(parseFloat(partnerDirectReceiveSetting?.value))
+                  ) {
+                    settingValue = parseFloat(partnerDirectReceiveSetting.value)
+                  } else {
+                    settingValue = parseFloat(directReceiveSetting.value)
+                  }
 
-                createdReleaseGood = await confirmReleaseGood(createdReleaseGood.name, context, childTx)
+                  createdReleaseGood = await confirmReleaseGood(createdReleaseGood.name, context, childTx)
 
-                if (settingValue > 1) {
-                  createdReleaseGood = await receiveReleaseGood(createdReleaseGood.name, context, childTx)
-                }
-              })
-            } catch (error) {
-              console.error(error)
+                  if (settingValue > 1) {
+                    createdReleaseGood = await receiveReleaseGood(createdReleaseGood.name, context, childTx)
+                  }
+                })
+              }
+            } catch (e) {
+              logger.error(`draft-release-good-mutation[generateReleaseGoodsFromDraft:${loggerJson}]: ${e?.message}`)
+            } finally {
+              console.timeEnd(`creating_order:${loggerJson}`)
             }
-          }
-        })
+          })
+        }
       }
+
+      return true
+    } catch (e) {
+      logger.error(`draft-release-good-mutation[generateReleaseGoodsFromDraft]: ${e?.message}`)
     }
 
-    return true
   }
 }
 
@@ -761,8 +772,8 @@ export async function upsertDraftReleaseGoodProducts(
         updatePatch['packingType'] = op?.packingType
           ? op.packingType
           : product?.packingType
-          ? product.packingType
-          : productBundle.packingType
+            ? product.packingType
+            : productBundle.packingType
         updatePatch['uom'] = op?.uom ? op.uom : product?.primaryUnit ? product.primaryUnit : 'UNIT'
         updatePatch['uomValue'] = op?.uomValue ? op.uomValue : product?.primaryValue ? product.primaryValue : 0
 

package/server/service/release-good/release-good-mutation.ts

@@ -159,7 +159,7 @@ export class ReleaseGoodMutation {
               childTx
             )
           }
-        } catch (error) {}
+        } catch (error) { }
     })
 
     if (errorsCaught.length)
@@ -652,8 +652,8 @@ export async function generateReleaseGoodFunction(
       orderMethod: releaseGood?.orderMethod
         ? releaseGood.orderMethod
         : releaseGood.orderInventories[0]?.inventory?.id
-        ? ORDER_METHOD.SELECT_BY_PALLET
-        : ORDER_METHOD.SELECT_BY_PRODUCT,
+          ? ORDER_METHOD.SELECT_BY_PALLET
+          : ORDER_METHOD.SELECT_BY_PRODUCT,
       status: ORDER_STATUS.PENDING,
       packageId: releaseGood?.packageId,
       storeName: releaseGood?.storeName,
@@ -931,26 +931,6 @@ export async function confirmReleaseGood(name: string, context: any, tx?: Entity
 
   const orderSource: string = foundReleaseGood.source
   switch (orderSource) {
-    case ApplicationType.SELLERCRAFT:
-      if (foundReleaseGood.type == 'b2c' && sellercraft) {
-        try {
-          let rg = await sellercraftCtrl.packOrder(sellercraft, {
-            ...foundReleaseGood,
-            orderProducts: foundOPs
-          })
-          foundReleaseGood = rg
-        } catch (error) {
-          logger.error(
-            `release-good-mutation[confirmReleaseGood]:(data:${JSON.stringify({
-              sellercraft,
-              foundReleaseGood,
-              domain,
-              user
-            })}) ${error} `
-          )
-        }
-      }
-      break
 
     case ApplicationType.MMS:
       // find for any existing marketplace store connections