tango-app-api-client 3.0.0 → 3.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-client",
-    "version": "3.0.0",
+    "version": "3.0.2",
     "description": "client",
     "main": "index.js",
     "type": "module",
@@ -14,13 +14,17 @@
     "license": "ISC",
     "dependencies": {
         "aws-sdk": "^2.1560.0",
+        "cors": "^2.8.5",
         "dotenv": "^16.4.4",
         "express": "^4.18.2",
+        "express-fileupload": "^1.4.3",
         "handlebars": "^4.7.8",
+        "joi": "^17.12.1",
+        "lodash": "^4.17.21",
         "mongodb": "^6.3.0",
         "nodemon": "^3.0.3",
-        "tango-api-schema": "^2.0.8",
-        "tango-app-api-middleware": "^1.0.16",
+        "tango-api-schema": "^2.0.33",
+        "tango-app-api-middleware": "^1.0.23",
         "winston": "^3.11.0",
         "winston-daily-rotate-file": "^5.0.0"
     },

package/src/controllers/client.controllers.js

@@ -1,5 +1,9 @@
-import { logger } from 'tango-app-api-middleware';
-import { createAuditQueue, findOne, getClientCount, insert, update, find } from '../service/client.service.js';
+import { billingDetailsUpdate, brandInfoUpdate, domainDetailsConfigurationUpdate, featureConfigurationUpdate, getClientData, signatoryDetailsUpdate, ticketConfigurationUpdate, documentsUpdate, getUserData, auditConfigurationUpdate, auditConfigurationGet, CsmUsersGet, OpsUsersGet, userConfigurationUpdate, findClient, aggregateClient, createAuditQueue, findOne, getClientCount, insert, update } from '../service/client.service.js';
+import { checkFileExist, fileUpload, signedUrl, chunkArray, download, logger } from 'tango-app-api-middleware';
+import { countDocumentsUser, findOneUser } from '../service/user.service.js';
+import { aggregateStore, countDocumentsStore } from '../service/store.service.js';
+import { aggregateCamera, countDocumentsCamera } from '../service/camera.service.js';
+import _ from 'lodash';
 
 export async function create( req, res ) {
   try {
@@ -62,7 +66,7 @@ export async function changeStatus( req, res, next ) {
 export async function getClients( req, res ) {
   try {
     const field = { clientName: 1, clientId: 1 };
-    const result = await find( {}, field );
+    const result = await findClient( {}, field );
     if ( result == 0 ) {
       return res.sendError( 'No Data Found', 204 );
     }
@@ -72,3 +76,573 @@ export async function getClients( req, res ) {
     return res.sendError( error, 500 );
   }
 }
+
+
+export async function clientDetails( req, res ) {
+  try {
+    const client = await getClientData( { id: req.params.id } );
+    if ( client ) {
+      const isLogoExist = await checkFileExist( { Bucket: `sandbox-tango-client`, Key: `${client.clientId}/logo/${client.profileDetails?.logo}` } );
+      const isGstCertificateExist = await checkFileExist( { Bucket: `sandbox-tango-client`, Key: `${client.clientId}/documents/${client.document?.gst?.path}` } );
+      const isAddressCertificateExist = await checkFileExist( { Bucket: `sandbox-tango-client`, Key: `${client.clientId}/documents/${client.document?.addressProof?.path}` } );
+      const isPanCertificateExist = await checkFileExist( { Bucket: `sandbox-tango-client`, Key: `${client.clientId}/documents/${client.document?.pan?.path}` } );
+      const isCinCertificateExist = await checkFileExist( { Bucket: `sandbox-tango-client`, Key: `${client.clientId}/documents/${client.document?.cin?.path}` } );
+      const isContractCertificateExist = await checkFileExist( { Bucket: `sandbox-tango-client`, Key: `documents/contract.pdf` } );
+      const isTermsAndConditionsExist = await checkFileExist( { Bucket: `sandbox-tango-client`, Key: `documents/terms&conditions.pdf` } );
+
+
+      if ( isLogoExist ) {
+        const signedFilUrl = await signedUrl( { Bucket: 'sandbox-tango-client', file_path: `${client.clientId}/logo/${client.profileDetails?.logo}` } );
+        client.profileDetails.logo = signedFilUrl;
+      } else {
+        client.profileDetails.logo = '';
+      }
+
+      if ( isGstCertificateExist ) {
+        const signedFilUrl = await signedUrl( { Bucket: 'sandbox-tango-client', 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: 'sandbox-tango-client', 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: 'sandbox-tango-client', 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: 'sandbox-tango-client', 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: 'sandbox-tango-client', file_path: `documents/contract.pdf` } );
+        client._doc.document.contract = signedFilUrl;
+      } else {
+        client._doc.document.contract = '';
+      }
+
+      if ( isTermsAndConditionsExist ) {
+        const signedFilUrl = await signedUrl( { Bucket: 'sandbox-tango-client', file_path: `documents/terms&conditions.pdf` } );
+        client._doc.document.termsAndconditions = signedFilUrl;
+      } else {
+        client._doc.document.termsAndconditions = '';
+      }
+
+      const user = await getUserData( { id: client.userId } );
+      const userData = {
+        corporateEmail: user?.email,
+        countryCode: user?.countryCode,
+        mobileNumber: user?.mobileNumber,
+      };
+      return res.sendSuccess( { userData, ...client._doc } );
+    } else {
+      return res.sendError( 'Client not found', 404 );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, message: req.params, function: 'clientDetails' } );
+  }
+}
+export async function detailedAllClientCount( req, res ) {
+  try {
+    const query = [
+      {
+        $project: {
+          activeClient: { $cond: [ { $eq: [ '$status', 'active' ] }, 1, 0 ] },
+          paidClient: { $cond: [ { $eq: [ '$status', 'paid' ] }, 1, 0 ] },
+          trialClient: { $cond: [ { $eq: [ '$status', 'trial' ] }, 1, 0 ] },
+          freeClient: { $cond: [ { $eq: [ '$status', 'free' ] }, 1, 0 ] },
+          holdClient: { $cond: [ { $eq: [ '$status', 'hold' ] }, 1, 0 ] },
+          suspendClient: { $cond: [ { $eq: [ '$status', 'suspend' ] }, 1, 0 ] },
+          deactiveClient: { $cond: [ { $eq: [ '$status', 'deactive' ] }, 1, 0 ] },
+        },
+      },
+      {
+        $group: {
+          _id: null,
+          totalCount: { $sum: 1 },
+          activeClient: { $sum: '$activeClient' },
+          paidClient: { $sum: '$paidClient' },
+          trialClient: { $sum: '$trialClient' },
+          freeClient: { $sum: '$freeClient' },
+          holdClient: { $sum: '$holdClient' },
+          suspendClient: { $sum: '$suspendClient' },
+          deactiveClient: { $sum: '$deactiveClient' },
+
+        },
+      },
+    ];
+    const result = await aggregateClient( query );
+    if ( result == 0 ) {
+      return res.sendError( 'No Data Found', 204 );
+    }
+    return res.sendSuccess( { result: result } );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'detailedAllClientCount' } );
+    return res.sendError( error, 500 );
+  }
+}
+
+export async function updateBrandInfo( req, res ) {
+  try {
+    if ( req.files?.logo ) {
+      const uploadDataParams = {
+        Bucket: 'sandbox-tango-client',
+        Key: `${req.params.id}/logo/`,
+        fileName: `brandLogo.${req.files.logo.name.split( '.' )[1]}`,
+        ContentType: req.files.logo.mimetype,
+        body: req.files.logo.data,
+      };
+      await fileUpload( uploadDataParams );
+    }
+
+    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.logo?.logo ? `brandLogo.${req.files.logo.name.split( '.' )[1]}` : undefined,
+    } );
+    if ( updateAck ) {
+      res.sendSuccess( { result: 'Updated Successfully' } );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, message: req.params, function: 'updateBrandInfo' } );
+    return res.sendError( error, 500 );
+  }
+}
+
+export async function updateBillingDetails( req, res ) {
+  try {
+    if ( req.files?.gstCertificate ) {
+      const uploadDataParams = {
+        Bucket: 'sandbox-tango-client',
+        Key: `${req.params.id}/documents/`,
+        fileName: `gstCertificate.${req.files.gstCertificate.name.split( '.' )[1]}`,
+        ContentType: req.files.gstCertificate.mimetype,
+        body: req.files.gstCertificate.data,
+      };
+      await fileUpload( uploadDataParams );
+    }
+
+    const updateAck = await billingDetailsUpdate( {
+      clientId: req.params?.id, tradeName: req.body?.tradeName, gstNumber: req.body?.gstNumber,
+      authorityName: req.body?.authorityName, authorityEmail: req.body?.authorityEmail, billingAddress: req.body?.billingAddress,
+      gstCertificate: req.files?.gstCertificate ? `gstCertificate.${req.files?.gstCertificate.name.split( '.' )[1]}` : undefined,
+    } );
+    if ( updateAck ) {
+      res.sendSuccess( { result: 'Updated Successfully' } );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, message: req.params, function: 'updateBillingDetails' } );
+    return res.sendError( error, 500 );
+  }
+}
+
+export async function updateSignatoryDetails( req, res ) {
+  try {
+    const updateAck = await signatoryDetailsUpdate( {
+      clientId: req.params?.id, name: req.body?.name, email: req.body?.email,
+      number: req.body?.number, designation: req.body?.designation,
+    } );
+    if ( updateAck ) {
+      res.sendSuccess( { result: 'Updated Successfully' } );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, message: req.params, function: 'updateSignatoryDetails' } );
+    return res.sendError( error, 500 );
+  }
+}
+
+export async function updateTicketConfiguration( req, res ) {
+  try {
+    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,
+      isRefreshAlert: req.body?.isRefreshAlert, isStatusCheckAlert: req.body?.isStatusCheckAlert, rcaTicketAssign: req.body?.rcaTicketAssign, reTrain: req.body?.reTrain,
+      refreshAlert: req.body?.refreshAlert, sendToAdmin: req.body?.sendToAdmin, sendToUser: req.body?.sendToUser, statusCheckAlert: req.body?.statusCheckAlert,
+    } );
+    if ( updateAck ) {
+      res.sendSuccess( { result: 'Updated Successfully' } );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, message: req.params, function: 'updateTicketConfiguration' } );
+    return res.sendError( error, 500 );
+  }
+}
+
+export async function updateFeatureConfiguration( req, res ) {
+  try {
+    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,
+    } );
+    if ( updateAck ) {
+      res.sendSuccess( { result: 'Updated Successfully' } );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, message: req.params, function: 'updateTicketConfiguration' } );
+    return res.sendError( error, 500 );
+  }
+}
+
+export async function domainDetailsConfiguration( req, res ) {
+  try {
+    const updateAck = await domainDetailsConfigurationUpdate( {
+      clientId: req.params?.id, domainName: req.body?.domainName, isEnable: req.body?.isEnable,
+    } );
+    if ( updateAck ) {
+      res.sendSuccess( { result: 'Updated Successfully' } );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, message: req.params, function: 'domainDetailsConfiguration' } );
+    return res.sendError( error, 500 );
+  }
+}
+
+export async function userConfiguration( req, res ) {
+  try {
+    const updateAck = await userConfigurationUpdate( {
+      clientId: req.params?.id, csm: req.body?.csm, ops: req.body?.ops,
+    } );
+    if ( updateAck ) {
+      res.sendSuccess( { result: 'Updated Successfully' } );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, message: req.params, function: 'userConfiguration' } );
+    return res.sendError( error, 500 );
+  }
+}
+
+export async function updateDocuments( req, res ) {
+  try {
+    if ( req.files?.addressDoc ) {
+      const uploadDataParams = {
+        Bucket: 'sandbox-tango-client',
+        Key: `${req.params.id}/documents/`,
+        fileName: `addressCertificate.${req.files.addressDoc.name.split( '.' )[1]}`,
+        ContentType: req.files.addressDoc.mimetype,
+        body: req.files.addressDoc.data,
+      };
+      await fileUpload( uploadDataParams );
+    }
+    if ( req.files?.gstDoc ) {
+      const uploadDataParams = {
+        Bucket: 'sandbox-tango-client',
+        Key: `${req.params.id}/documents/`,
+        fileName: `gstCertificate.${req.files.gstDoc.name.split( '.' )[1]}`,
+        ContentType: req.files.gstDoc.mimetype,
+        body: req.files.gstDoc.data,
+      };
+      await fileUpload( uploadDataParams );
+    }
+    if ( req.files?.panDoc ) {
+      const uploadDataParams = {
+        Bucket: 'sandbox-tango-client',
+        Key: `${req.params.id}/documents/`,
+        fileName: `panCertificate.${req.files.panDoc.name.split( '.' )[1]}`,
+        ContentType: req.files.panDoc.mimetype,
+        body: req.files.panDoc.data,
+      };
+      await fileUpload( uploadDataParams );
+    }
+    if ( req.files?.cinDoc ) {
+      const uploadDataParams = {
+        Bucket: 'sandbox-tango-client',
+        Key: `${req.params.id}/documents/`,
+        fileName: `cinCertificate.${req.files.cinDoc.name.split( '.' )[1]}`,
+        ContentType: req.files.cinDoc.mimetype,
+        body: req.files.cinDoc.data,
+      };
+      await fileUpload( uploadDataParams );
+    }
+
+    const updateAck = await documentsUpdate( {
+      clientId: req.params?.id, gstNumber: req.body.gstNumber, panNumber: req.body.panNumber, cinNumber: req.body.cinNumber,
+      addressDoc: req.files?.addressDoc ? `addressCertificate.${req.files?.addressDoc.name.split( '.' )[1]}` : undefined,
+      gstDoc: req.files?.gstDoc ? `gstCertificate.${req.files?.gstDoc.name.split( '.' )[1]}` : undefined,
+      panDoc: req.files?.panDoc ? `panCertificate.${req.files?.panDoc.name.split( '.' )[1]}` : undefined,
+      cinDoc: req.files?.cinDoc ? `cinCertificate.${req.files?.cinDoc.name.split( '.' )[1]}` : undefined,
+
+    } );
+    if ( updateAck ) {
+      res.sendSuccess( { result: 'Updated Successfully' } );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, message: req.params, function: 'updateBillingDetails' } );
+    return res.sendError( error, 500 );
+  }
+}
+
+export async function getAuditConfiguration( req, res ) {
+  try {
+    const auditConfig = await auditConfigurationGet( { storeId: req.params?.id } );
+    if ( auditConfig ) {
+      const isDocExist = await checkFileExist( { Bucket: `sandbox-tango-client`, Key: `templates/audit_bulk_update.xlsx` } );
+      if ( isDocExist ) {
+        const signedFilUrl = await signedUrl( { Bucket: 'sandbox-tango-client', file_path: `templates/audit_bulk_update.xlsx` } );
+        auditConfig._doc.templateUrl = signedFilUrl;
+      } else {
+        auditConfig._doc.templateUrl = '';
+      }
+      res.sendSuccess( auditConfig );
+    } else {
+      res.sendError( { error: 'Store not found' }, 404 );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, message: req.params, function: 'getAuditConfiguration' } );
+    return res.sendError( error, 500 );
+  }
+}
+
+
+export async function auditConfiguration( req, res ) {
+  try {
+    for ( let i = 0; i < req.body?.length; i++ ) {
+      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 ),
+      } );
+    }
+    res.sendSuccess( { result: 'Updated Successfully' } );
+  } catch ( error ) {
+    logger.error( { error: error, message: req.params, function: 'auditConfiguration' } );
+    return res.sendError( error, 500 );
+  }
+}
+
+function normalizeNumber( num, min, max ) {
+  return ( ( num - min ) / ( max - min ) ).toFixed( 2 );
+}
+
+export async function getCsmUsers( req, res ) {
+  try {
+    const users = await CsmUsersGet();
+    if ( users?.length ) {
+      res.sendSuccess( users );
+    } else {
+      res.sendError( 'No users found', 404 );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, message: req.params, function: 'getAuditConfiguration' } );
+  }
+}
+export async function clientList( req, res ) {
+  try {
+    const inputData = req.body;
+    let clientQuery = [];
+    const limit =inputData.limit || 10;
+    const skip = inputData.offset? ( inputData.offset - 1 ) * limit : 0;
+    if ( inputData.filterByPaymentStatus ) {
+      clientQuery.push(
+          {
+            $match: {
+              'planDetails.paymentStatus': { $in: inputData.filterByPaymentStatus },
+            },
+          },
+      );
+    }
+    if ( inputData.filterBySubscription ) {
+      clientQuery.push(
+          {
+            $match: {
+              'planDetails.subscriptionType': { $in: inputData.filterBySubscription },
+            },
+          },
+      );
+    }
+    if ( inputData.filterByStatus ) {
+      clientQuery.push(
+          {
+            $match: {
+              status: { $in: inputData.filterByStatus },
+            },
+          },
+      );
+    }
+
+    clientQuery.push(
+        {
+          $project: {
+            status: 1,
+            clientName: 1,
+            clientId: 1,
+            subscriptionType: '$planDetails.subscriptionType',
+            paymentStatus: '$planDetails.paymentStatus',
+          },
+        },
+    );
+
+    if ( 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' } },
+          ],
+
+        },
+      } );
+    }
+    const clientCount = await aggregateClient( clientQuery );
+    if ( clientCount.length == 0 ) {
+      return res.sendError( { error: 'No Data Found' }, 204 );
+    }
+
+    if ( inputData.sortColumName ) {
+      clientQuery.push( {
+        $sort: { [inputData.sortColumName]: inputData.sortBy || -1 },
+      } );
+    }
+    if ( inputData.isExport ) {
+      clientQuery.push( {
+        $limit: 10000,
+      } );
+    } else {
+      clientQuery.push(
+          { $skip: skip },
+          { $limit: limit },
+      );
+    }
+    const client = await aggregateClient( clientQuery );
+    const clientListChunk = await chunkArray( client, 10 );
+    const promises = clientListChunk.map( async ( chunk ) => {
+      const list = [];
+      for ( let i = 0; i< chunk.length; i++ ) {
+        list.push( chunk[i].clientId );
+      }
+      return list;
+    } );
+    const clientList = await Promise.all( promises );
+    clientList.flat();
+    const storeQuery =[
+      {
+        $match: {
+          $and: [
+            { status: { $eq: 'active' } },
+            { clientId: { $in: clientList } },
+          ],
+
+        },
+      },
+      {
+        $group: {
+          _id: '$clientId',
+          clientId: { $first: '$clientId' },
+          activeStoreCount: { $sum: 1 },
+
+        },
+      },
+    ];
+
+    const cameraQuery =[
+      {
+        $match: {
+          $and: [
+            { isActivated: { $eq: true } },
+            { isUp: { $eq: true } },
+            { clientId: { $in: clientList } },
+          ],
+        },
+      },
+      {
+        $group: {
+          _id: '$clientId',
+          clientId: { $first: '$clientId' },
+          activeCameraCount: { $sum: 1 },
+
+        },
+      },
+    ];
+
+    const activeStoreCount = await aggregateStore( storeQuery );
+    const activeCameraCount = await aggregateCamera( cameraQuery );
+    const result =_.values(
+        _.merge(
+            _.keyBy( client, 'clientId' ),
+            _.keyBy( activeStoreCount, 'clientId' ),
+            _.keyBy( activeCameraCount, 'clientId' ),
+        ),
+    );
+    if ( inputData.isExport ) {
+      const resultChunk = await chunkArray( result, 10 );
+      const promises = resultChunk.map( async ( chunk ) => {
+        const list = [];
+        for ( let i = 0; i< chunk.length; i++ ) {
+          list.push( {
+            'client Name': chunk[i].clientName,
+            'client Id': chunk[i].clientId,
+            'Active Store': chunk[i].activeStoreCount,
+            'Active Camera': chunk[i].activeCameraCount,
+            'Payment Status': chunk[i].paymentStatus,
+            'Subs Plan': chunk[i].subscriptionType,
+            'Status': chunk[i].status,
+          } );
+        }
+        return list;
+      } );
+      const exportResult = await Promise.all( promises );
+      exportResult.flat();
+      await download( exportResult, res );
+      return;
+    }
+    return res.sendSuccess( { result: result, count: clientCount.length } );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'clientList' } );
+    return res.sendError( error, 500 );
+  }
+}
+
+export async function getOpsUsers( req, res ) {
+  try {
+    const users = await OpsUsersGet();
+    if ( users?.length ) {
+      res.sendSuccess( users );
+    } else {
+      res.sendError( 'No users found', 404 );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, message: req.params, function: 'getOpsUsers' } );
+    return res.sendError( error, 500 );
+  }
+}
+
+
+export async function detailedClientCount( req, res ) {
+  try {
+    const inputData = req.query;
+    let result = {
+      clientName: inputData.clientName,
+      role: 'admin',
+    };
+    result['totalStoreCount'] = await countDocumentsStore( { clientId: inputData.clientId } );
+    result['totalGroupCount'] = await countDocumentsStore( { clientId: inputData.clientId } );
+    result['totalCameraCount'] = await countDocumentsCamera( { clientId: inputData.clientId } );
+    result['totalUserCount'] = await countDocumentsUser( { clientId: inputData.clientId, userType: 'client' } );
+
+    const user = await findOneUser( { _id: inputData.userId }, { userName: 1, email: 1 } );
+    result['userName'] = user?.userName;
+    result['email'] = user?.email;
+    result['profileCompletion'] = 70;
+
+    return res.sendSuccess( { result: result } );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'detailedClientCount' } );
+    return res.sendError( error, 500 );
+  }
+}