tango-app-api-client 3.0.1 → 3.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-client",
-    "version": "3.0.1",
+    "version": "3.0.3",
     "description": "client",
     "main": "index.js",
     "type": "module",
@@ -14,14 +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.33",
-        "tango-app-api-middleware": "^1.0.16",
+        "tango-app-api-middleware": "^1.0.24",
         "winston": "^3.11.0",
         "winston-daily-rotate-file": "^5.0.0"
     },

package/src/controllers/client.controllers.js

@@ -1,5 +1,5 @@
-import { logger } from 'tango-app-api-middleware';
-import { createAuditQueue, findOne, getClientCount, insert, update, findClient, aggregateClient } 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';
@@ -77,6 +77,83 @@ export async function getClients( req, res ) {
   }
 }
 
+
+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 = [
@@ -117,26 +194,298 @@ export async function detailedAllClientCount( req, res ) {
   }
 }
 
+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;
-    let clientQuery = [
-      {
-        $project: {
-          status: 1,
-          clientName: 1,
-          clientId: 1,
-          subscriptionType: 1,
-        },
-      },
-    ];
-    const clientCount = await aggregateClient( clientQuery );
-    if ( clientCount.length == 0 ) {
-      return res.sendError( { error: 'No Data Found' }, 204 );
+    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: {
@@ -150,19 +499,37 @@ export async function clientList( req, res ) {
         },
       } );
     }
+    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 },
       } );
     }
-
-    clientQuery.push(
-        { $skip: skip },
-        { $limit: limit },
-    );
+    if ( inputData.isExport ) {
+      clientQuery.push( {
+        $limit: 10000,
+      } );
+    } else {
+      clientQuery.push(
+          { $skip: skip },
+          { $limit: limit },
+      );
+    }
     const client = await aggregateClient( clientQuery );
-    const clientList = client.map( ( item ) => item.clientId );
+    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: {
@@ -212,6 +579,28 @@ export async function clientList( req, res ) {
             _.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' } );
@@ -219,6 +608,21 @@ export async function clientList( req, res ) {
   }
 }
 
+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;

package/src/dtos/client.dtos.js

@@ -1,14 +1,221 @@
 import joi from 'joi';
 
+export const clientDetailsSchema = joi.object( {
+  id: joi.string().required(),
+} );
+
+export const clientDetailsValid = {
+  params: clientDetailsSchema,
+};
+
+export const brandInfoSchemaBody = joi.object( {
+  registeredCompanyName: joi.string().optional(),
+  industry: joi.string().optional(),
+  clientType: joi.string().optional(),
+  registeredAddress: joi.string().optional(),
+  headQuarters: joi.string().optional(),
+  website: joi.string().optional(),
+  status: joi.string().optional(),
+  logo: joi.string().optional().allow( '' ),
+  clientId: joi.string().optional(),
+} );
+
+export const brandInfoSchemaParam = joi.object( {
+  id: joi.string().required(),
+} );
+
+export const brandInfoValid = {
+  params: brandInfoSchemaParam,
+  body: brandInfoSchemaBody,
+};
+
+export const billingDetailsSchemaBody = joi.object( {
+  tradeName: joi.string().optional(),
+  gstNumber: joi.string().optional(),
+  authorityName: joi.string().optional(),
+  authorityEmail: joi.string().optional(),
+  billingAddress: joi.string().optional(),
+  gstCertificate: joi.string().optional().allow( '' ),
+} );
+
+export const billingDetailsSchemaParam = joi.object( {
+  id: joi.string().required(),
+} );
+
+export const billingDetailsValid = {
+  params: billingDetailsSchemaParam,
+  body: billingDetailsSchemaBody,
+};
+
+export const signatoryDetailsSchemaBody = joi.object( {
+  name: joi.string().optional(),
+  email: joi.string().email().optional(),
+  number: joi.string().optional(),
+  designation: joi.string().optional(),
+} );
+
+export const signatoryDetailsSchemaParam = joi.object( {
+  id: joi.string().required(),
+} );
+
+export const signatoryDetailsValid = {
+  params: signatoryDetailsSchemaParam,
+  body: signatoryDetailsSchemaBody,
+};
+
+export const ticketConfigurationSchemaBody = joi.object( {
+  installationReAssign: joi.number().optional(),
+  sendToAdmin: joi.boolean().optional(),
+  sendToUser: joi.boolean().optional(),
+  downTimeType: joi.number().optional(),
+  infraDownTime: joi.number().optional(),
+  MinFilesCount: joi.number().optional(),
+  isRcaTicketAssign: joi.boolean().optional(),
+  rcaTicketAssign: joi.number().optional(),
+  isRefreshAlert: joi.boolean().optional(),
+  refreshAlert: joi.number().optional(),
+  isStatusCheckAlert: joi.boolean().optional(),
+  statusCheckAlert: joi.number().optional(),
+  accuracyPercentage: joi.number().optional(),
+  reTrain: joi.number().optional(),
+} );
+
+export const ticketConfigurationSchemaParam = joi.object( {
+  id: joi.string().required(),
+} );
+
+export const ticketConfigurationValid = {
+  params: ticketConfigurationSchemaParam,
+  body: ticketConfigurationSchemaBody,
+};
+
+export const featureConfigurationSchemaBody = joi.object(
+    {
+      open: joi.string().optional(),
+      close: joi.string().optional(),
+      infraAlertCondition: joi.string().optional(),
+      infraAlertValue: joi.number().optional(),
+      bouncedLimitCondition: joi.string().optional(),
+      bouncedLimitValue: joi.number().optional(),
+      conversionCondition: joi.string().optional(),
+      conversionValue: joi.number().optional(),
+      billableCalculation: joi.string().optional(),
+      missedOpportunityCalculation: joi.string().optional(),
+      conversionCalculation: joi.string().optional(),
+      isNormalized: joi.boolean().optional(),
+      isPasserByData: joi.boolean().optional(),
+      isFootfallDirectory: joi.boolean().optional(),
+    },
+);
+
+export const featureConfigurationSchemaParam = joi.object( {
+  id: joi.string().required(),
+} );
+
+export const featureConfigurationValid = {
+  params: featureConfigurationSchemaParam,
+  body: featureConfigurationSchemaBody,
+};
+
+export const domainDetailsSchemaBody = joi.object(
+    {
+      domainName: joi.array().items( joi.string() ).required(),
+      isEnable: joi.boolean().required(),
+    },
+);
+
+export const domainDetailsSchemaParam = joi.object( {
+  id: joi.string().required(),
+} );
+
+export const domainDetailsValid = {
+  params: domainDetailsSchemaParam,
+  body: domainDetailsSchemaBody,
+};
+
+export const userConfigurationSchemaBody = joi.object(
+    {
+      csm: joi.object( { userName: joi.string().required(), _id: joi.string().required() } ).required(),
+      ops: joi.array().items( joi.object( { userName: joi.string().required(), _id: joi.string().required() } ).required() ).required(),
+    },
+);
+
+export const userConfigurationSchemaParam = joi.object( {
+  id: joi.string().required(),
+} );
+
+export const userConfigurationValid = {
+  params: userConfigurationSchemaParam,
+  body: userConfigurationSchemaBody,
+};
+
 export const clientCreationSchema = joi.object( {
   status: joi.string().required(),
   clientName: joi.string().required(),
+  csm: joi.string().optional(),
 } );
 
 export const clientCreationValid = {
   body: clientCreationSchema,
 };
 
+export const documentsSchemaBody = joi.object(
+    {
+      gstNumber: joi.string().optional(),
+      panNumber: joi.string().optional(),
+      cinNumber: joi.string().optional(),
+      addressDoc: joi.string().optional().allow( '' ),
+      gstDoc: joi.string().optional().allow( '' ),
+      panDoc: joi.string().optional().allow( '' ),
+      cinDoc: joi.string().optional().allow( '' ),
+    },
+);
+
+export const documentsSchemaParam = joi.object( {
+  id: joi.string().required(),
+} );
+
+export const documentsSchemaFiles = joi.object(
+    {
+      addressDoc: joi.object().optional(),
+      gstDoc: joi.object().optional(),
+      panDoc: joi.object().optional(),
+      cinDoc: joi.object().optional(),
+    },
+);
+
+export const documentsValid = {
+  params: documentsSchemaParam,
+  body: documentsSchemaBody,
+  files: documentsSchemaFiles,
+};
+
+export const getAuditConfigSchemaParam = joi.object( {
+  id: joi.string().required(),
+} );
+
+export const getAuditConfigValid = {
+  params: getAuditConfigSchemaParam,
+};
+
+
+export const auditConfigSchemaBody = joi.array().items(
+    joi.object(
+        {
+          ratio: joi.number().required(),
+          count: joi.number().required(),
+          iteration: joi.number().required(),
+          storeId: joi.string().required(),
+        },
+    ).required(),
+).required();
+
+
+export const auditConfigValid = {
+  body: auditConfigSchemaBody,
+};
+
+
 export const detailedClientCountSchema = joi.object( {
   clientId: joi.string().required(),
 } );
@@ -22,6 +229,9 @@ export const clientListSchema = joi.object( {
   searchValue: joi.string().optional(),
   sortColumName: joi.string().optional(),
   sortBy: joi.number().optional(),
+  filterByPaymentStatus: joi.array().optional(),
+  filterBySubscription: joi.array().optional(),
+  filterByStatus: joi.array().optional(),
   limit: joi.number().optional(),
   offset: joi.number().optional(),
 } );

package/src/routes/client.routes.js

@@ -1,16 +1,31 @@
 
 import express from 'express';
-import { validate } from 'tango-app-api-middleware';
-import { clientCreationValid, clientListValid, detailedClientCountValid } from '../dtos/client.dtos.js';
+import { auditConfigValid, billingDetailsValid, brandInfoValid, clientCreationValid, clientDetailsValid, documentsValid, domainDetailsValid, featureConfigurationValid, getAuditConfigValid, signatoryDetailsValid, ticketConfigurationValid, userConfigurationValid } from '../dtos/client.dtos.js';
+import { auditConfiguration, changeStatus, clientDetails, create, domainDetailsConfiguration, getAuditConfiguration, getClients, getCsmUsers, getOpsUsers, updateBillingDetails, updateBrandInfo, updateDocuments, updateFeatureConfiguration, updateSignatoryDetails, updateTicketConfiguration, userConfiguration } from '../controllers/client.controllers.js';
+import { isAllowedSessionHandler, validate } from 'tango-app-api-middleware';
+import { clientListValid, detailedClientCountValid } from '../dtos/client.dtos.js';
 import { isclientIdExists, isclientNameExists } from '../validations/client.validations.js';
-import { changeStatus, create, getClients, detailedAllClientCount, detailedClientCount, clientList } from '../controllers/client.controllers.js';
+import { detailedAllClientCount, detailedClientCount, clientList } from '../controllers/client.controllers.js';
 
 export const clientRouter = express.Router();
 
-clientRouter.post( '/create', validate( clientCreationValid ), isclientNameExists, changeStatus, create );
-clientRouter.get( '/get-clients', getClients );
-clientRouter.get( '/detailed-all-client-count', detailedAllClientCount );
-clientRouter.post( '/client-list', validate( clientListValid ), clientList );
-clientRouter.get( '/detailed-client-count', validate( detailedClientCountValid ), isclientIdExists, detailedClientCount );
+clientRouter.post( '/create', isAllowedSessionHandler, validate( clientCreationValid ), isclientNameExists, changeStatus, create );
+clientRouter.get( '/get-clients', isAllowedSessionHandler, getClients );
+clientRouter.get( '/client-details/:id', isAllowedSessionHandler, validate( clientDetailsValid ), clientDetails );
+clientRouter.put( '/brand-info/:id', isAllowedSessionHandler, validate( brandInfoValid ), updateBrandInfo );
+clientRouter.put( '/billing-details/:id', isAllowedSessionHandler, validate( billingDetailsValid ), updateBillingDetails );
+clientRouter.put( '/signatory-details/:id', isAllowedSessionHandler, validate( signatoryDetailsValid ), updateSignatoryDetails );
+clientRouter.put( '/ticket-configuration/:id', isAllowedSessionHandler, validate( ticketConfigurationValid ), updateTicketConfiguration );
+clientRouter.put( '/feature-configuration/:id', isAllowedSessionHandler, validate( featureConfigurationValid ), updateFeatureConfiguration );
+clientRouter.put( '/domain-details/:id', isAllowedSessionHandler, validate( domainDetailsValid ), domainDetailsConfiguration );
+clientRouter.put( '/user-configuration/:id', isAllowedSessionHandler, validate( userConfigurationValid ), userConfiguration );
+clientRouter.put( '/documents/:id', isAllowedSessionHandler, validate( documentsValid ), updateDocuments );
+clientRouter.get( '/audit-configuration/:id', isAllowedSessionHandler, validate( getAuditConfigValid ), getAuditConfiguration );
+clientRouter.post( '/audit-configuration', isAllowedSessionHandler, validate( auditConfigValid ), auditConfiguration );
+clientRouter.get( '/get-csm-users', isAllowedSessionHandler, getCsmUsers );
+clientRouter.get( '/get-ops-users', isAllowedSessionHandler, getOpsUsers );
+clientRouter.get( '/detailed-all-client-count', isAllowedSessionHandler, detailedAllClientCount );
+clientRouter.post( '/client-list', isAllowedSessionHandler, validate( clientListValid ), clientList );
+clientRouter.get( '/detailed-client-count', isAllowedSessionHandler, validate( detailedClientCountValid ), isclientIdExists, detailedClientCount );
 
 

package/src/service/client.service.js

@@ -1,24 +1,28 @@
-import model from 'tango-api-schema';
+import clientModel from 'tango-api-schema/schema/client.model.js';
+import leadModel from 'tango-api-schema/schema/lead.model.js';
+import storeModel from 'tango-api-schema/schema/store.model.js';
+import userModel from 'tango-api-schema/schema/user.model.js';
 // import { createQueue, getQueueUrl } from 'tango-app-api-middleware';
 
+
 export function update( query, record ) {
-  return model.leadModel.updateMany( query, { $set: record } );
+  return leadModel.updateMany( query, { $set: record } );
 }
 
 export function findOne( query, field ) {
-  return model.leadModel.findOne( query, field );
+  return leadModel.findOne( query, field );
 }
 
 export function getClientCount( query ) {
-  return model.clientModel.countDocuments( query );
+  return clientModel.countDocuments( query );
 }
 
 export function insert( record ) {
-  return model.clientModel.insertMany( record );
+  return clientModel.insertMany( record );
 }
 
 export function findClient( query, field ) {
-  return model.clientModel.find( query, field );
+  return clientModel.find( query, field );
 }
 
 export async function createAuditQueue( queueName ) {
@@ -39,16 +43,235 @@ export async function createAuditQueue( queueName ) {
     // }
     return true;
   } catch ( error ) {
-    return false;
     logger.error( { error: error, message: queueName, function: 'createAuditQueue' } );
+    return false;
   }
 }
 
+
+export function getClientData( { id } ) {
+  return clientModel.findOne( { clientId: id } );
+}
+
+export function getUserData( { id } ) {
+  return userModel.findOne( { _id: id }, { email: 1, countryCode: 1, mobileNumber: 1 } );
+}
+
+export function brandInfoUpdate( { clientId, registeredCompanyName, industry, clientType, registeredAddress, headQuarters, website, status, logo } ) {
+  return clientModel.updateOne( { clientId: clientId },
+      {
+        $set: {
+          'profileDetails.registeredCompanyName': registeredCompanyName,
+          'profileDetails.industry': industry,
+          'profileDetails.clientType': clientType,
+          'profileDetails.registeredAddress': registeredAddress,
+          'profileDetails.headQuarters': headQuarters,
+          'profileDetails.website': website,
+          'profileDetails.logo': logo,
+          'status': status,
+        },
+      } );
+}
+
+export function billingDetailsUpdate( { clientId, tradeName, gstNumber, authorityName, authorityEmail, billingAddress, gstCertificate } ) {
+  return clientModel.updateOne( { clientId: clientId },
+      {
+        $set: {
+          'billingDetails.tradeName': tradeName,
+          'billingDetails.gstNumber': gstNumber,
+          'billingDetails.authorityName': authorityName,
+          'billingDetails.authorityEmail': authorityEmail,
+          'billingDetails.billingAddress': billingAddress,
+          'document.gst.number': gstNumber,
+          'document.gst.path': gstCertificate,
+        },
+      } );
+}
+
+export function signatoryDetailsUpdate( { clientId, name, email, number, designation } ) {
+  return clientModel.updateOne( { clientId: clientId },
+      {
+        $set: {
+          'signatoryDetail.name': name,
+          'signatoryDetail.email': email,
+          'signatoryDetail.number': number,
+          'signatoryDetail.designation': designation,
+        },
+      } );
+}
+
+export function ticketConfigurationUpdate( {
+  clientId, MinFilesCount, accuracyPercentage, downTimeType, infraDownTime, installationReAssign, isRcaTicketAssign,
+  isRefreshAlert, isStatusCheckAlert, rcaTicketAssign, reTrain, refreshAlert, sendToAdmin, sendToUser, statusCheckAlert,
+} ) {
+  return clientModel.updateOne( { clientId: clientId },
+      {
+        $set: {
+          'ticketConfigs.installationReAssign': installationReAssign,
+          'ticketConfigs.alertSentTo.admin': sendToAdmin,
+          'ticketConfigs.alertSentTo.user': sendToUser,
+          'ticketConfigs.downTimeType': downTimeType,
+          'ticketConfigs.infraDownTime': infraDownTime,
+          'ticketConfigs.MinFilesCount': MinFilesCount,
+          'ticketConfigs.isRcaTicketAssign': isRcaTicketAssign,
+          'ticketConfigs.rcaTicketAssign': rcaTicketAssign,
+          'ticketConfigs.isRefreshAlert': isRefreshAlert,
+          'ticketConfigs.refreshAlert': refreshAlert,
+          'ticketConfigs.isStatusCheckAlert': isStatusCheckAlert,
+          'ticketConfigs.statusCheckAlert': statusCheckAlert,
+          'ticketConfigs.reTrain': reTrain,
+          'ticketConfigs.accuracyPercentage': accuracyPercentage,
+        },
+      } );
+}
+
+export function featureConfigurationUpdate( {
+  clientId, billableCalculation, bouncedLimitCondition, bouncedLimitValue,
+  close, conversionCalculation, conversionCondition,
+  conversionValue, infraAlertCondition, infraAlertValue, isFootfallDirectory,
+  isNormalized, isPasserByData, missedOpportunityCalculation, open,
+} ) {
+  return clientModel.updateOne( { clientId: clientId },
+      {
+        $set: {
+          'featureConfigs.open': open,
+          'featureConfigs.close': close,
+          'featureConfigs.infraAlert.condition': infraAlertCondition,
+          'featureConfigs.infraAlert.value': infraAlertValue,
+          'featureConfigs.bouncedLimit.condition': bouncedLimitCondition,
+          'featureConfigs.bouncedLimit.value': bouncedLimitValue,
+          'featureConfigs.conversion.condition': conversionCondition,
+          'featureConfigs.conversion.value': conversionValue,
+          'featureConfigs.billableCalculation': billableCalculation,
+          'featureConfigs.missedOpportunityCalculation': missedOpportunityCalculation,
+          'featureConfigs.conversionCalculation': conversionCalculation,
+          'featureConfigs.isNormalized': isNormalized,
+          'featureConfigs.isPasserByData': isPasserByData,
+          'featureConfigs.isFootfallDirectory': isFootfallDirectory,
+        },
+      } );
+}
+
+export function domainDetailsConfigurationUpdate( { clientId, domainName, isEnable } ) {
+  return clientModel.updateOne( { clientId: clientId },
+      {
+        $set: {
+          'ssoLogin.domainName': domainName,
+          'ssoLogin.isEnable': isEnable,
+        },
+      } );
+}
+
+export function userConfigurationUpdate( { clientId, csm, ops } ) {
+  return clientModel.updateOne( { clientId: clientId },
+      {
+        $set: {
+          'assignedUsers.csm': csm,
+          'assignedUsers.ops': ops,
+        },
+      } );
+}
+
+export function documentsUpdate( { clientId, gstNumber, panNumber, cinNumber, addressDoc, gstDoc, panDoc, cinDoc } ) {
+  return clientModel.updateOne( { clientId: clientId },
+      {
+        $set: {
+          'document.addressProof.path': addressDoc,
+          'document.gst.number': gstNumber,
+          'document.gst.path': gstDoc,
+          'document.pan.number': panNumber,
+          'document.pan.path': panDoc,
+          'document.pan.number': panNumber,
+          'document.pan.path': panDoc,
+          'document.cin.number': cinNumber,
+          'document.cin.path': cinDoc,
+        },
+      } );
+}
+
+export function auditConfigurationGet( { storeId } ) {
+  return storeModel.findOne( { storeId: storeId },
+      {
+        'auditConfigs.count': 1,
+        'auditConfigs.iteration': 1,
+        'auditConfigs.ratio': 1,
+        'storeId': 1,
+        '_id': 0,
+      } );
+}
+
+export function auditConfigurationUpdate( { storeId, count, iteration, ratio } ) {
+  return storeModel.updateOne( { storeId: storeId },
+      {
+        $set: {
+          'auditConfigs.count': count,
+          'auditConfigs.iteration': iteration,
+          'auditConfigs.ratio': ratio,
+        },
+      } );
+}
+
+export function CsmUsersGet( ) {
+  return userModel.aggregate(
+      [
+        {
+          $match: {
+            $and: [
+              {
+                role: 'admin',
+              },
+              {
+                userType: 'tango',
+              },
+            ],
+          },
+        },
+        {
+          $project: {
+            userName: 1,
+          },
+        },
+      ],
+  );
+}
+
+export function OpsUsersGet( ) {
+  return userModel.aggregate(
+      [
+        {
+          $match: {
+            $and: [
+              {
+                $or: [
+                  {
+                    role: 'user',
+                  },
+                  {
+                    role: 'admin',
+                  },
+                ],
+              },
+              {
+                userType: 'tango',
+              },
+            ],
+          },
+        },
+        {
+          $project: {
+            userName: 1,
+          },
+        },
+      ],
+  );
+}
+
+
 export function aggregateClient( query ) {
-  return model.clientModel.aggregate( query );
+  return clientModel.aggregate( query );
 }
 
 export function findOneClient( query, field ) {
-  return model.clientModel.findOne( query, field );
+  return clientModel.findOne( query, field );
 }
 

package/src/services/client.services.js

@@ -0,0 +1,263 @@
+import clientModel from 'tango-api-schema/schema/client.model.js';
+import leadModel from 'tango-api-schema/schema/lead.model.js';
+import storeModel from 'tango-api-schema/schema/store.model.js';
+import userModel from 'tango-api-schema/schema/user.model.js';
+// import { createQueue, getQueueUrl } from 'tango-app-api-middleware';
+
+
+export function update( query, record ) {
+  return leadModel.updateMany( query, { $set: record } );
+}
+
+export function findOne( query, field ) {
+  return leadModel.findOne( query, field );
+}
+
+export function getClientCount( query ) {
+  return clientModel.countDocuments( query );
+}
+
+export function insert( record ) {
+  return clientModel.insertMany( record );
+}
+
+export function find( query, field ) {
+  return clientModel.find( query, field );
+}
+
+export async function createAuditQueue( queueName ) {
+  try {
+    // const isExist = await getQueueUrl( `${queueName}${config.aws.sqs.queueType}` );
+    // if ( isExist.statusCode ) {
+    //   const addQueue = await createQueue( `${queueName}${config.aws.sqs.queueType}` );
+    //   if ( addQueue.QueueUrl ) {
+    //     logger.info(
+    //         'Queueue Created'
+    //         , { queueName: addQueue.QueueUrl, addQueue },
+    //     );
+    //   } else {
+    //     logger.error( { error: 'Queue creation failed', function: 'createAuditQueue' } );
+    //   }
+    // } else {
+    //   logger.error( { error: 'Queue already exisit', message: queueName, function: 'createAuditQueue' } );
+    // }
+    return true;
+  } catch ( error ) {
+    return false;
+    logger.error( { error: error, message: queueName, function: 'createAuditQueue' } );
+  }
+}
+
+
+export function getClientData( { id } ) {
+  return clientModel.findOne( { clientId: id } );
+}
+
+export function getUserData( { id } ) {
+  return userModel.findOne( { _id: id }, { email: 1, countryCode: 1, mobileNumber: 1 } );
+}
+
+export function brandInfoUpdate( { clientId, registeredCompanyName, industry, clientType, registeredAddress, headQuarters, website, status, logo } ) {
+  return clientModel.updateOne( { clientId: clientId },
+      {
+        $set: {
+          'profileDetails.registeredCompanyName': registeredCompanyName,
+          'profileDetails.industry': industry,
+          'profileDetails.clientType': clientType,
+          'profileDetails.registeredAddress': registeredAddress,
+          'profileDetails.headQuarters': headQuarters,
+          'profileDetails.website': website,
+          'profileDetails.logo': logo,
+          'status': status,
+        },
+      } );
+}
+
+export function billingDetailsUpdate( { clientId, tradeName, gstNumber, authorityName, authorityEmail, billingAddress, gstCertificate } ) {
+  return clientModel.updateOne( { clientId: clientId },
+      {
+        $set: {
+          'billingDetails.tradeName': tradeName,
+          'billingDetails.gstNumber': gstNumber,
+          'billingDetails.authorityName': authorityName,
+          'billingDetails.authorityEmail': authorityEmail,
+          'billingDetails.billingAddress': billingAddress,
+          'document.gst.number': gstNumber,
+          'document.gst.path': gstCertificate,
+        },
+      } );
+}
+
+export function signatoryDetailsUpdate( { clientId, name, email, number, designation } ) {
+  return clientModel.updateOne( { clientId: clientId },
+      {
+        $set: {
+          'signatoryDetail.name': name,
+          'signatoryDetail.email': email,
+          'signatoryDetail.number': number,
+          'signatoryDetail.designation': designation,
+        },
+      } );
+}
+
+export function ticketConfigurationUpdate( {
+  clientId, MinFilesCount, accuracyPercentage, downTimeType, infraDownTime, installationReAssign, isRcaTicketAssign,
+  isRefreshAlert, isStatusCheckAlert, rcaTicketAssign, reTrain, refreshAlert, sendToAdmin, sendToUser, statusCheckAlert,
+} ) {
+  return clientModel.updateOne( { clientId: clientId },
+      {
+        $set: {
+          'ticketConfigs.installationReAssign': installationReAssign,
+          'ticketConfigs.alertSentTo.admin': sendToAdmin,
+          'ticketConfigs.alertSentTo.user': sendToUser,
+          'ticketConfigs.downTimeType': downTimeType,
+          'ticketConfigs.infraDownTime': infraDownTime,
+          'ticketConfigs.MinFilesCount': MinFilesCount,
+          'ticketConfigs.isRcaTicketAssign': isRcaTicketAssign,
+          'ticketConfigs.rcaTicketAssign': rcaTicketAssign,
+          'ticketConfigs.isRefreshAlert': isRefreshAlert,
+          'ticketConfigs.refreshAlert': refreshAlert,
+          'ticketConfigs.isStatusCheckAlert': isStatusCheckAlert,
+          'ticketConfigs.statusCheckAlert': statusCheckAlert,
+          'ticketConfigs.reTrain': reTrain,
+          'ticketConfigs.accuracyPercentage': accuracyPercentage,
+        },
+      } );
+}
+
+export function featureConfigurationUpdate( {
+  clientId, billableCalculation, bouncedLimitCondition, bouncedLimitValue,
+  close, conversionCalculation, conversionCondition,
+  conversionValue, infraAlertCondition, infraAlertValue, isFootfallDirectory,
+  isNormalized, isPasserByData, missedOpportunityCalculation, open,
+} ) {
+  return clientModel.updateOne( { clientId: clientId },
+      {
+        $set: {
+          'featureConfigs.open': open,
+          'featureConfigs.close': close,
+          'featureConfigs.infraAlert.condition': infraAlertCondition,
+          'featureConfigs.infraAlert.value': infraAlertValue,
+          'featureConfigs.bouncedLimit.condition': bouncedLimitCondition,
+          'featureConfigs.bouncedLimit.value': bouncedLimitValue,
+          'featureConfigs.conversion.condition': conversionCondition,
+          'featureConfigs.conversion.value': conversionValue,
+          'featureConfigs.billableCalculation': billableCalculation,
+          'featureConfigs.missedOpportunityCalculation': missedOpportunityCalculation,
+          'featureConfigs.conversionCalculation': conversionCalculation,
+          'featureConfigs.isNormalized': isNormalized,
+          'featureConfigs.isPasserByData': isPasserByData,
+          'featureConfigs.isFootfallDirectory': isFootfallDirectory,
+        },
+      } );
+}
+
+export function domainDetailsConfigurationUpdate( { clientId, domainName, isEnable } ) {
+  return clientModel.updateOne( { clientId: clientId },
+      {
+        $set: {
+          'ssoLogin.domainName': domainName,
+          'ssoLogin.isEnable': isEnable,
+        },
+      } );
+}
+
+export function userConfigurationUpdate( { clientId, csm, ops } ) {
+  return clientModel.updateOne( { clientId: clientId },
+      {
+        $set: {
+          'assignedUsers.csm': csm,
+          'assignedUsers.ops': ops,
+        },
+      } );
+}
+
+export function documentsUpdate( { clientId, gstNumber, panNumber, cinNumber, addressDoc, gstDoc, panDoc, cinDoc } ) {
+  return clientModel.updateOne( { clientId: clientId },
+      {
+        $set: {
+          'document.addressProof.path': addressDoc,
+          'document.gst.number': gstNumber,
+          'document.gst.path': gstDoc,
+          'document.pan.number': panNumber,
+          'document.pan.path': panDoc,
+          'document.pan.number': panNumber,
+          'document.pan.path': panDoc,
+          'document.cin.number': cinNumber,
+          'document.cin.path': cinDoc,
+        },
+      } );
+}
+
+export function auditConfigurationGet( { storeId } ) {
+  return storeModel.findOne( { storeId: storeId },
+      {
+        'auditConfigs.count': 1,
+        'auditConfigs.iteration': 1,
+        'auditConfigs.ratio': 1,
+        'storeId': 1,
+        '_id': 0,
+      } );
+}
+
+export function auditConfigurationUpdate( { storeId, count, iteration, ratio } ) {
+  return storeModel.updateOne( { storeId: storeId },
+      {
+        $set: {
+          'auditConfigs.count': count,
+          'auditConfigs.iteration': iteration,
+          'auditConfigs.ratio': ratio,
+        },
+      } );
+}
+
+export function CsmUsersGet( ) {
+  return userModel.aggregate( [
+    {
+      $match: {
+        $and: [
+          {
+            $or: [
+              {
+                role: 'user',
+              },
+              {
+                role: 'admin',
+              },
+            ],
+          },
+          {
+            userType: 'tango',
+          },
+        ],
+      },
+    },
+    {
+      $project: {
+        userName: 1,
+      },
+    },
+  ] );
+}
+
+export function OpsUsersGet( ) {
+  return userModel.aggregate( [
+    {
+      $match: {
+        $and: [
+          {
+            role: 'user',
+          },
+          {
+            userType: 'tango',
+          },
+        ],
+      },
+    },
+    {
+      $project: {
+        userName: 1,
+      },
+    },
+  ] );
+}