@things-factory/sales-base 4.3.512 → 4.3.514

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

@@ -1,10 +1,12 @@
 import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
+import { Bizplace } from '@things-factory/biz-base'
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
 import { EntityManager } from 'typeorm'
-import { NewVas, VasPatch, OrderVasPatch, OrderVasItemPatch, ReleaseGood, OrderVas, OrderVasItem } from '../'
+import { NewVas, VasPatch, OrderVasPatch, OrderVasItemPatch, ReleaseGood, OrderVas, OrderVasItem, NewOrderVas } from '../'
 import { Vas } from './vas'
 import { v4 as uuidv4 } from 'uuid'
+import { ORDER_STATUS, ORDER_VAS_STATUS } from '../../constants'
 
 @Resolver(Vas)
 export class VasMutation {
@@ -117,7 +119,21 @@ export class VasMutation {
   ): Promise<Boolean> {
     const response = await editVas(orderVasPatch, orderVasItemPatch, context)
 
-    return response
+    return response ?  true : false
+  }
+
+  @Directive('@privilege(category: "vas", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async proceedVasChanges(
+    @Arg('releaseOrderNo') releaseOrderNo: String,
+    @Arg('bizplaceId') bizplaceId: String,
+    @Arg('approvedVas', type => [OrderVasPatch], { nullable: true }) approvedVas: OrderVasPatch[],
+    @Arg('rejectedVas', type => [OrderVasPatch], { nullable: true }) rejectedVas: OrderVasPatch[],
+    @Ctx() context: any
+  ): Promise<Boolean> {
+    await proceedVasChanges({releaseOrderNo, bizplaceId, approvedVas, rejectedVas}, context) 
+    return true
   }
 }
 
@@ -130,11 +146,12 @@ export async function editVas(
   let results = []
   const orderVasRepo = tx.getRepository(OrderVas)
   const orderVasItemRepo = tx.getRepository(OrderVasItem)
+  
   // Order Vas
-  if (orderVasPatch.length > 0) {
-    const _deleteRecords = orderVasPatch.filter((patch: any) => patch.cuFlag.toUpperCase() === '-')
-    const _createRecords = orderVasPatch.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
-    const _updateRecords = orderVasPatch.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+  if (orderVasPatch?.length > 0) {
+    const _deleteRecords = orderVasPatch.filter((patch: any) => patch.cuFlag?.toUpperCase() === '-')
+    const _createRecords = orderVasPatch.filter((patch: any) => patch.cuFlag?.toUpperCase() === '+')
+    const _updateRecords = orderVasPatch.filter((patch: any) => patch.cuFlag?.toUpperCase() === 'M')
 
     if (_deleteRecords.length > 0) {
       for (let i = 0; i < _deleteRecords.length; i++) {
@@ -154,7 +171,7 @@ export async function editVas(
           name: `${_createRecords[i].product.name} - ${new Date()}`,
           domain: domain,
           creator: user,
-          updater: user
+          createdAt: new Date()
         })
 
         results.push({ ...result, cuFlag: '+' })
@@ -165,6 +182,7 @@ export async function editVas(
             orderVas: result.id,
             name: `${newRecord.orderVasItemsPatch[ii].vas.name} (${newRecord.orderVasItemsPatch[ii].vas.description})- ${result.id}`,
             vas: newRecord.orderVasItemsPatch[ii].vas,
+            itemEditType: newRecord.orderVasItemsPatch[ii].itemEditType ? newRecord.orderVasItemsPatch[ii].itemEditType : undefined,
             vasQty: newRecord.orderVasItemsPatch[ii].vasQty,
             vasRemark: newRecord.orderVasItemsPatch[ii]?.vasRemark,
             domain: domain,
@@ -183,33 +201,113 @@ export async function editVas(
           relations: ['product', 'productDetail', 'newProduct', 'newProductDetail', 'releaseGood', 'orderVasItems']
         })
 
-        const result = await orderVasRepo.save({
-          ...orderVas,
-          ...newRecord,
-          updater: user
-        })
+        if (newRecord.editType === ORDER_VAS_STATUS.REMOVED) {  
+          const result = await orderVasRepo.update(
+          { id: newRecord.id },
+          {
+            editType: newRecord.editType,
+            status: newRecord.status,
+            updater: user,
+            updatedAt: new Date()
+          })
 
-        results.push({ ...result, cuFlag: 'M' })
+          results.push({ ...result, cuFlag: 'M' })
+
+          for (let ii = 0; ii < orderVas.orderVasItems.length; ii++) {
+            await orderVasItemRepo.update(
+              { id: orderVas.orderVasItems[ii].id },
+              {
+                orderVas: { id: orderVas.id },
+                itemEditType: ORDER_VAS_STATUS.REMOVED,
+                updater: user,
+                updatedAt: new Date()
+              }
+            )
+          }
+        } else if (newRecord.editType === ORDER_VAS_STATUS.CHANGES) {
+          const result = await orderVasRepo.update(
+          { id: newRecord.id },
+          {
+            adjustedBatchId: newRecord.batchId,
+            adjustedProduct: newRecord.product,
+            adjustedProductDetail: newRecord.productDetail,
+            adjustedPackingType: newRecord.packingType,
+            adjustedUom: newRecord.uom,
+            adjustedUomValue: newRecord.uomValue,
+            adjustedNewProduct: newRecord.newProduct,
+            adjustedNewProductDetail: newRecord.newProductDetail,
+            adjustedQty: newRecord.qty,
+            adjustedNewBatchId: newRecord.newBatchId,
+            adjustedNewPackingType: newRecord.newPackingType,
+            adjustedNewUom: newRecord.newUom,
+            adjustedNewUomValue: newRecord.newUomValue,
+            adjustedOutputQty: newRecord.outputQty,
+            status: newRecord.status,
+            editType: newRecord.editType,
+            updater: user,
+            updatedAt: new Date()
+          })
 
-        for (let ii = 0; ii < newRecord.orderVasItemsPatch.length; ii++) {
-          await orderVasItemRepo.update(
-            { id: newRecord.orderVasItemsPatch[ii].id },
-            {
-              orderVas: { id: result.id },
-              name: `${newRecord.orderVasItemsPatch[ii].vas.name}- ${result.id}`,
-              vas: newRecord.orderVasItemsPatch[ii].vas,
-              vasQty: newRecord.orderVasItemsPatch[ii].vasQty,
-              vasRemark: newRecord.orderVasItemsPatch[ii]?.vasRemark,
-              domain: domain,
-              creator: user,
-              createdAt: new Date()
+          results.push({ ...result, cuFlag: 'M' })
+
+          // order Vas Item
+          for (const ovi of newRecord.orderVasItemsPatch) {
+            switch (ovi.itemEditType) {
+              case ORDER_VAS_STATUS.NEW:
+                await orderVasItemRepo.insert({
+                  id: uuidv4(),
+                  orderVas: { id: newRecord.id },
+                  name: `${ovi.vas.name} (${ovi.vas.description})- ${newRecord.id}`,
+                  itemEditType: ovi.itemEditType,
+                  vas: ovi.vas,
+                  vasQty: ovi.vasQty,
+                  vasRemark: ovi?.vasRemark,
+                  domain: domain,
+                  creator: user,
+                  createdAt: new Date()
+                })
+                break;
+              
+              case ORDER_VAS_STATUS.CHANGES:
+                await orderVasItemRepo.update(
+                  { id: ovi.id },
+                  {
+                    orderVas: { id: newRecord.id },
+                    name: `${ovi.vas.name} (${ovi.vas.description})- ${newRecord.id}`,
+                    itemEditType: ovi.itemEditType,
+                    vas: ovi.vas,
+                    adjustedVasQty: ovi.vasQty,
+                    adjustedVasRemark: ovi.vasRemark,
+                    domain: domain,
+                    updater: user,
+                    updatedAt: new Date()
+                  }
+                )
+                break;
+
+              case ORDER_VAS_STATUS.REMOVED:
+                await orderVasItemRepo.update(
+                  { id: ovi.id },
+                  {
+                    orderVas: { id: newRecord.id },
+                    name: `${ovi.vas.name}- ${newRecord.id}`,
+                    itemEditType: ovi.itemEditType,
+                    vas: ovi.vas,
+                    vasQty: ovi.vasQty,
+                    vasRemark: ovi?.vasRemark,
+                    domain: domain,
+                    updater: user,
+                    updatedAt: new Date()
+                  }
+                )
+                
             }
-          )
+          }
         }
       }
     }
   }
-
+  
   // order Vas Item
   if (orderVasItemPatch?.length > 0) {
     const _deleteRecords = orderVasItemPatch.filter((patch: any) => patch.cuFlag.toUpperCase() === '-')
@@ -228,10 +326,11 @@ export async function editVas(
     if (_createRecords.length > 0) {
       for (let i = 0; i < _createRecords.length; i++) {
         const newRecord = _createRecords[i]
-        const result = await orderVasItemRepo.save({
+        const result = await orderVasItemRepo.insert({
           id: uuidv4(),
           orderVas: newRecord.orderVas.id,
           name: `${newRecord.vas.name}- ${newRecord.orderVas.id}`,
+          itemEditType: newRecord?.itemEditType,
           vas: newRecord.vas,
           vasQty: newRecord.vasQty,
           vasRemark: newRecord?.vasRemark,
@@ -240,24 +339,288 @@ export async function editVas(
           createdAt: new Date()
         })
         results.push({ ...result, cuFlag: '+' })
+
+        await orderVasRepo.update(
+        { id: newRecord.orderVas.id },
+        {
+          editType: ORDER_VAS_STATUS.CHANGES,
+          status: ORDER_VAS_STATUS.PENDING_APPROVE,
+          updater: user,
+          updatedAt: new Date()
+        })
       }
     }
 
     if (_updateRecords.length > 0) {
       for (let i = 0; i < _updateRecords.length; i++) {
         const newRecord = _updateRecords[i]
-
-        const result = await tx.getRepository(OrderVasItem).update(
+        if (newRecord.itemEditType === ORDER_VAS_STATUS.CHANGES) {
+          const result = await orderVasItemRepo.update(
+          { id: newRecord.id },
+          { 
+            adjustedVasQty: newRecord.vasQty,
+            adjustedVasRemark: newRecord?.vasRemark, 
+            itemEditType: newRecord.itemEditType,
+            updater: user, 
+            updatedAt: new Date()
+          })
+          results.push({ ...result, cuFlag: 'M' })
+        } else if (newRecord.itemEditType === ORDER_VAS_STATUS.REMOVED) {
+          const result = await orderVasItemRepo.update(
+          { id: newRecord.id },
           {
-            id: newRecord.id
-          },
-          { vasQty: newRecord.vasQty,vasRemark: newRecord?.vasRemark, updater: user.id, updatedAt: new Date() }
-        )
+            itemEditType: newRecord.itemEditType,
+            updater: user,
+            updatedAt: new Date()
+          })
+          results.push({ ...result, cuFlag: 'M' })
+        }
 
-        results.push({ ...result, cuFlag: 'M' })
+        await orderVasRepo.update(
+        { id: newRecord.orderVas.id },
+        {
+          editType: ORDER_VAS_STATUS.CHANGES,
+          status: ORDER_VAS_STATUS.PENDING_APPROVE,
+          updater: user,
+          updatedAt: new Date()
+        })
       }
     }
   }
-
   return results ? true : false
 }
+
+export async function proceedVasChanges(
+  { releaseOrderNo, bizplaceId, approvedVas, rejectedVas }, 
+  context: any
+): Promise<void> {
+  const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+
+  let releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
+    where: {
+      name: releaseOrderNo,
+      domain,
+      bizplace: bizplaceId
+    }
+  })
+
+  if (!releaseGood) throw new Error(`Unable to find ${releaseGood.name} with edited VAS`)
+
+  // approved changes
+  if (approvedVas?.length) {
+    await _handleApprovedVas(tx, domain, user, releaseGood, approvedVas)
+  }
+
+  // rejected changes
+  if (rejectedVas?.length) {
+    await _handleRejectedVas(tx, domain, user, releaseGood, rejectedVas)
+  }
+}
+
+async function _handleApprovedVas(tx, domain, user, releaseGood, approvedVas) {
+  for(const ov of approvedVas) {
+    const orderVas: OrderVas = await tx.getRepository(OrderVas).findOne({
+      where: { domain, id: ov.id },
+      relations: ['product', 'productDetail', 'newProduct', 'newProductDetail', 'releaseGood', 'orderVasItems']
+    })
+
+    switch (ov.editType) {
+      case ORDER_VAS_STATUS.NEW:
+        await tx.getRepository(OrderVas).update(
+        { id: ov.id},
+        {
+          editType: undefined,
+          status: await _getNewStatus(releaseGood),
+          updater: user,
+          updatedAt: new Date(),
+        })
+        
+        for (const ovi of ov.orderVasItemsPatch) {
+          if (ovi.itemEditType === ORDER_VAS_STATUS.NEW) {
+            await tx.getRepository(OrderVasItem).update(
+            { id: ovi.id },
+            {
+              itemEditType: undefined,
+              updater: user,
+              updatedAt: new Date()
+            })
+          }
+        }
+        break;
+        
+      case ORDER_VAS_STATUS.CHANGES:
+        await tx.getRepository(OrderVas).update(
+        { id: ov.id },
+        {
+          batchId: orderVas.adjustedBatchId ? orderVas.adjustedBatchId : orderVas.batchId,
+          product: orderVas.adjustedProduct ? orderVas.adjustedProduct : orderVas.product,
+          productDetail: orderVas.adjustedProductDetail ? orderVas.adjustedProductDetail : orderVas.productDetail,
+          uom: orderVas.adjustedUom ? orderVas.adjustedUom  : orderVas.uom,
+          uomValue: orderVas.adjustedNewUom ? orderVas.adjustedUomValue : orderVas.uomValue,
+          packingType: orderVas.adjustedPackingType ? orderVas.adjustedPackingType : orderVas.packingType,
+          qty: orderVas.adjustedQty ? orderVas.adjustedQty : orderVas.qty,
+          outputQty: orderVas.adjustedOutputQty ? orderVas.adjustedOutputQty : orderVas.outputQty,
+          newProduct: orderVas.adjustedNewProduct ?  orderVas.adjustedNewProduct : orderVas.newProduct,
+          newProductDetail: orderVas.adjustedNewProductDetail ? orderVas.adjustedNewProductDetail : orderVas.newProductDetail,
+          newBatchId: orderVas.adjustedNewBatchId ? orderVas.adjustedNewBatchId : orderVas.newBatchId,
+          newPackingType: orderVas.adjustedNewPackingType ? orderVas.adjustedNewPackingType : orderVas.newPackingType,
+          newUom: orderVas.adjustedNewUom ? orderVas.adjustedNewUom : orderVas.newUom,
+          newUomValue: orderVas.adjustedNewUomValue ? orderVas.adjustedNewUomValue : orderVas.newUomValue,
+          editType: undefined,
+          status: await _getNewStatus(releaseGood),
+          updater: user,
+          updatedAt: new Date(),
+        })
+
+        for (const ovi of ov.orderVasItemsPatch) {
+          const orderVasItem: OrderVasItem = await tx.getRepository(OrderVasItem).findOne({
+            where: { id: ovi.id }
+          })
+
+          switch (ovi.itemEditType) {
+            case ORDER_VAS_STATUS.NEW:
+              await tx.getRepository(OrderVasItem).update(
+              { id: ovi.id },
+              {
+                itemEditType: undefined,
+                updater: user,
+                updatedAt: new Date()
+              })
+              break;
+            
+            case ORDER_VAS_STATUS.CHANGES:
+              await tx.getRepository(OrderVasItem).update(
+              { id: ovi.id },
+              {
+                orderVas: {id: orderVas.id},
+                vasRemark: orderVasItem.adjustedVasRemark ? orderVasItem.adjustedVasRemark : orderVasItem.vasRemark,
+                vasQty: orderVasItem.adjustedVasQty ? orderVasItem.adjustedVasQty : orderVasItem.vasQty,
+                itemEditType: undefined,
+                updater: user,
+                updatedAt: new Date()
+              })
+              break;
+
+            case ORDER_VAS_STATUS.REMOVED:
+              await tx.getRepository(OrderVasItem).delete(ovi.id)
+          }
+        }
+        break;
+
+      case ORDER_VAS_STATUS.REMOVED:
+        await tx.getRepository(OrderVasItem).delete({ orderVas: { id: ov.id } })
+        await tx.getRepository(OrderVas).delete(ov.id)
+    }
+  }
+  return true
+}
+
+async function _handleRejectedVas(tx, domain, user, releaseGood, rejectedVas) {
+  for (const ov of rejectedVas) {
+    const orderVas: OrderVas = await tx.getRepository(OrderVas).findOne({
+      where: { domain, id: ov.id },
+      relations: ['product', 'productDetail', 'newProduct', 'newProductDetail', 'releaseGood', 'orderVasItems']
+    })
+
+    switch (ov.editType) {
+    case ORDER_VAS_STATUS.NEW:
+      await tx.getRepository(OrderVasItem).delete({ orderVas: { id: ov.id } })
+      await tx.getRepository(OrderVas).delete(ov.id)
+      break;
+
+    case ORDER_VAS_STATUS.CHANGES:
+      await tx.getRepository(OrderVas).update(
+      { id: ov.id },
+      {
+        adjustedProduct: undefined,
+        adjustedProductDetail: undefined,
+        adjustedBatchId: undefined,
+        adjustedQty: undefined,
+        adjustedOutputQty: undefined,
+        adjustedPackingType: undefined,
+        adjustedUom: undefined,
+        adjustedUomValue: undefined,
+        adjustedNewProduct: undefined,
+        adjustedNewProductDetail: undefined,
+        adjustedNewBatchId: undefined,
+        adjustedNewPackingType: undefined,
+        adjustedNewUom: undefined,
+        adjustedNewUomValue: undefined,
+        editType: undefined,
+        status: await _getNewStatus(releaseGood),
+        updater: user,
+        updatedAt: new Date(),
+      })
+
+      for (const ovi of ov.orderVasItemsPatch) {
+        switch (ovi.itemEditType) {
+          case ORDER_VAS_STATUS.NEW:
+            await tx.getRepository(OrderVasItem).delete(ovi.id)
+            break;
+          
+          case ORDER_VAS_STATUS.CHANGES:
+            await tx.getRepository(OrderVasItem).update(
+            { id: ovi.id },
+            {
+              orderVas: {id: orderVas.id},
+              adjustedVasRemark: undefined,
+              adjustedVasQty: undefined,
+              itemEditType: undefined,
+              updater: user,
+              updatedAt: new Date()
+            })
+            break;
+
+          case ORDER_VAS_STATUS.REMOVED:
+            await tx.getRepository(OrderVasItem).update(
+              { id: ovi.id },
+              {
+                itemEditType: undefined,
+                updater: user,
+                updatedAt: new Date()
+              })
+        }
+      }
+      break;
+
+    case ORDER_VAS_STATUS.REMOVED:
+      await tx.getRepository(OrderVas).update(
+      { id: orderVas.id },
+      {
+        status: await _getNewStatus(releaseGood),
+        editType: undefined,
+        updater: user,
+        updatedAt: new Date()
+      })
+
+      for (const ovi of ov.orderVasItemsPatch) {
+        await tx.getRepository(OrderVasItem).update(
+        { id: ovi.id },
+        {
+          orderVas: {id: orderVas.id},
+          itemEditType: undefined,
+          updater: user,
+          updatedAt: new Date()
+        })
+      }
+    }
+  }
+  return true
+}
+
+async function _getNewStatus(releaseGood) {
+  let orderVasStatus = ''
+  switch (releaseGood.status) {
+    case ORDER_STATUS.PENDING:
+      orderVasStatus = ORDER_VAS_STATUS.PENDING
+      break;
+    case ORDER_STATUS.PENDING_RECEIVE:
+      orderVasStatus = ORDER_VAS_STATUS.PENDING_RECEIVE
+      break;
+    case ORDER_STATUS.PENDING_WORKSHEET:
+    case ORDER_STATUS.READY_TO_PICK:
+    case ORDER_STATUS.PICKING:
+      orderVasStatus = ORDER_VAS_STATUS.READY_TO_PROCESS
+  }
+  return orderVasStatus
+}