tango-app-api-infra 3.9.4 → 3.9.5-vms.10

package/package.json

@@ -1,11 +1,11 @@
 {
     "name": "tango-app-api-infra",
-    "version": "3.9.4",
+    "version": "3.9.5-vms.10",
     "description": "infra",
     "main": "index.js",
     "type": "module",
     "scripts": {
-        "start": "nodemon --exec \"eslint --fix . && node index.js\""
+        "start": "nodemon --exec \"eslint --fix . && node app.js\""
     },
     "engines": {
         "node": ">=18.10.0"
@@ -27,7 +27,7 @@
         "mongodb": "^6.4.0",
         "nodemon": "^3.1.0",
         "swagger-ui-express": "^5.0.0",
-        "tango-api-schema": "^2.3.8",
+        "tango-api-schema": "^2.4.28",
         "tango-app-api-middleware": "^3.1.93",
         "winston": "^3.12.0",
         "winston-daily-rotate-file": "^5.0.0"

package/src/controllers/footfallDirectory.controllers.js

@@ -1,11 +1,12 @@
 import { chunkArray, download, logger, sendMessageToFIFOQueue, sendMessageToQueue } from 'tango-app-api-middleware';
-import { bulkUpdate, getOpenSearchById, getOpenSearchCount, getOpenSearchData, insertWithId, updateOpenSearchData } from 'tango-app-api-middleware/src/utils/openSearch.js';
+import { bulkUpdate, getOpenSearchById, getOpenSearchCount, getOpenSearchData, insertWithId, updateOpenSearchData, upsertOpenSearchData } from 'tango-app-api-middleware/src/utils/openSearch.js';
 import { findOneStore } from '../services/store.service.js';
 import { countDocumnetsCamera } from '../services/camera.service.js';
 import { findOneRevopDownload, upsertRevopDownload } from '../services/revopDownload.service.js';
 import dayjs from 'dayjs';
 import utc from 'dayjs/plugin/utc.js';
 import timezone from 'dayjs/plugin/timezone.js';
+import { findUser } from '../services/user.service.js';
 
 dayjs.extend( utc );
 dayjs.extend( timezone );
@@ -133,7 +134,7 @@ async function bulkUpdateStatusToPending( indexName, inputData ) {
   }
 }
 
-export async function ticketSummary( req, res ) {
+export async function ticketSummary1( req, res ) {
   try {
     const openSearch = JSON.parse( process.env.OPENSEARCH );
     const inputData = req.query;
@@ -215,7 +216,59 @@ export async function ticketSummary( req, res ) {
   }
 }
 
-export async function ticketList( req, res ) {
+export async function ticketSummary( req, res ) {
+  try {
+    let result = '';
+    const userInfo = req.user;
+    const ticketsFeature = userInfo?.rolespermission?.some( ( f ) => f.featureName === 'FootfallDirectory' && ( f.modules.find( ( m ) => m.name =='reviewer' && ( m.isAdd==true || m.isEdit==true ) ) ) );
+
+    if ( req.user.userType =='tango' ) {
+      result ={
+        totalTickets: 0,
+        averageAccuracyOverAll: 0,
+        openTickets: 0,
+        openInfraIssues: 0,
+        inprogress: 0,
+        closedTickets: 0,
+        ticketAccuracyAbove: '0%',
+        ticketAccuracyBelow: '0%',
+      };
+    } else {
+      result = req.user.role === 'superadmin'?
+{
+  totalTickets: 0,
+  openTickets: 0,
+  inprogress: 0,
+  closedTickets: 0,
+  dueToday: 0,
+  Expired: 0,
+  underTangoReview: 0,
+  avgTicket: '0%',
+  avgAccuracy: '0%',
+} :
+req.user.role === 'user'? 'NA':
+ticketsFeature?
+{
+  totalTickets: 0,
+  openTickets: 0,
+  inprogress: 0,
+  closedTickets: 0,
+  dueToday: 0,
+  Expired: 0,
+  avgTicket: '0%',
+  avgAccuracy: '0%',
+}: 'NA';
+    }
+
+    return res.sendSuccess( { result: result } );
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { error: error, messgage: req.query } );
+    return res.sendSuccess( err, 500 );
+  }
+}
+
+export async function ticketList1( req, res ) {
   try {
     const openSearch = JSON.parse( process.env.OPENSEARCH );
     const inputData = req.query;
@@ -436,6 +489,165 @@ export async function ticketList( req, res ) {
   }
 }
 
+export async function ticketList( req, res ) {
+  try {
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    const inputData= req.query;
+    const userInfo = req.user;
+    const limit =inputData?.limit || 10;
+    const offset = inputData.offset == 0 ? 0 : ( inputData.offset - 1 ) * limit || 0;
+    inputData.clientId = inputData.clientId.split( ',' ); // convert strig to array
+    inputData.storeId = inputData.storeId.split( ',' );
+    const ticketsFeature = userInfo?.rolespermission?.some( ( f ) => f.featureName === 'FootfallDirectory' && ( f.modules.find( ( m ) => m.name =='reviewer' && ( m.isAdd==true || m.isEdit==true ) ) ) );
+
+
+    const searchQuery = {
+
+      size: limit, // or use parseInt(req.query.limit) for dynamic
+      from: offset, // or use parseInt(req.query.offset) for dynamic
+      sort: [ { 'createdAt': { order: 'desc' } } ],
+      query: {
+        bool: {
+          must: [
+            {
+              terms: {
+                'clientId.keyword': Array.isArray( inputData.clientId ) ?
+                  inputData.clientId :
+                 [ inputData.clientId ],
+              },
+            },
+          ],
+        },
+      },
+    };
+
+    // Example: Filtering by storeId if present in the query
+    if ( inputData.storeId ) {
+      searchQuery.query.bool.must.push( {
+        terms: {
+          'storeId.keyword': Array.isArray( inputData.storeId ) ?
+          inputData.storeId :
+          [ inputData.storeId ],
+        },
+      } );
+    }
+
+
+    // You can add more filters as needed
+    logger.info( { searchQuery, index: openSearch.footfallDirectory } );
+    const searchResult = await getOpenSearchData( openSearch.footfallDirectory, searchQuery );
+
+    const count = searchResult?.body?.hits?.total?.value || 0;
+    if ( count === 0 ) {
+      return res.sendError( 'no data found', 204 );
+    }
+    const ticketListData = searchResult?.body?.hits?.hits?.map( ( hit ) => hit._source ) || [];
+
+    let temp =[];
+    if ( req.user.userType =='tango' ) {
+      if ( inputData.tangotype == 'store' ) {
+        for ( let item of ticketListData ) {
+          temp.push( {
+
+            ticketId: item?.ticketId,
+            storeId: item?.storeId,
+            storeName: item?.storeName,
+
+            ticketRaised: item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.createdAt,
+            issueDate: item?.dateString,
+            dueDate: '',
+            footfall: item?.footfallCount,
+            storeRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.revicedPerc || '--',
+            reviewerRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.revicedPerc|| '--',
+            approverRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.revicedPerc||'--',
+            tangoRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.revicedPerc || '--',
+            status: item?.status,
+
+          } );
+        }
+      } else {
+        for ( let item of ticketListData ) {
+          temp.push( {
+
+            ticketId: item?.ticketId,
+            storeId: item?.storeId,
+            storeName: item?.storeName,
+
+            ticketRaised: item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.createdAt,
+            issueDate: item?.dateString,
+            footfall: item?.footfallCount,
+            dueDate: '',
+            type: item.type || 'store',
+            storeRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.revicedPerc || '--',
+            reviewerRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.revicedPerc|| '--',
+            approverRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.revicedPerc||'--',
+            tangoRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.revicedPerc || '--',
+            status: item?.status,
+            tangoStatus: item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.revicedPerc || '--',
+
+          } );
+        }
+      }
+    } else {
+      if ( req.user.role === 'superadmin' ) {
+        for ( let item of ticketListData ) {
+          temp.push( {
+
+            ticketId: item?.ticketId,
+            storeId: item?.storeId,
+            storeName: item?.storeName,
+
+            ticketRaised: item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.createdAt,
+            issueDate: item?.dateString,
+            dueDate: '',
+            footfall: item?.footfallCount,
+
+            type: item.type || 'store',
+            storeRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.revicedPerc || '--',
+            reviewerRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.revicedPerc|| '--',
+            approverRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.revicedPerc||'--',
+            tangoRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.revicedPerc || '--',
+            status: item?.status,
+            tangoStatus: item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.revicedPerc || '--',
+            approvedBy: item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.createdByEmail||'--',
+
+          } );
+        }
+      } else if ( req.user.role === 'user' ) {
+        temp = [];
+      } else if ( ticketsFeature ) {
+        for ( let item of ticketListData ) {
+          temp.push( {
+
+            ticketId: item?.ticketId,
+            storeId: item?.storeId,
+            storeName: item?.storeName,
+            ticketRaised: item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.createdAt,
+            issueDate: item?.dateString,
+            footfall: item?.footfallCount,
+            dueDate: '',
+            type: item.type || 'store',
+            storeRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.revicedPerc || '--',
+            reviewerRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.revicedPerc|| '--',
+
+            status: item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.status|| '--',
+            ReviewedBy: item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.createdByEmail||'--',
+
+          } );
+        }
+      } else {
+        temp =[];
+      }
+    }
+
+    return res.sendSuccess( { result: temp } );
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { error: error, messgage: req.query } );
+    return res.sendSuccess( err, 500 );
+  }
+}
+
 export async function getTickets( req, res ) {
   try {
     const openSearch = JSON.parse( process.env.OPENSEARCH );
@@ -444,7 +656,7 @@ export async function getTickets( req, res ) {
     const skip = inputData.offset == 0 ? 0 : ( inputData.offset - 1 ) * limit || 0;
     inputData.storeId = inputData.storeId.split( ',' ); // convert strig to array
     logger.info( { inputData: inputData, limit: limit, skip: skip } );
-    let source = [ 'storeId', 'dateString', 'ticketName', 'footfallCount', 'employeeCount', 'houseKeepingCount', 'duplicateCount', 'junkCount', 'junkACCount', 'comments', 'employee', 'houseKeeping', 'junk', 'duplicateImages', 'ticketId', 'clientId', 'storeName', 'createdAt', 'updatedAt', 'userName', 'email', 'role', 'status', 'employeeStatus', 'houseKeepingStatus', 'duplicateStatus', 'junkStatus', 'houseKeepingACCount', 'houseKeepingCount', 'employeeCount', 'employeeACCount', 'duplicateCount', 'duplicateACCount', 'approverRole', 'approverUserName', 'approverEmail' ];
+    let source = [ 'storeId', 'dateString', 'ticketName', 'revicedFootfall', 'revicedPerc', 'mappingInfo', 'footfallCount', 'employeeCount', 'houseKeepingCount', 'duplicateCount', 'junkCount', 'junkACCount', 'comments', 'employee', 'houseKeeping', 'junk', 'duplicateImages', 'ticketId', 'clientId', 'storeName', 'createdAt', 'updatedAt', 'userName', 'email', 'role', 'status', 'employeeStatus', 'houseKeepingStatus', 'duplicateStatus', 'junkStatus', 'houseKeepingACCount', 'houseKeepingCount', 'employeeCount', 'employeeACCount', 'duplicateCount', 'duplicateACCount', 'approverRole', 'approverUserName', 'approverEmail' ];
     let filter = [
 
       {
@@ -520,10 +732,10 @@ export async function getTickets( req, res ) {
               },
             },
           } );
-      source = inputData.revopsType == 'employee' ? [ 'storeId', 'dateString', 'ticketName', 'footfallCount', 'employeeCount', 'comments', 'employee', 'ticketId', 'clientId', 'storeName', 'createdAt', 'updatedAt', 'email', 'userName', 'role', 'status', 'employeeStatus', 'houseKeepingStatus', 'duplicateStatus', 'houseKeepingACCount', 'houseKeepingCount', 'employeeCount', 'employeeACCount', 'duplicateCount', 'duplicateACCount', 'junkCount', 'junkStatus', 'junkACCount', 'approverRole', 'approverUserName', 'approverEmail' ] :
-        inputData.revopsType == 'houseKeeping' ? [ 'storeId', 'dateString', 'ticketName', 'footfallCount', 'houseKeepingCount', 'comments', 'houseKeeping', 'ticketId', 'clientId', 'storeName', 'createdAt', 'updatedAt', 'userName', 'email', 'role', 'status', 'employeeStatus', 'houseKeepingStatus', 'duplicateStatus', 'houseKeepingACCount', 'houseKeepingCount', 'employeeCount', 'employeeACCount', 'duplicateCount', 'duplicateACCount', 'junkCount', 'junkStatus', 'junkACCount', 'approverRole', 'approverUserName', 'approverEmail' ] :
-        inputData.revopsType == 'duplicateImages' ? [ 'storeId', 'dateString', 'ticketName', 'footfallCount', 'duplicateCount', 'comments', 'duplicateImages', 'ticketId', 'clientId', 'storeName', 'createdAt', 'updatedAt', 'userName', 'email', 'role', 'status', 'employeeStatus', 'houseKeepingStatus', 'duplicateStatus', 'houseKeepingACCount', 'houseKeepingCount', 'employeeCount', 'employeeACCount', 'duplicateCount', 'duplicateACCount', 'junkCount', 'junkStatus', 'junkACCount', 'approverRole', 'approverUserName', 'approverEmail' ] :
-        inputData.revopsType == 'junk' ? [ 'storeId', 'dateString', 'ticketName', 'footfallCount', 'duplicateCount', 'comments', 'junk', 'ticketId', 'clientId', 'storeName', 'createdAt', 'updatedAt', 'userName', 'email', 'role', 'status', 'employeeStatus', 'houseKeepingStatus', 'duplicateStatus', 'houseKeepingACCount', 'houseKeepingCount', 'employeeCount', 'employeeACCount', 'duplicateCount', 'duplicateACCount', 'junkCount', 'junkACCount', 'junkStatus', 'approverRole', 'approverUserName', 'approverEmail' ] : [];
+      source = inputData.revopsType == 'employee' ? [ 'storeId', 'dateString', 'ticketName', 'revicedFootfall', 'revicedPerc', 'mappingInfo', 'footfallCount', 'employeeCount', 'comments', 'employee', 'ticketId', 'clientId', 'storeName', 'createdAt', 'updatedAt', 'email', 'userName', 'role', 'status', 'employeeStatus', 'houseKeepingStatus', 'duplicateStatus', 'houseKeepingACCount', 'houseKeepingCount', 'employeeCount', 'employeeACCount', 'duplicateCount', 'duplicateACCount', 'junkCount', 'junkStatus', 'junkACCount', 'approverRole', 'approverUserName', 'approverEmail' ] :
+        inputData.revopsType == 'houseKeeping' ? [ 'storeId', 'dateString', 'ticketName', 'revicedFootfall', 'revicedPerc', 'mappingInfo', 'footfallCount', 'houseKeepingCount', 'comments', 'houseKeeping', 'ticketId', 'clientId', 'storeName', 'createdAt', 'updatedAt', 'userName', 'email', 'role', 'status', 'employeeStatus', 'houseKeepingStatus', 'duplicateStatus', 'houseKeepingACCount', 'houseKeepingCount', 'employeeCount', 'employeeACCount', 'duplicateCount', 'duplicateACCount', 'junkCount', 'junkStatus', 'junkACCount', 'approverRole', 'approverUserName', 'approverEmail' ] :
+        inputData.revopsType == 'duplicateImages' ? [ 'storeId', 'dateString', 'ticketName', 'revicedFootfall', 'revicedPerc', 'mappingInfo', 'footfallCount', 'duplicateCount', 'comments', 'duplicateImages', 'ticketId', 'clientId', 'storeName', 'createdAt', 'updatedAt', 'userName', 'email', 'role', 'status', 'employeeStatus', 'houseKeepingStatus', 'duplicateStatus', 'houseKeepingACCount', 'houseKeepingCount', 'employeeCount', 'employeeACCount', 'duplicateCount', 'duplicateACCount', 'junkCount', 'junkStatus', 'junkACCount', 'approverRole', 'approverUserName', 'approverEmail' ] :
+        inputData.revopsType == 'junk' ? [ 'storeId', 'dateString', 'ticketName', 'revicedFootfall', 'revicedPerc', 'mappingInfo', 'footfallCount', 'duplicateCount', 'comments', 'junk', 'ticketId', 'clientId', 'storeName', 'createdAt', 'updatedAt', 'userName', 'email', 'role', 'status', 'employeeStatus', 'houseKeepingStatus', 'duplicateStatus', 'houseKeepingACCount', 'houseKeepingCount', 'employeeCount', 'employeeACCount', 'duplicateCount', 'duplicateACCount', 'junkCount', 'junkACCount', 'junkStatus', 'approverRole', 'approverUserName', 'approverEmail' ] : [];
     }
 
     if ( inputData.action ) {
@@ -632,7 +844,10 @@ export async function getTickets( req, res ) {
           storeId: hit._source.storeId,
           dateString: hit?._source?.dateString,
           ticketName: hit?._source?.ticketName,
-          status: hit?._source?.status,
+          status: hit?._source?.status?.revicedFootfall,
+          revicedPerc: hit?._source?.revicedPerc,
+          revicedFootfall: hit?._source?.revicedFootfall,
+          mappingInfo: hit?._source?.mappingInfo,
           employeeStatus: hit?._source?.employeeStatus,
           houseKeepingStatus: hit?._source?.houseKeepingStatus,
           duplicateStatus: hit?._source?.duplicateStatus,
@@ -1504,3 +1719,305 @@ async function extractTempIds( document ) {
   return result;
 }
 
+export async function reviewerList( req, res ) {
+  try {
+    const inputData = req.query;
+    // Build the query for users who have rolespermission with featureName "FootfallDirectory",
+    // and a module "Reviewer" where isAdd or isEdit is true.
+    const reviewerRoleQuery = {
+      'clientId': inputData.clientId,
+      'rolespermission': {
+        $elemMatch: {
+          featureName: 'FootfallDirectory',
+          modules: {
+            $elemMatch: {
+              name: 'Reviewer',
+              $or: [ { isAdd: true }, { isEdit: true } ],
+            },
+          },
+        },
+      },
+    };
+
+    const getUserlist = await findUser( reviewerRoleQuery, { userName: 1, email: 1, role: 1 } );
+    return res.sendSuccess( getUserlist|| [] );
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    return res.sendError( err, 500 );
+  }
+}
+
+export async function openTicketList( req, res ) {
+  try {
+    const inputData = req.body;
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+
+    // INSERT_YOUR_CODE
+    // Build the query to match storeId(s) and dateString range [fromDate, toDate], format: 'yyyy-mm-dd'
+    const { clientId, fromDate, toDate } = inputData;
+
+    const filter = [
+      {
+        terms: {
+          clientId: Array.isArray( clientId ) ? clientId : [ clientId ],
+        },
+      },
+      {
+        range: {
+          dateString: {
+            gte: fromDate,
+            lte: toDate,
+            format: 'yyyy-MM-dd',
+          },
+        },
+      },
+    ];
+
+    const openSearchQuery = {
+      size: 10000,
+      query: {
+        bool: {
+          filter: filter,
+        },
+      },
+      _source: [ 'ticketId', 'storeName', 'revicedFootfall', 'footfallCount', 'revicedPerc' ],
+    };
+
+
+    // Assuming getOpenSearchData and openSearch.footfallDirectoryTagging are available
+    const result = await getOpenSearchData( openSearch.footfallDirectory, openSearchQuery );
+    const getUserlist = result?.body?.hits?.hits?.map( ( hit ) => hit._source ) || [];
+    return res.sendSuccess( getUserlist|| [] );
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { error: error, function: 'openTicketList' } );
+    return res.sendError( err, 500 );
+  }
+}
+
+export async function assignTicket( req, res ) {
+  try {
+    const inputData = req.body;
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+
+    // INSERT_YOUR_CODE
+    // Build the query to match storeId(s) and dateString range [fromDate, toDate], format: 'yyyy-mm-dd'
+    const { email, userName, role, actionType } = inputData;
+
+    // INSERT_YOUR_CODE
+
+    // Find and update mappingInfo fields for the provided ticketId and actionType
+    // Requires ticketId in inputData
+    const { ticketId } = inputData;
+    if ( !ticketId ) {
+      return res.sendError( 'ticketId is required', 400 );
+    }
+
+    // Build the OpenSearch update-by-query body
+    const updateBody = {
+      script: {
+        source: `
+          if (ctx._source.mappingInfo != null) {
+            for (int i = 0; i < ctx._source.mappingInfo.length; i++) {
+              if (ctx._source.mappingInfo[i].type == params.actionType) {
+                ctx._source.mappingInfo[i].createdByEmail = params.email;
+                ctx._source.mappingInfo[i].createdByUserName = params.userName;
+                ctx._source.mappingInfo[i].createdByRole = params.role;
+              }
+            }
+          }
+        `,
+        lang: 'painless',
+        params: {
+          email,
+          userName,
+          role,
+          actionType,
+        },
+      },
+      query: {
+        bool: {
+          must: [
+            { term: { 'ticketId.keyword': ticketId } },
+            {
+              nested: {
+                path: 'mappingInfo',
+                query: {
+                  bool: {
+                    must: [
+                      { match: { 'mappingInfo.type': actionType } },
+                    ],
+                  },
+                },
+              },
+            },
+          ],
+        },
+      },
+    };
+
+    // Call OpenSearch _update_by_query to update doc(s) where ticketId and mappingInfo[i].type == actionType
+    const response = await upsertOpenSearchData(
+        openSearch.footfallDirectory,
+        '11-1716_2025-11-20_footfall-directory-tagging',
+        updateBody, // custom arg to indicate passthrough for update-by-query, depends on helper implementation
+    );
+
+
+    logger.info( { response } );
+
+    return res.sendSuccess( { updated: response?.body?.updated ?? 0 } );
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { error: error, function: 'assignTicket' } );
+    return res.sendError( err, 500 );
+  }
+}
+
+export async function updateTempStatus( req, res ) {
+  try {
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    const { id, status } = req.body;
+
+    // Use bulk update API via bucketing (batch update) -- fetch docs, then bulk-update
+    // 1. Search for all documents matching the ticket IDs
+    const searchBody = {
+      query: {
+        bool: {
+          must: [
+            {
+              terms: {
+                'id.keyword': id,
+              },
+            },
+          ],
+        },
+      },
+      _source: [ '_id' ], // Only bring _id for efficiency
+    };
+
+    const searchResp = await getOpenSearchData(
+        openSearch.revop,
+        searchBody,
+    );
+    logger.info( { searchResp: searchResp } );
+    // Extract bulk IDs to update
+    const hits = searchResp?.body?.hits?.hits ?? [];
+    logger.info( { hits: hits } );
+    if ( !hits.length ) {
+      return res.sendError( 'no data', 204 );
+    }
+
+    // 2. Build bulk update commands
+    // Each doc: { update: { _id: ..., _index: ... } }, { doc: { status: status } }
+
+    // 1. Get all IDs from hits
+    const docIdToIndex = {};
+    hits.forEach( ( doc ) => {
+      docIdToIndex[doc._id] = doc._index;
+    } );
+    const docIds = hits.map( ( doc ) => doc._id );
+    logger.info( { docIds } );
+    // 2. Fetch all docs by ID to get 'actions' (in chunks if large)
+    const getBody = [];
+    for ( const doc of hits ) {
+      getBody.push( { _index: doc._index, _id: doc._id } );
+    }
+
+    let mgetResp;
+    try {
+      mgetResp = await getOpenSearchData(
+          openSearch.revop,
+          {
+            query: {
+              ids: {
+                values: docIds,
+              },
+            },
+            _source: true,
+          },
+      );
+    } catch ( err ) {
+      logger.error( { error: err } );
+      mgetResp = undefined;
+    }
+    logger.info( { mgetResp } );
+    // (If you have a utility for multi-get, you may want to use that. Else, you might need to fetch each by ID.)
+    // For fallback, fetch all source fields via another search
+    let fullDocs = [];
+    if ( mgetResp && mgetResp.body && mgetResp.body.docs && Array.isArray( mgetResp.body.docs ) ) {
+      fullDocs = mgetResp.body.docs;
+    } else if ( searchResp.body && searchResp.body.hits && searchResp.body.hits.hits ) {
+      // fallback: use searchResp docs (request _source above)
+      fullDocs = searchResp.body.hits.hits;
+    }
+
+    // 3. Prepare the new actions array for each doc, and set up bulk update payloads
+    const reviewActions = [ 'approved', 'rejected' ];
+    const docsToUpdate = [];
+    logger.info( { fullDocs: fullDocs } );
+    for ( const doc of fullDocs ) {
+      const source = doc._source || doc.fields || {}; // support mget and search hits
+      let actions = Array.isArray( source.actions ) ? [ ...source.actions ] : [];
+      if ( reviewActions.includes( status ) ) {
+        // for review: update or push 'review'
+        let found = false;
+        actions = actions.map( ( item ) => {
+          if ( item.actionType === 'review' ) {
+            found = true;
+            return { ...item, action: status };
+          }
+          return item;
+        } );
+        if ( !found ) {
+          actions.push( { actionType: 'review', action: status } );
+        }
+      } else {
+        // tagging: update or push 'tagging'
+        let found = false;
+        actions = actions.map( ( item ) => {
+          if ( item.actionType === 'tagging' ) {
+            found = true;
+            return { ...item, action: 'submitted' };
+          }
+          return item;
+        } );
+        if ( !found ) {
+          actions.push( { actionType: 'tagging', action: 'submitted' } );
+        }
+      }
+      docsToUpdate.push( {
+        _index: doc._index || docIdToIndex[doc._id],
+        _id: doc._id,
+        actions,
+      } );
+    }
+    const bulkPayload = [];
+    // 4. Build bulk update payload
+    for ( const doc of docsToUpdate ) {
+      bulkPayload.push( {
+        update: { _index: doc._index, _id: doc._id },
+      } );
+      bulkPayload.push( {
+        doc: { actions: doc.actions },
+      } );
+    }
+    logger.info( { bulkPayload: bulkPayload } );
+
+
+    // 3. Execute bulk update
+    const bulkResp = await bulkUpdate( bulkPayload );
+
+    // Count successes
+    const updatedCount = bulkResp?.body?.items?.filter( ( item ) => item?.update?.result === 'updated' || item?.update?.result === 'noop' ).length ?? 0;
+
+    logger.info( { updated: updatedCount, by: 'updateTempStatus', ids: id } );
+
+    return res.sendSuccess( { updated: updatedCount } );
+  } catch ( error ) {
+    const err = error.message;
+    logger.info( { error: err, function: 'updateTempStatus' } );
+    return res.sendError( err, 500 );
+  }
+}
+

package/src/dtos/footfallDirectory.dtos.js

@@ -6,61 +6,16 @@ export const createTicketSchema = Joi.object().keys( {
   dateString: Joi.string().required(),
   storeId: Joi.string().required(),
   ticketName: Joi.string().required(),
-  footfallCount: Joi.number().optional(),
-  duplicateCount: Joi.number().optional(),
-  employeeCount: Joi.number().optional(),
-  houseKeepingCount: Joi.number().optional(),
-  junkCount: Joi.number().optional(),
-  comments: Joi.string().optional().allow( '' ),
-  duplicateImages: Joi.array().items(
-      Joi.object( {
-        tempId: Joi.number().required(),
-        filePath: Joi.string().required(),
-        entryTime: Joi.string().required(),
-        exitTime: Joi.string().required(),
-        timeRange: Joi.string().required(),
-        isChecked: Joi.boolean().required(),
-        data: Joi.array().items(
-            Joi.object( {
-              tempId: Joi.number().required(),
-              filePath: Joi.string().required(),
-              entryTime: Joi.string().required(),
-              exitTime: Joi.string().required(),
-              timeRange: Joi.string().required(),
-              isChecked: Joi.boolean().required(),
-            } ),
-        ).optional(),
-      } ) ).optional(),
-
-  houseKeeping: Joi.array().items( Joi.object( {
-    tempId: Joi.number().required(),
-    filePath: Joi.string().required(),
-    entryTime: Joi.string().required(),
-    exitTime: Joi.string().required(),
-    timeRange: Joi.string().required(),
-    isChecked: Joi.boolean().required(),
-  } ) ).optional(),
-
-  employee: Joi.array().items( Joi.object( {
-    tempId: Joi.number().required(),
-    filePath: Joi.string().required(),
-    entryTime: Joi.string().required(),
-    exitTime: Joi.string().required(),
-    timeRange: Joi.string().required(),
-    isChecked: Joi.boolean().required(),
-
-  } ) ).optional(),
-
-  junk: Joi.array().items( Joi.object( {
-    tempId: Joi.number().required(),
-    filePath: Joi.string().required(),
-    entryTime: Joi.string().required(),
-    exitTime: Joi.string().required(),
-    timeRange: Joi.string().required(),
-    isChecked: Joi.boolean().required(),
-
-  } ) ).optional(),
+  type: Joi.string()
+      .required()
+      .valid( 'create', 'review', 'approve', 'tangRreview' )
+      .messages( {
+        'any.only': 'type must be one of [create, review, approve, tangRreview]',
+      } ),
 
+  mode: Joi.string().valid( 'mobile', 'web' ).required().messages( {
+    'any.only': 'type must be one of [mobile,web]',
+  } ),
 
 } );
 
@@ -139,6 +94,7 @@ export const ticketListSchema = Joi.object().keys( {
   isExport: Joi.boolean().optional(),
   sortBy: Joi.string().optional().allow( '' ),
   sortOrder: Joi.number().valid( -1, 1 ).optional(),
+  tangoType: Joi.string().valid( 'store', 'internal', '' ).optional(),
   fromDate: Joi.string()
       .pattern( /^\d{4}-\d{2}-\d{2}$/, 'YYYY-MM-DD format' )
       .required()
@@ -483,3 +439,52 @@ export const downloadTicketsSchema = Joi.object().keys( {
 export const downloadTicketsValid = {
   query: downloadTicketsSchema,
 };
+
+export const reviewerListSchema = Joi.object().keys( {
+  clientId: Joi.string().required(),
+} );
+
+export const reviewerListValid = {
+  query: reviewerListSchema,
+};
+
+export const openTicketListSchema = Joi.object().keys( {
+  fromDate: Joi.string().required(),
+  toDate: Joi.string().required(),
+  clientId: Joi.array().items(
+      Joi.string().required(),
+  ).required(),
+
+
+} );
+
+export const openTicketListValid = {
+  body: openTicketListSchema,
+};
+
+
+export const assignTicketSchema = Joi.object().keys( {
+  email: Joi.string().required(),
+  userName: Joi.string().optional(),
+  role: Joi.string().optional(),
+  actionType: Joi.string().required(),
+  ticketId: Joi.string().required(),
+
+
+} );
+
+export const assignTicketValid = {
+  body: assignTicketSchema,
+};
+
+export const updateTempStatusSchema = Joi.object().keys( {
+  id: Joi.array().items( Joi.string().required() ).required(),
+  status: Joi.string().required(),
+  type: Joi.string().required(),
+
+
+} );
+
+export const updateTempStatusValid = {
+  body: updateTempStatusSchema,
+};

package/src/routes/footfallDirectory.routes.js

@@ -1,17 +1,23 @@
 import express from 'express';
-import { getClusters, isExist, isTicketExists } from '../validations/footfallDirectory.validation.js';
-import { createTicket, downloadTickets, getTaggedStores, getTickets, ticketList, ticketSummary, updateStatus } from '../controllers/footfallDirectory.controllers.js';
-import { createTicketValid, downloadTicketsValid, getTaggedStoresValid, getTicketsValid, ticketListValid, ticketSummaryValid, updateStatusValid } from '../dtos/footfallDirectory.dtos.js';
+import { getClusters, getConfig, isGrantedUsers, isTicketExists, ticketCreation } from '../validations/footfallDirectory.validation.js';
+import { assignTicket, createTicket, downloadTickets, getTaggedStores, getTickets, openTicketList, reviewerList, ticketList, ticketSummary, updateStatus, updateTempStatus } from '../controllers/footfallDirectory.controllers.js';
+import { createTicketValid, downloadTicketsValid, getTaggedStoresValid, getTicketsValid, openTicketListValid, reviewerListValid, ticketListValid, ticketSummaryValid, updateStatusValid, assignTicketValid, updateTempStatusValid } from '../dtos/footfallDirectory.dtos.js';
 import { bulkValidate, getAssinedStore, isAllowedSessionHandler, validate } from 'tango-app-api-middleware';
 
 export const footfallDirectoryRouter = express.Router();
 
-footfallDirectoryRouter.post( '/create-ticket', isAllowedSessionHandler, validate( createTicketValid ), isExist, createTicket );
+footfallDirectoryRouter.post( '/create-ticket', isAllowedSessionHandler, validate( createTicketValid ), isGrantedUsers, getConfig, ticketCreation, createTicket );
 footfallDirectoryRouter.get( '/ticket-summary', isAllowedSessionHandler, bulkValidate( ticketSummaryValid ), ticketSummary );
 
 footfallDirectoryRouter.get( '/ticket-list', isAllowedSessionHandler, bulkValidate( ticketListValid ), ticketList );
+// footfallDirectoryRouter.get( '/ticket-list', isAllowedSessionHandler, bulkValidate( ticketListValid ), ticketList );
 footfallDirectoryRouter.get( '/get-tickets', isAllowedSessionHandler, bulkValidate( getTicketsValid ), getTickets );
 footfallDirectoryRouter.get( '/get-tagged-stores', isAllowedSessionHandler, bulkValidate( getTaggedStoresValid ), getAssinedStore, getClusters, getTaggedStores );
 footfallDirectoryRouter.put( '/update-status', isAllowedSessionHandler, bulkValidate( updateStatusValid ), updateStatus );
 footfallDirectoryRouter.get( '/download-tickets', isAllowedSessionHandler, bulkValidate( downloadTicketsValid ), isTicketExists, downloadTickets );
+footfallDirectoryRouter.get( '/reviewer-list', isAllowedSessionHandler, bulkValidate( reviewerListValid ), reviewerList );
+footfallDirectoryRouter.post( '/open-ticket-list', isAllowedSessionHandler, bulkValidate( openTicketListValid ), openTicketList );
+footfallDirectoryRouter.post( '/assign-ticket', isAllowedSessionHandler, bulkValidate( assignTicketValid ), assignTicket );
+footfallDirectoryRouter.post( '/update-temp-status', isAllowedSessionHandler, bulkValidate( updateTempStatusValid ), updateTempStatus );
+
 

package/src/services/vmsStoreRequest.service.js

@@ -0,0 +1,4 @@
+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 } );
+};

package/src/validations/footfallDirectory.validation.js

@@ -1,6 +1,55 @@
-import { getOpenSearchCount, logger } from 'tango-app-api-middleware';
+import { bulkUpdate, getOpenSearchCount, getOpenSearchData, insertWithId, logger } from 'tango-app-api-middleware';
 import { aggregateCluster } from '../services/cluster.service.js';
 import { findOneRevopDownload } from '../services/revopDownload.service.js';
+import { findOneStore } from '../services/store.service.js';
+import { findOneClient } from '../services/client.service.js';
+import { updateOneUpsertVmsStoreRequest } from '../services/vmsStoreRequest.service.js';
+
+function formatRevopTaggingHits( hits = [] ) {
+  return hits
+      .map( ( hit ) => {
+        const source = hit?._source || {};
+        if ( Object.keys( source ).length === 0 ) {
+          return null;
+        }
+
+        const duplicateImages = Array.isArray( source.duplicateImage ) ?
+          source.duplicateImage.map( ( item ) => ( {
+            tempId: item?.tempId,
+            timeRange: item?.timeRange,
+            entryTime: item?.entryTime,
+            exitTime: item?.exitTime,
+            filePath: item?.filePath,
+            status: item?.status,
+            isChecked: Boolean( item?.isChecked ),
+          } ) ) :
+          [];
+
+        return {
+          id: hit?._id,
+          clientId: source?.clientId,
+          storeId: source?.storeId,
+          tempId: source?.tempId,
+          dateString: source?.dateString,
+          timeRange: source?.timeRange,
+          processType: source?.processType,
+          revopsType: source?.revopsType,
+          entryTime: source?.entryTime,
+          exitTime: source?.exitTime,
+          filePath: source?.filePath,
+          status: source?.status,
+          description: source?.description || '',
+          isChecked: Boolean( source?.isChecked ),
+          type: source?.type,
+          parent: source?.parent ?? null,
+          isParent: duplicateImages.length > 0 && !source?.parent,
+          createdAt: source?.createdAt,
+          updatedAt: source?.updatedAt,
+          data: duplicateImages,
+        };
+      } )
+      .filter( Boolean );
+}
 
 export async function isExist( req, res, next ) {
   try {
@@ -129,3 +178,507 @@ export async function isTicketExists( req, res, next ) {
   }
 }
 
+export async function isGrantedUsers( req, res, next ) {
+  try {
+    const userInfo = req?.user;
+    switch ( userInfo.userType ) {
+      case 'client':
+        const ticketsFeature = userInfo?.rolespermission?.find( ( f ) => f.featureName === 'FootfallDirectory' && ( f.modules.find( ( m ) => m.name =='creator' && m.isAdd==true ) || f.modules.find( ( m ) => m.name =='Reviewer' && m.isAdd==true ) || f.modules.find( ( m ) => m.name =='Approver' && m.isAdd==true ) ) );
+        logger.info( { ticketsFeature } );
+        if ( ticketsFeature ) {
+          return next();
+        } else {
+          return res.sendError( 'Forbidden to this action', 403 );
+        }
+
+      case 'tango':
+        return next();
+      default:
+        return res.sendError( 'userType doesnot match', 400 );
+    }
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    return res.sendError( err, 500 );
+  }
+}
+
+export async function getConfig( req, res, next ) {
+  try {
+    const inputData = req.body;
+    const storeKey = inputData.storeId.split( '-' )[0];
+
+    const config = await findOneClient( { clientId: storeKey }, { footfallDirectoryConfigs: 1 } );
+    logger.info( { config, storeKey } );
+    const accuracyBreach = config?.footfallDirectoryConfigs?.accuracyBreach;
+    req.accuracyBreach = accuracyBreach || '';
+    return next();
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    return res.sendError( err, 500 );
+  }
+}
+
+
+export async function ticketCreation( req, res, next ) {
+  try {
+    const inputData = req.body;
+    if ( inputData?.type !== 'create' ) {
+      return next();
+    }
+    // check the createtion permission from the user permission
+    const userInfo = req?.user;
+    const ticketsFeature = userInfo?.rolespermission?.some( ( f ) => f.featureName === 'FootfallDirectory' && ( f.modules.find( ( m ) => m.name =='creator' && ( m.isAdd==true || m.isEdit==true ) ) ) );
+    if ( !ticketsFeature ) {
+      return res.sendError( 'Forbidden to Create Ticket', 403 );
+    }
+
+    // get store info by the storeId into mongo db
+    const getstoreName = await findOneStore( { storeId: inputData.storeId, status: 'active' }, { storeId: 1, storeName: 1, clientId: 1 } );
+
+    if ( !getstoreName || getstoreName == null ) {
+      return res.sendError( 'The store ID is either inActive or not found', 400 );
+    }
+
+    // get the footfall count from opensearch
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    const dateString = `${inputData.storeId}_${inputData.dateString}`;
+    const getQuery = {
+      query: {
+        terms: {
+          _id: [ dateString ],
+        },
+      },
+      _source: [ 'footfall', 'date_string', 'store_id', 'down_time', 'footfall_count' ],
+      sort: [
+        {
+          date_iso: {
+            order: 'desc',
+          },
+        },
+      ],
+    };
+
+    const getFootfallCount = await getOpenSearchData( openSearch.footfall, getQuery );
+    const hits = getFootfallCount?.body?.hits?.hits || [];
+    if ( hits?.[0]?._source?.footfall_count <= 0 ) {
+      return res.sendError( 'You can’t create a ticket because this store has 0 footfall data' );
+    }
+
+    // get category details from the client level configuration
+    const getConfig = await findOneClient( { clientId: getstoreName.clientId }, { footfallDirectoryConfigs: 1 } );
+    if ( !getConfig || getConfig == null ) {
+      return res.sendError( 'The Client ID is either not configured or not found', 400 );
+    }
+
+    // Get taggingLimitation from config (check both possible paths)
+    const taggingLimitation = getConfig?.footfallDirectoryConfigs?.taggingLimitation;
+    // Initialize count object from taggingLimitation
+    const tempAcc = [];
+    const getCategory = taggingLimitation?.reduce( ( acc, item ) => {
+      if ( item?.type ) {
+        // Convert type to camelCase with "Count" suffix
+        // e.g., "duplicate" -> "duplicateCount", "housekeeping" -> "houseKeepingCount"
+        const typeLower = item.type.toLowerCase();
+        let key;
+        if ( typeLower === 'housekeeping' ) {
+          key = 'houseKeepingCount';
+        } else {
+          // Convert first letter to lowercase and append "Count"
+          key = typeLower.charAt( 0 ) + typeLower.slice( 1 ) + 'Count';
+        }
+
+
+        // To change from an object to the desired array structure, assemble an array of objects:
+        tempAcc.push( {
+          name: item.name,
+          value: 0,
+          key: key,
+          type: item.type,
+        } );
+
+
+        return acc;
+      }
+    }, {} ) || {};
+
+    // Query OpenSearch revop index to get actual counts for each type
+    if ( taggingLimitation && taggingLimitation.length > 0 ) {
+      const revopQuery = {
+        size: 0,
+        query: {
+          bool: {
+            must: [
+              {
+                term: {
+                  'storeId.keyword': inputData.storeId,
+                },
+              },
+              {
+                term: {
+                  'dateString': inputData.dateString,
+                },
+              },
+            ],
+          },
+        },
+        aggs: {
+          type_counts: {
+            terms: {
+              field: 'revopsType.keyword',
+              size: 100,
+            },
+          },
+        },
+      };
+
+
+      const revopData = await getOpenSearchData( openSearch.revop, revopQuery );
+      const buckets = revopData?.body?.aggregations?.type_counts?.buckets || [];
+
+      // Map OpenSearch revopsType values to count object keys
+      buckets.forEach( ( bucket ) => {
+        const revopsType = bucket.key;
+        const count = bucket.doc_count || 0;
+
+
+        if ( Array.isArray( tempAcc ) ) {
+          // Find the tempAcc entry whose type (case-insensitive) matches revopsType
+          const accMatch = tempAcc.find(
+              ( acc ) =>
+                acc.type &&
+              acc.type === revopsType,
+          );
+
+          if ( accMatch && accMatch.key ) {
+            tempAcc.find( ( a ) => a.key === accMatch.key ).value = count;
+          }
+        }
+      } );
+    }
+
+
+    // Calculate revisedFootfall: footfallCount - (sum of all counts)
+
+    const totalCount = Array.isArray( tempAcc ) ?
+      tempAcc.reduce( ( sum, acc ) => sum + ( acc.value || 0 ), 0 ) :
+      0;
+    const footfallCount = hits?.[0]?._source?.footfall_count || 0;
+    const revisedFootfall = Math.max( 0, footfallCount - totalCount );
+    if ( footfallCount - revisedFootfall == 0 ) {
+      return res.sendError( 'Cannot create a ticket because footfall hasn’t changed', 400 );
+    }
+
+    const taggingData = {
+      size: 10000,
+      query: {
+        bool: {
+          must: [
+            {
+              term: {
+                'storeId.keyword': inputData.storeId,
+              },
+            },
+            {
+              term: {
+                'dateString': inputData.dateString,
+              },
+            },
+          ],
+        },
+      },
+    };
+
+    const revopTaggingData = await getOpenSearchData( openSearch.revop, taggingData );
+    const taggingImages = revopTaggingData?.body?.hits?.hits;
+    if ( !taggingImages || taggingImages?.length == 0 ) {
+      return res.sendError( 'You don’t have any tagged images right now', 400 );
+    }
+    const formattedTaggingData = formatRevopTaggingHits( taggingImages );
+
+    const record = {
+      storeId: inputData.storeId,
+      type: 'store',
+      dateString: inputData.dateString,
+      storeName: getstoreName?.storeName,
+      ticketName: inputData.ticketName|| 'footfall-directory',
+      footfallCount: footfallCount,
+      clientId: getstoreName?.clientId,
+      ticketId: 'TE_FDT_' + new Date().valueOf(),
+      createdAt: new Date(),
+      updatedAt: new Date(),
+      status: 'raised',
+      revicedFootfall: revisedFootfall,
+      revicedPerc: Math.round( ( revisedFootfall/footfallCount ) * 100 || 0 ) + '%',
+      mappingInfo: [
+        {
+          type: 'tagging',
+          mode: inputData.mode,
+          revicedFootfall: revisedFootfall,
+          revicedPerc: Math.round( ( revisedFootfall/footfallCount ) * 100 || 0 ) + '%',
+          count: tempAcc,
+          revisedDetail: formattedTaggingData,
+          status: 'raised',
+          createdByEmail: req?.user?.email,
+          createdByUserName: req?.user?.userName,
+          createdByRole: req?.user?.role,
+          createdAt: new Date(),
+        },
+      ],
+    };
+
+
+    // Retrieve client footfallDirectoryConfigs revision
+    let isAutoCloseEnable = false;
+    let autoCloseAccuracy = '95%';
+    try {
+      const clientData = await clientModel.findOne( { clientId: getstoreName?.clientId } ).lean();
+      if ( clientData?.footfallDirectoryConfigs ) {
+        isAutoCloseEnable = clientData.footfallDirectoryConfigs.isAutoCloseEnable ?? false;
+        autoCloseAccuracy = clientData.footfallDirectoryConfigs.autoCloseAccuracy || '95%';
+      }
+    } catch ( e ) {
+      isAutoCloseEnable = false;
+      autoCloseAccuracy = '95%';
+    }
+
+    let autoCloseAccuracyValue = parseFloat( ( autoCloseAccuracy || '95' ).replace( '%', '' ) );
+    let revisedPercentage = 0;
+    if ( typeof getCategory === 'number' && getCategory > 0 ) {
+      revisedPercentage = ( revisedFootfall / getCategory ) * 100;
+    }
+
+    // If autoclose enabled and revisedPercentage meets/exceeds threshold, close ticket and skip revision
+    if (
+      isAutoCloseEnable === true &&
+      revisedPercentage >= autoCloseAccuracyValue
+    ) {
+      record.status = 'closed';
+      record.mappingInfo = [
+        {
+          type: 'tagging',
+          mode: inputData.mode,
+          revicedFootfall: revisedFootfall,
+          revicedPerc: Math.round( ( revisedFootfall/footfallCount ) * 100 || 0 ) + '%',
+          count: getCategory,
+          revisedDetail: formattedTaggingData,
+          status: 'closed',
+          createdByEmail: req?.user?.email,
+          createdByUserName: req?.user?.userName,
+          createdByRole: req?.user?.role,
+        },
+      ];
+    } else {
+    // If ticket is closed, do not proceed with revision mapping
+      let revisionArray = [];
+      try {
+        const clientData = await clientModel.findOne( { clientId: getstoreName?.clientId } ).lean();
+        revisionArray = clientData?.footfallDirectoryConfigs?.revision || [];
+      } catch ( e ) {
+        revisionArray = [];
+      }
+
+      // Default fallbacks
+      let revisionMapping = null;
+      let approverMapping = null;
+      let tangoReviewMapping = null;
+
+      // Find out which roles have isChecked true
+      if ( Array.isArray( revisionArray ) && revisionArray.length > 0 ) {
+        for ( const r of revisionArray ) {
+          if ( r.actionType === 'reviewer' && r.isChecked === true ) {
+            revisionMapping = {
+              type: 'review',
+              revicedFootfall: revisedFootfall,
+              revicedPerc: Math.round( ( revisedFootfall/footfallCount ) * 100 || 0 ) + '%',
+              count: getCategory,
+              revisedDetail: formattedTaggingData,
+              status: 'open',
+            };
+          } else if ( r.actionType === 'approver' && r.isChecked === true ) {
+            approverMapping = {
+              type: 'approver',
+              revicedFootfall: revisedFootfall,
+              revicedPerc: Math.round( ( revisedFootfall/footfallCount ) * 100 || 0 ) + '%',
+              count: getCategory,
+              revisedDetail: formattedTaggingData,
+              status: 'open',
+            };
+          } else if ( r.actionType === 'tango' && r.isChecked === true ) {
+            tangoReviewMapping = {
+              type: 'tango-review',
+              revicedFootfall: revisedFootfall,
+              revicedPerc: Math.round( ( revisedFootfall/footfallCount ) * 100 || 0 ) + '%',
+              count: getCategory,
+              revisedDetail: formattedTaggingData,
+              status: 'open',
+            };
+          }
+        }
+      }
+
+      // Insert appropriate mappingInfo blocks
+      if ( revisionMapping ) {
+      // If reviewer and checked
+        record.mappingInfo.push( revisionMapping );
+      } else if ( approverMapping ) {
+      // If approver and checked
+        record.mappingInfo.push( approverMapping );
+      } else if ( tangoReviewMapping ) {
+      // If none above, then tangoReview
+        record.mappingInfo.push( tangoReviewMapping );
+      }
+    }
+
+
+    const id = `${inputData.storeId}_${inputData.dateString}_footfall-directory-tagging`;
+    const insertResult = await insertWithId( openSearch.footfallDirectory, id, record );
+    if ( insertResult && insertResult.statusCode === 201 ) {
+      // After successful ticket creation, update status to "submitted" in revop index for the relevant records
+      try {
+        const bulkUpdateBody = taggingImages.map( ( img ) => [
+          { update: { _index: openSearch.revop, _id: img._id } },
+          { doc: { status: 'submitted' } },
+        ] ).flat();
+
+        if ( bulkUpdateBody.length > 0 ) {
+          await bulkUpdate( bulkUpdateBody ); // Optionally use a dedicated bulk helper if available
+        }
+      } catch ( updateErr ) {
+        logger.error( { error: updateErr, message: 'Failed to update status to submitted in revop index' } );
+        // Do not block the success response for this failure
+      }
+
+      // Check if ticketCount exceeds breach limit within config months and revised footfall percentage > config accuracy
+
+      if ( req.accuracyBreach && req.accuracyBreach.ticketCount && req.accuracyBreach.days && req.accuracyBreach.accuracy ) {
+        const breachDays = Number( req.accuracyBreach.days );
+        const breachCount = Number( req.accuracyBreach.ticketCount );
+
+        // req.accuracyBreach.accuracy is a string like "95%", so remove "%" and convert to Number
+        const breachAccuracy = Number( req.accuracyBreach.accuracy.replace( '%', '' ) );
+        const storeId = inputData.storeId;
+        const ticketName =inputData.ticketName || 'footfall-directory'; // adjust if ticket name variable differs
+
+
+        const formatDate = ( d ) =>
+          `${d.getFullYear()}-${String( d.getMonth() + 1 ).padStart( 2, '0' )}-${String( d.getDate() ).padStart( 2, '0' )}`;
+
+        // Compute current date object
+
+
+        // Calculate start date based on config days
+        // If 30 days: start from first day of current month
+        // If 60 days: start from first day of last month
+        const currentDateObj = new Date(); // Declare currentDateObj as today's date
+        const startDateObj = new Date( currentDateObj );
+
+        if ( breachDays === 30 ) {
+          // Consider within this month
+          startDateObj.setDate( 1 ); // First day of current month
+        } else if ( breachDays === 60 ) {
+          // Consider this month and last month
+          startDateObj.setMonth( startDateObj.getMonth() - 1 );
+          startDateObj.setDate( 1 ); // First day of last month
+        } else {
+          // For other values, calculate months from days
+          const breachMonths = Math.ceil( breachDays / 30 );
+          startDateObj.setMonth( startDateObj.getMonth() - breachMonths + 1 );
+          startDateObj.setDate( 1 );
+        }
+
+
+        const startDate = startDateObj;
+
+
+        const endDate = new Date;
+        // Query for tickets within this months window for this store and ticket name
+        const query = {
+          query: {
+            bool: {
+              must: [
+                { term: { 'storeId.keyword': storeId } },
+                { term: { 'ticketName.keyword': ticketName } },
+                { range: { createdAt: { gte: startDate, lte: endDate } } },
+              ],
+            },
+          },
+        };
+
+        // Search in OpenSearch for recent similar tickets
+        const breachTicketsResult = await getOpenSearchData( openSearch.footfallDirectory, query );
+        const tickets = breachTicketsResult?.body?.hits?.hits || [];
+
+        // Filter tickets where revised footfall percentage > config accuracy
+        let breachTicketsCount = 0;
+        for ( const ticket of tickets ) {
+          const source = ticket._source || {};
+          const footfallCount = source.footfallCount || 0;
+          const revicedFootfall = source.mappingInfo?.[0]?.revicedFootfall || 0;
+
+          // Calculate revised footfall percentage
+          let revisedPercentage = 0;
+          if ( footfallCount > 0 ) {
+            revisedPercentage = ( revicedFootfall / footfallCount ) * 100;
+          }
+
+          // Check if revised footfall percentage > config accuracy
+          if ( revisedPercentage > breachAccuracy ) {
+            breachTicketsCount++;
+          }
+        }
+
+        if ( breachTicketsCount >= breachCount ) {
+          // Calculate remaining future days in the config period
+          const futureDates = [];
+
+          // Calculate end date of config period
+          const configEndDateObj = new Date( currentDateObj );
+          if ( breachDays === 30 ) {
+            // End of current month
+            configEndDateObj.setMonth( configEndDateObj.getMonth() + 1 );
+            configEndDateObj.setDate( 0 ); // Last day of current month
+          } else if ( breachDays === 60 ) {
+            // End of next month
+            configEndDateObj.setMonth( configEndDateObj.getMonth() + 2 );
+            configEndDateObj.setDate( 0 ); // Last day of next month
+          } else {
+            // For other values, add the remaining days
+            const remainingDays = breachDays - ( Math.floor( ( currentDateObj - startDateObj ) / ( 1000 * 60 * 60 * 24 ) ) );
+            configEndDateObj.setDate( configEndDateObj.getDate() + remainingDays );
+          }
+
+          // Generate all dates from tomorrow until end of config period
+          const tomorrow = new Date( currentDateObj );
+          tomorrow.setDate( tomorrow.getDate() + 1 );
+
+          const dateIterator = new Date( tomorrow );
+          while ( dateIterator <= configEndDateObj ) {
+            futureDates.push( formatDate( dateIterator ) );
+            dateIterator.setDate( dateIterator.getDate() + 1 );
+          }
+
+          // Insert a record for each future date
+          for ( const futureDateString of futureDates ) {
+            const record = {
+              clientId: getstoreName?.clientId,
+              storeId: inputData?.storeId,
+              storeName: getstoreName?.storeName,
+              dateString: futureDateString,
+              status: 'block',
+            };
+
+            await updateOneUpsertVmsStoreRequest( { storeId: inputData?.storeId, dateString: futureDateString }, record );
+          }
+        }
+      }
+
+      return res.sendSuccess( 'Ticket raised successfully' );
+    }
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { error: err, funtion: 'ticketCreation' } );
+    return res.sendError( err, 500 );
+  }
+}
+
+