tango-app-api-infra 3.9.5-vms.6 → 3.9.5-vms.8

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-infra",
-    "version": "3.9.5-vms.6",
+    "version": "3.9.5-vms.8",
     "description": "infra",
     "main": "index.js",
     "type": "module",
@@ -27,7 +27,7 @@
         "mongodb": "^6.4.0",
         "nodemon": "^3.1.0",
         "swagger-ui-express": "^5.0.0",
-        "tango-api-schema": "^2.4.20",
+        "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

@@ -497,7 +497,7 @@ export async function ticketList( req, res ) {
     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 =inputData.tangotyep == 'store'?
+      result =inputData.tangotype == 'store'?
 
 
       [
@@ -716,18 +716,18 @@ export async function ticketList( req, res ) {
       [
 
         {
-          ticketId: 'TE_FDT_1763539990306',
+          ticketId: 'TE_FDT_1763860421803',
           storeId: '11-1716',
           storeName: 'LKST1916',
-          ticketRaised: '2025-11-16',
-          issueDate: '2025-11-16',
-          footfall: 200,
-          type: 'internal',
-          storeRevisedAccuracy: '98%',
-          reviewerRevisedAccuracy: '97%',
-          approverRevisedAccuracy: '98%',
-          tangoRevisedAccuracy: '98%',
-          status: 'Closed',
+          ticketRaised: '2025-11-21',
+          issueDate: '2025-11-20',
+          footfall: 94,
+          type: 'store',
+          storeRevisedAccuracy: '95%',
+          reviewerRevisedAccuracy: '--',
+          approverRevisedAccuracy: '--',
+          tangoRevisedAccuracy: '--',
+          status: 'Open',
           tangoStatus: 'Open',
         },
         {
@@ -1023,13 +1023,13 @@ req.user.role === 'user'? 'NA':
 ticketsFeature?
 [
   {
-    ticketId: 'TE_FDT_17635399903490',
+    ticketId: 'TE_FDT_1763860421803',
     storeId: '11-1716',
     storeName: 'LKST1916',
-    ticketRaised: '2025-11-16',
-    issueDate: '2025-11-15',
+    ticketRaised: '2025-11-21',
+    issueDate: '2025-11-20',
     dueDate: 'Due Today',
-    footfall: 213,
+    footfall: 90,
     storeRevisedAccuracy: '90%',
     reviewerRevisedAccuracy: '0%',
     status: 'Open',
@@ -1039,13 +1039,13 @@ ticketsFeature?
     ticketId: 'TE_FDT_1763539990346',
     storeId: '11-2000',
     storeName: 'LKST2368',
-    ticketRaised: '2025-11-16',
-    issueDate: '2025-11-14',
-    dueDate: '2025-11-18',
+    ticketRaised: '2025-11-21',
+    issueDate: '2025-11-20',
+    dueDate: '2025-11-26',
     footfall: 90,
     storeRevisedAccuracy: '90%',
     reviewerRevisedAccuracy: '--',
-    status: 'Expired',
+    status: 'In-Progress',
     ReviewedBy: 'mu_mu@yopmail.com',
   },
   {
@@ -2310,7 +2310,7 @@ export async function openTicketList( req, res ) {
   }
 }
 
-export async function updateiTcket( req, res ) {
+export async function assignTicket( req, res ) {
   try {
     const inputData = req.body;
     const openSearch = JSON.parse( process.env.OPENSEARCH );
@@ -2384,7 +2384,154 @@ export async function updateiTcket( req, res ) {
     return res.sendSuccess( { updated: response?.body?.updated ?? 0 } );
   } catch ( error ) {
     const err = error.message || 'Internal Server Error';
-    logger.error( { error: error, function: 'updateticket' } );
+    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

@@ -463,7 +463,7 @@ export const openTicketListValid = {
 };
 
 
-export const updateTicketListSchema = Joi.object().keys( {
+export const assignTicketSchema = Joi.object().keys( {
   email: Joi.string().required(),
   userName: Joi.string().optional(),
   role: Joi.string().optional(),
@@ -473,6 +473,18 @@ export const updateTicketListSchema = Joi.object().keys( {
 
 } );
 
-export const updateTicketListValid = {
-  body: updateTicketListSchema,
+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,7 +1,7 @@
 import express from 'express';
 import { getClusters, getConfig, isGrantedUsers, isTicketExists, ticketCreation } from '../validations/footfallDirectory.validation.js';
-import { createTicket, downloadTickets, getTaggedStores, getTickets, openTicketList, reviewerList, ticketList, ticketSummary, updateiTcket, updateStatus } from '../controllers/footfallDirectory.controllers.js';
-import { createTicketValid, downloadTicketsValid, getTaggedStoresValid, getTicketsValid, openTicketListValid, reviewerListValid, ticketListValid, ticketSummaryValid, updateStatusValid, updateTicketListValid } from '../dtos/footfallDirectory.dtos.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();
@@ -17,6 +17,7 @@ footfallDirectoryRouter.put( '/update-status', isAllowedSessionHandler, bulkVali
 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( '/update-ticket-user', isAllowedSessionHandler, bulkValidate( updateTicketListValid ), updateiTcket );
+footfallDirectoryRouter.post( '/assign-ticket', isAllowedSessionHandler, bulkValidate( assignTicketValid ), assignTicket );
+footfallDirectoryRouter.post( '/update-temp-status', isAllowedSessionHandler, bulkValidate( updateTempStatusValid ), updateTempStatus );
 
 

package/src/validations/footfallDirectory.validation.js

@@ -228,14 +228,13 @@ export async function ticketCreation( req, res, 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 ) ) ) );
-    logger.info( { ticketsFeature } );
     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 } );
-    logger.info( { getstoreName } );
+
     if ( !getstoreName || getstoreName == null ) {
       return res.sendError( 'The store ID is either inActive or not found', 400 );
     }
@@ -261,22 +260,20 @@ export async function ticketCreation( req, res, next ) {
 
     const getFootfallCount = await getOpenSearchData( openSearch.footfall, getQuery );
     const hits = getFootfallCount?.body?.hits?.hits || [];
-    logger.info( { 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 } );
-    logger.info( { getConfig, ta123: getConfig?.footfallDirectoryConfigs } );
     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;
-    logger.info( { taggingLimitation, tagginngs: getConfig?.footfallDirectoryConfigs } );
     // Initialize count object from taggingLimitation
+    const tempAcc = [];
     const getCategory = taggingLimitation?.reduce( ( acc, item ) => {
       if ( item?.type ) {
         // Convert type to camelCase with "Count" suffix
@@ -289,11 +286,21 @@ export async function ticketCreation( req, res, next ) {
           // Convert first letter to lowercase and append "Count"
           key = typeLower.charAt( 0 ) + typeLower.slice( 1 ) + 'Count';
         }
-        acc[key] = 0;
+
+
+        // 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;
       }
-      return acc;
     }, {} ) || {};
-    logger.info( { getCategory } );
+
     // Query OpenSearch revop index to get actual counts for each type
     if ( taggingLimitation && taggingLimitation.length > 0 ) {
       const revopQuery = {
@@ -324,51 +331,38 @@ export async function ticketCreation( req, res, next ) {
         },
       };
 
-      try {
-        const revopData = await getOpenSearchData( openSearch.revop, revopQuery );
-        logger.info( { revopData: revopData } );
-        const buckets = revopData?.body?.aggregations?.type_counts?.buckets || [];
-
-        // Map OpenSearch revopsType values to count object keys
-        buckets.forEach( ( bucket ) => {
-          const revopsType = bucket.key?.toLowerCase();
-          const count = bucket.doc_count || 0;
-
-          // Map the revopsType to the correct count key
-          // Handle variations: duplicate, duplicateImages, duplicateimages
-          if ( revopsType === 'duplicate' ) {
-            if ( getCategory.hasOwnProperty( 'duplicateCount' ) ) {
-              getCategory.duplicateCount = count;
-            }
-          } else if ( revopsType === 'employee' ) {
-            if ( getCategory.hasOwnProperty( 'employeeCount' ) ) {
-              getCategory.employeeCount = count;
-            }
-          } else if ( revopsType === 'housekeeping' ) {
-            if ( getCategory.hasOwnProperty( 'houseKeepingCount' ) ) {
-              getCategory.houseKeepingCount = count;
-            }
-          } else if ( revopsType === 'junk' ) {
-            if ( getCategory.hasOwnProperty( 'junkCount' ) ) {
-              getCategory.junkCount = count;
-            }
+
+      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;
           }
-        } );
-      } catch ( error ) {
-        logger.error( { error: error, message: 'Error fetching revop counts', function: 'footfallDirectoryTicket-ticketCreation' } );
-        // Continue with default 0 values if query fails
-      }
+        }
+      } );
     }
 
-    logger.info( { getCategory: getCategory } );
 
     // Calculate revisedFootfall: footfallCount - (sum of all counts)
-    const totalCount = ( getCategory.duplicateCount || 0 ) +
-                      ( getCategory.employeeCount || 0 ) +
-                      ( getCategory.houseKeepingCount || 0 ) +
-                      ( getCategory.junkCount || 0 );
+
+    const totalCount = Array.isArray( tempAcc ) ?
+      tempAcc.reduce( ( sum, acc ) => sum + ( acc.value || 0 ), 0 ) :
+      0;
     const footfallCount = hits?.[0]?._source?.footfall_count || 0;
-    logger.info( { footfallCount, totalCount } );
     const revisedFootfall = Math.max( 0, footfallCount - totalCount );
     if ( footfallCount - revisedFootfall == 0 ) {
       return res.sendError( 'Cannot create a ticket because footfall hasn’t changed', 400 );
@@ -400,7 +394,6 @@ export async function ticketCreation( req, res, next ) {
       return res.sendError( 'You don’t have any tagged images right now', 400 );
     }
     const formattedTaggingData = formatRevopTaggingHits( taggingImages );
-    logger.info( { revopTaggingData: formattedTaggingData } );
 
     const record = {
       storeId: inputData.storeId,
@@ -420,12 +413,13 @@ export async function ticketCreation( req, res, next ) {
           type: 'tagging',
           mode: inputData.mode,
           revicedFootfall: revisedFootfall,
-          count: getCategory,
+          count: tempAcc,
           revisedDetail: formattedTaggingData,
           status: 'raised',
           createdByEmail: req?.user?.email,
           createdByUserName: req?.user?.userName,
           createdByRole: req?.user?.role,
+          createdAt: new Date(),
         },
       ],
     };