tango-app-api-client 3.3.3-beta.9 → 3.4.0-beta.1

package/src/controllers/client.controllers.js

@@ -142,7 +142,23 @@ export async function create( req, res ) {
       'isDefaults': true,
     };
 
-    await createclusterModel( defaultcluster );
+    const cluster = await createclusterModel( defaultcluster );
+
+    const logClusterObj = {
+      clientId: insertedClientRecord.clientId,
+      userName: req.user?.userName,
+      userId: req?.user?._id,
+      email: req.user?.email,
+      clusterId: cluster._id,
+      date: new Date(),
+      logType: 'cluster',
+      logSubType: 'clusterCreated',
+      changes: [ 'All stores' ],
+      eventType: 'create',
+      showTo: [ 'client', 'tango' ],
+    };
+
+    await insertOpenSearchData( openSearch.activityLog, logClusterObj );
 
 
     const defaultGroup = {
@@ -284,6 +300,7 @@ export async function create( req, res ) {
     const logObj = {
       clientId: insertedClientRecord.clientId,
       userName: req.user?.userName,
+      userId: req?.user?._id,
       email: req.user?.email,
       date: new Date(),
       logType: 'brandDetails',
@@ -691,7 +708,7 @@ export async function updateBrandInfo( req, res ) {
         ContentType: req.files.logo.mimetype,
         body: req.files.logo.data,
       };
-      updateKeys.push( 'Logo' );
+      updateKeys.push( 'Brand Logo' );
       await fileUpload( uploadDataParams );
     }
 
@@ -701,32 +718,93 @@ export async function updateBrandInfo( req, res ) {
       } );
     }
 
-    const user = await getUserNameEmailById( req.userId );
+    // Get updated client information before the update operation (fetch selected fields only)
+    const getPreCientInfo = await findOneClient(
+        { clientId: req.params.id }, // Filter by clientId
+        {
+          '_id': 0,
+          'profileDetails.registeredCompanyName': 1,
+          'profileDetails.industry': 1,
+          'profileDetails.clientType': 1,
+          'profileDetails.registeredAddress': 1,
+          'profileDetails.headQuarters': 1,
+          'profileDetails.website': 1,
+          'status': 1,
+          'averageTransactionValue': 1,
+        },
+    );
+
 
+    const updateAck = await brandInfoUpdate( {
+      clientId: req.params?.id, registeredCompanyName: req.body?.registeredCompanyName, industry: req.body?.industry,
+      clientType: req.body?.clientType, registeredAddress: req.body?.registeredAddress, headQuarters: req.body?.headQuarters,
+      website: req.body?.website, status: req.body?.status, logo: req.files?.logo ? `brandLogo.${req.files.logo.name.split( '.' )[1]}` : undefined, averageTransactionValue: req.body?.averageTransactionValue,
+    } );
 
+    // Get updated client information after the update operation (fetch selected fields only)
+    const getPosCientInfo = await findOneClient(
+        { clientId: req.params.id }, // Filter by clientId
+        {
+          '_id': 0,
+          'profileDetails.registeredCompanyName': 1,
+          'profileDetails.industry': 1,
+          'profileDetails.clientType': 1,
+          'profileDetails.registeredAddress': 1,
+          'profileDetails.headQuarters': 1,
+          'profileDetails.website': 1,
+          'status': 1,
+          'averageTransactionValue': 1,
+        },
+    );
+    // Map and rename keys from previous client info for UI display and logging
+    const oldData = {
+      RegisteredCompanyName: getPreCientInfo?.profileDetails?.registeredCompanyName,
+      IndustryType: getPreCientInfo?.profileDetails?.industry,
+      FirmType: getPreCientInfo?.profileDetails?.clientType,
+      RegisteredAddress: getPreCientInfo?.profileDetails?.registeredAddress,
+      HeadQuarters: getPreCientInfo?.profileDetails?.headQuarters,
+      CompanyWebsite: getPreCientInfo?.profileDetails?.website,
+      ProcessingStatus: getPreCientInfo?.status,
+      AverageTransactionValue: getPreCientInfo?.averageTransactionValue,
+    };
+
+    // Map and rename keys from current client info for UI display and logging
+    const newData ={
+      RegisteredCompanyName: getPosCientInfo?.profileDetails?.registeredCompanyName,
+      IndustryType: getPosCientInfo?.profileDetails?.industry,
+      FirmType: getPosCientInfo?.profileDetails?.clientType,
+      RegisteredAddress: getPosCientInfo?.profileDetails?.registeredAddress,
+      HeadQuarters: getPosCientInfo?.profileDetails?.headQuarters,
+      CompanyWebsite: getPosCientInfo?.profileDetails?.website,
+      ProcessingStatus: getPosCientInfo?.status,
+      AverageTransactionValue: getPosCientInfo?.averageTransactionValue,
+
+    };
+
+    // Prepare activity log object with all relevant details for OpenSearch logging
     const logObj = {
-      clientId: req.params?.id,
-      userName: user?.userName,
-      email: user?.email,
-      date: new Date(),
-      logType: 'brandDetails',
-      logSubType: 'brandInfo',
-      changes: updateKeys,
-      eventType: 'update',
-      showTo: [ 'client', 'tango' ],
+      clientId: req.params?.id, // ID of the client whose data was updated
+      userName: req?.user?.userName, // Name of the user performing the update
+      email: req?.user?.email, // Email of the user performing the update
+      date: new Date(), // Timestamp of the update event
+      logType: 'brandDetails', // Type of log (e.g., related to brand details)
+      logSubType: 'brandInfo', // Subtype for more specific categorization
+      changes: updateKeys, // List of fields that were updated.these will shown in the UI as part of activity log
+      eventType: 'update', // Type of event (update operation)
+      showTo: [ 'client', 'tango' ], // Visibility of the log (who can see this log)
+      previous: getPreCientInfo, // Previous (old) client information before update based on DB keys (for internal reference and comparison).
+      current: getPosCientInfo, // Current (new) client information after update based on DB keys (for internal reference and comparison).
+      oldData: oldData, // Previous (old) client information before update (used for showing detailed changes in the UI).
+      newData: newData, // Current (new) client information after update (used for showing detailed changes in the UI).
     };
+    logger.info( { logObj: logObj, updateKeys: updateKeys, length: updateKeys?.length } );
 
+    // Insert activity log into OpenSearch if there are fields that were updated
     if ( updateKeys.length ) {
-      await insertOpenSearchData( openSearch.activityLog, logObj );
+      await insertOpenSearchData( openSearch.activityLog, logObj ); // Insert activity log
     }
 
 
-    const updateAck = await brandInfoUpdate( {
-      clientId: req.params?.id, registeredCompanyName: req.body?.registeredCompanyName, industry: req.body?.industry,
-      clientType: req.body?.clientType, registeredAddress: req.body?.registeredAddress, headQuarters: req.body?.headQuarters,
-      website: req.body?.website, status: req.body?.status, logo: req.files?.logo ? `brandLogo.${req.files.logo.name.split( '.' )[1]}` : undefined, averageTransactionValue: req.body?.averageTransactionValue,
-    } );
-
     if ( req.body?.status === 'active' ) {
       await updateManyStore( { clientId: req.params?.id }, { status: 'active' } );
       await updateManyUser( { clientId: req.params?.id }, { isActive: true } );
@@ -743,7 +821,6 @@ export async function updateBrandInfo( req, res ) {
 
     if ( req.body?.status === 'deactive' ) {
       await updateManyStore( { clientId: req.params?.id }, { status: 'deactive' } );
-      // await updateManyCamera( { clientId: req.params?.id }, { isUp: false, isActivated: false } );
       await updateManyUser( { clientId: req.params?.id }, { isActive: false } );
     }
 
@@ -769,7 +846,7 @@ export async function updateBrandInfo( req, res ) {
     await postApi( `${url.oldapidomain}/oldBrandUpdate/${data?._id}`, { clientStatus: data.clientStatus } );
 
     if ( updateAck ) {
-      res.sendSuccess( { result: 'Updated Successfully' } );
+      return res.sendSuccess( { result: 'Updated Successfully' } );
     }
   } catch ( error ) {
     logger.error( { error: error, message: req.params, function: 'updateBrandInfo' } );
@@ -878,7 +955,25 @@ export async function updateSignatoryDetails( req, res ) {
 export async function updateTicketConfiguration( req, res ) {
   try {
     const openSearch = JSON.parse( process.env.OPENSEARCH );
-    let  findClient =  await findOneClient({clientId:req.params?.id})
+    const fields ={
+      'ticketConfigs.downTimeType': 1,
+      'ticketConfigs.installationReAssign': 1,
+      'ticketConfigs.infraDownTime': 1,
+      'ticketConfigs.MinFilesCount': 1,
+      'ticketConfigs.rcaTicketAssign': 1,
+      'ticketConfigs.refreshAlert': 1,
+      'ticketConfigs.statusCheckAlert': 1,
+      'ticketConfigs.accuracyPercentage': 1,
+      'ticketConfigs.reTrain': 1,
+    };
+
+    // Get updated client ticket configuration before the update operation (fetch selected fields only)
+    let findClient = await findOneClient(
+        { clientId: req.params?.id }, // Filter by clientId
+        fields,
+    );
+
+    // update the requested values in Mongo DB
     const updateAck = await ticketConfigurationUpdate( {
       clientId: req.params?.id, MinFilesCount: req.body?.MinFilesCount, accuracyPercentage: req.body?.accuracyPercentage, downTimeType: req.body?.downTimeType,
       infraDownTime: req.body?.infraDownTime, installationReAssign: req.body?.installationReAssign, isRcaTicketAssign: req.body?.isRcaTicketAssign,
@@ -886,40 +981,75 @@ export async function updateTicketConfiguration( req, res ) {
       refreshAlert: req.body?.refreshAlert, sendToAdmin: req.body?.sendToAdmin, sendToUser: req.body?.sendToUser, statusCheckAlert: req.body?.statusCheckAlert,
     } );
 
-    let updateKeys = [];
+    let updateKeys = []; // List of updated field names in readable format
+
+    // Check if request body has any fields to update
     if ( Object.keys( req.body ).length > 0 ) {
       Object.keys( req.body ).forEach( ( element ) => {
-        updateKeys.push( camelCaseToWords( element ) );
+        updateKeys.push( camelCaseToWords( element ) ); // Convert camelCase field name to readable format and add to updateKeys
       } );
     }
 
-    const user = await getUserNameEmailById( req.userId );
-    let  updatedClient =  await findOneClient({clientId:req.params?.id})
 
+    // Get updated client ticket configuration after the update operation (fetch selected fields only)
+    let updatedClient = await findOneClient( { clientId: req.params?.id }, fields );
+
+    // Map and rename keys from previous client info for UI display and logging
+    const oldData = {
+      InfraDowntimeType: findClient?.ticketConfigs?.downTimeType,
+      AutoReAssignInstallation: findClient?.ticketConfigs?.installationReAssign,
+      InfraDowntime: findClient?.ticketConfigs?.infraDownTime,
+      InfraFiles: findClient?.ticketConfigs?.MinFilesCount,
+      RcaTicket: findClient?.ticketConfigs?.rcaTicketAssign,
+      RefreshTicketAlert: findClient?.ticketConfigs?.refreshAlert,
+      StatusCheckAlert: findClient?.ticketConfigs?.statusCheckAlert,
+      DataMismatchAccuracyPercentage: findClient?.ticketConfigs?.accuracyPercentage,
+      DataMismatchReTraining: findClient?.ticketConfigs?.reTrain,
+    };
+
+    // Map and rename keys from current client info for UI display and logging
+    const newData ={
+      InfraDowntimeType: updatedClient?.ticketConfigs?.downTimeType,
+      AutoReAssignInstallation: updatedClient?.ticketConfigs?.installationReAssign,
+      InfraDowntime: updatedClient?.ticketConfigs?.infraDownTime,
+      InfraFiles: updatedClient?.ticketConfigs?.MinFilesCount,
+      RcaTicket: updatedClient?.ticketConfigs?.rcaTicketAssign,
+      RefreshTicketAlert: updatedClient?.ticketConfigs?.refreshAlert,
+      StatusCheckAlert: updatedClient?.ticketConfigs?.statusCheckAlert,
+      DataMismatchAccuracyPercentage: updatedClient?.ticketConfigs?.accuracyPercentage,
+      DataMismatchReTraining: updatedClient?.ticketConfigs?.reTrain,
+
+    };
+
+    // Prepare activity log object with all relevant details for OpenSearch logging
     const logObj = {
-      clientId: req.params?.id,
-      userName: user.userName,
-      email: user.email,
-      date: new Date(),
-      logType: 'configuration',
-      logSubType: 'ticketConfig',
-      changes: updateKeys,
-      eventType: 'update',
-      showTo: [ 'tango' ],
-      current:updatedClient.ticketConfigs,
-      previous:findClient.ticketConfigs
+      clientId: req.params?.id, // ID of the client whose data was updated
+      userName: req?.user?.userName, // Name of the user performing the update
+      email: req?.user?.email, // Email of the user performing the update
+      date: new Date(), // Timestamp of the update event
+      logType: 'configuration', // Type of log (e.g., related to brand details)
+      logSubType: 'ticketConfig', // Subtype for more specific categorization
+      changes: updateKeys, // List of fields that were updated.these will shown in the UI as part of activity log
+      eventType: 'update', // Type of event (update operation)
+      showTo: [ 'tango' ], // Visibility of the log (who can see this log)
+      current: updatedClient.ticketConfigs, // Previous (old) client information before update based on DB keys (for internal reference and comparison).
+      previous: findClient.ticketConfigs, // Current (new) client information after update based on DB keys (for internal reference and comparison).
+      oldData: oldData, // Previous (old) client information before update (used for showing detailed changes in the UI).
+      newData: newData, // Current (new) client information after update (used for showing detailed changes in the UI).
     };
 
+    // Insert activity log into OpenSearch if there are fields that were updated
     if ( updateKeys.length ) {
-      await insertOpenSearchData( openSearch.activityLog, logObj );
+      await insertOpenSearchData( openSearch.activityLog, logObj ); // Insert activity log
     }
 
     if ( updateAck ) {
       res.sendSuccess( { result: 'Updated Successfully' } );
     }
   } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
     logger.error( { error: error, message: req.params, function: 'updateTicketConfiguration' } );
-    return res.sendError( 'Internal Server Error', 500 );
+    return res.sendError( err, 500 );
   }
 }
 
@@ -927,6 +1057,9 @@ export async function updateFeatureConfiguration( req, res ) {
   try {
     const openSearch = JSON.parse( process.env.OPENSEARCH );
     const url = JSON.parse( process.env.URL );
+
+    // Get updated client Feature configuration before the update operation (fetch selected fields only)
+    const previousData = await findOneClient( { clientId: req.params?.id }, { featureConfigs: 1 } );
     const inputData = req.body;
     if ( inputData?.bouncedLimitValue ) {
       inputData.missedOpportunityFromValue = inputData?.bouncedLimitValue;
@@ -937,11 +1070,15 @@ export async function updateFeatureConfiguration( req, res ) {
     }
     const updateAck = await featureConfigurationUpdate( { clientId: req.params?.id }, inputData );
 
-    let updateKeys = [];
+    // Get updated client Feature configuration after the update operation (fetch selected fields only)
+    const postData = await findOneClient( { clientId: req.params?.id }, { featureConfigs: 1 } );
+    let updateKeys = []; // List of updated field names in readable format
 
+    // Check if request body has any fields to update
     if ( Object.keys( inputData ).length > 0 ) {
       Object.keys( inputData ).forEach( ( element ) => {
-        updateKeys.push( camelCaseToWords( element ) );
+        element === 'billableCalculation'? 'potentialCalculation': element; // Replace 'billableCalculation' with 'potentialCalculation' if present
+        updateKeys.push( camelCaseToWords( element ) ); // Convert camelCase field name to readable format and add to updateKeys
       } );
     }
 
@@ -990,21 +1127,105 @@ export async function updateFeatureConfiguration( req, res ) {
     }
 
     await postApi( `${url.oldapidomain}/oldBrandUpdate/${data?._id}`, { brandConfigs: data.brandConfigs } );
+    const keysArray = [
+      'isExcludedArea', 'isPasserByData', 'isNormalized', 'isbillingDisabled',
+      'isCameraDisabled', 'isFootfallDirectory', 'isNOB', 'isNewTraffic',
+      'isTrax', 'isNewZone', 'isNewReports', 'isNewDashboard', 'streamBy',
+    ];
+    // Map and rename keys from previous client info for UI display and logging
+    const oldData = {
+      StoreOpenTime: previousData?.featureConfigs?.open,
+      StoreCloseTime: previousData?.featureConfigs?.close,
+      ConversionCalculations: previousData?.featureConfigs?.conversionCalculation,
+      MissedOpportunityCalculation: previousData?.featureConfigs?.missedOpportunityCalculation,
+      PotentialCalculations: previousData?.featureConfigs?.billableCalculation,
+      ConversionCondition: previousData?.featureConfigs?.conversion.condition,
+      ConversionValue: previousData?.featureConfigs?.conversion.value,
+      MissedOpportunityFromCondition: previousData?.featureConfigs?.missedOpportunityFrom?.condition,
+      MissedOpportunityToCondition: previousData?.featureConfigs?.missedOpportunityTo?.condition,
+      MissedOpportunityFromValue: previousData?.featureConfigs?.missedOpportunityFrom?.value,
+      MissedOpportunityToValue: previousData?.featureConfigs?.missedOpportunityTo?.value,
+      BouncedLimitCondition: previousData?.featureConfigs?.bouncedLimit?.condition,
+      BouncedLimitValue: previousData?.featureConfigs?.bouncedLimit?.value,
+      InfraAlertValue: previousData?.featureConfigs?.infraAlert?.value,
+      InfraAlertCondition: previousData?.featureConfigs?.infraAlert?.condition,
+      ConversionCalculations: previousData?.featureConfigs?.conversionCalculation,
+      ExcludedArea: previousData?.featureConfigs?.isExcludedArea ==true ? 'Enable': 'Disable',
+      PasserBydata: previousData?.featureConfigs?.isPasserByData ==true ? 'Enable': 'Disable',
+      NormalizedDataDuringDowntime: previousData?.featureConfigs?.isNormalized ==true ? 'Enable': 'Disable',
+      Billing: previousData?.featureConfigs?.isbillingDisabled ==true ? 'Enable': 'Disable',
+      CameraBlurring: previousData?.featureConfigs?.isCameraDisabled ==true ? 'Enable': 'Disable',
+      FootfallDirectory: previousData?.featureConfigs?.isFootfallDirectory ==true ? 'Enable': 'Disable',
+      NOBStatus: previousData?.featureConfigs?.isNOB ==true ? 'Enable': 'Disable',
+      EnableAnalyze: previousData?.featureConfigs?.isNewDashboard ==true ? 'Enable': 'Disable',
+      Traffic: previousData?.featureConfigs?.isNewTraffic==true ? 'Enable': 'Disable',
+      Zone: previousData?.featureConfigs?.isNewZone ==true ? 'Enable': 'Disable',
+      Zonev2: previousData?.featureConfigs?.isNewZoneV2 ==true ? 'Enable': 'Disable',
+      Reports: previousData?.featureConfigs?.isNewReports ==true ? 'Enable': 'Disable',
+      Trax: previousData?.featureConfigs?.isTrax ==true ? 'Enable': 'Disable',
+      StreamType: previousData?.featureConfigs?.streamBy =='Edge' ? 'Edge App': 'RTSP',
+      FootfallDirectoryOnlyAudit: previousData?.featureConfigs?.isFootfallDirectoryAudit ==true ? 'Enable': 'Disable',
+      FootfallDirectoryOnlyFew: previousData?.featureConfigs?.isFootfallDirectoryLimit ==true ? 'Enable': 'Disable',
+
+    };
 
+    // Map and rename keys from current client info for UI display and logging
+    const newData ={
+      StoreOpenTime: postData?.featureConfigs?.open,
+      StoreCloseTime: postData?.featureConfigs?.close,
+      ConversionCalculations: postData?.featureConfigs?.conversionCalculation,
+      MissedOpportunityCalculation: postData?.featureConfigs?.missedOpportunityCalculation,
+      PotentialCalculations: postData?.featureConfigs?.billableCalculation,
+      ConversionCondition: postData?.featureConfigs?.conversion.condition,
+      ConversionValue: postData?.featureConfigs?.conversion.value,
+      MissedOpportunityFromCondition: postData?.featureConfigs?.missedOpportunityFrom?.condition,
+      MissedOpportunityToCondition: postData?.featureConfigs?.missedOpportunityTo?.condition,
+      MissedOpportunityFromValue: postData?.featureConfigs?.missedOpportunityFrom?.value,
+      MissedOpportunityToValue: postData?.featureConfigs?.missedOpportunityTo?.value,
+      BouncedLimitCondition: postData?.featureConfigs?.bouncedLimit?.condition,
+      BouncedLimitValue: postData?.featureConfigs?.bouncedLimit?.value,
+      InfraAlertValue: postData?.featureConfigs?.infraAlert?.value,
+      InfraAlertCondition: postData?.featureConfigs?.infraAlert?.condition,
+      ConversionCalculations: postData?.featureConfigs?.conversionCalculation,
+      ExcludedArea: postData?.featureConfigs?.isExcludedArea ==true ? 'Enable': 'Disable',
+      PasserBydata: postData?.featureConfigs?.isPasserByData ==true ? 'Enable': 'Disable',
+      NormalizedDataDuringDowntime: postData?.featureConfigs?.isNormalized ==true ? 'Enable': 'Disable',
+      Billing: postData?.featureConfigs?.isbillingDisabled ==true ? 'Enable': 'Disable',
+      CameraBlurring: postData?.featureConfigs?.isCameraDisabled ==true ? 'Enable': 'Disable',
+      FootfallDirectory: postData?.featureConfigs?.isFootfallDirectory ==true ? 'Enable': 'Disable',
+      NOBStatus: postData?.featureConfigs?.isNOB ==true ? 'Enable': 'Disable',
+      EnableAnalyze: postData?.featureConfigs?.isNewDashboard ==true ? 'Enable': 'Disable',
+      Traffic: postData?.featureConfigs?.isNewTraffic==true ? 'Enable': 'Disable',
+      Zone: postData?.featureConfigs?.isNewZone ==true ? 'Enable': 'Disable',
+      Zonev2: postData?.featureConfigs?.isNewZoneV2 ==true ? 'Enable': 'Disable',
+      Reports: postData?.featureConfigs?.isNewReports ==true ? 'Enable': 'Disable',
+      Trax: postData?.featureConfigs?.isTrax ==true ? 'Enable': 'Disable',
+      StreamType: postData?.featureConfigs?.streamBy =='Edge' ? 'Edge App': 'RTSP',
+      FootfallDirectoryOnlyAudit: postData?.featureConfigs?.isFootfallDirectoryAudit ==true ? 'Enable': 'Disable',
+      FootfallDirectoryOnlyFew: postData?.featureConfigs?.isFootfallDirectoryLimit ==true ? 'Enable': 'Disable',
 
+    };
+
+    // Prepare activity log object with all relevant details for OpenSearch logging
     const logObj = {
-      clientId: req.params?.id,
-      userName: user?.userName,
-      email: user?.email,
-      date: new Date(),
-      logType: 'configuration',
-      logSubType: 'featureConfig',
-      changes: updateKeys,
-      eventType: 'update',
-      showTo: [ 'client', 'tango' ],
+      clientId: req.params?.id, // ID of the client whose data was updated
+      userName: user?.userName, // Name of the user performing the update
+      email: user?.email, // Email of the user performing the update
+      date: new Date(), // Timestamp of the update event
+      logType: 'configuration', // Type of log (e.g., related to brand details)
+      logSubType: Object.keys( inputData ).some( ( key ) => keysArray.includes( key ) ) ? 'dashboardConfig' : 'featureConfig', // Subtype for more specific categorization
+      changes: updateKeys, // List of fields that were updated.these will shown in the UI as part of activity log
+      eventType: 'update', // Type of event (update operation)
+      showTo: [ 'client', 'tango' ], // Visibility of the log (who can see this log)
+      previous: previousData.featureConfigs, // Previous (old) client information before update based on DB keys (for internal reference and comparison).
+      current: postData.featureConfigs, // Current (new) client information after update based on DB keys (for internal reference and comparison).
+      oldData: oldData, // Previous (old) client information before update (used for showing detailed changes in the UI).
+      newData: newData, // Current (new) client information after update (used for showing detailed changes in the UI).
     };
+
+    // Insert activity log into OpenSearch if there are fields that were updated
     if ( updateKeys.length ) {
-      await insertOpenSearchData( openSearch.activityLog, logObj );
+      await insertOpenSearchData( openSearch.activityLog, logObj ); // Insert activity log
     }
 
     if ( updateAck ) {
@@ -1020,6 +1241,18 @@ export async function updateFeatureConfiguration( req, res ) {
 export async function domainDetailsConfiguration( req, res ) {
   try {
     const openSearch = JSON.parse( process.env.OPENSEARCH );
+
+    // Get updated client domain configuration before the update operation (fetch selected fields only)
+    const getPreData = await findOneClient(
+        { clientId: req.params?.id }, // filter by clientId
+        {
+          domainName: '$domainConfig.ssoLogin.domainName',
+          isEnable: '$domainConfig.ssoLogin.isEnable',
+          ipWhitelist: '$domainConfig.ipWhitelisting.enableWhitelisting',
+          WhitelistedIps: '$domainConfig.ipWhitelisting.allowedIps',
+          TwoFactorAuthentication: '$domainConfig.enableOtp',
+        },
+    );
     const updateAck = await domainDetailsConfigurationUpdate( {
       clientId: req.params?.id, domainName: req.body?.domainName, isEnable: req.body?.isEnable,
       enableWhitelisting: req.body?.enableWhitelisting, allowedIps: req.body?.allowedIps, enableOtp: req.body?.enableOtp,
@@ -1027,30 +1260,66 @@ export async function domainDetailsConfiguration( req, res ) {
 
     let updateKeys = [];
 
-
+    // Check if request body has any fields to update
     if ( Object.keys( req.body ).length > 0 ) {
       Object.keys( req.body ).forEach( ( element ) => {
         updateKeys.push( camelCaseToWords( element ) );
       } );
     }
 
-    const user = await getUserNameEmailById( req.userId );
+    // Get updated client domain configuration after the update operation (fetch selected fields only)
+    const getPostData = await findOneClient(
+        { clientId: req.params?.id }, // Filter by clientId
+        {
+          domainName: '$domainConfig.ssoLogin.domainName',
+          isEnable: '$domainConfig.ssoLogin.isEnable',
+          ipWhitelist: '$domainConfig.ipWhitelisting.enableWhitelisting',
+          WhitelistedIps: '$domainConfig.ipWhitelisting.allowedIps',
+          TwoFactorAuthentication: '$domainConfig.enableOtp',
+        },
+    );
+
 
+    // Map and rename keys from previous client info for UI display and logging
+    const oldData = {
+      DomainName: getPreData?.domainConfig?.ssoLogin?.domainName,
+      IsEnable: getPreData?.domainConfig?.ssoLogin?.isEnable ==true ? 'Enable': 'Disable',
+      IPWhitelist: getPreData?.domainConfig?.ipWhitelisting?.enableWhitelisting ==true ? 'Enable': 'Disable',
+      WhitelistedIps: ( getPreData?.domainConfig?.ipWhitelisting?.allowedIps ).join( ', ' ),
+      TwoFactorAuthentication: getPreData?.domainConfig?.enableOtp ==true ? 'Enable': 'Disable',
+
+    };
 
+    // Map and rename keys from current client info for UI display and logging
+    const newData ={
+      DomainName: getPostData?.domainConfig?.ssoLogin?.domainName,
+      IsEnable: getPostData?.domainConfig?.ssoLogin?.isEnable ==true ? 'Enable': 'Disable',
+      IPWhitelist: getPostData?.domainConfig?.ipWhitelisting?.enableWhitelisting ==true ? 'Enable': 'Disable',
+      WhitelistedIps: ( getPostData?.domainConfig?.ipWhitelisting?.allowedIps ).join( ', ' ),
+      TwoFactorAuthentication: getPostData?.domainConfig?.enableOtp ==true ? 'Enable': 'Disable',
+    };
+
+
+    // Prepare activity log object with all relevant details for OpenSearch logging
     const logObj = {
-      clientId: req.params?.id,
-      userName: user?.userName,
-      email: user?.email,
-      date: new Date(),
-      logType: 'configuration',
-      logSubType: 'domainDetails',
-      changes: updateKeys,
-      eventType: 'update',
-      showTo: [ 'client', 'tango' ],
+      clientId: req.params?.id, // ID of the client whose data was updated
+      userName: req?.user?.userName, // Name of the user performing the update
+      email: req?.user?.email, // Email of the user performing the update
+      date: new Date(), // Timestamp of the update event
+      logType: 'configuration', // Type of log (e.g., related to brand details)
+      logSubType: 'domainDetails', // Subtype for more specific categorization
+      changes: updateKeys, // List of fields that were updated.these will shown in the UI as part of activity log
+      eventType: 'update', // Type of event (update operation)
+      showTo: [ 'client', 'tango' ], // Visibility of the log (who can see this log)
+      previous: getPreData, // Previous (old) client information before update based on DB keys (for internal reference and comparison).
+      current: getPostData, // Current (new) client information after update based on DB keys (for internal reference and comparison).
+      oldData: oldData, // Previous (old) client information before update (used for showing detailed changes in the UI).
+      newData: newData, // Current (new) client information after update (used for showing detailed changes in the UI).
     };
 
+    // Insert activity log into OpenSearch if there are fields that were updated
     if ( updateKeys.length ) {
-      await insertOpenSearchData( openSearch.activityLog, logObj );
+      await insertOpenSearchData( openSearch.activityLog, logObj ); // Insert activity log
     }
 
     if ( updateAck ) {
@@ -1152,7 +1421,6 @@ export async function updateDocuments( req, res ) {
 
     const user = await getUserNameEmailById( req.userId );
 
-
     const logObj = {
       clientId: req.params?.id,
       userName: user?.userName,
@@ -1214,14 +1482,29 @@ export async function auditConfiguration( req, res ) {
       auditConfigs: 1, _id: 0,
     };
     const previousClient = await findOneClient( query, fields );
+    previousClient.auditConfigs.ratio = previousClient?.auditConfigs?.ratio? ( previousClient.auditConfigs.ratio )*100 : null;
     const record = {
       'auditConfigs.count': inputData.count,
       'auditConfigs.audit': inputData.audit,
       'auditConfigs.ratio': Number( normalizeNumber( inputData.ratio, 0, 100 ) ),
     };
-    logger.info( { record: record, query: query } );
-    const a = await updateOneClient( query, record );
-    logger.info( { a: a } );
+    await updateOneClient( query, record );
+
+
+    // Map and rename keys from previous client info for UI display and logging
+    const oldData = {
+      AuditStatus: inputData?.audit ==true ? 'Enable': 'Disable',
+      MappingPercentage: inputData?.ratio,
+      AuditCount: inputData?.count,
+
+    };
+
+    // Map and rename keys from current client info for UI display and logging
+    const newData ={
+      AuditStatus: previousClient.auditConfigs?.audit ==true ? 'Enable': 'Disable',
+      MappingPercentage: previousClient.auditConfigs?.ratio,
+      AuditCount: previousClient.auditConfigs?.count,
+    };
     const logObj = {
       clientId: req.params?.id,
       userName: req.user?.userName,
@@ -1232,13 +1515,15 @@ export async function auditConfiguration( req, res ) {
       eventType: 'update',
       showTo: [ 'tango' ],
       changes: [ `Audit config for client id ${req.params?.id}` ],
-      previous: previousClient,
+      previous: previousClient.auditConfigs,
       current: {
         clientId: req.params?.id,
         count: inputData.count,
         audit: inputData.audit,
-        ratio: normalizeNumber( inputData.ratio, 0, 100 ),
+        ratio: inputData.ratio,
       },
+      oldData: oldData,
+      newData: newData,
     };
 
     await insertOpenSearchData( openSearch.activityLog, logObj );
@@ -1281,17 +1566,6 @@ export async function clientList( req, res ) {
           $match: {
             userEmail: { $eq: req?.user?.email },
             userType: 'tango',
-            // $expr: {
-            //   $cond: {
-            //     if: {
-            //       $and: [
-            //         { $eq: [ '$tangoUserType', 'csm' ] },
-            //       ],
-            //     },
-            //     then: { $eq: [ '$isClientApproved', true ] },
-            //     else: true,
-            //   },
-            // },
 
           },
         }, {
@@ -1607,17 +1881,6 @@ export async function clientListV1( req, res ) {
           $match: {
             userEmail: { $eq: req?.user?.email },
             userType: 'tango',
-            // $expr: {
-            //   $cond: {
-            //     if: {
-            //       $and: [
-            //         { $eq: [ '$tangoUserType', 'csm' ] },
-            //       ],
-            //     },
-            //     then: { $eq: [ '$isClientApproved', true ] },
-            //     else: true,
-            //   },
-            // },
 
           },
         },
@@ -2013,9 +2276,37 @@ export async function detailedClientCount( req, res ) {
   }
 }
 
-export async function getActivityLogs( req, res ) {
+export async function getActivityLogs1( req, res ) {
   try {
+    const inputData = req.body;
     const openSearch = JSON.parse( process.env.OPENSEARCH );
+    const clientQuery =[
+      {
+        $match: {
+          $and: [
+            {
+              clientId: { $in: inputData },
+            },
+          ],
+        },
+      },
+      {
+        $group: {
+          _id: null,
+          clientName: { $push: '$clientName' },
+        },
+      },
+      {
+        $project: {
+          _id: 0,
+          clientName: 1,
+        },
+      },
+    ];
+    const getClientName = await aggregateClient( clientQuery );
+    if ( getClientName?.length == 0 || getClientName[0]?.clientName?.length ===0 ) {
+      return res.sendError( 'No Data Found', 204 );
+    }
     const query = {
       '_source': [
         'userId', 'userName', 'email', 'date', 'logType', 'logSubType',
@@ -2023,13 +2314,27 @@ export async function getActivityLogs( req, res ) {
       ],
       'query': {
         'bool': {
-          'must': [
+          // 'must': [
+          //   {
+          //     'terms': {
+          //       'clientId.keyword': [ req.body.clientId ],
+          //     },
+          //   },
+          // ],
+
+          'should': [
+            {
+              'terms': {
+                'clientId.keyword': [ inputData.clientId ],
+              },
+            },
             {
               'terms': {
-                'clientId.keyword': [ req.body.clientId ],
+                'clientName.keyword': [ getClientName[0].clientName ], // Add clientName condition
               },
             },
           ],
+          'minimum_should_match': 1, // Ensures at least one condition must match
         },
       },
       'from': ( req.body.offset - 1 ) * req.body.limit,
@@ -2076,30 +2381,22 @@ export async function getActivityLogs( req, res ) {
 
     const hits = logs?.body?.hits?.hits;
     const totalDocuments = logs?.body?.hits?.total?.value;
+
     let temp = [];
     if ( totalDocuments ) {
       hits.map( ( hit, i ) => {
-        temp.push( hit?._source );
+        let respo ={};
+        hit._source.logSubType = hit._source.logSubType === 'documentUpload'? 'documentsUpload': hit._source.logSubType === 'domainDetails'? 'securityFeatures': hit?._source?.logSubType;
         if ( ( ( hit?._source?.eventType ).match( /update/ ) || ( hit?._source?.eventType ).match( /edit/ ) )&& hit?._source?.previous ) {
-          const previous = removeIndexedKeysAndFlatten( hit?._source?.previous );
-          const current=removeIndexedKeysAndFlatten( hit?._source?.current );
-          delete previous?._id;
-          delete current?._id;
-          delete previous?.updatedAt;
-          delete current?.updatedAt;
-          delete current?.createdAt;
-
-          logger.info( { previous2: hit?._source?.previous, previous: previous, current: hit?._source?.current, current: current } );
-          const diff = Object.entries( current )
-              .reduce( ( acc, [ key, value ] ) => {
-                if ( value !== previous[key] & typeof previous[key] === 'string' ) {
-                  acc[key] = { previous: previous[key], current: value };
-                }
-
-                return acc;
-              }, {} );
-          logger.info( { diff: diff } );
-          temp[i].updatedValue = diff;
+          const previous = hit?._source?.previous;
+          const current=hit?._source?.current;
+          const logType =hit?._source?.logType;
+
+          const logSubType =hit?._source?.logSubType;
+          respo = findDifferences1( previous, current, logType, logSubType );
+          hit._source.updatedValue = respo;
+          temp.push( hit?._source );
+          hit._source.changes =logSubType === 'ticketConfig'? Object.keys( respo ).map( ( item ) => item ) : hit._source.changes;
         } else {
           temp.push( hit?._source );
         }
@@ -2114,25 +2411,292 @@ export async function getActivityLogs( req, res ) {
     return res.sendError( 'Internal Server Error', 500 );
   }
 }
-function removeIndexedKeysAndFlatten( obj ) {
-  const result = {};
 
-  for ( const [ key, value ] of Object.entries( obj ) ) {
-    // Skip numeric keys and preserve arrays intact
-    if ( /^\d+$/.test( key ) ) continue;
 
-    if ( Array.isArray( value ) ) {
-      result[key] = value;
-    } else if ( typeof value === 'object' && value !== null ) {
-      Object.assign( result, removeIndexedKeysAndFlatten( value ) );
+function findDifferences1( previous, current, logType, logSubType, path = '' ) {
+  const dbKeys = JSON.parse( process.env.DB_KEYS );
+  const ignoredKeys = new Set( [
+    '_id', 'updatedAt', 'createdAt', 'password', 'clientId',
+    'storeId', 'refreshToken', 'employeeId', 'fcmToken', 'permission', 'updateFeatureConfig',
+  ] );
+  const documents = dbKeys.DOCUMENTS;
+  // Get correct key mapping based on logType
+  const keyMapping = logType == 'stores' ?documents.stores: logType == 'users' ?documents.users :logSubType=='reportConfig'?documents.reports: logType=='brandInfo'?documents.client:documents.client;
+
+
+  let differences = {};
+
+  for ( const key in current ) {
+    if ( !Object.prototype.hasOwnProperty.call( current, key ) || ignoredKeys.has( key ) ) continue;
+
+    const prevValue = previous[key];
+    const currValue = current[key];
+
+    if ( typeof prevValue === 'object' && typeof currValue === 'object' && prevValue !== null && currValue !== null ) {
+      if ( logSubType!== 'userUpdated' ) {
+        if ( key == 'spocDetails' ) {
+          if ( _.isEqual( prevValue, currValue ) ) {
+            continue;
+          } else {
+            let result = compareArrayObjects( prevValue, currValue );
+            differences = { ...differences, ...result };
+          }
+        } else if ( Array.isArray( prevValue ) && prevValue.every( ( item ) => typeof item === 'string' ) ||Array.isArray( currValue ) && currValue.every( ( item ) => typeof item === 'string' ) ) {
+      JSON.stringify( prevValue ) !== JSON.stringify( currValue )?
+      differences[`${path}${key}`] = { previous: prevValue.length> 0 ? prevValue.join( ',' ): null, current: currValue.length > 0? currValue.join( ',' ): null } : null;
+
+          // differences[`${path}${key}`] = { previous: removed.length> 0 ? prevValue.join( ',' ): prevValue.join( ', ' ) :, current: added.length > 0? addedUsers.join( ', ' ) : currValue.join( ',' ) } : null;
+        } else {
+          const nestedDiffs = findDifferences1( prevValue, currValue, logType, logSubType, `${path}${key}.` );
+          Object.assign( differences, nestedDiffs );
+        }
+      } else {
+        const nestedDiffs = findDifferences1( prevValue, currValue, logType, logSubType, `${path}${key}.` );
+        Object.assign( differences, nestedDiffs );
+      }
+    } else if ( prevValue !== currValue ) {
+      if (
+        ( prevValue === '' && currValue === '' ) ||
+        ( Array.isArray( prevValue ) && Array.isArray( currValue ) && prevValue.length === 0 && currValue.length === 0 )
+      ) {
+        continue;
+      }
+      differences[`${path}${key}`] = { previous: prevValue, current: currValue };
+    }
+  }
+
+  // **Transform & Filter Differences**
+  let updatedDifferences = {};
+  Object.keys( differences ).forEach( ( key ) => {
+    let newKey = key.replace( /spocDetails\.\d+\./, 'spocDetails.' ).replace( /WhitelistedIps\.\d+/, 'Whitelisted Ips' );
+    let diff = differences[key];
+    if ( newKey.toLowerCase().includes( 'isactive' ) ) {
+      diff = {
+        previous: diff.previous ? 'Active' : 'Deactive',
+        current: diff.current ? 'Active' : 'Deactive',
+      };
+    }
+
+    const userFriendlyKey = getUserFriendlyKey( newKey, keyMapping );
+    if ( userFriendlyKey ) {
+      newKey = userFriendlyKey;
+    }
+    const binaryKeys = [ 'Two Factor Authentication', 'Mat Enabled', 'Audit Status', 'Infra Email Alert', 'Ip Whitelist', 'Excluded Area', 'Passer-by data', 'Normalized data during downtime', 'Billing', 'Camera Blurring', 'Footfall Directory', 'Footfall Directory Audit', 'Footfall Directory Limit', 'NOB Status', 'Traffic', 'Trax', 'Zone V1', 'Zone V2', 'Reports', 'Analyze' ];
+    if ( binaryKeys.includes( newKey ) ) {
+      diff.previous = ( diff.previous == true || diff.previous == 'Enabled' ) ? 'Enabled' : 'Disabled';
+      diff.current = ( diff.current == true || diff.current == 'Enabled' ) ? 'Enabled' : 'Disabled';
+    }
+    if ( newKey === 'Server Type' ) {
+      diff.previous = ( diff.previous == true || diff.previous == 'Server' ) ? 'Server' : 'Serverless';
+      diff.current = ( diff.current == true || diff.current == 'Server' ) ? 'Server' : 'Serverless';
+    }
+
+    if ( newKey === 'Stream Type' ) {
+      diff.previous = ( diff.previous == 'Edge' || diff.previous == 'Edge App' ) ? 'Edge App' : 'RTSP';
+      diff.current = ( diff.current == 'Edge' || diff.current == 'Edge App' ) ? 'Edge App' : 'RTSP';
+    }
+
+    // **Transform Roles Permission Keys**
+    const rolesPermissionMatch = newKey.match( /rolespermission\.(\d+)\.modules\.(\d+)\.(isAdd|isEdit)/ );
+    if ( rolesPermissionMatch ) {
+      const [ , roleIndex, moduleIndex, action ] = rolesPermissionMatch;
+      const role = previous.rolespermission?.[roleIndex];
+      const module = role?.modules?.[moduleIndex];
+
+      if ( module ) {
+        newKey = `User's ${module.name} Module ${action === 'isAdd' ? 'Add' : 'Edit'}`;
+        diff.previous = diff.previous ? 'Enabled' : 'Disabled';
+        diff.current = diff.current ? 'Enabled' : 'Disabled';
+      }
+    }
+
+    if ( !newKey || ( diff.previous === '' && !diff.current ) ) return;
+
+    if (
+      ( diff.previous === '' || diff.previous === null || ( Array.isArray( diff.previous ) && diff.previous.length === 0 ) ) &&
+            diff.current === undefined
+    ) {
+      return;
+    }
+    if (
+      ( diff.current === '' || diff.current === null || ( Array.isArray( diff.current ) && diff.current.length === 0 ) ) &&
+            diff.previous === undefined
+    ) {
+      return;
+    }
+
+    updatedDifferences[newKey] = diff;
+  } );
+
+  return updatedDifferences;
+}
+
+
+function getUserFriendlyKey( keyPath, mapping ) {
+  const keys = keyPath.split( '.' ); // Split the key path (e.g., storeProfile.pincode → ['storeProfile', 'pincode'])
+  let value = mapping;
+
+  for ( const key of keys ) {
+    if ( value && typeof value === 'object' && key in value ) {
+      value = value[key]; // Traverse down the object
+    } else {
+      return null; // Return original if not found
+    }
+  }
+
+  return typeof value === 'string' ? value : keyPath; // Return mapped value or original key
+}
+
+export async function getActivityLogs( req, res ) {
+  try {
+    const inputData = req.body;
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    const clientQuery =[
+      {
+        $match: {
+          $and: [
+            {
+              clientId: { $eq: inputData.clientId },
+            },
+          ],
+        },
+      },
+      {
+        $group: {
+          _id: null,
+          clientName: { $push: '$clientName' },
+        },
+      },
+      {
+        $project: {
+          _id: 0,
+          clientName: 1,
+        },
+      },
+    ];
+    const getClientName = await aggregateClient( clientQuery );
+    if ( getClientName?.length == 0 || getClientName[0]?.clientName?.length ===0 ) {
+      return res.sendError( 'No Data Found', 204 );
+    }
+    const query = {
+      '_source': [
+        'userId', 'userName', 'email', 'date', 'logType', 'logSubType',
+        'changes', 'eventType', 'previous', 'current', 'oldData', 'newData',
+      ],
+      'query': {
+        'bool': {
+          'must': [
+            {
+              'terms': {
+                'clientId.keyword': [ inputData.clientId ],
+              },
+            },
+
+          ],
+          'should': [
+            {
+              'terms': {
+                'clientName.keyword': getClientName[0].clientName, // Add clientName condition
+              },
+            },
+          ],
+        },
+      },
+      'from': ( req.body.offset - 1 ) * req.body.limit,
+      'size': req.body.limit,
+      'sort': [
+        {
+          'date': {
+            'order': 'desc',
+          },
+        },
+      ],
+    };
+
+    if ( req.body?.logTypeFilters?.length ) {
+      query.query.bool.must.push(
+          {
+            'terms': {
+              'logType.keyword': req.body.logTypeFilters,
+            },
+          },
+      );
+    }
+
+    if ( req.body?.startDate || req.body?.endDate ) {
+      query.query.bool.must.push( {
+        'range': {
+          'date': {
+            'gte': req.body?.startDate ? req.body.startDate : '',
+            'lte': req.body?.endDate ? req.body.endDate : '',
+          },
+        },
+      } );
+    }
+
+    query.query.bool.must.push(
+        {
+          'terms': {
+            'showTo.keyword': [ req.user.userType ],
+          },
+        },
+    );
+
+    const logs = await getOpenSearchData( openSearch.activityLog, query );
+
+    const hits = logs?.body?.hits?.hits;
+    const totalDocuments = logs?.body?.hits?.total?.value;
+
+    let temp = [];
+    if ( totalDocuments ) {
+      hits.map( ( hit, i ) => {
+        let respo ={};
+        hit._source.logSubType = hit._source.logSubType === 'documentUpload'? 'documentsUpload': hit._source.logSubType === 'domainDetails'? 'securityFeatures': hit?._source?.logSubType;
+        if ( ( ( hit?._source?.eventType ).match( /update/ ) || ( hit?._source?.eventType ).match( /edit/ ) )&& hit?._source?.previous ) {
+          const previous = hit?._source?.oldData;
+          const current=hit?._source?.newData;
+          respo = findDifferences( previous, current );
+          hit._source.updatedValue = respo;
+          temp.push( hit?._source );
+          // hit._source.changes =logSubType === 'ticketConfig'? Object.keys( respo ).map( ( item ) => item ) : hit._source.changes;
+        } else {
+          temp.push( hit?._source );
+        }
+      },
+      );
+      res.sendSuccess( { data: temp, count: totalDocuments } );
     } else {
-      result[key] = value;
+      res.sendError( 'No data found', 204 );
     }
+  } catch ( error ) {
+    logger.error( { error: error, message: req.body, function: 'getActivityLogs' } );
+    return res.sendError( 'Internal Server Error', 500 );
   }
+}
+
+function findDifferences( oldData, newData ) {
+  const allKeys = new Set( [ ...Object.keys( oldData ), ...Object.keys( newData ) ] );
+  const diff = {};
+
+  allKeys.forEach( ( key ) => {
+    const previous = key in oldData ? oldData[key] : null;
+    const current = key in newData ? newData[key] : null;
+
+    // Only include fields that are added or updated (where previous !== current)
+    if ( previous !== current ) {
+      diff[splitCamelCase( key )] = {
+        previous,
+        current,
+      };
+    }
+  } );
 
-  return result;
+  return diff;
 }
 
+function splitCamelCase( text ) {
+  return text.replace( /([a-z])([A-Z])/g, '$1 $2' );
+}
 
 async function postApi( url, data ) {
   const requestOptions = {
@@ -2201,3 +2765,34 @@ export async function clientCsmAssignAction( req, res ) {
     return res.sendError( 'Internal Server Error', 500 );
   }
 }
+
+function compareArrayObjects( prevArray, currArray ) {
+  let changes = {};
+  // logger.info( { prevArray: prevArray, currArray: currArray } );
+  // Find the longest array length to avoid index mismatch
+  let maxLength = Math.max( prevArray.length, currArray.length );
+
+  for ( let i = 0; i < maxLength; i++ ) {
+    let prevObj = prevArray[i] || {}; // Default to empty object if missing
+    let currObj = currArray[i] || {};
+    let diff = {};
+
+    Object.keys( { ...prevObj, ...currObj } ).forEach( ( key ) => {
+      if ( prevObj[key] !== currObj[key] && key !== '_id' ) {
+        const key1 = key == 'contact'? 'Contact Number': key == 'email'? 'Email ID':key == 'name'?'Name': key == 'designation'?'Designation':key;
+        const name = i ==0? 'Primary Spoc': `Alternate Spoc ${i+1}`;
+        diff[`${name} ${key1}`] = {
+          previous: prevObj[key] || 'null',
+          current: currObj[key] || 'null',
+        };
+      }
+    } );
+
+    if ( Object.keys( diff ).length > 0 ) {
+      // changes.push( { index: i, changes: diff } );
+      changes = { ...changes, ...diff };
+    }
+  }
+
+  return changes;
+}