feat: remove channel

Author: rtkay123

src/services/helper.service.ts

@@ -1,86 +1,30 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import apm from '../apm';
-import { CalculateDuration } from '@frmscoe/frms-coe-lib/lib/helpers/calculatePrcg';
+// import { CalculateDuration } from '@frmscoe/frms-coe-lib/lib/helpers/calculatePrcg';
 import { databaseManager, loggerService } from '..';
-import { type Channel, type Message, type NetworkMap, type Pacs002 } from '@frmscoe/frms-coe-lib/lib/interfaces';
-import { type ChannelResult } from '@frmscoe/frms-coe-lib/lib/interfaces/processor-files/ChannelResult';
+import { type NetworkMap, type Pacs002 } from '@frmscoe/frms-coe-lib/lib/interfaces';
 import { type TypologyResult } from '@frmscoe/frms-coe-lib/lib/interfaces/processor-files/TypologyResult';
 
-export const handleChannels = async (
-  message: Message,
-  transaction: Pacs002,
-  networkMap: NetworkMap,
-  channelResult: ChannelResult,
-): Promise<{ channelResults: ChannelResult[]; review: boolean }> => {
-  const span = apm.startSpan('handleChannels');
-  const functionName = 'handleChannels()';
-
-  try {
-    const transactionType = 'FIToFIPmtSts';
-    const transactionID = transaction[transactionType].GrpHdr.MsgId;
-    const cacheKey = `tadp_${transactionID}_${message.id}_${message.cfg}`;
-    const spanDBMembers = apm.startSpan('db.get.members');
-    const jchannelCount = await databaseManager.addOneGetCount(cacheKey, { channelResult: { ...channelResult } });
-
-    // check if all Channel results for this transaction is found
-    if (jchannelCount && jchannelCount < message.channels.length) {
-      span?.end();
-      loggerService.log('All channels not completed.', functionName, transactionID);
-      return { channelResults: [], review: false };
-    }
-    const jchannelResults = await databaseManager.getMemberValues(cacheKey);
-    spanDBMembers?.end();
-
-    const channelResults: ChannelResult[] = jchannelResults.map(
-      (jchannelResult: { channelResult: ChannelResult }) => jchannelResult.channelResult,
-    );
-
-    let review = false;
-    for (const configuredChannel of networkMap.messages[0].channels) {
-      if (configuredChannel) {
-        const channelRes = channelResults.find((c) => c.id === configuredChannel.id && c.cfg === configuredChannel.cfg);
-        if (!channelRes) continue;
-        for (const typology of configuredChannel.typologies) {
-          const typologyResult = channelRes?.typologyResult.find((t) => t.id === typology.id && t.cfg === typology.cfg);
-          if (!typologyResult) continue;
-          if (typologyResult.review) review = true;
-        }
-      }
-    }
-
-    // Delete interim cache as transaction processed to fulfilment
-    await databaseManager.deleteKey(cacheKey);
-
-    span?.end();
-    return { channelResults, review };
-  } catch (error) {
-    span?.end();
-    let innerError;
-    loggerService.error(error as string, innerError, functionName);
-    throw error;
-  }
-};
-
 export const handleTypologies = async (
   transaction: Pacs002,
-  channel: Channel,
   networkMap: NetworkMap,
   typologyResult: TypologyResult,
-): Promise<{ channelResults: ChannelResult[]; review: boolean }> => {
+): Promise<{ typologyResult: TypologyResult[]; review: boolean }> => {
   let span;
-  const startTime = process.hrtime.bigint();
+  //  const startTime = process.hrtime.bigint();
   const functionName = 'handleTypologies()';
   try {
+    const typologies = networkMap.messages[0].typologies.filter((t) => t.id === typologyResult.id && t.cfg === typologyResult.cfg);
     const transactionID = transaction.FIToFIPmtSts.GrpHdr.MsgId;
-    const cacheKey = `CADP_${transactionID}_${channel.id}_${channel.cfg}`;
+    const cacheKey = `TADP_${transactionID}_${typologyResult.id}_${typologyResult.cfg}`;
     const jtypologyCount = await databaseManager.addOneGetCount(cacheKey, { typologyResult: { ...typologyResult } });
 
     // check if all results for this Channel is found
-    if (jtypologyCount && jtypologyCount < channel.typologies.length) {
+    if (jtypologyCount && jtypologyCount < typologies.length) {
       return {
         review: false,
-        channelResults: [],
+        typologyResult: [],
       };
     }
 
@@ -92,47 +36,46 @@ export const handleTypologies = async (
     if (!typologyResults || !typologyResults.length)
       return {
         review: false,
-        channelResults: [],
+        typologyResult: [],
       };
 
-    const channelResult: ChannelResult = {
-      prcgTm: CalculateDuration(startTime),
-      result: 0.0,
-      cfg: channel.cfg,
-      id: channel.id,
-      typologyResult: typologyResults,
-    };
     const apmTadProc = apm.startSpan('tadProc.exec');
 
     const message = networkMap.messages.find((tran) => tran.txTp === transaction.TxTp);
 
     if (!message) {
       let innerError;
       loggerService.error(
-        `Failed to process Channel ${channel.id} request , Message missing from networkmap.`,
+        `Failed to process Typology ${typologyResult.id}@${typologyResult.cfg} request , Message missing from networkmap.`,
         innerError,
         functionName,
         transactionID,
       );
       return {
         review: false,
-        channelResults: [],
+        typologyResult: [],
       };
     }
 
-    const { channelResults, review } = await handleChannels(message, transaction, networkMap, channelResult);
+    let review = false;
+    for (const typology of networkMap.messages[0].typologies) {
+      const typologyResult = typologyResults.find((t) => t.id === typology.id && t.cfg === typology.cfg);
+      if (!typologyResult) continue;
+      if (typologyResult.review) review = true;
+    }
+
     apmTadProc?.end();
 
     span = apm.startSpan(`[${transactionID}] Delete Channel interim cache key`);
     await databaseManager.deleteKey(cacheKey);
     span?.end();
-    return { channelResults, review };
+    return { typologyResult: typologyResults, review };
   } catch (error) {
     span?.end();
-    loggerService.error(`Failed to process Channel ${channel.id} request`, error as Error, functionName);
+    loggerService.error(`Failed to process Typology ${typologyResult.id}@${typologyResult.cfg} request`, error as Error, functionName);
     return {
       review: false,
-      channelResults: [],
+      typologyResult: [],
     };
   }
 };

src/services/logic.service.ts

@@ -11,7 +11,7 @@ import { type TADPResult } from '@frmscoe/frms-coe-lib/lib/interfaces/processor-
 import { type TypologyResult } from '@frmscoe/frms-coe-lib/lib/interfaces/processor-files/TypologyResult';
 import { type MetaData } from '@frmscoe/frms-coe-lib/lib/interfaces/metaData';
 
-export const handleExecute = async (rawTransaction: any): Promise<any> => {
+export const handleExecute = async (rawTransaction: any): Promise<void> => {
   const functionName = 'handleExecute()';
   let apmTransaction = null;
   try {
@@ -35,30 +35,32 @@ export const handleExecute = async (rawTransaction: any): Promise<any> => {
     const toReturn: TADPResult = {
       id: '',
       cfg: '',
-      channelResult: [],
+      typologyResult: [],
       prcgTm: 0,
     };
 
-    // Messages is hardcoded at the moment since we only ever have 1. Should we move to include more messages, we will have to revist.
-    const channel = networkMap.messages[0].channels.filter((c) =>
-      c.typologies.some((t) => t.id === typologyResult.id && t.cfg === typologyResult.cfg),
-    )[0];
+    const typologies = networkMap.messages[0].typologies.filter((t) => t.id === typologyResult.id && t.cfg === typologyResult.cfg);
+    /* typologies.find()
 
-    loggerService.debug(`Processing Channel ${channel.id}.`, functionName, transactionID);
-    const { channelResults, review } = await handleTypologies(transaction, channel, networkMap, typologyResult);
+    const typologyResult = channelRes?.typologyResult.find((t) => t.id === typology.id && t.cfg === typology.cfg);
+    if (!typologyResult) continue;
+    if (typologyResult.review) review = true; */
 
-    if (channelResults.length > 0 && channelResults.length === networkMap.messages[0].channels.length) {
+    loggerService.debug(`Processing Typology ${typologyResult.id}.`, functionName, transactionID);
+    const { typologyResult: typologyResults, review } = await handleTypologies(transaction, networkMap, typologyResult);
+
+    if (typologyResults.length && typologyResults.length === networkMap.messages[0].typologies.length) {
       toReturn.id = networkMap.messages[0].id;
       toReturn.cfg = networkMap.messages[0].cfg;
-      toReturn.channelResult = channelResults;
+      toReturn.typologyResult = typologyResults;
       toReturn.prcgTm = CalculateDuration(startTime);
 
       const alert = new Alert();
       alert.tadpResult = toReturn;
       alert.status = review ? 'ALRT' : 'NALT';
       alert.metaData = metaData;
       const result: CMSRequest = {
-        message: `Successfully completed ${channelResults.length} channels`,
+        message: `Successfully completed ${typologies.length} typologies`,
         report: alert,
         transaction,
         networkMap,
@@ -71,7 +73,6 @@ export const handleExecute = async (rawTransaction: any): Promise<any> => {
       await server.handleResponse(result);
     }
     apmTransaction?.end();
-    return channelResults;
   } catch (e) {
     loggerService.error('Error while calculating Transaction score', e as Error, functionName);
   } finally {