tango-app-api-infra 3.9.5-vms.54 → 3.9.5-vms.56

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-infra",
-    "version": "3.9.5-vms.54",
+    "version": "3.9.5-vms.56",
     "description": "infra",
     "main": "index.js",
     "type": "module",

package/src/controllers/footfallDirectory.controllers.js

@@ -856,6 +856,7 @@ export async function ticketList( req, res ) {
       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: [
@@ -881,7 +882,24 @@ export async function ticketList( req, res ) {
       },
     };
 
+    if ( inputData.sortBy ) {
+      let sortOrder = inputData.sortOrder === 1? 'asc': 'desc';
+
+      // Remove default sort so we don't duplicate/conflict
+      // INSERT_YOUR_CODE
+      // If sortBy is present, check if the field needs ".keyword" (for string fields like storeName, storeId, ticketId)
+      // This avoids OpenSearch errors about sorting on text fields.
+      const stringKeywordFields = [ 'storeName', 'storeId', 'ticketId', 'status', 'type', 'clientId' ];
+      let sortField = inputData.sortBy == 'footfall'? 'footfallCount' :inputData.sortBy == 'issueDate'?'dateString':inputData.sortBy;
+      if ( stringKeywordFields.includes( sortField ) ) {
+        sortField = `${sortField}.keyword`;
+      }
 
+      // Remove default sort so we don't duplicate/conflict
+      searchQuery.sort = [
+        { [sortField]: { order: sortOrder } },
+      ];
+    }
     // Example: Filtering by storeId if present in the query
     if ( inputData.storeId ) {
       inputData.storeId = inputData?.storeId?.split( ',' );
@@ -963,7 +981,7 @@ export async function ticketList( req, res ) {
     }
     // You can add more filters as needed
     const searchResult = await getOpenSearchData( openSearch.footfallDirectory, searchQuery );
-
+    logger.info( { searchResult } );
     const count = searchResult?.body?.hits?.total?.value || 0;
 
     if ( count === 0 ) {
@@ -1318,10 +1336,153 @@ export async function getTickets( req, res ) {
 
         ) {
           item._source.mappingInfo.revisedDetail = processedRevopSources;
+          const vmsCommentsLogIndex = openSearch.vmsCommentsLog || 'vms-comments-log-dev';
+          let commentsResponse = [];
+          const commentsFilter = [
+            { term: { 'storeId.keyword': item?._source?.storeId } },
+            { term: { dateString: item?._source?.dateString } },
+
+          ];
+
+          const commentsQuery = {
+            size: 10000,
+            sort: [
+              { createdAt: { order: 'desc' } }, // Sort descending by createdAt
+            ],
+            query: {
+              bool: {
+                filter: commentsFilter,
+              },
+            },
+          };
+
+          const commentsRes = await getOpenSearchData( vmsCommentsLogIndex, commentsQuery );
           // If mappingInfo is an array, update revisedDetail for each mappingInfo object
           if ( Array.isArray( item._source.mappingInfo ) ) {
             item._source.mappingInfo.forEach( ( mappingObj ) => {
-              if ( Object.prototype.hasOwnProperty.call( mappingObj, 'revisedDetail' ) && mappingObj.type !== 'tangoreview' ) {
+              if ( mappingObj.status == 'In-Progress' ) {
+                commentsResponse = commentsRes?.body?.hits?.hits?.map( ( hit ) => hit._source ) || [];
+
+                // Check if duplicate condition exists in commentsResponse
+                const isDuplicate = Array.isArray( commentsResponse ) &&
+                  commentsResponse.some( ( c ) => c.category === 'duplicate' );
+
+                // Structure comments output
+                let commentsDetails = [];
+                if ( isDuplicate ) {
+                  // Duplicate case - check from commentsResponse
+                  // Collect for each type (tagging, review, approve)
+                  const types = [ 'tagging', 'review', 'approve' ];
+                  commentsDetails = types.map( ( typeValue ) => {
+                    // parent value from original comment structure
+                    let parent = null;
+                    // Get all comments of this type (no filter by category)
+                    let comms = commentsResponse
+                        .filter( ( c ) => c.type === typeValue )
+                        .map( ( c ) => {
+                          if ( typeValue === 'tagging' ) {
+                            parent = c.parent;
+                            return {
+                              createdByEmail: c.createdByEmail,
+                              createdByUserName: c.createdByUserName,
+                              createdByRole: c.createdByRole,
+                              message: c.message,
+                            };
+                          }
+                          if ( typeValue === 'review' || typeValue === 'approve' ) {
+                            return {
+                              parent: c.parent,
+                              category: c.category,
+                              taggedImages: Array.isArray( c.taggedImages ) ?
+                              c.taggedImages.map( ( img ) => ( {
+                                id: img?._source?.id,
+                                tempId: img?._source?.tempId,
+                                timeRange: img?._source?.timeRange,
+                                entryTime: img?._source?.entryTime,
+                                exitTime: img?._source?.exitTime,
+                                filePath: img?._source?.filePath,
+                                isChecked: img?._source?.isChecked,
+                              } ) ) :
+                              [],
+                              createdByEmail: c.createdByEmail,
+                              createdByUserName: c.createdByUserName,
+                              createdByRole: c.createdByRole,
+                              status: c.status,
+                              message: c.message,
+                            };
+                          }
+                          return {};
+                        } );
+                    return {
+                      ...( typeValue === 'tagging' ? { category: 'duplicate' } : {} ),
+                      type: typeValue,
+                      ...( typeValue === 'tagging' ? { parent } : {} ),
+                      comments: comms,
+                    };
+                  } );
+                } else {
+                  // For non-duplicate categories
+                  // Collect by type/tag (tagging/review/approve) and build similar structure
+                  const types = [ 'tagging', 'review', 'approve' ];
+                  commentsDetails = types.map( ( typeValue ) => {
+                    // parent for these non-duplicate is always null
+                    let comms = commentsResponse
+                        .filter( ( c ) => c.type === typeValue )
+                        .map( ( c ) => {
+                          if ( typeValue === 'tagging' ) {
+                            return {
+                              id: c.id,
+                              tempId: c.tempId,
+                              timeRange: c.timeRange,
+                              entryTime: c.entryTime,
+                              exitTime: c.exitTime,
+                              filePath: c.filePath,
+                              isChecked: c.isChecked,
+                              createdAt: c.createdAt,
+                              message: c.message,
+                              createdByEmail: c.createdByEmail,
+                              createdByUserName: c.createdByUserName,
+                              createdByRole: c.createdByRole,
+                            };
+                          }
+                          if ( typeValue === 'review' || typeValue === 'approve' ) {
+                            return {
+                              category: c.category,
+                              taggedImages: Array.isArray( c.taggedImages ) ?
+                              c.taggedImages.map( ( img ) => ( {
+                                id: img?._source?.id,
+                                tempId: img?._source?.tempId,
+                                timeRange: img?._source?.timeRange,
+                                entryTime: img?._source?.entryTime,
+                                exitTime: img?._source?.exitTime,
+                                filePath: img?._source?.filePath,
+                                isChecked: img?._source?.isChecked,
+                              } ) ) :
+                              [],
+                              createdByEmail: c.createdByEmail,
+                              createdByUserName: c.createdByUserName,
+                              createdByRole: c.createdByRole,
+                              status: c.status,
+                              message: c.message,
+                            };
+                          }
+                          return {};
+                        } );
+                    return {
+                      ...( typeValue === 'tagging' ? { category: 'duplicate' } : {} ),
+                      parent: null,
+                      type: typeValue,
+                      comments: comms,
+                    };
+                  } );
+                }
+
+                item._source.commentsDetails = commentsDetails;
+              }
+              if (
+                Object.prototype.hasOwnProperty.call( mappingObj, 'revisedDetail' ) &&
+                mappingObj.type !== 'tangoreview'
+              ) {
                 mappingObj.revisedDetail = processedRevopSources;
               }
             } );
@@ -2171,6 +2332,16 @@ export async function openTicketList( req, res ) {
           clientId: Array.isArray( clientId ) ? clientId : [ clientId ],
         },
       },
+      {
+        term: {
+          'mappingInfo.type': inputData.type,
+        },
+      },
+      {
+        term: {
+          'mappingInfo.status.keyword': 'Open',
+        },
+      },
       {
         range: {
           dateString: {
@@ -2191,10 +2362,16 @@ export async function openTicketList( req, res ) {
       },
       _source: [ 'ticketId', 'storeName', 'storeId', 'dateString', 'revicedFootfall', 'footfallCount', 'revicedPerc', 'type' ],
     };
+    // INSERT_YOUR_CODE
+    // Add sorting by revicedPerc descending (highest revised accuracy first)
+    openSearchQuery.sort = [
+      { 'revicedPerc.keyword': { order: inputData?.sortOrder === 1? 'asc':'desc' } },
+    ];
 
 
     // Assuming getOpenSearchData and openSearch.footfallDirectoryTagging are available
     const result = await getOpenSearchData( openSearch.footfallDirectory, openSearchQuery );
+    logger.info( { result } );
     const getUserlist = result?.body?.hits?.hits?.map( ( hit ) => hit._source ) || [];
     return res.sendSuccess( getUserlist || [] );
   } catch ( error ) {

package/src/dtos/footfallDirectory.dtos.js

@@ -509,6 +509,8 @@ export const openTicketListSchema = Joi.object().keys( {
   clientId: Joi.array().items(
       Joi.string().required(),
   ).required(),
+  type: Joi.string().required().allow( 'review', 'approve' ),
+  sortOrder: Joi.number().allow( 1, -1 ).optional(),
 
 
 } );