tango-app-api-analysis-traffic 3.8.9 → 3.8.11

package/src/controllers/revop.controller.js

@@ -1,7 +1,8 @@
 import { logger, insertOpenSearchData, getOpenSearchData, updateOpenSearchData } from 'tango-app-api-middleware';
 import { findOnerevopConfig } from '../services/revopConfig.service.js';
 import * as clientService from '../services/clients.services.js';
-import { bulkUpdate, upsertWithScript } from 'tango-app-api-middleware/src/utils/openSearch.js';
+import { bulkUpdate, insertWithId, scrollResponse, searchOpenSearchData, upsertWithScript } from 'tango-app-api-middleware/src/utils/openSearch.js';
+import { findOneVmsStoreRequest } from '../services/vmsStoreRequest.service.js';
 import dayjs from 'dayjs';
 // Lamda Service Call //
 async function LamdaServiceCall( url, data ) {
@@ -16,7 +17,6 @@ async function LamdaServiceCall( url, data ) {
     const response = await fetch( url, requestOptions );
     if ( !response.ok ) {
       throw new Error( `Response status: ${response.status}` );
-      return false;
     }
     const json = await response.json();
     return json;
@@ -69,7 +69,7 @@ export async function revoptagging( req, res ) {
 
       let respo= await getOpenSearchData( openSearch.revops, searchQuery );
       const revopData = respo?.body?.hits?.hits;
-      if ( revopData&& revopData.length>0 ) {
+      if ( revopData && revopData.length>0 ) {
         await updateOpenSearchData( openSearch.revops, revopData[0]._id, { doc: item } );
       } else {
         item.createdAt = new Date();
@@ -92,7 +92,7 @@ async function getClientConfig( clientId ) {
     }
     return getClientData;
   } catch ( error ) {
-    logger.error( { error: error, message: data, function: 'getClientConfig' } );
+    logger.error( { error: error, message: clientId, function: 'getClientConfig' } );
     return false;
   }
 }
@@ -126,7 +126,7 @@ export async function getrevoptagging( req, res ) {
     };
     let respo= await getOpenSearchData( openSearch.revops, searchQuery );
     const revopData = respo?.body?.hits?.hits;
-    if ( revopData.length>0 ) {
+    if ( revopData && revopData.length>0 ) {
       return res.sendSuccess( revopData[0]._source );
     } else {
       return res.sendError( 'no data found', 204 );
@@ -136,6 +136,690 @@ export async function getrevoptagging( req, res ) {
     return res.sendError( { error: error }, 500 );
   }
 }
+
+export async function migrateRevopIndex( req, res ) {
+  try {
+    const { storeId, dateString, size = 100 } = req.body;
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+
+    const query = {
+      size: size,
+      query: {
+        bool: {
+          must: [
+            // {
+            //   range: {
+            //     createdAt: {
+            //       gte: '2025-10-01T00:00:00.000Z',
+            //       lte: '2025-10-31T23:59:59.000Z',
+            //     },
+            //   },
+            // },
+            {
+              term: {
+                'type.keyword': 'tagging-reflect',
+
+              },
+            },
+          ],
+        },
+      },
+    };
+
+    if ( storeId ) {
+      query.query.bool.must.push( {
+        term: {
+          'storeId.keyword': storeId,
+        },
+      } );
+    }
+
+    if ( dateString ) {
+      query.query.bool.must.push( {
+        terms: {
+          dateString: Array.isArray( dateString ) ? dateString : `${dateString}`.split( ',' ),
+        },
+      } );
+    }
+
+    // const response = await getOpenSearchData( openSearch.revop, query );
+    // const hits = response?.body?.hits?.hits || [];
+
+    // Use OpenSearch scroll API to retrieve up to 60000 records efficiently
+    let allHits = [];
+    let scrollId = null;
+    let totalFetched = 0;
+    let firstResponse = await searchOpenSearchData( openSearch.revop, query );
+    // Collect first batch
+    let hitsBatch = firstResponse?.body?.hits?.hits || [];
+    if ( hitsBatch.length > 0 ) {
+      allHits.push( ...hitsBatch );
+      totalFetched += hitsBatch.length;
+      scrollId = firstResponse.body._scroll_id;
+    }
+
+    const bulkBody = [];
+    for ( const hit of hitsBatch ) {
+      const src = hit._source || {};
+      const statusValue = ( src.status || '' ).toLowerCase();
+      // const parentValue = src.parent;
+
+      // Get ticket sattasu from the footfalldirectory index matching src.storeId and src.dateString
+      let ticketStatus = null;
+
+      const footfallQuery = {
+        size: 1,
+        query: {
+          bool: {
+            must: [
+              { term: { 'storeId.keyword': src.storeId } },
+              { term: { 'dateString': src.dateString } },
+            ],
+          },
+        },
+      };
+      const footfallResp = await getOpenSearchData( openSearch.oldFootfallDirectory, footfallQuery );
+      ticketStatus = footfallResp?.body?.hits?.hits?.[0]?._source?.status || null;
+      if ( src?.duplicateImage?.length > 0 ) {
+        src.duplicateImage = src.duplicateImage.map( ( item ) => ( {
+          ...item,
+          id: `${src.storeId || ''}_${src.dateString || src.dteString || ''}_${item.tempId || ''}`,
+          actions: ( ticketStatus === 'closed' && item.isChecked === true ) ? [
+            {
+              actionType: 'tagging',
+              action: 'submitted',
+            },
+            {
+              actionType: 'review',
+              action: 'approved',
+            },
+          ]: ( ticketStatus === 'closed' && item.isChecked === false )?
+        [
+          {
+            actionType: 'tagging',
+            action: 'submitted',
+          },
+          {
+            actionType: 'review',
+            action: 'rejected',
+          },
+        ]:
+        [
+          {
+            actionType: 'tagging',
+            action: 'submitted',
+          },
+        ],
+        // Include relevant action, assuming 'actions' will be determined below
+        } ) );
+      }
+
+
+      const idValue = `${src.storeId || ''}_${src.dateString || src.dteString || ''}_${src.tempId || ''}`;
+      let actions = [
+        {
+          actionType: 'tagging',
+          action: 'submitted',
+        },
+      ];
+
+      if ( statusValue === 'approved' ) {
+        actions = [
+          {
+            actionType: 'tagging',
+            action: 'submitted',
+          },
+          {
+            actionType: 'review',
+            action: 'approved',
+          },
+        ];
+      } else if ( statusValue === 'rejected' ) {
+        actions = [
+          {
+            actionType: 'tagging',
+            action: 'submitted',
+          },
+          {
+            actionType: 'review',
+            action: 'rejected',
+          },
+        ];
+      }
+
+
+      const doc = {
+        ...src,
+        id: idValue,
+        revopsType: src?.revopsType === 'house-keeping'? 'houseKeeping' : src?.revopsType,
+        isParent: src?.duplicateImage?.length > 0? true : false,
+        actions,
+        ticketStatus: src.status,
+      // updatedAt: new Date(),
+      };
+
+      bulkBody.push(
+          { update: { _index: openSearch.newRevop, _id: hit._id } },
+          { doc: doc, doc_as_upsert: true },
+      );
+    }
+
+    const bulkRes = await bulkUpdate( bulkBody );
+
+    if ( bulkRes?.errors ) {
+      logger.error( 'Bulk migration errors:', bulkRes.items );
+      return res.sendError( 'Failed to migrate some records', 500 );
+    }
+
+    while ( hitsBatch.length > 0 && scrollId ) {
+      // Fetch next batch using scroll_id
+      const nextScrollRes = await scrollResponse( scrollId );
+
+      hitsBatch = nextScrollRes?.body?.hits?.hits || [];
+      if ( hitsBatch.length === 0 ) break;
+      logger.info( { hitsBatch: hitsBatch?.length } );
+      const bulkBody = [];
+      for ( const hit of hitsBatch ) {
+        const src = hit._source || {};
+        const statusValue = ( src.status || '' ).toLowerCase();
+        // const parentValue = src.parent;
+
+        // Get ticket sattasu from the footfalldirectory index matching src.storeId and src.dateString
+        let ticketStatus = null;
+
+        const footfallQuery = {
+          size: 1,
+          query: {
+            bool: {
+              must: [
+                { term: { 'storeId.keyword': src.storeId } },
+                { term: { 'dateString': src.dateString } },
+              ],
+            },
+          },
+        };
+        const footfallResp = await getOpenSearchData( openSearch.oldFootfallDirectory, footfallQuery );
+        ticketStatus = footfallResp?.body?.hits?.hits?.[0]?._source?.status || null;
+        if ( src?.duplicateImage?.length > 0 ) {
+          src.duplicateImage = src.duplicateImage.map( ( item ) => ( {
+            ...item,
+            id: `${src.storeId || ''}_${src.dateString || src.dteString || ''}_${item.tempId || ''}`,
+            actions: ( ticketStatus === 'closed' && item.isChecked === true ) ? [
+              {
+                actionType: 'tagging',
+                action: 'submitted',
+              },
+              {
+                actionType: 'review',
+                action: 'approved',
+              },
+            ]: ( ticketStatus === 'closed' && item.isChecked === false )?
+          [
+            {
+              actionType: 'tagging',
+              action: 'submitted',
+            },
+            {
+              actionType: 'review',
+              action: 'rejected',
+            },
+          ]:
+          [
+            {
+              actionType: 'tagging',
+              action: 'submitted',
+            },
+          ],
+          // Include relevant action, assuming 'actions' will be determined below
+          } ) );
+        }
+
+
+        const idValue = `${src.storeId || ''}_${src.dateString || src.dteString || ''}_${src.tempId || ''}`;
+        logger.info( { idValue } );
+        let actions = [
+          {
+            actionType: 'tagging',
+            action: 'submitted',
+          },
+        ];
+
+        if ( statusValue === 'approved' ) {
+          actions = [
+            {
+              actionType: 'tagging',
+              action: 'submitted',
+            },
+            {
+              actionType: 'review',
+              action: 'approved',
+            },
+          ];
+        } else if ( statusValue === 'rejected' ) {
+          actions = [
+            {
+              actionType: 'tagging',
+              action: 'submitted',
+            },
+            {
+              actionType: 'review',
+              action: 'rejected',
+            },
+          ];
+        }
+
+
+        const doc = {
+          ...src,
+          id: idValue,
+          revopsType: src?.revopsType === 'house-keeping'? 'houseKeeping' : src?.revopsType,
+          isParent: src?.duplicateImage?.length > 0? true : false,
+          actions,
+          ticketStatus: src.status,
+        // updatedAt: new Date(),
+        };
+
+        bulkBody.push(
+            { update: { _index: openSearch.newRevop, _id: hit._id } },
+            { doc: doc, doc_as_upsert: true },
+        );
+      }
+
+      const bulkRes = await bulkUpdate( bulkBody );
+
+      if ( bulkRes?.errors ) {
+        logger.error( 'Bulk migration errors:', bulkRes.items );
+        return res.sendError( 'Failed to migrate some records', 500 );
+      }
+      allHits.push( ...hitsBatch );
+      totalFetched += hitsBatch.length;
+      logger.info( { totalFetched } );
+      // Protect against exceeding limit
+
+      scrollId = nextScrollRes.body._scroll_id;
+    }
+
+    // For downstream logic, use allHits instead of hits
+    const hits = allHits;
+
+    if ( hits.length === 0 ) {
+      return res.sendSuccess( { message: 'No records found for migration', updated: 0 } );
+    }
+
+
+    // for ( const hit of hits ) {
+    //   const src = hit._source || {};
+    //   const statusValue = ( src.status || '' ).toLowerCase();
+    //   // const parentValue = src.parent;
+
+    //   // Get ticket sattasu from the footfalldirectory index matching src.storeId and src.dateString
+    //   let ticketStatus = null;
+
+    //   const footfallQuery = {
+    //     size: 1,
+    //     query: {
+    //       bool: {
+    //         must: [
+    //           { term: { 'storeId.keyword': src.storeId } },
+    //           { term: { 'dateString': src.dateString } },
+    //         ],
+    //       },
+    //     },
+    //   };
+    //   const footfallResp = await getOpenSearchData( openSearch.oldFootfallDirectory, footfallQuery );
+    //   ticketStatus = footfallResp?.body?.hits?.hits?.[0]?._source?.status || null;
+    //   if ( src?.duplicateImage?.length > 0 ) {
+    //     src.duplicateImage = src.duplicateImage.map( ( item ) => ( {
+    //       ...item,
+    //       id: `${src.storeId || ''}_${src.dateString || src.dteString || ''}_${item.tempId || ''}`,
+    //       actions: ( ticketStatus === 'closed' && item.isChecked === true ) ? [
+    //         {
+    //           actionType: 'tagging',
+    //           action: 'submitted',
+    //         },
+    //         {
+    //           actionType: 'review',
+    //           action: 'approved',
+    //         },
+    //       ]: ( ticketStatus === 'closed' && item.isChecked === false )?
+    //       [
+    //         {
+    //           actionType: 'tagging',
+    //           action: 'submitted',
+    //         },
+    //         {
+    //           actionType: 'review',
+    //           action: 'rejected',
+    //         },
+    //       ]:
+    //       [
+    //         {
+    //           actionType: 'tagging',
+    //           action: 'submitted',
+    //         },
+    //       ],
+    //       // Include relevant action, assuming 'actions' will be determined below
+    //     } ) );
+    //   }
+
+
+    //   const idValue = `${src.storeId || ''}_${src.dateString || src.dteString || ''}_${src.tempId || ''}`;
+
+    //   let actions = [
+    //     {
+    //       actionType: 'tagging',
+    //       action: 'submitted',
+    //     },
+    //   ];
+
+    //   if ( statusValue === 'approved' ) {
+    //     actions = [
+    //       {
+    //         actionType: 'tagging',
+    //         action: 'submitted',
+    //       },
+    //       {
+    //         actionType: 'review',
+    //         action: 'approved',
+    //       },
+    //     ];
+    //   } else if ( statusValue === 'rejected' ) {
+    //     actions = [
+    //       {
+    //         actionType: 'tagging',
+    //         action: 'submitted',
+    //       },
+    //       {
+    //         actionType: 'review',
+    //         action: 'rejected',
+    //       },
+    //     ];
+    //   }
+
+
+    //   const doc = {
+    //     ...src,
+    //     id: idValue,
+    //     revopsType: src?.revopsType === 'house-keeping'? 'houseKeeping' : src?.revopsType,
+    //     isParent: src?.duplicateImage?.length > 0? true : false,
+    //     actions,
+    //     ticketStatus: src.status,
+    //     // updatedAt: new Date(),
+    //   };
+
+
+    //   bulkBody.push(
+    //       { update: { _index: openSearch.newRevop, _id: hit._id } },
+    //       { doc: doc, doc_as_upsert: true },
+    //   );
+    // }
+    // Implement batch by batch update
+    // const BATCH_SIZE = 10000; // You can adjust the batch size as needed
+
+    // for ( let i = 0; i < bulkBody.length; i += BATCH_SIZE ) {
+    //   const batch = bulkBody.slice( i, i + BATCH_SIZE );
+    //   const bulkRes = await bulkUpdate( batch );
+
+    //   if ( bulkRes?.errors ) {
+    //     logger.error( 'Bulk migration errors:', bulkRes.items );
+    //     return res.sendError( 'Failed to migrate some records', 500 );
+    //   }
+    // }
+
+    // const bulkRes = await bulkUpdate( bulkBody );
+
+    // if ( bulkRes?.errors ) {
+    //   logger.error( 'Bulk migration errors:', bulkRes.items );
+    //   return res.sendError( 'Failed to migrate some records', 500 );
+    // }
+
+    return res.sendSuccess( { message: 'Migration completed', updated: hits.length } );
+  } catch ( error ) {
+    logger.error( { error: error, message: req.body, function: 'migrateRevopIndex' } );
+    return res.sendError( { error: error }, 500 );
+  }
+}
+
+export async function expireReviewStatus( req, res ) {
+  try {
+    const {
+      thresholdDate,
+      batchSize = 500,
+      storeId,
+      dateString,
+    } = req.body;
+    const cutoffDate = new Date( thresholdDate );
+    // Convert cutoffDate to "2026-01-12T23:59:59.000Z"
+
+    cutoffDate.setUTCHours( 23, 59, 59, 0 );
+
+    console.log( cutoffDate );
+    if ( Number.isNaN( cutoffDate.getTime() ) ) {
+      return res.sendError( 'Invalid thresholdDate', 400 );
+    }
+
+
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    const query = {
+      size: batchSize,
+      query: {
+        bool: {
+          must: [
+            { term: { 'ticketName.keyword': 'footfall-directory' } },
+            { term: { 'type.keyword': 'store' } },
+          ],
+          must_not: [
+            { terms: { 'status.keyword': [ 'Closed' ] } },
+          ],
+        },
+      },
+    };
+
+
+    if ( storeId ) {
+      query.query.bool.must.push( { term: { 'storeId.keyword': storeId } } );
+    }
+
+
+    if ( dateString ) {
+      query.query.bool.must.push( {
+        terms: {
+          dateString: Array.isArray( dateString ) ? dateString : `${dateString}`.split( ',' ),
+        },
+      } );
+    }
+
+
+    let totalUpdated = 0;
+    let scrollId = null;
+
+    let firstResponse = await searchOpenSearchData( openSearch.footfallDirectory, query );
+    let hitsBatch = firstResponse?.body?.hits?.hits || [];
+    scrollId = firstResponse?.body?._scroll_id;
+
+    while ( hitsBatch.length > 0 ) {
+      const bulkBody = [];
+
+      for ( const hit of hitsBatch ) {
+        const src = hit._source || {};
+        const mappingInfo = Array.isArray( src.mappingInfo ) ? src.mappingInfo : [];
+        let changed = false;
+        let updatedMapping = mappingInfo.map( ( item ) => {
+          if ( item?.type === 'review' && item?.status !== 'Closed' && item?.dueDate ) {
+            const due = new Date( item.dueDate );
+            if ( !Number.isNaN( due.getTime() ) && due < cutoffDate ) {
+              changed = true;
+
+              return { ...item, status: 'Expired' };
+            }
+          }
+
+          return item;
+        } );
+        if ( changed ) {
+          updatedMapping = updatedMapping.map( ( item ) => {
+            if ( item?.type === 'tagging' ) {
+              return { ...item, status: 'Expired' };
+            }
+            return item;
+          } );
+        }
+
+        if ( changed ) {
+          const doc = {
+            mappingInfo: updatedMapping,
+            status: 'Reviewer-Expired',
+          };
+          logger.info( { updatedMapping } );
+          bulkBody.push(
+              { update: { _index: openSearch.footfallDirectory, _id: hit._id } },
+              { doc: doc, doc_as_upsert: true },
+          );
+        }
+      }
+
+      if ( bulkBody.length > 0 ) {
+        const bulkRes = await bulkUpdate( bulkBody );
+        if ( bulkRes?.errors ) {
+          logger.error( { message: 'Bulk expire errors', items: bulkRes.items } );
+        }
+        totalUpdated += bulkBody.length / 2;
+      }
+      logger.info( { totalUpdated, msg: '........9' } );
+      if ( !scrollId ) break;
+      const nextRes = await scrollResponse( scrollId );
+      hitsBatch = nextRes?.body?.hits?.hits || [];
+      scrollId = nextRes?.body?._scroll_id;
+    }
+
+    return res.sendSuccess( { message: 'Expired review status updated', updated: totalUpdated } );
+  } catch ( error ) {
+    logger.error( { error: error, message: req.body, function: 'expireReviewStatus' } );
+    return res.sendError( { error: error }, 500 );
+  }
+}
+
+
+export async function expireApproveStatus( req, res ) {
+  try {
+    const {
+      thresholdDate = '2026-01-21',
+      batchSize = 500,
+      storeId,
+      dateString,
+    } = req.body;
+    const cutoffDate = new Date( thresholdDate );
+    if ( Number.isNaN( cutoffDate.getTime() ) ) {
+      return res.sendError( 'Invalid thresholdDate', 400 );
+    }
+
+
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    const query = {
+      size: batchSize,
+      query: {
+        bool: {
+          must: [
+            { term: { 'ticketName.keyword': 'footfall-directory' } },
+            { term: { 'type.keyword': 'store' } },
+          ],
+          must_not: [
+            { terms: { 'status.keyword': [ 'Closed' ] } },
+          ],
+        },
+      },
+    };
+
+
+    if ( storeId ) {
+      query.query.bool.must.push( { term: { 'storeId.keyword': storeId } } );
+    }
+
+
+    if ( dateString ) {
+      query.query.bool.must.push( {
+        terms: {
+          dateString: Array.isArray( dateString ) ? dateString : `${dateString}`.split( ',' ),
+        },
+      } );
+    }
+
+
+    let totalUpdated = 0;
+    let scrollId = null;
+
+    let firstResponse = await searchOpenSearchData( openSearch.footfallDirectory, query );
+    let hitsBatch = firstResponse?.body?.hits?.hits || [];
+    scrollId = firstResponse?.body?._scroll_id;
+
+    while ( hitsBatch.length > 0 ) {
+      const bulkBody = [];
+
+      for ( const hit of hitsBatch ) {
+        const src = hit._source || {};
+        const mappingInfo = Array.isArray( src.mappingInfo ) ? src.mappingInfo : [];
+        let changed = false;
+        let updatedMapping = mappingInfo.map( ( item ) => {
+          if ( item?.type === 'approve' && item?.status !== 'Closed' && item?.dueDate ) {
+            const due = new Date( item.dueDate );
+            logger.info( { item, due, msg: '..........1', cutoffDate } );
+            if ( !Number.isNaN( due.getTime() ) && due < cutoffDate ) {
+              changed = true;
+
+              return { ...item, status: 'Expired' };
+            }
+          }
+
+          return item;
+        } );
+        logger.info( { updatedMapping, msh: '.......12' } );
+        if ( changed ) {
+          logger.info( { changed, msg: '.......2' } );
+          updatedMapping = updatedMapping.map( ( item ) => {
+            logger.info( { item, msg: '.......3' } );
+            if ( item?.type === 'tagging' ) {
+              logger.info( { item: item?.type, msg: '.......4' } );
+              return { ...item, status: 'Expired' };
+            }
+            return item;
+          } );
+        }
+
+        logger.info( { updatedMapping, msh: '.......13' } );
+        if ( changed ) {
+          const doc = {
+            mappingInfo: updatedMapping,
+            status: 'Expired',
+          };
+          logger.info( { updatedMapping } );
+          bulkBody.push(
+              { update: { _index: openSearch.footfallDirectory, _id: hit._id } },
+              { doc: doc, doc_as_upsert: true },
+          );
+        }
+      }
+
+      if ( bulkBody.length > 0 ) {
+        const bulkRes = await bulkUpdate( bulkBody );
+        if ( bulkRes?.errors ) {
+          logger.error( { message: 'Bulk expire errors', items: bulkRes.items } );
+        }
+        totalUpdated += bulkBody.length / 2;
+      }
+      logger.info( { totalUpdated, msg: '........9' } );
+      if ( !scrollId ) break;
+      const nextRes = await scrollResponse( scrollId );
+      hitsBatch = nextRes?.body?.hits?.hits || [];
+      scrollId = nextRes?.body?._scroll_id;
+    }
+
+    return res.sendSuccess( { message: 'Expired approve status updated', updated: totalUpdated } );
+  } catch ( error ) {
+    logger.error( { error: error, message: req.body, function: 'expireApproveStatus' } );
+    return res.sendError( { error: error }, 500 );
+  }
+}
+
 export async function revoptaggingcount( req, res ) {
   try {
     const openSearch = JSON.parse( process.env.OPENSEARCH );
@@ -211,44 +895,180 @@ export async function storeProcessedData( req, res ) {
   try {
     const openSearch = JSON.parse( process.env.OPENSEARCH );
     const inputData = req.query;
-    const previousDate = dayjs( inputData.dateString ).subtract( 1, 'day' ).format( 'YYYY-MM-DD' );
-    const dateString = `${inputData.storeId}_${inputData.dateString}`;
-    const dateStringPrevious = `${inputData.storeId}_${previousDate}`;
-    const getQuery = {
-      query: {
-        terms: {
-          _id: [ dateString, dateStringPrevious ],
-        },
-      },
-      _source: [ 'footfall', 'date_string', 'store_id', 'down_time', 'footfall_count' ],
-      sort: [
-        {
-          date_iso: {
-            order: 'desc',
+    const { fromDate, toDate, storeId } = inputData;
+
+    // Multi-date range handling for a single store
+    if ( fromDate && toDate && storeId ) {
+      const dayjs = ( await import( 'dayjs' ) ).default;
+      const isSameOrBefore = ( await import( 'dayjs/plugin/isSameOrBefore.js' ) ).default;
+      dayjs.extend( isSameOrBefore );
+
+      let start = dayjs( fromDate );
+      // get start value from the before day one
+      // Move start one day back so we can access "day before" when looping
+      start = start.subtract( 1, 'day' );
+      let end = dayjs( toDate );
+
+      if ( !start.isValid() || !end.isValid() ) {
+        return res.sendError( 'Invalid date range supplied', 400 );
+      }
+
+      if ( end.isBefore( start ) ) {
+        [ start, end ] = [ end, start ];
+      }
+
+      const allDateStrings = [];
+      const orderedDates = [];
+
+      while ( start.isSameOrBefore( end ) ) {
+        const formatted = start.format( 'YYYY-MM-DD' );
+        orderedDates.push( formatted );
+        allDateStrings.push( `${storeId}_${formatted}` );
+        start = start.add( 1, 'day' );
+      }
+
+      if ( allDateStrings.length === 0 ) {
+        return res.sendSuccess( [] );
+      }
+
+      const footfallQuery = {
+        query: {
+          terms: {
+            _id: allDateStrings,
           },
         },
-      ],
-    };
+        _source: [ 'footfall', 'date_string', 'store_id', 'down_time', 'footfall_count' ],
+        sort: [
+          { date_iso: { order: 'asc' } },
+        ],
+        size: allDateStrings.length,
+      };
 
-    const getData = await getOpenSearchData( openSearch.footfall, getQuery );
-    const hits = getData?.body?.hits?.hits || [];
+      const multiGet = await getOpenSearchData( openSearch.footfall, footfallQuery );
+      const multiHits = multiGet?.body?.hits?.hits || [];
+      const hitsMap = new Map();
+      multiHits.forEach( ( hit ) => {
+        hitsMap.set( hit?._id, hit?._source || null );
+      } );
 
-    const processedData = hits.find( ( d ) => d._id === dateString )?._source || null;
-    const previousData = hits.find( ( d ) => d._id === dateStringPrevious )?._source || null;
+      const responseArray = [];
 
-    let footfallCountTrend = 0;
+      for ( let i = 1; i < orderedDates.length; i++ ) {
+        const currentDate = orderedDates[i];
+        const currentId = `${storeId}_${currentDate}`;
+        logger.info( { currentId, currentDate } );
+        const processedData = hitsMap.get( currentId );
+        logger.info( { processedData } );
+        if ( !processedData ) {
+          responseArray.push( {
+            date: currentDate,
+            footfallCount: 0,
+            footfallCountTrend: 0,
+            downtime: 0,
+          } );
+          continue;
+        }
 
-    if ( processedData && previousData && previousData.footfall_count ) {
-      footfallCountTrend = Math.round(
-          ( ( processedData.footfall_count - previousData.footfall_count ) / previousData.footfall_count ) * 100,
-      );
-    }
+        const prevDate = dayjs( currentDate ).subtract( 1, 'day' ).format( 'YYYY-MM-DD' );
+        const prevId = `${storeId}_${prevDate}`;
+        logger.info( { prevId, prevDate } );
+        const previousData = hitsMap.get( prevId );
 
-    return res.sendSuccess( {
-      footfallCount: processedData?.footfall_count || 0,
-      footfallCountTrend,
-      downtime: processedData?.down_time || 0,
-    } );
+        let footfallCountTrend = 0;
+        logger.info( { previousData, previoucubr1: previousData?.footfall_count } );
+        if ( previousData && previousData.footfall_count ) {
+          logger.info( { previousData, previoucubr: previousData?.footfall_count } );
+          footfallCountTrend = Math.round(
+              ( ( processedData.footfall_count - previousData?.footfall_count ) / previousData.footfall_count ) * 100,
+          );
+          logger.info( { footfallCountTrend } );
+        }
+        // Add ticket status from openSearch.footfallDirectory (_source.status)
+        let ticketStatus = null;
+        let receivedfootfall = null;
+        // Try to find a matching footfallDirectory record for this date+storeId
+        // const ticketKey = `${storeId}_${currentDate}`;
+        const footfallDirQuery = {
+          query: {
+            bool: {
+              must: [
+                { term: { 'storeId.keyword': storeId } },
+                { term: { 'dateString': currentDate } },
+                { term: { 'ticketName.keyword': 'footfall-directory' } },
+                {
+                  'term': {
+                    'type.keyword': 'store',
+                  },
+                },
+              ],
+            },
+          },
+          size: 1,
+          _source: [ 'status', 'mappingInfo', 'footfallCount' ],
+        };
+        try {
+          const footfallDirRes = await getOpenSearchData( openSearch.footfallDirectory, footfallDirQuery );
+          const hit = footfallDirRes?.body?.hits?.hits?.[0];
+          receivedfootfall = hit._source.footfallCount;
+          if ( hit?._source?.mappingInfo && Array.isArray( hit._source.mappingInfo ) ) {
+            for ( let i = 0; i < hit._source.mappingInfo.length; i++ ) {
+              if ( hit._source.mappingInfo[i].type === 'tagging' ) {
+                ticketStatus = hit._source.mappingInfo[i].status;
+                break;
+              }
+            }
+          }
+        } catch ( err ) {
+          logger.warn( { message: 'Could not get ticket status from footfallDirectory', error: err } );
+        }
+        // Check if request status ("raised") should be enabled or disabled by querying MongoDB config
+        // We'll assume findOnerevopConfig can fetch the record with status for this storeId and dateString
+        let raisedStatusEnabled = 'reset'; // default: enabled
+        try {
+          const mongoConfig = await findOneVmsStoreRequest( { storeId: storeId, dateString: currentDate } );
+          if ( mongoConfig && mongoConfig.status ) {
+            raisedStatusEnabled = mongoConfig.status;
+          }
+        } catch ( err ) {
+          logger.warn( { message: 'Could not get request status from MongoDB', error: err } );
+          // Leave raisedStatusEnabled as default
+        }
+        let statusArray=[ 'Closed', 'Open - Accuracy Issue', 'Closed - Accuracy Issue' ];
+
+        responseArray.push( {
+          date: processedData?.date_string || currentDate,
+          footfallCount: processedData?.footfall_count || 0,
+          footfallCountTrend,
+          downtime: processedData?.down_time || 0,
+          ticketStatus,
+          raisedStatusEnabled,
+          footfallticketCount: statusArray.includes( ticketStatus )?receivedfootfall:processedData?.footfall_count,
+        } );
+        console.log( '🚀 ~ storeProcessedData ~ ticketStatus:', ticketStatus );
+
+        if ( raisedStatusEnabled === 'block' ) {
+          // Calculate the number of days from currentDate + 1 to the end of the month
+          // Assume currentDate is in format 'YYYY-MM-DD'
+          const currentDateObj = new Date( currentDate );
+          // Move to next day
+          const nextDay = new Date( currentDateObj );
+          nextDay.setDate( currentDateObj.getDate() + 1 );
+
+          // Get the last date of the current month
+          const endOfMonth = new Date( currentDateObj.getFullYear(), currentDateObj.getMonth() + 1, 0 );
+
+          // Calculate number of days (inclusive of end date, exclusive of nextDay)
+          let noOfBlockedDays = Math.floor( ( endOfMonth - nextDay ) / ( 1000 * 60 * 60 * 24 ) ) + 1;
+          if ( noOfBlockedDays < 0 ) noOfBlockedDays = 0;
+
+          // Add to response
+          responseArray[responseArray.length - 1].noOfBlockedDays = noOfBlockedDays;
+        }
+      }
+
+      return res.sendSuccess( responseArray );
+    }
+    return res.sendError( 'Required parameters missing', 400 );
   } catch ( error ) {
     logger.error( { message: error, data: req.query, function: 'storeProcessedData' } );
     const err = error.message || 'Internal Server Error';
@@ -284,43 +1104,183 @@ export async function footFallImages( req, res ) {
                 'ticketName.keyword': 'footfall-directory',
               },
             },
+            {
+              'term': {
+                'type.keyword': 'store',
+              },
+            },
           ],
         },
       },
-      '_source': [ 'dateString', 'storeId', 'duplicateCount', 'footfallCount', 'employeeCount', 'houseKeepingCount', 'junkCount', 'status', 'ticketId', 'comments', 'userName', 'role', 'createdAt', 'email', 'houseKeepingACCount', 'duplicateACCount', 'employeeACCount', 'junkACCount', 'approverEmail', 'approverRole', 'approverUserName' ],
+      '_source': [ 'dateString', 'storeId', 'mappingInfo', 'revicedFootfall', 'revicedPerc', 'reviced', 'createdAt', 'updatedAt', 'footfallCount' ],
 
     };
 
     const getData = await getOpenSearchData( opensearch.footfallDirectory, query );
     const ticketDetails = getData?.body?.hits?.hits[0];
     let temp = [];
-   ticketDetails?._source? temp.push( ticketDetails?._source ) :null;
-   //  temp[0].status = 'open';
-   if ( ticketDetails?._source?.status == 'closed' ) {
-     delete temp[0].status;
-     temp.push( { ...ticketDetails?._source, status: 'closed' } );
-
-     temp[1].userName = getData?.body?.hits?.hits?.[0]?._source?.approverUserName;
-     temp[1].email = getData?.body?.hits?.hits?.[0]?._source?.approverEmail;
-     temp[1].role = getData?.body?.hits?.hits?.[0]?._source?.approverRole;
-     temp[1].employeeCount = getData?.body?.hits?.hits?.[0]?._source?.employeeACCount;
-     temp[1].houseKeepingCount = getData?.body?.hits?.hits?.[0]?._source?.houseKeepingACCount;
-     temp[1].duplicateCount = getData?.body?.hits?.hits?.[0]?._source?.duplicateACCount;
-     temp[1].junkCount = getData?.body?.hits?.hits?.[0]?._source?.junkACCount;
-   }
-   const LamdaURL = revop.getImages;
-   let resultData = await LamdaServiceCall( LamdaURL, inputData );
-   logger.info( { resultData: resultData } );
-   if ( resultData ) {
-   temp.length? temp[0].status = 'open': null;
-   if ( resultData.status_code == '200' ) {
-     return res.sendSuccess( { ...resultData, ticketStatus: temp?.length > 0? temp : null, config: req?.store?.revopTagging } );
-   } else {
-     return res.sendError( 'No Content', 204 );
-   }
-   } else {
-     return res.sendError( 'No Content', 204 );
-   }
+    const footfallValue = ticketDetails?._source?.footfallCount ?? 0;
+    const mappingInfoArray = ticketDetails?._source?.mappingInfo ?? [];
+    // Helper to get mappingInfo for an actionType
+    function getMappingForType( type ) {
+      return mappingInfoArray.find( ( m ) => m?.type === type ) || {};
+    }
+    const getTagging = getMappingForType( 'tagging' );
+    const getFinal = getMappingForType( 'finalRevision' );
+    const taggingRevised = getTagging.revicedFootfall ?? 0;
+    const finalRevised = getFinal.revicedFootfall ?? 0;
+    // List of actionTypes to process in sequence
+
+    if ( req.user.userType !== 'tango' && req.user.role !== 'superadmin' ) {
+      switch ( req.user.role ) {
+        case 'user':
+          const actionTypesUser = [ 'tagging', 'finalRevision' ];
+
+          temp = [];
+          actionTypesUser.forEach( ( type ) => {
+            const mapping = getMappingForType( type );
+            if ( type === 'tagging' ) {
+              const revisedFootfall = mapping.revicedFootfall ?? 0;
+              const revisedPerc =
+                footfallValue > 0 ?
+                  `${Math.round( ( revisedFootfall / footfallValue ) * 100 )}` :
+                  '0';
+              const countObj = mapping.count ? [ ...mapping.count ] : [];
+              temp.push( {
+                actionType: type,
+                footfall: footfallValue,
+                revicedFootfall: revisedFootfall,
+                revicedPerc: revisedPerc,
+                count: countObj,
+                createdAt: mapping.createdAt ?? '',
+                createdByEmail: mapping.createdByEmail ?? '',
+                createdByUserName: mapping.createdByUserName ?? '',
+                createdByRole: mapping.createdByRole ?? '',
+                isUp: false,
+              } );
+            } else if ( type !== 'tagging' && mapping.status === 'Closed' ) {
+              const revisedFootfall = mapping.revicedFootfall ?? 0;
+              const revisedPerc =
+                footfallValue > 0 ?
+                  `${Math.round( ( revisedFootfall / footfallValue ) * 100 )}` :
+                  '0';
+              const countObj = mapping.count ? [ ...mapping.count ] : [];
+              temp.push( {
+                actionType: type,
+                footfall: footfallValue,
+                revicedFootfall: revisedFootfall,
+                revicedPerc: revisedPerc,
+                count: countObj,
+                createdAt: mapping.createdAt ?? '',
+                createdByEmail: mapping.createdByEmail ?? '',
+                createdByUserName: mapping.createdByUserName ?? '',
+                createdByRole: mapping.createdByRole ?? '',
+                isUp: finalRevised > taggingRevised? true : false,
+              } );
+            }
+          } );
+          break;
+        case 'admin':
+          const actionTypesAdmin = [ 'tagging', 'review', 'finalRevision' ];
+          temp = [];
+          actionTypesAdmin.forEach( ( type ) => {
+            const mapping = getMappingForType( type );
+            if ( type === 'tagging' ) {
+              const revisedFootfall = mapping.revicedFootfall ?? 0;
+              const revisedPerc =
+                footfallValue > 0 ?
+                  `${Math.round( ( revisedFootfall / footfallValue ) * 100 )}` :
+                  '0';
+              const countObj = mapping.count ? [ ...mapping.count ] : [];
+              temp.push( {
+                actionType: type,
+                footfall: footfallValue,
+                revicedFootfall: revisedFootfall,
+                revicedPerc: revisedPerc,
+                count: countObj,
+                createdAt: mapping.createdAt ?? '',
+                createdByEmail: mapping.createdByEmail ?? '',
+                createdByUserName: mapping.createdByUserName ?? '',
+                createdByRole: mapping.createdByRole ?? '',
+                isUp: false,
+              } );
+            } else if ( type !== 'tagging' && mapping.status === 'Closed' ) {
+              const revisedFootfall = mapping.revicedFootfall ?? 0;
+              const revisedPerc =
+                footfallValue > 0 ?
+                  `${Math.round( ( revisedFootfall / footfallValue ) * 100 )}` :
+                  '0';
+              const countObj = mapping.count ? [ ...mapping.count ] : [];
+              temp.push( {
+                actionType: type,
+                footfall: footfallValue,
+                revicedFootfall: revisedFootfall,
+                revicedPerc: revisedPerc,
+                count: countObj,
+                createdAt: mapping.createdAt ?? '',
+                createdByEmail: mapping.createdByEmail ?? '',
+                createdByUserName: mapping.createdByUserName ?? '',
+                createdByRole: mapping.createdByRole ?? '',
+                isUp: finalRevised > taggingRevised? true : false,
+              } );
+            }
+          } );
+      }
+    } else {
+      const actionTypes = [ 'tagging', 'review', 'approve', 'tangoreview', 'finalRevision' ];
+
+      // Dynamically add to temp only if actionType matches and status is 'closed',
+      // except for 'tagging' where status must be 'raised'
+      temp = [];
+      actionTypes.forEach( ( type ) => {
+        const mapping = getMappingForType( type );
+        if ( type === 'tagging' ) {
+          const countObj = mapping.count ? [ ...mapping.count ] : [];
+          temp.push( {
+            actionType: type,
+            footfall: footfallValue,
+            revicedFootfall: mapping.revicedFootfall ?? 0,
+            revicedPerc: mapping?.reviced?.toString() ?? '--',
+            count: countObj,
+            createdAt: mapping.createdAt ?? '',
+            createdByEmail: mapping.createdByEmail ?? '',
+            createdByUserName: mapping.createdByUserName ?? '',
+            createdByRole: mapping.createdByRole ?? '',
+            isUp: false,
+          } );
+        }
+        if ( type !== 'tagging' && mapping.status === 'Closed' ) {
+          const countObj = mapping.count ? [ ...mapping.count ] : [];
+          temp.push( {
+            actionType: type,
+            footfall: footfallValue,
+            revicedFootfall: mapping.revicedFootfall ?? 0,
+            revicedPerc: mapping?.reviced?.toString() ?? '--',
+            count: countObj,
+            createdAt: mapping.createdAt ?? '',
+            createdByEmail: mapping.createdByEmail ?? '',
+            createdByUserName: mapping.createdByUserName ?? '',
+            createdByRole: mapping.createdByRole ?? '',
+            isUp: finalRevised > taggingRevised? true : false,
+          } );
+        }
+      } );
+    }
+
+
+    const LamdaURL = revop.getImages;
+    let resultData = await LamdaServiceCall( LamdaURL, inputData );
+    if ( resultData ) {
+      //  temp.length? temp[0].status = 'open': null;
+
+      if ( resultData.status_code == '200' ) {
+        return res.sendSuccess( { ...resultData, ticketStatus: temp?.length > 0 && ticketDetails? temp : null, config: req?.store?.footfallDirectoryConfigs } );
+      } else {
+        return res.sendError( 'No Content', 204 );
+      }
+    } else {
+      return res.sendError( 'No Content', 204 );
+    }
   } catch ( error ) {
     logger.error( { message: error, data: req.query, function: 'storeProcessedData' } );
     const err = error.message || 'Internal Server Error';
@@ -330,12 +1290,20 @@ export async function footFallImages( req, res ) {
 
 export async function tagTempId( req, res ) {
   try {
-    const openSearch = JSON.parse( process.env.OPENSEARCH );
     const inputData = req.body;
+    const today = dayjs();
+    const diff = today.diff( inputData.dateString, 'day' );
+    const taggingDueDate = req?.client?.footfallDirectoryConfigs?.allowTicketCreation || 0;
+    if ( diff > taggingDueDate ) {
+      return res.sendError( `Tagging is not allowed for a period exceeding ${taggingDueDate} days`, 400 );
+    }
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+
     const upsertRecord = {
       clientId: inputData.storeId.split( '-' )[0],
       storeId: inputData.storeId,
       tempId: inputData.tempId,
+      id: `${inputData?.storeId}_${inputData?.dateString}_${inputData?.tempId}`,
       dateString: inputData.dateString,
       timeRange: inputData.timeRange,
       processType: inputData.processType,
@@ -344,10 +1312,31 @@ export async function tagTempId( req, res ) {
       exitTime: inputData.exitTime,
       filePath: inputData.filePath,
       status: inputData?.revopsType == 'non-tagging' ?'':'submitted',
-      description: '',
-      isChecked: inputData.isChecked,
-      duplicateImage: inputData?.duplicateImage?.length>0? inputData?.duplicateImage :[],
+      description: inputData.comments || '',
+      isChecked: null,
+      // Add id to each object in duplicateImage if it exists and is an array
+      duplicateImage: Array.isArray( inputData?.duplicateImage ) ?
+        inputData.duplicateImage.map( ( img ) => ( {
+          ...img,
+          id: `${inputData?.storeId}_${inputData?.dateString}_${img?.tempId}`,
+          actions: [
+            {
+              actionType: 'tagging',
+              action: 'submitted',
+            },
+          ],
+        } ) ) :
+        [],
       type: 'tagging-reflect',
+      ticketStatus: 'submitted',
+      isParent: inputData?.revopsType === 'duplicate'? true : false,
+      actions: [
+        {
+          actionType: 'tagging',
+          action: 'submitted',
+        },
+      ],
+      comments: inputData.comments || '',
       createdAt: new Date(),
       updatedAt: new Date(),
 
@@ -363,8 +1352,10 @@ export async function tagTempId( req, res ) {
     ctx._source.description = params.description;
     ctx._source.isChecked = params.isChecked;
     ctx._source.duplicateImage = params.duplicateImage;
+     ctx._source.isParent = params.isParent;
     ctx._source.updatedAt = params.updatedAt;
     ctx._source.timeRange = params.timeRange;
+    ctx._source.comments = params.comments;
     if (ctx._source.createdAt == null) {
       ctx._source.createdAt = params.createdAt;
        ctx._source.clientId = params.clientId;
@@ -379,6 +1370,32 @@ export async function tagTempId( req, res ) {
     };
     const id = `${inputData.storeId}_${inputData.dateString}_${inputData.timeRange}_${inputData.tempId}`;
     await upsertWithScript( openSearch.revop, id, { script, upsert: upsertRecord } );
+    if ( inputData?.comments && inputData?.comments !== '' ) {
+      const id = `${inputData.storeId}_${inputData.dateString}_${Date.now()}`;
+      const logs = {
+        type: 'tagging',
+        parent: inputData?.revopsType == 'duplicate'? inputData.tempId : null,
+        id: `${inputData?.storeId}_${inputData?.dateString}_${inputData?.tempId}`,
+        tempId: inputData.tempId,
+        timeRange: inputData.timeRange,
+        storeId: inputData.storeId,
+        dateString: inputData.dateString,
+        processType: inputData.processType,
+        category: inputData.revopsType,
+        entryTime: inputData.entryTime,
+        exitTime: inputData.exitTime,
+        filePath: inputData.filePath,
+        status: inputData?.revopsType == 'non-tagging' ?'':'submitted',
+        description: inputData.comments || '',
+        isChecked: null,
+        createdByEmail: req?.user?.email,
+        createdByUserName: req?.user?.userName,
+        createdByRole: req?.user?.role,
+        message: inputData.comments || '',
+        createdAt: new Date(),
+      };
+      await insertWithId( openSearch.vmsCommentsLog, id, logs );
+    }
     if ( inputData?.duplicateImage?.length> 0 ) {
       let bulkBody = [];
       for ( let item of inputData?.duplicateImage ) {
@@ -386,9 +1403,10 @@ export async function tagTempId( req, res ) {
           clientId: inputData.storeId.split( '-' )[0],
           storeId: inputData.storeId,
           tempId: item.tempId,
+          id: `${inputData?.storeId}_${inputData?.dateString}_${item?.tempId}`,
           dateString: inputData.dateString,
           timeRange: item.timeRange,
-          isChecked: item.isChecked,
+          isChecked: null,
           processType: inputData.processType,
           revopsType: item.revopsType,
           entryTime: item.entryTime,
@@ -397,7 +1415,16 @@ export async function tagTempId( req, res ) {
           status: item?.revopsType == 'non-tagging' ?'':'submitted',
           description: '',
           duplicateImage: [],
+          isParent: false,
           type: 'tagging-reflect',
+          ticketStatus: 'submitted',
+          comments: inputData.comments || '',
+          actions: [
+            {
+              actionType: 'tagging',
+              action: 'submitted',
+            },
+          ],
           createdAt: new Date(),
           updatedAt: new Date(),
 
@@ -419,12 +1446,20 @@ export async function tagTempId( req, res ) {
           return { success: false, errors: res1.items };
         } else {
           logger.info( { msg: 'res1' } );
-          return res.sendSuccess( `ID tagged as duplicates` );
+          return res.sendSuccess( `ID tagged as Duplicates` );
           // return { success: true };
         }
       }
     } else {
-      const message = inputData?.revopsType == 'non-tagging' ? 'ID removed from tagging' :inputData?.revopsType == 'employee' ?'ID tagged as an employee/staff':inputData?.revopsType == 'junk'? 'ID tagged as a junk':'ID tagged as an house keeping';
+      // Convert camelCase revopsType to space-separated and capitalize first letter of each word
+      function camelCaseToTitle( str ) {
+        if ( !str ) return '';
+        return str.replace( /([A-Z])/g, ' $1' ).replace( /^./, ( s ) => s.toUpperCase() );
+      }
+      const titleRevopsType = camelCaseToTitle( inputData?.revopsType );
+      const message = inputData?.revopsType == 'non-tagging' ?
+        'ID removed from tagging' :
+        `ID tagged as ${titleRevopsType}`;
       return res.sendSuccess( message );
     }
   } catch ( error ) {
@@ -451,3 +1486,390 @@ export async function getCategorizedImages( req, res ) {
     return res.sendError( err, 500 );
   }
 }
+
+export async function vmsDataMigration( req, res ) {
+  try {
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    const inputData = req.body;
+    const { storeId, dateString, limit = 10000 } = inputData;
+
+    // Build query to fetch old structure documents
+    const query = {
+      query: {
+        bool: {
+          must: [
+            {
+              term: {
+                'ticketName.keyword': 'footfall-directory',
+              },
+            },
+            // {
+            //   range: {
+            //     createdAt: {
+            //       gte: '2025-12-01T00:00:00.000Z',
+            //       lte: '2025-12-03T00:00:00.000Z',
+            //     },
+            //   },
+            // },
+          ],
+        },
+      },
+      size: parseInt( limit ),
+    };
+
+    // Add storeId filter if provided
+    if ( storeId ) {
+      query.query.bool.must.push( {
+        term: {
+          'storeId.keyword': storeId,
+        },
+      } );
+    }
+
+    // Add dateString filter if provided
+    if ( dateString ) {
+      query.query.bool.must.push( {
+        terms: {
+          dateString: dateString?.split( ',' ),
+        },
+      } );
+    }
+
+    // Exclude documents that already have the new structure (have mappingInfo or type: 'store')
+    query.query.bool.must_not = [
+      {
+        exists: {
+          field: 'mappingInfo',
+        },
+      },
+      {
+        term: {
+          'type.keyword': 'store',
+        },
+      },
+    ];
+
+    const getData = await getOpenSearchData( openSearch.oldFootfallDirectory, query );
+    logger.info( { getData } );
+    const hits = getData?.body?.hits?.hits || [];
+
+    if ( hits.length === 0 ) {
+      return res.sendSuccess( { message: 'No documents found to migrate', migrated: 0 } );
+    }
+
+    let migratedCount = 0;
+    const errors = [];
+
+    for ( const hit of hits ) {
+      try {
+        const oldSource = hit._source;
+        const documentId = hit._id;
+
+        // Calculate revicedFootfall (sum of AC counts)
+        const tempFootfall =oldSource?.status === 'open' ?
+        ( oldSource.duplicateCount || 0 ) +
+          ( oldSource.employeeCount || 0 ) +
+          ( oldSource.houseKeepingCount || 0 ) +
+          ( oldSource.junkCount || 0 ):
+          ( oldSource.duplicateACCount || 0 ) +
+          ( oldSource.employeeACCount || 0 ) +
+          ( oldSource.houseKeepingACCount || 0 ) +
+          ( oldSource.junkACCount || 0 );
+
+        // Calculate revicedPerc
+        const footfallCount = oldSource.footfallCount || 0;
+        const revicedFootfall = footfallCount - tempFootfall;
+        const revicedPerc = footfallCount > 0 ?
+          Math.round( ( revicedFootfall / footfallCount ) * 100 ) :
+          0;
+        // Calculate reviced
+        const reviced = parseInt( revicedPerc );
+
+        // Transform arrays to revisedDetail format
+        const revisedDetail = [];
+
+        // Transform duplicateImages
+        if ( Array.isArray( oldSource.duplicateImages ) ) {
+          for ( const duplicate of oldSource.duplicateImages ) {
+            const parentId = `${oldSource.storeId}_${oldSource.dateString}_${duplicate.tempId}`;
+            const parentDetail = {
+              id: parentId,
+              clientId: oldSource.clientId,
+              storeId: oldSource.storeId,
+              tempId: duplicate.tempId,
+              dateString: oldSource.dateString,
+              timeRange: duplicate.timeRange,
+              processType: 'footfall',
+              revopsType: 'duplicate',
+              entryTime: duplicate.entryTime,
+              exitTime: duplicate.exitTime,
+              filePath: duplicate.filePath,
+              status: oldSource.duplicateStatus || 'submitted',
+              description: '',
+              isChecked: duplicate.isChecked !== undefined ? duplicate.isChecked : false,
+              type: 'tagging-reflect',
+              parent: null,
+              isParent: true,
+              createdAt: oldSource.createdAt || new Date(),
+              updatedAt: oldSource.updatedAt || new Date(),
+              duplicateImage: [],
+            };
+
+            // Add child duplicate images
+            if ( Array.isArray( duplicate.data ) ) {
+              parentDetail.duplicateImage = duplicate.data.map( ( child ) => ( {
+                id: `${oldSource.storeId}_${oldSource.dateString}_${child.tempId}`,
+                tempId: child.tempId,
+                timeRange: child.timeRange,
+                entryTime: child.entryTime,
+                exitTime: child.exitTime,
+                filePath: child.filePath,
+                isChecked: child.isChecked !== undefined ? child.isChecked : true,
+              } ) );
+
+              // Add child details to revisedDetail
+              for ( const child of duplicate.data ) {
+                revisedDetail.push( {
+                  id: `${oldSource.storeId}_${oldSource.dateString}_${child.tempId}`,
+                  clientId: oldSource.clientId,
+                  storeId: oldSource.storeId,
+                  tempId: child.tempId,
+                  dateString: oldSource.dateString,
+                  timeRange: child.timeRange,
+                  processType: 'footfall',
+                  revopsType: 'duplicate',
+                  entryTime: child.entryTime,
+                  exitTime: child.exitTime,
+                  filePath: child.filePath,
+                  status: oldSource.duplicateStatus || 'submitted',
+                  description: '',
+                  isChecked: child.isChecked !== undefined ? child.isChecked : false,
+                  type: 'tagging-reflect',
+                  parent: duplicate.tempId,
+                  isParent: false,
+                  createdAt: oldSource.createdAt || new Date(),
+                  updatedAt: oldSource.updatedAt || new Date(),
+                  duplicateImage: [],
+                } );
+              }
+            }
+
+            revisedDetail.push( parentDetail );
+          }
+        }
+
+        // Transform houseKeeping
+        if ( Array.isArray( oldSource.houseKeeping ) ) {
+          for ( const item of oldSource.houseKeeping ) {
+            revisedDetail.push( {
+              id: `${oldSource.storeId}_${oldSource.dateString}_${item.tempId}`,
+              clientId: oldSource.clientId,
+              storeId: oldSource.storeId,
+              tempId: item.tempId,
+              dateString: oldSource.dateString,
+              timeRange: item.timeRange,
+              processType: 'footfall',
+              revopsType: 'houseKeeping',
+              entryTime: item.entryTime,
+              exitTime: item.exitTime,
+              filePath: item.filePath,
+              status: oldSource.houseKeepingStatus || 'submitted',
+              description: '',
+              isChecked: item.isChecked !== undefined ? item.isChecked : false,
+              type: 'tagging-reflect',
+              parent: null,
+              isParent: false,
+              createdAt: oldSource.createdAt || new Date(),
+              updatedAt: oldSource.updatedAt || new Date(),
+              duplicateImage: [],
+            } );
+          }
+        }
+
+        // Transform employee
+        if ( Array.isArray( oldSource.employee ) ) {
+          for ( const item of oldSource.employee ) {
+            revisedDetail.push( {
+              id: `${oldSource.storeId}_${oldSource.dateString}_${item.tempId}`,
+              clientId: oldSource.clientId,
+              storeId: oldSource.storeId,
+              tempId: item.tempId,
+              dateString: oldSource.dateString,
+              timeRange: item.timeRange,
+              processType: 'footfall',
+              revopsType: 'employee',
+              entryTime: item.entryTime,
+              exitTime: item.exitTime,
+              filePath: item.filePath,
+              status: oldSource.employeeStatus || 'submitted',
+              description: '',
+              isChecked: item.isChecked !== undefined ? item.isChecked : false,
+              type: 'tagging-reflect',
+              parent: null,
+              isParent: false,
+              createdAt: oldSource.createdAt || new Date(),
+              updatedAt: oldSource.updatedAt || new Date(),
+              duplicateImage: [],
+            } );
+          }
+        }
+
+        // Transform junk
+        if ( Array.isArray( oldSource.junk ) ) {
+          for ( const item of oldSource.junk ) {
+            revisedDetail.push( {
+              id: `${oldSource.storeId}_${oldSource.dateString}_${item.tempId}`,
+              clientId: oldSource.clientId,
+              storeId: oldSource.storeId,
+              tempId: item.tempId,
+              dateString: oldSource.dateString,
+              timeRange: item.timeRange,
+              processType: 'footfall',
+              revopsType: 'junk',
+              entryTime: item.entryTime,
+              exitTime: item.exitTime,
+              filePath: item.filePath,
+              status: 'submitted',
+              description: '',
+              isChecked: item.isChecked !== undefined ? item.isChecked : false,
+              type: 'tagging-reflect',
+              parent: null,
+              isParent: false,
+              createdAt: oldSource.createdAt || new Date(),
+              updatedAt: oldSource.updatedAt || new Date(),
+              duplicateImage: [],
+            } );
+          }
+        }
+
+        // Create count array
+        const count = [
+          {
+            name: 'Duplicate',
+            value: oldSource.duplicateCount || 0,
+            key: 'duplicateCount',
+            type: 'duplicate',
+          },
+          {
+            name: 'Employee',
+            value: oldSource.employeeCount || 0,
+            key: 'employeeCount',
+            type: 'employee',
+          },
+          {
+            name: 'House keeping',
+            value: oldSource.houseKeepingCount || 0,
+            key: 'houseKeepingCount',
+            type: 'houseKeeping',
+          },
+          {
+            name: 'Junk',
+            value: oldSource.junkCount || 0,
+            key: 'junkCount',
+            type: 'junk',
+          },
+        ];
+
+        // Create mappingInfo array
+        const mappingInfo = oldSource.status === 'open' ?
+        [
+          {
+            type: 'tagging',
+            mode: 'mobile',
+            revicedFootfall,
+            revicedPerc: `${revicedPerc}%`,
+            reviced,
+            count,
+            revisedDetail,
+            status: oldSource.status === 'open' ? 'Raised' : oldSource.status || 'Raised',
+            createdByEmail: oldSource.email || '',
+            createdByUserName: oldSource.userName || '',
+            createdByRole: oldSource.role || 'user',
+            createdAt: oldSource.createdAt || new Date(),
+          },
+          {
+            type: 'review',
+            count,
+            revisedDetail,
+            status: oldSource.status === 'open' ? 'Open' : oldSource.status || 'Open',
+            dueDate: oldSource.updatedAt ? new Date( new Date( oldSource.updatedAt ).getTime() + 3 * 24 * 60 * 60 * 1000 ) : new Date( Date.now() + 3 * 24 * 60 * 60 * 1000 ),
+            createdAt: oldSource.createdAt || new Date(),
+          },
+        ]:
+
+ [
+   {
+     type: 'tagging',
+     mode: 'web',
+     revicedFootfall,
+     revicedPerc: `${revicedPerc}%`,
+     reviced,
+     count,
+     revisedDetail,
+     status: oldSource.status === 'closed' ? 'Closed' : oldSource.status || 'Closed',
+     createdByEmail: oldSource.email || '',
+     createdByUserName: oldSource.userName || '',
+     createdByRole: oldSource.role || 'user',
+     createdAt: oldSource.createdAt || new Date(),
+   },
+   {
+     type: 'review',
+     mode: 'web',
+     revicedFootfall,
+     revicedPerc: `${revicedPerc}%`,
+     reviced,
+     count,
+     revisedDetail,
+     status: oldSource.status === 'closed' ? 'Closed' : oldSource.status || 'Closed',
+     dueDate: oldSource.createdAt ? new Date( new Date( oldSource.createdAt ).getTime() + 3 * 24 * 60 * 60 * 1000 ) : new Date( Date.now() + 3 * 24 * 60 * 60 * 1000 ),
+     createdAt: oldSource.createdAt || new Date(),
+     createdByEmail: oldSource.approverEmail || '',
+     createdByUserName: oldSource.approverUserName || '',
+     createdByRole: oldSource.approverRole || 'user',
+   },
+ ];
+        // Create new structure
+        const newSource = {
+          storeId: oldSource.storeId,
+          type: 'store',
+          dateString: oldSource.dateString,
+          storeName: oldSource.storeName,
+          ticketName: oldSource.ticketName,
+          footfallCount: oldSource.footfallCount,
+          clientId: oldSource.clientId,
+          ticketId: oldSource.ticketId,
+          createdAt: oldSource.createdAt,
+          updatedAt: oldSource.updatedAt,
+          status: oldSource.status === 'open' ? 'Raised' : ( oldSource.status === 'closed' ? 'Closed' : 'Raised' ),
+          comments: oldSource.comments || '',
+          revicedFootfall,
+          revicedPerc: `${revicedPerc}%`,
+          reviced,
+          mappingInfo,
+        };
+
+        // Update document in OpenSearch
+        const updatedData = await updateOpenSearchData( openSearch.footfallDirectory, documentId, { doc: newSource, doc_as_upsert: true } );
+        logger.info( { updatedData } );
+        migratedCount++;
+
+        logger.info( { message: 'Document migrated successfully', newSource, documentId, storeId: oldSource.storeId, dateString: oldSource.dateString } );
+      } catch ( error ) {
+        const errorMsg = `Error migrating document ${hit._id}: ${error.message}`;
+        errors.push( errorMsg );
+        logger.error( { error: error, documentId: hit._id, function: 'vmsDataMigration' } );
+      }
+    }
+
+    return res.sendSuccess( {
+      message: `Migration completed. ${migratedCount} document(s) migrated.`,
+      migrated: migratedCount,
+      total: hits.length,
+      errors: errors.length > 0 ? errors : undefined,
+    } );
+  } catch ( error ) {
+    logger.error( { error: error, message: req.query, function: 'vmsDataMigration' } );
+    const err = error.message || 'Internal Server Error';
+    return res.sendError( err, 500 );
+  }
+}