tango-app-api-client 3.6.5-vms.0 → 3.6.5-vms.10

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "tango-app-api-client",
-  "version": "3.6.5-vms.0",
+  "version": "3.6.5-vms.10",
   "description": "client",
   "main": "index.js",
-  "type": "module",
+  "type": "module", 
   "scripts": {
     "start": "nodemon --exec \"eslint --fix . && node app.js\"",
     "build:patch": "node build.js patch && npm publish",
@@ -18,6 +18,7 @@
   "dependencies": {
     "aws-sdk": "^2.1560.0",
     "cors": "^2.8.5",
+    "dayjs": "^1.11.19",
     "dotenv": "^16.4.4",
     "express": "^4.18.2",
     "express-fileupload": "^1.4.3",
@@ -30,7 +31,7 @@
     "npm": "^10.9.1",
     "sharp": "^0.34.3",
     "swagger-ui-express": "^5.0.0",
-    "tango-api-schema": "^2.4.19",
+    "tango-api-schema": "^2.4.27",
     "tango-app-api-middleware": "^3.6.0",
     "winston": "^3.11.0",
     "winston-daily-rotate-file": "^5.0.0"

package/src/controllers/client.controllers.js

@@ -1,7 +1,7 @@
 import { billingDetailsUpdate, brandInfoUpdate, domainDetailsConfigurationUpdate, featureConfigurationUpdate, getClientData, signatoryDetailsUpdate, ticketConfigurationUpdate, documentsUpdate, getUserData, CsmUsersGet, OpsUsersGet, userConfigurationUpdate, findClient, aggregateClient, createAuditQueue, findOne, insert, update, findOneClient, updateOneClient } from '../service/client.service.js';
 import { checkFileExist, signedUrl, chunkArray, download, logger, getOpenSearchData, insertOpenSearchData, sendEmailWithSES, createCustomer, createVirtualAccount, getUuid, fileRestrictedUpload, getXsscheck, customSignedUrl } from 'tango-app-api-middleware';
 import { countDocumentsUser, findOneAndUpdateUser, findOneUser, getUserNameEmailById, updateManyUser } from '../service/user.service.js';
-import { aggregateStore, countDocumentsStore, findStore, updateManyStore } from '../service/store.service.js';
+import { aggregateStore, countDocumentsStore, findOneStore, findStore, updateManyStore } from '../service/store.service.js';
 import { aggregateCamera, countDocumentsCamera } from '../service/camera.service.js';
 import _ from 'lodash';
 import { findOneStandaredRole } from '../service/standaredRole.service.js';
@@ -18,6 +18,8 @@ import { countDocumentsClusters, createclusterModel } from '../service/cluster.s
 import { countDocumentsTeams } from '../service/teams.service.js';
 import { createauditConfig, updateauditConfig, aggregateAuditconfig } from '../service/auditConfig.service.js';
 import { findOnerevopConfig, createrevopConfig, updaterevopConfig } from '../service/revopConfig.service.js';
+import clientModel from 'tango-api-schema/schema/client.model.js';
+import { aggregateVmsStoreRequest, updateOneUpsertVmsStoreRequest, updateOneVmsStoreRequest } from '../service/vmsStoreRequest.service.js';
 
 export async function create( req, res ) {
   try {
@@ -2965,10 +2967,89 @@ export async function updateFDConfig( req, res ) {
 export async function getFDConfig( req, res ) {
   try {
     const inputData = req.query;
-    let result = await findOneClient( { clientId: inputData.clientId }, { footfallDirectoryConfigs: 1 } );
-    if ( result===null ) {
+    // let result = await findOneClient( { clientId: inputData.clientId }, { footfallDirectoryConfigs: 1 } );
+    const configQuery = [
+      {
+        $match: {
+          clientId: inputData?.clientId,
+        },
+      },
+
+      // Convert all effectiveFrom to proper Date
+      {
+        $addFields: {
+          taggingLimitationWithDate: {
+            $map: {
+              input: '$footfallDirectoryConfigs.taggingLimitation',
+              as: 'item',
+              in: {
+                effectiveFrom: { $toDate: '$$item.effectiveFrom' },
+                values: '$$item.values',
+              },
+            },
+          },
+        },
+      },
+
+      // Filter items <= input date
+      {
+        $addFields: {
+          matchedLimitation: {
+            $filter: {
+              input: '$taggingLimitationWithDate',
+              as: 'item',
+              cond: {
+                $lte: [
+                  '$$item.effectiveFrom',
+                  { $toDate: inputData.dateString },
+                ],
+              },
+            },
+          },
+        },
+      },
+
+      // Sort DESC and pick ONLY top 1 -> latest effective record
+      {
+        $addFields: {
+          effectiveLimitation: {
+            $arrayElemAt: [
+              {
+                $slice: [
+                  {
+                    $sortArray: {
+                      input: '$matchedLimitation',
+                      sortBy: { effectiveFrom: -1 },
+                    },
+                  },
+                  1,
+                ],
+              },
+              0,
+            ],
+          },
+        },
+      },
+
+      {
+        $project: {
+          'config': 1,
+          'effectiveLimitation': 1,
+          'footfallDirectoryConfigs': 1,
+
+        },
+      },
+    ];
+
+
+    const getData = await aggregateClient( configQuery );
+    let result = getData[0];
+    if ( !result || result===null ) {
       return res.sendError( 'no data found', 204 );
     }
+    result.footfallDirectoryConfigs.taggingLimitation = result?.effectiveLimitation?.values;
+    delete result.effectiveLimitation;
+
     return res.sendSuccess( result );
   } catch ( error ) {
     const err = error.message || 'Internal Server Error';
@@ -2977,3 +3058,210 @@ export async function getFDConfig( req, res ) {
   }
 }
 
+
+export async function updateTaggingType( req, res ) {
+  try {
+    const inputData = req.body;
+
+    const inputQuery = req.query; // up
+    const types = inputData?.taggingLimitation?.map( ( x ) => x.type );
+    // Step 1: remove existing items with same "type"
+    await clientModel.updateOne(
+        { clientId: inputQuery.clientId },
+        {
+          $pull: {
+            'footfallDirectoryConfigs.taggingLimitation': {
+              type: { $in: types },
+            },
+          },
+        },
+    );
+
+    // Remove duplicate entries by type
+    const uniqueData = uniqueByType( inputData.taggingLimitation );
+
+    // Step 2: insert fresh new items
+    let result =await clientModel.updateOne(
+        { clientId: inputQuery.clientId },
+        {
+          $addToSet: {
+            'footfallDirectoryConfigs.taggingLimitation': {
+              $addToSet: {
+                effectiveFrom: new Date().toISOString().split( 'T' )[0],
+                values: uniqueData,
+              },
+            },
+          },
+        },
+    );
+
+    if ( result?.acknowledged === true ) {
+      return res.sendSuccess( result );
+    } else {
+      return res.sendError( 'no data', 204 );
+    }
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { error: error, message: req.query, function: 'updateTaggingType' } );
+    return res.sendError( err, 500 );
+  }
+}
+
+function uniqueByType( arr ) {
+  const seen = new Set();
+  return arr.filter( ( item ) => {
+    if ( seen.has( item.type ) ) return false;
+    seen.add( item.type );
+    return true;
+  } );
+}
+
+export async function createStoreRequest( req, res ) {
+  try {
+    const inputData = req.body;
+    const getClientId = await findOneStore( { storeId: inputData?.storeId }, { clientId: 1, storeName: 1 } );
+    const record = {
+      clientId: getClientId?.clientId,
+      storeId: inputData?.storeId,
+      storeName: getClientId?.storeName,
+      dateString: inputData?.dateString,
+      raisedBy: req?.user?._id,
+      status: 'request',
+
+    };
+    const upsertRecord = await updateOneUpsertVmsStoreRequest( { storeId: inputData?.storeId, dateString: inputData?.dateString }, record );
+    logger.info( { upsertRecord } );
+    if ( upsertRecord?.upsertedCount === 1 ) {
+      return res.sendSuccess( 'The Request has been sent Successfully' );
+    } else if ( upsertRecord?.matchedCount === 1 && upsertRecord?.modifiedCount === 1 ) {
+      return res.sendSuccess( 'The Request has been updated Successfully' );
+    } else if ( upsertRecord?.matchedCount === 1 && upsertRecord?.modifiedCount === 0 ) {
+      return res.sendSuccess( 'The Request already exists and nothing to update' );
+    } else {
+      return res.sendError( 'Internal Server Error', 500 );
+    }
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { error: error, message: req.query, function: 'createStoreRequest' } );
+    return res.sendError( err, 500 );
+  }
+}
+
+export async function listStoreRequest( req, res ) {
+  try {
+    const inputData = req.query;
+
+    const today = new Date();
+    const threeDaysAgo = new Date();
+    threeDaysAgo.setDate( today.getDate() - 3 );
+
+    const todayStr = today.toISOString().slice( 0, 10 );
+    const threeDaysAgoStr = threeDaysAgo.toISOString().slice( 0, 10 );
+
+
+    const query = [
+      {
+        $match: {
+          $and: [
+            {
+              clientId: { $eq: inputData?.clientId },
+            },
+            {
+              status: { $eq: 'request' },
+            },
+            {
+              dateString: { $gte: threeDaysAgoStr, $lte: todayStr },
+            },
+          ],
+        },
+      },
+      {
+        $project: {
+          _id: 0,
+          id: { $concat: [ '$storeId', '_', '$dateString' ] },
+          storeName: 1,
+          storeId: 1,
+          dateString: 1,
+          raisedOn: { $ifNull: [ { $dateToString: { format: '%d %b, %Y', date: '$createdAt' } }, '' ] },
+          totalRaised: null,
+        },
+      },
+    ];
+    const result = await aggregateVmsStoreRequest( query );
+    if ( !result || result.length === 0 ) {
+      return res.sendError( 'no data found', 204 );
+    }
+    const getStores = result.map( ( item ) => item.storeId );
+    if ( !getStores || getStores.length === 0 ) {
+      return res.sendError( 'no data found', 204 );
+    }
+    const getCountQuery = [
+      {
+        $match: {
+          $and: [
+            {
+              storeId: { $in: getStores },
+            },
+            {
+              status: 'reset',
+            },
+          ],
+        },
+      },
+      {
+        $sort: {
+          createdAt: -1,
+        },
+      },
+      {
+        $group: {
+          _id: '$storeId',
+          storeId: { $first: '$storeId' },
+          lastRaised: { $first: '$createdAt' },
+          total: { $sum: 1 },
+
+        },
+      },
+      {
+        $project: {
+          _id: 0,
+          storeId: 1,
+          lastRaised: { $dateToString: { format: '%d %b, %Y', date: '$lastRaised' } },
+          totalRaised: '$total',
+        },
+      },
+    ];
+
+    const getCounts = await aggregateVmsStoreRequest( getCountQuery );
+    if ( !getCounts || getCounts?.length === 0 ) {
+      return res.sendSuccess( { result: result } );
+    } else {
+      const merged = result.map( ( item ) => {
+        const match = getCounts.find( ( g ) => g.storeId === item.storeId );
+
+        return {
+          ...item,
+          ...( match || {} ),
+        };
+      } );
+      return res.sendSuccess( { result: merged } );
+    }
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { error: error, message: req.query, function: 'listStoreRequest' } );
+    return res.sendError( err, 500 );
+  }
+}
+export async function resetStoreRequest( req, res ) {
+  try {
+    const inputData = req.body;
+    for ( const item of inputData?.arrayOfStores ) {
+      await updateOneVmsStoreRequest( { clientId: inputData.clientId, storeId: item.storeId, dateString: item.dateString }, { status: 'reset', appovedBy: req?.user?._id } );
+    }
+    return res.sendSuccess( 'The Request has been reset Successfully' );
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { error: error, message: req.body, function: 'resetStoreRequest' } );
+    return res.sendError( err, 500 );
+  }
+}

package/src/controllers/vmsAudit.controller.js

@@ -0,0 +1,345 @@
+import { logger, searchOpenSearchData } from 'tango-app-api-middleware';
+import { findOneStore } from '../service/store.service.js';
+import { aggregatevmsUserAudit, createvmsUserAudit, findOnevmsUserAudit, updateOnevmsUserAudit } from '../service/vmsuserAudit.service.js';
+import { createvmsAuditLog, findOnevmsAuditLog } from '../service/vmsauditLog.service.js';
+import { insertOpenSearchData, clearScroll, scrollResponse } from 'tango-app-api-middleware';
+import { findOneUser } from '../service/user.service.js';
+import dayjs from 'dayjs';
+import utc from 'dayjs/plugin/utc.js';
+import timezone from 'dayjs/plugin/timezone.js';
+
+dayjs.extend( utc );
+dayjs.extend( timezone );
+export async function getAuditFile( req, res ) {
+  try {
+    // const bucket = JSON.parse( process.env.BUCKET );
+    const url = JSON.parse( process.env.URL );
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    const inputData = req.query;
+    const files = [];
+    const storeQuery = {
+      storeId: inputData.storeId,
+    };
+    const storeFields = {
+      storeName: 1,
+      clientId: 1,
+      address: '$storeProfile.address',
+    };
+    const storeInfo = await findOneStore( storeQuery, storeFields );
+
+    const userQuery = [
+      {
+        $match: {
+          $and: [
+            { userId: req.user._id },
+            { auditStatus: { $nin: [ 'completed', 'skipped' ] } },
+            { storeId: inputData.storeId },
+            { fileDate: inputData.Date },
+          ],
+        },
+      },
+      {
+        $sort: { createdAt: -1 },
+      },
+      {
+        $limit: 1,
+      },
+    ];
+
+    const userDetails = await aggregatevmsUserAudit( userQuery );
+    console.log( '🚀 ~ getAuditFile ~ userDetails:', userDetails );
+    const auditStatus = userDetails && userDetails.length > 0 ? userDetails[0].auditStatus : null;
+    if ( auditStatus === 'drafted' ) {
+      const log = await findOnevmsAuditLog(
+          {
+            userId: userDetails[0].userId,
+            fileDate: userDetails[0].fileDate,
+            storeId: userDetails[0].storeId,
+            totalCount: userDetails[0].beforeCount,
+          },
+          {},
+          { createdAt: -1 },
+      );
+      console.log( '🚀 ~ getAuditFile ~ log:', log );
+      if ( !log ) {
+        await updateOnevmsUserAudit(
+            { _id: userDetails[0]._id },
+            { $set: { isDraft: false, auditStatus: 'skipped' } },
+        );
+        logger.info( 'audit update in drafted', {
+          _id: userDetails[0]._id,
+          isDraft: false,
+          auditStatus: 'skipped',
+        } );
+        return res.sendError( 'User saved data has been deleted', 204 );
+      }
+
+      const file = {
+        auditId: userDetails[0]._id,
+        storeId: userDetails[0].storeId,
+        Date: userDetails[0].fileDate,
+        userId: log.userId,
+        timeSpent: log.timeSpent,
+        clientId: userDetails[0].clientId,
+      };
+      const userdata = await findOneUser( { _id: log.userId } );
+      if (
+        !inputData.nextId ||
+        inputData.nextId === '' ||
+        inputData.nextId == null
+      ) {
+        const logData = {
+          userId: log.userId,
+          userName: userdata.userName,
+          logType: 'vmsaudit',
+          logSubType: 'auditStart',
+          logData: {
+            fileDate: userDetails[0].fileDate,
+            storeId: userDetails[0].storeId,
+            auditId: userDetails[0]._id,
+            beforeCount: userDetails[0].beforeCount,
+          },
+          createdAt: new Date(),
+        };
+        await insertOpenSearchData( openSearch.vmsauditLog, logData );
+      }
+      const storeQuery = {
+        storeId: userDetails[0].storeId,
+      };
+      const storeFields = {
+        storeId: 1,
+        storeName: 1,
+        address: '$storeProfile.address',
+      };
+      const storeDetails = await findOneStore( storeQuery, storeFields );
+      return res.sendSuccess( {
+        result: log.draftedData,
+        storeId: storeDetails?.storeId,
+        storeName: storeDetails?.storeName,
+        address: storeDetails?.address || '',
+        count: log.totalCount,
+        timeSpent: log.timeSpent,
+        file: file,
+        isDraft: userDetails[0].isDraft,
+      } );
+    }
+    console.log( inputData );
+
+    const query = {
+      size: inputData?.limit || 2,
+      _source: [ 'module', 'status', 'date', 'store_id', 'outputCluster', 'personPath', 'REIDCluster', 'isEmployee', 'isJunk', 'EmployeeStatusFinal' ], // Only fetch necessary fields
+
+      query: {
+        bool: {
+          'must': [
+            {
+              term: { 'store_id.keyword': inputData.storeId },
+            },
+            {
+              term: { 'date.keyword': dayjs( inputData.Date ).format( 'DD-MM-YYYY' ) },
+            },
+            {
+              term: { 'module.keyword': 'CUSTOMER' },
+            },
+            {
+              term: { 'status.keyword': 'PP_CLUSTER_FORMED' },
+            },
+            {
+              terms: { EmployeeStatusFinal: [ 1, 2 ] },
+            },
+          ],
+          'should': [
+            { 'term': { 'isJunk': false } },
+            { 'bool': { 'must_not': { 'exists': { 'field': 'isJunk' } } } },
+          ],
+          'minimum_should_match': 1,
+        },
+      },
+
+    };
+    console.log( openSearch.vmsAudit );
+    let list =inputData.nextId? await scrollResponse( inputData.nextId ): await searchOpenSearchData( openSearch.vmsAudit, query );
+    const folderPath = list?.body?.hits?.hits;
+    if ( list?.body?.hits?.hits?.length ==0 ) {
+      await clearScroll( list?.body?._scroll_id );
+    }
+    if ( folderPath?.length > 0 ) {
+      for ( let i = 0; i < folderPath.length; i++ ) {
+        const img = folderPath[i]?._source?.personPath?.split( '/' );
+        const image = img[3]?.split( '.' );
+        const indexes = folderPath[i]?._source?.outputCluster === 50000 ? folderPath[i]?._source?.REIDCluster : folderPath[i]?._source?.outputCluster;
+        // fetchData.file_path = folderPath[i]?._source?.personPath;
+        const data = `${url.trackInput}${folderPath[i]?._source?.personPath}`;
+        const mapimg = {
+          img_path: data,
+          img_name: indexes,
+          img_id: image[0],
+        };
+        addUniqueFile( files, {
+          img_path: data,
+          img_name: indexes,
+          img_id: image[0],
+          selected: false,
+          dropped: false,
+          demographic: '',
+          count: 1,
+          mappedid: [ mapimg ],
+        } );
+      }
+    } else if ( inputData.nextId !== '' && inputData.nextId !== null && inputData.nextId !== undefined ) {
+      if ( !list ) {
+        return res.sendError( 'token expired', 404 );
+      }
+      list.body._scroll_id = '';
+      // insertData = userDetails[0];
+    } else {
+      logger.error( {
+        error: { folderPath: folderPath, nextQuery: inputData.nextId },
+        function: 'getAuditFile',
+        message: 'Bucket image data not availale',
+      } );
+      return res.sendError( 'Bucket is Empty', 204 );
+    }
+    const [ year, month, day ] = inputData.Date.split( '-' );
+    const temp = `${year}-${month}-${day}`;
+    console.log( temp );
+    let start = new Date( temp );
+    const userTimezoneOffset = start.getTimezoneOffset() * 60000;
+    start = new Date( start.getTime() - userTimezoneOffset );
+    start.setUTCHours( 0, 0, 0, 0 );
+    console.log( start );
+    const record = {
+      userId: req.user._id,
+      storeId: inputData.storeId,
+      clientId: storeInfo?.clientId,
+      fileDate: inputData.Date,
+      beforeCount: inputData.count,
+      auditStatus: 'inprogress',
+      fileDateISO: start,
+      timeSpent: 0,
+      startTime: new Date(),
+    };
+    const insertData = await createvmsUserAudit( record );
+    if ( inputData.nextId !== '' && inputData.nextId !== null && inputData.nextId !== undefined && inputData.moduleType === 'track' ) {
+      if ( !list ) {
+        return res.sendError( 'token expired', 404 );
+      }
+      list.body._scroll_id = '';
+    }
+    return res.sendSuccess( {
+      result: files,
+      count: inputData.count,
+      storeId: inputData.storeId,
+      storeName: storeInfo?.storeName,
+      address: storeInfo?.address,
+      file: {
+        clientId: storeInfo?.clientId,
+        storeId: inputData.storeId,
+        Date: inputData.Date,
+        auditId: insertData._id,
+        userId: insertData.userId,
+        nextToken: list?.body?._scroll_id ?list?.body?._scroll_id:null,
+
+      },
+      isDraft: insertData.isDraft,
+    } );
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( {
+      error: error,
+      message: req.query,
+      function: 'getAuditFile',
+    } );
+    return res.sendError( err, 500 );
+  }
+}
+function addUniqueFile( files, newFile ) {
+  const exists = files.some( ( file ) => file.img_name === newFile.img_name );
+  if ( !exists ) {
+    files.push( newFile );
+  }
+}
+export async function saveDraft( req, res ) {
+  try {
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    const inputData = req.body;
+    inputData.userId = req.user._id;
+    const getUserAuditData = await findOnevmsUserAudit( { _id: inputData.auditId } );
+    if ( !getUserAuditData ) {
+      return res.sendError( 'No Data Found', 204 );
+    }
+    if ( getUserAuditData.auditStatus == 'skipped' ) {
+      return res.sendError( 'File Assigned to Someone else', 203 );
+    }
+
+    const userQuery = {
+      _id: inputData.auditId,
+    };
+    let userRecord = {
+      isDraft: true,
+      auditStatus: 'drafted',
+    };
+
+
+    if ( getUserAuditData?.startTime ) {
+      userRecord.timeSpent = inputData.timeSpent;
+    }
+
+    if ( inputData.userCommands ) {
+      userRecord.userCommands = inputData.userCommands;
+      const logData = {
+        userId: req.user._id,
+        userName: req.user.userName,
+        logType: 'vmsaudit',
+        logSubType: 'auditDraft',
+        logData: {
+          fileDate: inputData.fileDate,
+          storeId: inputData.storeId,
+          beforeCount: inputData.totalCount,
+          afterCount: inputData.customerCount,
+          timeSpent: inputData.timeSpent,
+          auditId: inputData.auditId,
+        },
+        createdAt: new Date(),
+      };
+      await insertOpenSearchData( openSearch.vmsauditLog, logData );
+    }
+    await createvmsAuditLog( inputData );
+    await updateOnevmsUserAudit( userQuery, userRecord );
+    console.log( '🚀 ~ saveDraft ~ userRecord:', userRecord );
+    return res.sendSuccess( {
+      result: 'The file has been drafted successfully',
+    } );
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { error: error, message: req.body, function: 'saveDraft' } );
+    return res.sendError( err, 500 );
+  }
+}
+export async function getDraftedData( req, res ) {
+  try {
+    const inputData = req.query;
+    const userId = inputData.userId || req.user._id;
+    const query = {
+      fileDate: inputData.fileDate,
+      storeId: inputData.storeId,
+      userId: userId,
+      auditId: inputData.auditId,
+    };
+    console.log( query );
+    const result = await findOnevmsAuditLog( query, {}, { createdAt: -1 }, 1 );
+
+    if ( !result ) {
+      return res.sendError( 'No Data Found', 204 );
+    }
+    return res.sendSuccess( { result: result } );
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( {
+      error: error,
+      message: req.query,
+      function: 'getDraftedData',
+    } );
+    return res.sendError( err, 500 );
+  }
+}

package/src/dtos/client.dtos.js

@@ -1,4 +1,5 @@
 import joi from 'joi';
+import dayjs from 'dayjs';
 
 export const clientDetailsSchema = joi.object( {
   id: joi.string().required(),
@@ -359,12 +360,15 @@ export const updateFDConfigBodySchema = joi.object( {
   tangoReview: joi.string().optional(),
   revision: joi.array().items( joi.object( {
     actionType: joi.string().required(),
-    isChecked: joi.boolean().required(),
+    isChecked: joi.boolean().optional().default( false ),
   } ) ).optional(),
   taggingLimitation: joi.array().items( joi.object( {
+    iconName: joi.string().optional(),
+    name: joi.string().optional(),
     type: joi.string().required(),
     value: joi.number().required(),
     unit: joi.string().required(),
+    key: joi.string().required(),
   } ) ).optional(),
 
 } );
@@ -373,8 +377,12 @@ export const updateFDConfigQuerySchema = joi.object( {
   clientId: joi.string().required(),
 } );
 
+
+const todayDate = () => new Date().toISOString().split( 'T' )[0];
+
 export const getFDConfigSchema = joi.object( {
   clientId: joi.string().required(),
+  dateString: joi.string().optional().default( () => todayDate() ),
 } );
 
 export const updateFDConfigValid = {
@@ -384,3 +392,70 @@ export const updateFDConfigValid = {
 export const getFDConfigValid = {
   query: getFDConfigSchema,
 };
+
+export const updateTaggingTypeSchema = joi.object( {
+  clientId: joi.string().required(),
+  taggingLimitation: joi.array().items( joi.object( {
+    type: joi.string().required(),
+    value: joi.number().required(),
+    unit: joi.string().required(),
+  } ) ).required(),
+
+} );
+
+export const updateTaggingTypeQuerySchema = joi.object( {
+  clientId: joi.string().required(),
+} );
+
+
+export const updateTaggingTypeValid = {
+  body: updateTaggingTypeSchema,
+  query: updateTaggingTypeQuerySchema,
+};
+
+export const createStoreRequestSchema = joi.object( {
+  storeId: joi.string().required(),
+  dateString: joi.string().required().custom( ( value, helpers ) => {
+    const inputDate = dayjs( value, 'YYYY-MM-DD', true );
+    const today = dayjs();
+
+    if ( !inputDate.isValid() ) {
+      return helpers.error( 'any.invalid' );
+    }
+
+    const diff = today.diff( inputDate, 'day' );
+
+    if ( diff > 3 ) {
+      return helpers.message( 'The request is not sent for a period exceeding 3 days' );
+    }
+
+    return value;
+  } ),
+
+} );
+
+export const createStoreRequestValid = {
+  body: createStoreRequestSchema,
+};
+
+export const listStoreRequestSchema = joi.object( {
+  clientId: joi.string().required(),
+} );
+
+export const listStoreRequestValid = {
+  query: listStoreRequestSchema,
+};
+
+export const resetStoreRequestSchema = joi.object( {
+  clientId: joi.string().required(),
+  arrayOfStores: joi.array().items(
+      joi.object( {
+        storeId: joi.string().required(),
+        dateString: joi.string().required(),
+      } ),
+  ).required(),
+} );
+
+export const resetStoreRequestValid = {
+  body: resetStoreRequestSchema,
+};

package/src/dtos/vmsAudit.dtos.js

@@ -0,0 +1,24 @@
+
+import joi from 'joi';
+export const getDraftedDataSchema = joi.object( {
+  storeId: joi.string().required(),
+  fileDate: joi.string().required(),
+  userId: joi.string().optional(),
+  auditId: joi.string().required(),
+} );
+export const getFileSchema = joi.object( {
+  nextId: joi.string().optional().allow( '' ),
+  limit: joi.number().optional(),
+  storeId: joi.string().required(),
+  Date: joi.string().required(),
+  count: joi.string().required(),
+} );
+
+
+export const getDraftedDataValid = {
+  query: getDraftedDataSchema,
+};
+
+export const getFileValid = {
+  query: getFileSchema,
+};

package/src/routes/client.routes.js

@@ -1,7 +1,7 @@
 
 import express from 'express';
-import { activityLogValid, auditConfigValid, billingDetailsValid, brandInfoValid, clientCreationValid, clientDetailsValid, documentsValid, domainDetailsValid, featureConfigurationValid, getAssignedClientValid, getAuditConfigValid, getFDConfigValid, postClientCamApprovalValid, signatoryDetailsValid, ticketConfigurationValid, updateFDConfigValid, userConfigurationValid } from '../dtos/client.dtos.js';
-import { auditConfiguration, changeStatus, clientCsmAssignAction, clientDetails, create, csmAssignConfirmation, domainDetailsConfiguration, getActivityLogs, getAuditConfiguration, getClients, getCsmUsers, getFDConfig, getOpsUsers, updateBillingDetails, updateBrandInfo, updateDocuments, updateFDConfig, updateFeatureConfiguration, updateSignatoryDetails, updateTicketConfiguration, userConfiguration } from '../controllers/client.controllers.js';
+import { activityLogValid, auditConfigValid, billingDetailsValid, brandInfoValid, clientCreationValid, clientDetailsValid, createStoreRequestValid, documentsValid, domainDetailsValid, featureConfigurationValid, getAssignedClientValid, getAuditConfigValid, getFDConfigValid, listStoreRequestValid, postClientCamApprovalValid, resetStoreRequestValid, signatoryDetailsValid, ticketConfigurationValid, updateFDConfigValid, updateTaggingTypeValid, userConfigurationValid } from '../dtos/client.dtos.js';
+import { auditConfiguration, changeStatus, clientCsmAssignAction, clientDetails, create, createStoreRequest, csmAssignConfirmation, domainDetailsConfiguration, getActivityLogs, getAuditConfiguration, getClients, getCsmUsers, getFDConfig, getOpsUsers, listStoreRequest, resetStoreRequest, updateBillingDetails, updateBrandInfo, updateDocuments, updateFDConfig, updateFeatureConfiguration, updateSignatoryDetails, updateTaggingType, updateTicketConfiguration, userConfiguration } from '../controllers/client.controllers.js';
 import { accessVerification, isAllowedSessionHandler, validate } from 'tango-app-api-middleware';
 import { clientListValid, detailedClientCountValid, createAuditConfigValid, AuditConfiglistValid, revopconfigValid, revopconfiggetValid } from '../dtos/client.dtos.js';
 import { isclientIdExists, isclientNameExists, roleVerification } from '../validations/client.validations.js';
@@ -115,4 +115,9 @@ clientRouter.get( '/revopconfig', isAllowedSessionHandler,
 // footfall directory configurations
 clientRouter.put( '/update-footfall-directory-config', isAllowedSessionHandler, validate( updateFDConfigValid ), updateFDConfig );
 clientRouter.get( '/get-footfall-directory-config', isAllowedSessionHandler, validate( getFDConfigValid ), getFDConfig );
+clientRouter.put( '/update-tagging-type/', isAllowedSessionHandler, validate( updateTaggingTypeValid ), updateTaggingType );
 
+// store request create/list/reset
+clientRouter.post( '/create-store-request', isAllowedSessionHandler, validate( createStoreRequestValid ), createStoreRequest );
+clientRouter.get( '/list-store-request', isAllowedSessionHandler, validate( listStoreRequestValid ), listStoreRequest );
+clientRouter.post( '/reset-store-request', isAllowedSessionHandler, validate( resetStoreRequestValid ), resetStoreRequest );

package/src/routes/vmsAudit.routes.js

@@ -0,0 +1,10 @@
+import express from 'express';
+import { accessVerification, isAllowedSessionHandler, validate } from 'tango-app-api-middleware';
+import { getDraftedDataValid, getFileValid } from '../dtos/vmsAudit.dtos.js';
+import { getAuditFile, getDraftedData, saveDraft } from '../controllers/vmsAudit.controller.js';
+export const vmsauditRouter = express.Router();
+
+
+vmsauditRouter.get( '/get-file', isAllowedSessionHandler, accessVerification( { userType: [ 'tango' ] } ), validate( getFileValid ), getAuditFile );
+vmsauditRouter.post( '/save-draft', isAllowedSessionHandler, accessVerification( { userType: [ 'tango' ] } ), saveDraft );
+vmsauditRouter.get( '/get-drafted-data', isAllowedSessionHandler, accessVerification( { userType: [ 'tango' ] } ), validate( getDraftedDataValid ), getDraftedData );

package/src/service/client.service.js

@@ -297,3 +297,7 @@ export async function updateOneClient( query, record ) {
   );
 }
 
+export async function updateOneAddToSetClient( query, record ) {
+  return clientModel.updateOne( query, { $addToSet: record } );
+}
+

package/src/service/vmsStoreRequest.service.js

@@ -0,0 +1,13 @@
+import vmsStoreRequestModel from 'tango-api-schema/schema/vmsStoreRequest.model.js';
+
+export async function updateOneUpsertVmsStoreRequest( query, record ) {
+  return await vmsStoreRequestModel.updateOne( query, { $set: record }, { upsert: true } );
+};
+
+export async function updateOneVmsStoreRequest( query, record ) {
+  return await vmsStoreRequestModel.updateOne( query, { $set: record } );
+};
+
+export async function aggregateVmsStoreRequest( query ) {
+  return await vmsStoreRequestModel.aggregate( query );
+};

package/src/service/vmsauditLog.service.js

@@ -0,0 +1,10 @@
+import vmsauditLogsModel from 'tango-api-schema/schema/vmsauditLogs.model.js';
+
+
+export function createvmsAuditLog( record ) {
+  return vmsauditLogsModel.create( record );
+}
+
+export function findOnevmsAuditLog( query, fields={}, sort={ createdAt: -1 }, limit=10 ) {
+  return vmsauditLogsModel.findOne( query, fields ).sort( sort ).limit( limit );
+}

package/src/service/vmsuserAudit.service.js

@@ -0,0 +1,22 @@
+import vmsuserAuditModel from 'tango-api-schema/schema/vmsuserAudit.model.js';
+
+
+export function aggregatevmsUserAudit( query ) {
+  return vmsuserAuditModel.aggregate( query, { collation: { locale: 'en', strength: 2 } } );
+}
+
+export function updateOnevmsUserAudit( query, record ) {
+  return vmsuserAuditModel.updateOne( query, { $set: record } );
+}
+
+export function createvmsUserAudit( record ) {
+  return vmsuserAuditModel.create( record );
+}
+
+export function findOnevmsUserAudit( query, fields ) {
+  return vmsuserAuditModel.findOne( query, fields );
+}
+
+export function aggregatevmsUserAuditCount( query ) {
+  return vmsuserAuditModel.aggregate( query );
+}