tango-app-api-client 3.1.14 → 3.1.16

package/src/controllers/client.controllers.js

@@ -1,21 +1,23 @@
-import { billingDetailsUpdate, brandInfoUpdate, domainDetailsConfigurationUpdate, featureConfigurationUpdate, getClientData, signatoryDetailsUpdate, ticketConfigurationUpdate, documentsUpdate, getUserData, auditConfigurationUpdate, auditConfigurationGet, CsmUsersGet, OpsUsersGet, userConfigurationUpdate, findClient, aggregateClient, createAuditQueue, findOne, insert, update, findOneClient } from '../service/client.service.js';
-import { checkFileExist, fileUpload, signedUrl, chunkArray, download, logger, getOpenSearchData, insertOpenSearchData, appConfig, sendEmailWithSES } from 'tango-app-api-middleware';
+import { billingDetailsUpdate, brandInfoUpdate, domainDetailsConfigurationUpdate, featureConfigurationUpdate, getClientData, signatoryDetailsUpdate, ticketConfigurationUpdate, documentsUpdate, getUserData, auditConfigurationUpdate, auditConfigurationGet, CsmUsersGet, OpsUsersGet, userConfigurationUpdate, findClient, aggregateClient, createAuditQueue, findOne, insert, update, findOneClient, updateOneClient } from '../service/client.service.js';
+import { checkFileExist, fileUpload, signedUrl, chunkArray, download, logger, getOpenSearchData, insertOpenSearchData, sendEmailWithSES } from 'tango-app-api-middleware';
 import { countDocumentsUser, findOneAndUpdateUser, findOneUser, getUserNameEmailById, updateManyUser } from '../service/user.service.js';
-import { aggregateStore, countDocumentsStore, updateManyStore } from '../service/store.service.js';
-import { aggregateCamera, countDocumentsCamera, updateManyCamera } from '../service/camera.service.js';
+import { aggregateStore, countDocumentsStore, findStore, findOneStore, updateManyStore } from '../service/store.service.js';
+import { aggregateCamera, countDocumentsCamera } from '../service/camera.service.js';
 import _ from 'lodash';
 import { findOneStandaredRole } from '../service/standaredRole.service.js';
-import { aggregateUserAssignedStore } from '../service/userAssignedStore.service.js';
+import { aggregateUserAssignedStore, deleteOneAssignedStore, updateOneUserAssignedStore } from '../service/userAssignedStore.service.js';
 import { aggregateTickets } from '../service/tangoticket.service.js';
 import { join } from 'path';
 import { readFileSync } from 'fs';
 import handlebars from 'handlebars';
-import { countDocumentsGroup } from '../service/group.service.js';
+import { countDocumentsGroup, createGroupModel, findOneGroup } from '../service/group.service.js';
 import { deleteOneAuthentication } from '../service/authentication.service.js';
 
 
 export async function create( req, res ) {
   try {
+    const url = JSON.parse( process.env.URL );
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
     const inputData = req.body;
     const countQuery = [
       {
@@ -71,9 +73,33 @@ export async function create( req, res ) {
 
     const insertClient = await insert( record );
 
+    const insertedClientRecord = await findOneClient( { clientId: record.clientId }, {} );
+
+    const defaultGroup = {
+      'groupName': 'All stores',
+      'description': 'Contains all the onboarded stores',
+      'storeList': [],
+      'clientId': insertedClientRecord.clientId,
+      'isDefault': true,
+    };
+
+    await createGroupModel( defaultGroup );
+
+    const createdGroup = await findOneGroup( { clientId: insertedClientRecord.clientId, isDefault: true }, {} );
+
+    let oldGroup = {
+      '_id': createdGroup._id,
+      'client_id': createdGroup.clientId,
+      'groupName': createdGroup.groupName,
+      'description': createdGroup.description,
+      'storeList': createdGroup.storeList,
+    };
+
+
+    await postApi( `${url.oldapidomain}/oldGroupAdd`, [ oldGroup ] );
+
     // For old dashboard insert
 
-    const insertedClientRecord = await findOneClient( { clientId: record.clientId }, {} );
 
     const oldBrandInsertData = {
       '_id': insertedClientRecord._id,
@@ -93,9 +119,7 @@ export async function create( req, res ) {
         'birdsEye',
         'tangoZone',
         'tangoTraffic',
-        'Support',
-        'footFallDirectory',
-        'tangoSOP',
+        'support',
       ],
       'planType': insertedClientRecord.planDetails.subscriptionPeriod,
       'storeCount': insertedClientRecord.planDetails.totalStores,
@@ -176,9 +200,47 @@ export async function create( req, res ) {
       'role': 'storesuperadmin',
     };
 
-    await postApi( `${appConfig.url.oldapidomain}/oldBrandAdd`, oldBrandInsertData );
+    await postApi( `${url.oldapidomain}/oldBrandAdd`, oldBrandInsertData );
+
+    await postApi( `${url.oldapidomain}/oldDefaultRoleInsert`, oldDefaultRolesInsertData );
+
+    const logObj = {
+      clientId: insertedClientRecord.clientId,
+      userName: req.user?.userName,
+      email: req.user?.email,
+      date: new Date(),
+      logType: 'brandDetails',
+      logSubType: 'brandApproval',
+      changes: [ insertedClientRecord.clientName ],
+      showTo: [],
+      eventType: 'approve',
+      showTo: [ 'client', 'tango' ],
+    };
+
+    await insertOpenSearchData( openSearch.activityLog, logObj );
+
+    for ( let index = 0; index < leadRecord?.planDetails?.product?.length; index++ ) {
+      const logObj = {
+        userName: req.user?.userName,
+        email: req.user?.email,
+        clientId: insertedClientRecord.clientId,
+        clientNotification: false,
+        adminNotification: true,
+        logSubType: 'startTrial',
+        description: 'Subscription - Your 14 Days free trial has been started',
+        title: 'Subscription',
+        alertCta: [],
+        markasRead: false,
+        logType: 'subscription',
+        showPushNotification: true,
+        date: new Date(),
+        changes: [ `${convertTitleCase( leadRecord?.planDetails?.product[index] )} trial started` ],
+        eventType: '',
+        showTo: [ 'client', 'tango' ],
+      };
 
-    await postApi( `${appConfig.url.oldapidomain}/oldDefaultRoleInsert`, oldDefaultRolesInsertData );
+      await insertOpenSearchData( openSearch.activityLog, logObj );
+    }
 
 
     if ( insertClient ) {
@@ -200,14 +262,23 @@ export async function create( req, res ) {
   }
 }
 
+function convertTitleCase( data ) {
+  let [ firstWord, secondWord ] = data.replace( /([a-z])([A-Z])/g, '$1 $2' ).split( ' ' );
+  firstWord = firstWord.charAt( 0 ).toUpperCase() + firstWord.slice( 1 );
+  data = firstWord + ' ' + secondWord;
+  return data;
+}
+
 export const sendEmail = ( data ) => {
   try {
+    const url = JSON.parse( process.env.URL );
+    const ses = JSON.parse( process.env.SES );
     const attachments = null;
     const subject = data.subject;
     const fileContent = readFileSync( join() + data.path, 'utf8' );
     const htmlContent = handlebars.compile( fileContent );
-    const html = htmlContent( { url: appConfig.url.store, logo: `${appConfig.url.domain}/logo.png` } );
-    return sendEmailWithSES( data.email, subject, html, attachments, appConfig.cloud.aws.ses.adminEmail );
+    const html = htmlContent( { url: url.store, logo: `${url.apiDomain}/logo.png` } );
+    return sendEmailWithSES( data.email, subject, html, attachments, ses.adminEmail );
   } catch ( error ) {
     return error;
   }
@@ -249,6 +320,18 @@ export async function getClients( req, res ) {
           $match: {
             userEmail: req?.user?.email,
             assignedType: { $eq: 'client' },
+            $expr: {
+              $cond: {
+                if: {
+                  $and: [
+                    { $eq: [ '$userType', 'tango' ] },
+                    { $eq: [ '$tangoUserType', 'csm' ] },
+                  ],
+                },
+                then: { $eq: [ '$isClientApproved', true ] },
+                else: true,
+              },
+            },
           },
         },
         {
@@ -302,61 +385,62 @@ export async function getClients( req, res ) {
 
 export async function clientDetails( req, res ) {
   try {
+    const bucket = JSON.parse( process.env.BUCKET );
     const client = await getClientData( { id: req.params.id } );
     if ( client ) {
-      const isLogoExist = await checkFileExist( { Bucket: appConfig.cloud.aws.bucket.assets, Key: `${client.clientId}/logo/${client.profileDetails?.logo}` } );
-      const isGstCertificateExist = await checkFileExist( { Bucket: appConfig.cloud.aws.bucket.assets, Key: `${client.clientId}/documents/${client.document?.gst?.path}` } );
-      const isAddressCertificateExist = await checkFileExist( { Bucket: appConfig.cloud.aws.bucket.assets, Key: `${client.clientId}/documents/${client.document?.addressProof?.path}` } );
-      const isPanCertificateExist = await checkFileExist( { Bucket: appConfig.cloud.aws.bucket.assets, Key: `${client.clientId}/documents/${client.document?.pan?.path}` } );
-      const isCinCertificateExist = await checkFileExist( { Bucket: appConfig.cloud.aws.bucket.assets, Key: `${client.clientId}/documents/${client.document?.cin?.path}` } );
-      const isContractCertificateExist = await checkFileExist( { Bucket: appConfig.cloud.aws.bucket.assets, Key: `documents/contract.pdf` } );
-      const isTermsAndConditionsExist = await checkFileExist( { Bucket: appConfig.cloud.aws.bucket.assets, Key: `documents/terms&conditions.pdf` } );
+      const isLogoExist = await checkFileExist( { Bucket: bucket.assets, Key: `${client.clientId}/logo/${client.profileDetails?.logo}` } );
+      const isGstCertificateExist = await checkFileExist( { Bucket: bucket.assets, Key: `${client.clientId}/documents/${client.document?.gst?.path}` } );
+      const isAddressCertificateExist = await checkFileExist( { Bucket: bucket.assets, Key: `${client.clientId}/documents/${client.document?.addressProof?.path}` } );
+      const isPanCertificateExist = await checkFileExist( { Bucket: bucket.assets, Key: `${client.clientId}/documents/${client.document?.pan?.path}` } );
+      const isCinCertificateExist = await checkFileExist( { Bucket: bucket.assets, Key: `${client.clientId}/documents/${client.document?.cin?.path}` } );
+      const isContractCertificateExist = await checkFileExist( { Bucket: bucket.assets, Key: `documents/contract.pdf` } );
+      const isTermsAndConditionsExist = await checkFileExist( { Bucket: bucket.assets, Key: `documents/terms&conditions.pdf` } );
 
 
       if ( isLogoExist ) {
-        const signedFilUrl = await signedUrl( { Bucket: appConfig.cloud.aws.bucket.assets, file_path: `${client.clientId}/logo/${client.profileDetails?.logo}` } );
+        const signedFilUrl = await signedUrl( { Bucket: bucket.assets, file_path: `${client.clientId}/logo/${client.profileDetails?.logo}` } );
         client.profileDetails.logo = signedFilUrl;
       } else {
         client.profileDetails.logo = '';
       }
 
       if ( isGstCertificateExist ) {
-        const signedFilUrl = await signedUrl( { Bucket: appConfig.cloud.aws.bucket.assets, file_path: `${client.clientId}/documents/${client.document?.gst?.path}` } );
+        const signedFilUrl = await signedUrl( { Bucket: bucket.assets, file_path: `${client.clientId}/documents/${client.document?.gst?.path}` } );
         client.document.gst.path = signedFilUrl;
       } else {
         client.document.gst.path = '';
       }
 
       if ( isAddressCertificateExist ) {
-        const signedFilUrl = await signedUrl( { Bucket: appConfig.cloud.aws.bucket.assets, file_path: `${client.clientId}/documents/${client.document?.addressProof?.path}` } );
+        const signedFilUrl = await signedUrl( { Bucket: bucket.assets, file_path: `${client.clientId}/documents/${client.document?.addressProof?.path}` } );
         client.document.addressProof.path = signedFilUrl;
       } else {
         client.document.addressProof.path = '';
       }
 
       if ( isPanCertificateExist ) {
-        const signedFilUrl = await signedUrl( { Bucket: appConfig.cloud.aws.bucket.assets, file_path: `${client.clientId}/documents/${client.document?.pan?.path}` } );
+        const signedFilUrl = await signedUrl( { Bucket: bucket.assets, file_path: `${client.clientId}/documents/${client.document?.pan?.path}` } );
         client.document.pan.path = signedFilUrl;
       } else {
         client.document.pan.path = '';
       }
 
       if ( isCinCertificateExist ) {
-        const signedFilUrl = await signedUrl( { Bucket: appConfig.cloud.aws.bucket.assets, file_path: `${client.clientId}/documents/${client.document?.cin?.path}` } );
+        const signedFilUrl = await signedUrl( { Bucket: bucket.assets, file_path: `${client.clientId}/documents/${client.document?.cin?.path}` } );
         client.document.cin.path = signedFilUrl;
       } else {
         client.document.cin.path = '';
       }
 
       if ( isContractCertificateExist ) {
-        const signedFilUrl = await signedUrl( { Bucket: appConfig.cloud.aws.bucket.assets, file_path: `documents/contract.pdf` } );
+        const signedFilUrl = await signedUrl( { Bucket: bucket.assets, file_path: `documents/contract.pdf` } );
         client._doc.document.contract = signedFilUrl;
       } else {
         client._doc.document.contract = '';
       }
 
       if ( isTermsAndConditionsExist ) {
-        const signedFilUrl = await signedUrl( { Bucket: appConfig.cloud.aws.bucket.assets, file_path: `documents/terms&conditions.pdf` } );
+        const signedFilUrl = await signedUrl( { Bucket: bucket.assets, file_path: `documents/terms&conditions.pdf` } );
         client._doc.document.termsAndconditions = signedFilUrl;
       } else {
         client._doc.document.termsAndconditions = '';
@@ -382,18 +466,30 @@ export async function detailedAllClientCount( req, res ) {
       {
         $project: {
           activeClient: { $cond: [ { $eq: [ '$status', 'active' ] }, 1, 0 ] },
-          paidClient: { $cond: [ { $and: [
-            { $eq: [ '$status', 'active' ] },
-            { $in: [ '$planDetails.paymentStatus', [ 'paid', 'unbilled', 'due' ] ] },
-          ] }, 1, 0 ] },
-          trialClient: { $cond: [ { $and: [
-            { $eq: [ '$status', 'active' ] },
-            { $eq: [ '$planDetails.paymentStatus', 'trial' ] },
-          ] }, 1, 0 ] },
-
-          freeClient: { $cond: [ { $and: [
-            { $eq: [ '$status', 'active' ] }, { $eq: [ '$planDetails.paymentStatus', 'free' ] },
-          ] }, 1, 0 ] },
+          paidClient: {
+            $cond: [ {
+              $and: [
+                { $eq: [ '$status', 'active' ] },
+                { $in: [ '$planDetails.paymentStatus', [ 'paid', 'unbilled', 'due' ] ] },
+              ],
+            }, 1, 0 ],
+          },
+          trialClient: {
+            $cond: [ {
+              $and: [
+                { $eq: [ '$status', 'active' ] },
+                { $eq: [ '$planDetails.paymentStatus', 'trial' ] },
+              ],
+            }, 1, 0 ],
+          },
+
+          freeClient: {
+            $cond: [ {
+              $and: [
+                { $eq: [ '$status', 'active' ] }, { $eq: [ '$planDetails.paymentStatus', 'free' ] },
+              ],
+            }, 1, 0 ],
+          },
           holdClient: { $cond: [ { $eq: [ '$status', 'hold' ] }, 1, 0 ] },
           suspendClient: { $cond: [ { $eq: [ '$status', 'suspended' ] }, 1, 0 ] },
           deactiveClient: { $cond: [ { $eq: [ '$status', 'deactive' ] }, 1, 0 ] },
@@ -413,11 +509,34 @@ export async function detailedAllClientCount( req, res ) {
 
         },
       },
+      {
+        $project: {
+          _id: 0,
+          totalCount: 1,
+          activeClient: 1,
+          paidClient: 1,
+          trialClient: 1,
+          freeClient: 1,
+          holdClient: 1,
+          suspendClient: 1,
+          deactiveClient: 1,
+          activeStoresCount: { $ifNull: [ 0, 0 ] },
+          activeCameraCount: { $ifNull: [ 0, 0 ] },
+        },
+      },
     ];
     const result = await aggregateClient( query );
-    if ( result == 0 ) {
+    const activeStores = await findStore( { 'status': 'active', 'edge.firstFile': true }, { storeId: 1 } );
+    let storesList = [];
+    for ( let store of activeStores ) {
+      storesList.push( store.storeId );
+    }
+    const activeCameras = await countDocumentsCamera( { storeId: { $in: storesList }, isUp: true, isActivated: true } );
+    if ( result.length == 0 ) {
       return res.sendError( 'No Data Found', 204 );
     }
+    result[0].activeStoresCount = activeStores.length;
+    result[0].activeCameraCount = activeCameras;
     return res.sendSuccess( { result: result } );
   } catch ( error ) {
     logger.error( { error: error, function: 'detailedAllClientCount' } );
@@ -433,11 +552,14 @@ function camelCaseToWords( camelCaseString ) {
 
 export async function updateBrandInfo( req, res ) {
   try {
+    const bucket = JSON.parse( process.env.BUCKET );
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    const url = JSON.parse( process.env.URL );
     let updateKeys = [];
 
     if ( req.files?.logo ) {
       const uploadDataParams = {
-        Bucket: appConfig.cloud.aws.bucket.assets,
+        Bucket: bucket.assets,
         Key: `${req.params.id}/logo/`,
         fileName: `brandLogo.${req.files.logo.name.split( '.' )[1]}`,
         ContentType: req.files.logo.mimetype,
@@ -465,9 +587,12 @@ export async function updateBrandInfo( req, res ) {
       logSubType: 'brandInfo',
       changes: updateKeys,
       eventType: 'update',
+      showTo: [ 'client', 'tango' ],
     };
 
-    await insertOpenSearchData( 'tango-retail-activity-logs', logObj );
+    if ( updateKeys.length ) {
+      await insertOpenSearchData( openSearch.activityLog, logObj );
+    }
 
 
     const updateAck = await brandInfoUpdate( {
@@ -492,11 +617,11 @@ 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 updateManyCamera( { clientId: req.params?.id }, { isUp: false, isActivated: false } );
       await updateManyUser( { clientId: req.params?.id }, { isActive: false } );
     }
 
-    const { data } = await getApi( `${appConfig.url.oldapidomain}/oldBrandGet/${req.params?.id}` );
+    const { data } = await getApi( `${url.oldapidomain}/oldBrandGet/${req.params?.id}` );
 
     switch ( req.body?.status ) {
       case 'active':
@@ -515,7 +640,7 @@ export async function updateBrandInfo( req, res ) {
         data.clientStatus = 'live';
     }
 
-    await postApi( `${appConfig.url.oldapidomain}/oldBrandUpdate/${data?._id}`, { clientStatus: data.clientStatus } );
+    await postApi( `${url.oldapidomain}/oldBrandUpdate/${data?._id}`, { clientStatus: data.clientStatus } );
 
     if ( updateAck ) {
       res.sendSuccess( { result: 'Updated Successfully' } );
@@ -528,11 +653,13 @@ export async function updateBrandInfo( req, res ) {
 
 export async function updateBillingDetails( req, res ) {
   try {
+    const bucket = JSON.parse( process.env.BUCKET );
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
     let updateKeys = [];
 
     if ( req.files?.gstCertificate ) {
       const uploadDataParams = {
-        Bucket: appConfig.cloud.aws.bucket.assets,
+        Bucket: bucket.assets,
         Key: `${req.params.id}/documents/`,
         fileName: `gstCertificate.${req.files.gstCertificate.name.split( '.' )[1]}`,
         ContentType: req.files.gstCertificate.mimetype,
@@ -559,9 +686,13 @@ export async function updateBillingDetails( req, res ) {
       logSubType: 'billingDetails',
       changes: updateKeys,
       eventType: 'update',
+      showTo: [ 'client', 'tango' ],
     };
 
-    await insertOpenSearchData( 'tango-retail-activity-logs', logObj );
+    if ( updateKeys.length ) {
+      await insertOpenSearchData( openSearch.activityLog, logObj );
+    }
+
 
     const updateAck = await billingDetailsUpdate( {
       clientId: req.params?.id, tradeName: req.body?.tradeName, gstNumber: req.body?.gstNumber,
@@ -579,6 +710,7 @@ export async function updateBillingDetails( req, res ) {
 
 export async function updateSignatoryDetails( req, res ) {
   try {
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
     let updateKeys = [];
     if ( Object.keys( req.body ).length > 0 ) {
       Object.keys( req.body ).forEach( ( element ) => {
@@ -597,9 +729,13 @@ export async function updateSignatoryDetails( req, res ) {
       logSubType: 'signatoryDetails',
       changes: updateKeys,
       eventType: 'update',
+      showTo: [ 'client', 'tango' ],
     };
 
-    await insertOpenSearchData( 'tango-retail-activity-logs', logObj );
+    if ( updateKeys.length ) {
+      await insertOpenSearchData( openSearch.activityLog, logObj );
+    }
+
     const updateAck = await signatoryDetailsUpdate( {
       clientId: req.params?.id, name: req.body?.name, email: req.body?.email,
       number: req.body?.number, designation: req.body?.designation,
@@ -615,6 +751,7 @@ export async function updateSignatoryDetails( req, res ) {
 
 export async function updateTicketConfiguration( req, res ) {
   try {
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
     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,
@@ -640,8 +777,12 @@ export async function updateTicketConfiguration( req, res ) {
       logSubType: 'ticketConfig',
       changes: updateKeys,
       eventType: 'update',
+      showTo: [ 'tango' ],
     };
-    await insertOpenSearchData( 'tango-retail-activity-logs', logObj );
+
+    if ( updateKeys.length ) {
+      await insertOpenSearchData( openSearch.activityLog, logObj );
+    }
 
     if ( updateAck ) {
       res.sendSuccess( { result: 'Updated Successfully' } );
@@ -654,11 +795,14 @@ export async function updateTicketConfiguration( req, res ) {
 
 export async function updateFeatureConfiguration( req, res ) {
   try {
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    const url = JSON.parse( process.env.URL );
     const updateAck = await featureConfigurationUpdate( {
       clientId: req.params?.id, billableCalculation: req.body?.billableCalculation, bouncedLimitCondition: req.body?.bouncedLimitCondition, bouncedLimitValue: req.body?.bouncedLimitValue,
       close: req.body?.close, conversionCalculation: req.body?.conversionCalculation, conversionCondition: req.body?.conversionCondition,
       conversionValue: req.body?.conversionValue, infraAlertCondition: req.body?.infraAlertCondition, infraAlertValue: req.body?.infraAlertValue, isFootfallDirectory: req.body?.isFootfallDirectory,
       isNormalized: req.body?.isNormalized, isPasserByData: req.body?.isPasserByData, missedOpportunityCalculation: req.body?.missedOpportunityCalculation, open: req.body?.open,
+      isExcludedArea: req.body?.isExcludedArea,
     } );
 
     let updateKeys = [];
@@ -671,7 +815,7 @@ export async function updateFeatureConfiguration( req, res ) {
 
     const user = await getUserNameEmailById( req.userId );
 
-    const { data } = await getApi( `${appConfig.url.oldapidomain}/oldBrandGet/${req.params?.id}` );
+    const { data } = await getApi( `${url.oldapidomain}/oldBrandGet/${req.params?.id}` );
 
     if ( req.body?.open ) {
       data.brandConfigs.storeOpenTime = req.body?.open;
@@ -713,7 +857,7 @@ export async function updateFeatureConfiguration( req, res ) {
       data.brandConfigs.missedOpportunityEndTime = data.brandConfigs.missedOpportunityEndTime.replace( /\d+/, req.body?.conversionValue );
     }
 
-    await postApi( `${appConfig.url.oldapidomain}/oldBrandUpdate/${data?._id}`, { brandConfigs: data.brandConfigs } );
+    await postApi( `${url.oldapidomain}/oldBrandUpdate/${data?._id}`, { brandConfigs: data.brandConfigs } );
 
 
     const logObj = {
@@ -725,8 +869,11 @@ export async function updateFeatureConfiguration( req, res ) {
       logSubType: 'featureConfig',
       changes: updateKeys,
       eventType: 'update',
+      showTo: [ 'client', 'tango' ],
     };
-    await insertOpenSearchData( 'tango-retail-activity-logs', logObj );
+    if ( updateKeys.length ) {
+      await insertOpenSearchData( openSearch.activityLog, logObj );
+    }
 
     if ( updateAck ) {
       res.sendSuccess( { result: 'Updated Successfully' } );
@@ -739,6 +886,7 @@ export async function updateFeatureConfiguration( req, res ) {
 
 export async function domainDetailsConfiguration( req, res ) {
   try {
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
     const updateAck = await domainDetailsConfigurationUpdate( {
       clientId: req.params?.id, domainName: req.body?.domainName, isEnable: req.body?.isEnable,
     } );
@@ -764,9 +912,13 @@ export async function domainDetailsConfiguration( req, res ) {
       logSubType: 'domainDetails',
       changes: updateKeys,
       eventType: 'update',
+      showTo: [ 'client', 'tango' ],
     };
 
-    await insertOpenSearchData( 'tango-retail-activity-logs', logObj );
+    if ( updateKeys.length ) {
+      await insertOpenSearchData( openSearch.activityLog, logObj );
+    }
+
     if ( updateAck ) {
       res.sendSuccess( { result: 'Updated Successfully' } );
     }
@@ -792,11 +944,13 @@ export async function userConfiguration( req, res ) {
 
 export async function updateDocuments( req, res ) {
   try {
+    const bucket = JSON.parse( process.env.BUCKET );
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
     let updateKeys = [];
 
     if ( req.files?.addressDoc ) {
       const uploadDataParams = {
-        Bucket: appConfig.cloud.aws.bucket.assets,
+        Bucket: bucket.assets,
         Key: `${req.params.id}/documents/`,
         fileName: `addressCertificate.${req.files.addressDoc.name.split( '.' )[1]}`,
         ContentType: req.files.addressDoc.mimetype,
@@ -809,7 +963,7 @@ export async function updateDocuments( req, res ) {
     }
     if ( req.files?.gstDoc ) {
       const uploadDataParams = {
-        Bucket: appConfig.cloud.aws.bucket.assets,
+        Bucket: bucket.assets,
         Key: `${req.params.id}/documents/`,
         fileName: `gstCertificate.${req.files.gstDoc.name.split( '.' )[1]}`,
         ContentType: req.files.gstDoc.mimetype,
@@ -822,7 +976,7 @@ export async function updateDocuments( req, res ) {
     }
     if ( req.files?.panDoc ) {
       const uploadDataParams = {
-        Bucket: appConfig.cloud.aws.bucket.assets,
+        Bucket: bucket.assets,
         Key: `${req.params.id}/documents/`,
         fileName: `panCertificate.${req.files.panDoc.name.split( '.' )[1]}`,
         ContentType: req.files.panDoc.mimetype,
@@ -835,7 +989,7 @@ export async function updateDocuments( req, res ) {
     }
     if ( req.files?.cinDoc ) {
       const uploadDataParams = {
-        Bucket: appConfig.cloud.aws.bucket.assets,
+        Bucket: bucket.assets,
         Key: `${req.params.id}/documents/`,
         fileName: `cinCertificate.${req.files.cinDoc.name.split( '.' )[1]}`,
         ContentType: req.files.cinDoc.mimetype,
@@ -874,9 +1028,12 @@ export async function updateDocuments( req, res ) {
       logSubType: 'documentUpload',
       changes: updateKeys,
       eventType: 'update',
+      showTo: [ 'client', 'tango' ],
     };
 
-    await insertOpenSearchData( 'tango-retail-activity-logs', logObj );
+    if ( updateKeys.length ) {
+      await insertOpenSearchData( openSearch.activityLog, logObj );
+    }
 
     if ( updateAck ) {
       res.sendSuccess( { result: 'Updated Successfully' } );
@@ -889,11 +1046,12 @@ export async function updateDocuments( req, res ) {
 
 export async function getAuditConfiguration( req, res ) {
   try {
+    const bucket = JSON.parse( process.env.BUCKET );
     const auditConfig = await auditConfigurationGet( { storeId: req.params?.id } );
     if ( auditConfig ) {
-      const isDocExist = await checkFileExist( { Bucket: appConfig.cloud.aws.bucket.assets, Key: `templates/audit_bulk_update.xlsx` } );
+      const isDocExist = await checkFileExist( { Bucket: bucket.assets, Key: `templates/audit_bulk_update.xlsx` } );
       if ( isDocExist ) {
-        const signedFilUrl = await signedUrl( { Bucket: appConfig.cloud.aws.bucket.assets, file_path: `templates/audit_bulk_update.xlsx` } );
+        const signedFilUrl = await signedUrl( { Bucket: bucket.assets, file_path: `templates/audit_bulk_update.xlsx` } );
         auditConfig._doc.templateUrl = signedFilUrl;
       } else {
         auditConfig._doc.templateUrl = '';
@@ -911,36 +1069,39 @@ export async function getAuditConfiguration( req, res ) {
 
 export async function auditConfiguration( req, res ) {
   try {
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
     for ( let i = 0; i < req.body?.length; i++ ) {
+      const previousStore = await findOneStore( { storeId: req.body[i].storeId }, { auditConfigs: 1, _id: 0 } );
       await auditConfigurationUpdate( {
         storeId: req.body[i].storeId,
         count: req.body[i].count,
         iteration: req.body[i].iteration,
         ratio: normalizeNumber( req.body[i].ratio, 0, 100 ),
       } );
-    }
-
-    const user = await getUserNameEmailById( req.userId );
 
-    const logObj = {
-      clientId: req.params?.id,
-      userName: user.userName,
-      email: user.email,
-      date: new Date(),
-      logType: 'configuration',
-      logSubType: 'auditConfig',
-      eventType: 'update',
-    };
-
-    if ( req.body?.length === 1 ) {
-      logObj.changes = [ `Audit config for store id ${req.body[0].storeId}` ];
-    }
+      const logObj = {
+        clientId: req.params?.id,
+        userName: req.user?.userName,
+        email: req.user?.email,
+        date: new Date(),
+        logType: 'configuration',
+        logSubType: 'auditConfig',
+        eventType: 'update',
+        showTo: [ 'tango' ],
+        changes: [ `Audit config for store id ${req.body[i].storeId}` ],
+        storeId: req.body[i].storeId,
+        previous: previousStore,
+        current: {
+          storeId: req.body[i].storeId,
+          count: req.body[i].count,
+          iteration: req.body[i].iteration,
+          ratio: normalizeNumber( req.body[i].ratio, 0, 100 ),
+        },
+      };
 
-    if ( req.body?.length > 1 ) {
-      logObj.changes = [ `Audit config bulk` ];
+      await insertOpenSearchData( openSearch.activityLog, logObj );
     }
 
-    await insertOpenSearchData( 'tango-retail-activity-logs', logObj );
 
     res.sendSuccess( { result: 'Updated Successfully' } );
   } catch ( error ) {
@@ -978,6 +1139,17 @@ 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,
+              },
+            },
 
           },
         }, {
@@ -990,7 +1162,7 @@ export async function clientList( req, res ) {
       ];
       const clientIdList = await aggregateUserAssignedStore( query );
       logger.info( { message: clientIdList, value: 'clientIdList' } );
-      if ( clientIdList.length ==0 ) {
+      if ( clientIdList.length == 0 ) {
         return res.sendError( 'No Data Found', 204 );
       }
 
@@ -1003,6 +1175,10 @@ export async function clientList( req, res ) {
       );
     }
     if ( inputData.filterByPaymentStatus ) {
+      if ( inputData.filterByPaymentStatus.includes( 'paid' ) ) {
+        inputData.filterByPaymentStatus.push( ...[ 'unbilled', 'due' ] );
+      }
+
       clientQuery.push(
           {
             $match: {
@@ -1253,8 +1429,13 @@ export async function clientList( req, res ) {
           list.push( {
             'client Name': chunk[i]?.clientName,
             'client Id': chunk[i]?.clientId,
+            'Installation Stores Count': chunk[i]?.installedStores || 0,
+            'Onboarded Stores Count': chunk[i]?.totalStores,
+            'Store Progress': chunk[i]?.installedStores ? `${( ( chunk[i]?.installedStores / chunk[i]?.totalStores ) * 100 ).toFixed( 0 )}%` : '0%',
             'Active Store': chunk[i]?.activeStoreCount || 0,
             'Active Camera': chunk[i]?.activeCameraCount && chunk[i]?.activeCameraCount != undefined ? chunk[i]?.activeCameraCount : 0,
+            'Pending Stores': chunk[i]?.pendingStores || 0,
+            'Failed Stores': chunk[i]?.failedStores || 0,
             'Payment Status': chunk[i]?.paymentStatus,
             'Subs Plan': chunk[i]?.subscriptionType,
             'Status': chunk[i]?.status,
@@ -1273,7 +1454,344 @@ export async function clientList( req, res ) {
     return res.sendError( 'Internal Server Error', 500 );
   }
 }
+export async function clientListV1( req, res ) {
+  try {
+    const inputData = req.body;
+    let clientQuery = [];
+    logger.info( { message: req?.user?.role } );
+    if ( req?.user?.role !== 'superadmin' ) {
+      const query = [
+        {
+          $match: {
+            userEmail: { $eq: req?.user?.email },
+            userType: 'tango',
+            $expr: {
+              $cond: {
+                if: {
+                  $and: [
+                    { $eq: [ '$tangoUserType', 'csm' ] },
+                  ],
+                },
+                then: { $eq: [ '$isClientApproved', true ] },
+                else: true,
+              },
+            },
+
+          },
+        },
+        {
+          $group: {
+            _id: null,
+            clientList: { $push: '$assignedValue' },
+          },
+        },
+      ];
+      const clientIdList = await aggregateUserAssignedStore( query );
+      logger.info( { message: clientIdList, value: 'clientIdList' } );
+      if ( clientIdList.length == 0 ) {
+        return res.sendError( 'No Data Found', 204 );
+      }
+      clientQuery.push(
+          {
+            $match: {
+              clientId: { $in: clientIdList[0].clientList },
+            },
+          },
+      );
+    }
+    clientQuery.push(
+        {
+          $project: {
+            status: 1,
+            clientName: 1,
+            clientId: 1,
+            subscriptionType: '$planDetails.subscriptionType',
+            PaymentPlan: '$planDetails.paymentStatus',
+          },
+        },
+    );
+    if ( inputData.filterByPaymentStatus ) {
+      if ( inputData.filterByPaymentStatus.includes( 'paid' ) ) {
+        inputData.filterByPaymentStatus.push( ...[ 'unbilled', 'due' ] );
+      }
+
+      clientQuery.push(
+          {
+            $match: {
+              'PaymentPlan': { $in: inputData.filterByPaymentStatus },
+            },
+          },
+      );
+    }
+    if ( inputData.filterBySubscription ) {
+      clientQuery.push(
+          {
+            $match: {
+              'subscriptionType': { $in: inputData.filterBySubscription },
+            },
+          },
+      );
+    }
+    if ( inputData.filterByStatus ) {
+      clientQuery.push(
+          {
+            $match: {
+              status: { $in: inputData.filterByStatus },
+            },
+          },
+      );
+    }
+    if ( inputData.searchValue && inputData.searchValue != '' ) {
+      clientQuery.push( {
+        $match: {
+          $or: [
+            { clientId: { $regex: inputData.searchValue, $options: 'i' } },
+            { clientName: { $regex: inputData.searchValue, $options: 'i' } },
+            { subscriptionType: { $regex: inputData.searchValue, $options: 'i' } },
+            { status: { $regex: inputData.searchValue, $options: 'i' } },
+          ],
+        },
+      } );
+    }
+    clientQuery.push( {
+      $lookup: {
+        from: 'stores',
+        let: { clientId: '$clientId' },
+        pipeline: [
+          {
+            $match: {
+              $expr: {
+                $and: [
+                  { $eq: [ '$clientId', '$$clientId' ] },
+                ],
+              },
+            },
+          },
+          {
+            $project: {
+              edge: 1,
+              status: 1,
+              clientId: 1,
+              storeId: 1,
+            },
+          },
+        ], as: 'stores',
+      },
+    },
+
+    {
+      $unwind: { path: '$stores', preserveNullAndEmptyArrays: true },
+    },
+    {
+      $project: {
+        clientId: 1,
+        status: 1,
+        clientName: 1,
+        subscriptionType: 1,
+        PaymentPlan: 1,
+        installed: {
+          $cond: [ { $or: [ { $eq: [ '$stores.edge.firstFile', true ] } ] }, 1, 0,
+          ],
+        },
+        activeStores: {
+          $cond: [ { $and: [ { $eq: [ '$stores.status', 'active' ] } ] }, 1, 0,
+          ],
+        },
+        InactiveStores: {
+          $cond: [ { $and: [ { $ne: [ '$stores.status', 'active' ] } ] }, 1, 0,
+          ],
+        },
+      },
+    },
+    {
+      $group: {
+        _id: '$clientId',
+        clientId: { $first: '$clientId' },
+        onboardedStores: { $sum: 1 },
+        installedStore: { $sum: '$installed' },
+        activeStores: { $sum: '$activeStores' },
+        InactiveStores: { $sum: '$InactiveStores' },
+        ProcessingStatus: { $first: '$status' },
+        clientName: { $first: '$clientName' },
+        subscriptionPlan: { $first: '$subscriptionType' },
+        PaymentPlan: { $first: '$PaymentPlan' },
+      },
+    },
+    {
+      $lookup: {
+        from: 'tangoTicket',
+        let: { clientId: '$clientId' },
+        pipeline: [
+          {
+            $match: {
+              $expr: {
+                $and: [
+                  { $eq: [ '$issueType', 'installation' ] },
+                  { $eq: [ '$basicDetails.clientId', '$$clientId' ] },
+                ],
+              },
+            },
+
+          },
+          {
+            $project: {
+              ticketDetails: 1,
+              status: 1,
+              basicDetails: 1,
+            },
+          },
+        ], as: 'ticket',
+      },
+    },
+    {
+      $unwind: { path: '$ticket', preserveNullAndEmptyArrays: true },
+    },
+    {
+      $project: {
+        clientId: 1,
+        ProcessingStatus: 1,
+        onboardedStores: 1,
+        clientName: 1,
+        PaymentPlan: 1,
+        subscriptionPlan: 1,
+        installedStore: 1,
+        activeStores: 1,
+        InactiveStores: 1,
+        installedPending: {
+          $cond: [ { $and: [ { $ne: [ '$ticket.status', 'closed' ] } ] }, 1, 0 ],
+        },
+        installedFailed: {
+          $cond: [ { $and: [ { $ne: [ '$ticket.status', 'closed' ] }, { $eq: [ '$ticket.ticketDetails.issueStatus', 'identified' ] } ] }, 1, 0 ],
+        },
+      },
+    },
+    {
+      $group: {
+        _id: '$clientId',
+        clientId: { $first: '$clientId' },
+        onboardedStores: { $first: '$onboardedStores' },
+        installedStore: { $first: '$installedStore' },
+        activeStores: { $first: '$activeStores' },
+        InactiveStores: { $first: '$InactiveStores' },
+        ProcessingStatus: { $first: '$ProcessingStatus' },
+        clientName: { $first: '$clientName' },
+        subscriptionPlan: { $first: '$subscriptionPlan' },
+        PaymentPlan: { $first: '$PaymentPlan' },
+        installedPending: { $sum: '$installedPending' },
+        installedFailed: { $sum: '$installedFailed' },
+      },
+    },
+    {
+      $project: {
+        clientId: { $toInt: '$clientId' },
+        onboardedStores: 1,
+        installedStore: 1,
+        activeStores: { $max: [
+          { $subtract: [ '$activeStores', '$installedPending' ] },
+          0,
+        ] },
+        InactiveStores: 1,
+        ProcessingStatus: 1,
+        clientName: 1,
+        subscriptionPlan: 1,
+        PaymentPlan: 1,
+        PaymentPlan: {
+          $cond: {
+            if: { $eq: [ '$PaymentPlan', 'unbilled' ] },
+            then: 'paid',
+            else: {
+              $cond: {
+                if: { $eq: [ '$PaymentPlan', 'due' ] },
+                then: 'paid',
+                else: '$PaymentPlan',
+              },
+            },
+          },
+        },
+        installedPending: 1,
+        installedFailed: 1,
+        ProgressBar: {
+          $cond: {
+            if: { $eq: [ '$onboardedStores', 0 ] },
+            then: 0,
+            else: {
+              $round: [
+                { $multiply: [ { $divide: [ '$installedStore', '$onboardedStores' ] }, 100 ] },
+                0,
+              ],
+            },
+          },
+        },
+      },
+    },
+    );
 
+    const clientCount = await aggregateClient( clientQuery );
+    if ( clientCount.length == 0 ) {
+      return res.sendError( 'No Data Found', 204 );
+    }
+
+    if ( inputData.sortColumName&&inputData.sortColumName!=''&& req.body.sortBy&&req.body.sortBy!='' ) {
+      clientQuery.push( {
+        $sort: { [req.body.sortColumName]: req.body.sortBy },
+      },
+      );
+    } else {
+      clientQuery.push( {
+        $sort: { activeStores: -1 },
+      },
+      );
+    }
+    clientQuery.push( {
+      $project: {
+        clientId: { $toString: '$clientId' },
+        onboardedStores: 1,
+        installedStore: 1,
+        activeStores: 1,
+        InactiveStores: 1,
+        ProcessingStatus: 1,
+        clientName: 1,
+        subscriptionPlan: 1,
+        PaymentPlan: 1,
+        installedPending: 1,
+        installedFailed: 1,
+        ProgressBar: 1,
+      },
+    } );
+    if ( req.body.limit && req.body.offset && !req.body.isExport ) {
+      clientQuery.push(
+          { $skip: ( req.body.offset - 1 ) * req.body.limit },
+          { $limit: Number( req.body.limit ) },
+      );
+    }
+    const clientList = await aggregateClient( clientQuery );
+
+    if ( inputData.isExport ) {
+      const exportResult = [];
+      for ( let client of clientList ) {
+        exportResult.push( {
+          'Brand Name': client.clientName,
+          'Brand ID': client.clientId,
+          'Onboarded Stores': client.onboardedStores||0,
+          'Installed Stores': client.installedStore || 0,
+          'Progress Status': client.ProgressBar||0,
+          'Active Stores': client.activeStores || 0,
+          'In-Active Stores': client.InactiveStores || 0,
+          'Pending Configuration': client.installedPending || 0,
+          'Payment Plan': client.PaymentPlan == 'free'?'Lifetime Free':client.PaymentPlan,
+          'Subscription Plan': client.subscriptionPlan,
+          'Processing Status': client.ProcessingStatus=='active'?'Activated':client.ProcessingStatus=='deactive'?'Deactivated':client.ProcessingStatus,
+        } );
+      }
+      await download( exportResult, res );
+      return;
+    }
+    return res.sendSuccess( { result: clientList, count: clientCount.length } );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'clientList' } );
+    return res.sendError( 'Internal Server Error', 500 );
+  }
+}
 export async function getOpsUsers( req, res ) {
   try {
     const users = await OpsUsersGet();
@@ -1291,6 +1809,7 @@ export async function getOpsUsers( req, res ) {
 
 export async function detailedClientCount( req, res ) {
   try {
+    const bucket = JSON.parse( process.env.BUCKET );
     const inputData = req.query;
     let result = {
       clientName: inputData.clientName,
@@ -1304,10 +1823,10 @@ export async function detailedClientCount( req, res ) {
     const client = await findOneClient( { clientId: inputData.clientId }, { userId: 1, clientId: 1, profileDetails: 1 } );
     const user = await findOneUser( { _id: client.userId }, { userName: 1, email: 1 } );
 
-    const isLogoExist = await checkFileExist( { Bucket: appConfig.cloud.aws.bucket.assets, Key: `${client.clientId}/logo/${client.profileDetails?.logo}` } );
+    const isLogoExist = await checkFileExist( { Bucket: bucket.assets, Key: `${client.clientId}/logo/${client.profileDetails?.logo}` } );
 
     if ( isLogoExist ) {
-      const signedFilUrl = await signedUrl( { Bucket: appConfig.cloud.aws.bucket.assets, file_path: `${client.clientId}/logo/${client.profileDetails?.logo}` } );
+      const signedFilUrl = await signedUrl( { Bucket: bucket.assets, file_path: `${client.clientId}/logo/${client.profileDetails?.logo}` } );
       result['logo'] = signedFilUrl;
     } else {
       result['logo'] = '';
@@ -1315,6 +1834,19 @@ export async function detailedClientCount( req, res ) {
     result['userName'] = user?.userName;
     result['email'] = user?.email;
     result['profileCompletion'] = 70;
+    let findCsm = await aggregateUserAssignedStore( [
+      {
+        $match: {
+          clientId: inputData.clientId,
+          tangoUserType: 'csm',
+        },
+      },
+    ] );
+
+    if ( findCsm&&findCsm.length>0 ) {
+      let finduser = await findOneUser( { email: findCsm[0].userEmail }, { userName: 1, email: 1, countryCode: 1, mobileNumber: 1 } );
+      result['csm'] = finduser;
+    }
 
     return res.sendSuccess( { result: result } );
   } catch ( error ) {
@@ -1325,8 +1857,12 @@ export async function detailedClientCount( req, res ) {
 
 export async function getActivityLogs( req, res ) {
   try {
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
     const query = {
-      '_source': [ 'userId', 'userName', 'email', 'date', 'logType', 'logSubType', 'changes', 'eventType' ],
+      '_source': [
+        'userId', 'userName', 'email', 'date', 'logType', 'logSubType',
+        'changes', 'eventType',
+      ],
       'query': {
         'bool': {
           'must': [
@@ -1340,6 +1876,13 @@ export async function getActivityLogs( req, res ) {
       },
       'from': ( req.body.offset - 1 ) * req.body.limit,
       'size': req.body.limit,
+      'sort': [
+        {
+          'date': {
+            'order': 'desc',
+          },
+        },
+      ],
     };
 
     if ( req.body?.logTypeFilters?.length ) {
@@ -1363,7 +1906,15 @@ export async function getActivityLogs( req, res ) {
       } );
     }
 
-    const logs = await getOpenSearchData( 'tango-retail-activity-logs', query );
+    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;
@@ -1379,6 +1930,7 @@ export async function getActivityLogs( req, res ) {
   }
 }
 
+
 async function postApi( url, data ) {
   const requestOptions = {
     method: 'POST',
@@ -1415,3 +1967,34 @@ async function getApi( url ) {
   }
 }
 
+
+export async function csmAssignConfirmation( req, res ) {
+  try {
+    const client = await findOneClient( { clientId: req.query.clientId }, { notifyCsmAssign: 1, _id: 0 } );
+    if ( !client ) {
+      res.sendError( 'No data found', 204 );
+    }
+    res.sendSuccess( client );
+  } catch ( error ) {
+    logger.error( { error: error, message: req.params, function: 'csmAssignConfirmation' } );
+    return res.sendError( 'Internal Server Error', 500 );
+  }
+}
+
+export async function clientCsmAssignAction( req, res ) {
+  try {
+    await updateOneClient( { clientId: req.query.clientId }, { notifyCsmAssign: false } );
+    if ( req.body.action === 'approve' ) {
+      await updateOneUserAssignedStore( { clientId: req.query.clientId, tangoUserType: 'csm', assignedType: 'client' }, { isClientApproved: true } );
+    }
+
+    if ( req.body.action === 'decline' ) {
+      await deleteOneAssignedStore( { clientId: req.query.clientId, tangoUserType: 'csm', assignedType: 'client' } );
+    }
+
+    res.sendSuccess( 'Updated Succesfully' );
+  } catch ( error ) {
+    logger.error( { error: error, message: req.params, function: 'csmAssignConfirmation' } );
+    return res.sendError( 'Internal Server Error', 500 );
+  }
+}