tango-app-api-infra 3.9.5-vms.70 → 3.9.5-vms.71

package/package.json

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

package/src/controllers/footfallDirectory.controllers.js

@@ -450,6 +450,361 @@ export async function tangoReviewTicket( req, res ) {
   }
 }
 
+export async function tangoReviewAccuracyClosedTicket( req, res ) {
+  try {
+    const inputData = req.body;
+
+    // get store info by the storeId into mongo db
+    const getstoreName = await findOneStore( { storeId: inputData.storeId, status: 'active' }, { storeId: 1, storeName: 1, clientId: 1 } );
+
+    if ( !getstoreName || getstoreName == null ) {
+      return res.sendError( 'The store ID is either inActive or not found', 400 );
+    }
+
+    // get the footfall count from opensearch
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    const dateString = `${inputData.storeId}_${inputData.dateString}`;
+    const getQuery = {
+      query: {
+        terms: {
+          _id: [ dateString ],
+        },
+      },
+      _source: [ 'footfall', 'date_string', 'store_id', 'down_time', 'footfall_count' ],
+      sort: [
+        {
+          date_iso: {
+            order: 'desc',
+          },
+        },
+      ],
+    };
+
+    const getFootfallCount = await getOpenSearchData( openSearch.footfall, getQuery );
+    const hits = getFootfallCount?.body?.hits?.hits || [];
+    if ( hits?.[0]?._source?.footfall_count <= 0 ) {
+      return res.sendError( 'You can’t create a ticket because this store has 0 footfall data' );
+    }
+
+    // get category details from the client level configuration
+    const getConfig = await findOneClient( { clientId: getstoreName.clientId }, { footfallDirectoryConfigs: 1 } );
+    if ( !getConfig || getConfig == null ) {
+      return res.sendError( 'The Client ID is either not configured or not found', 400 );
+    }
+    let findQuery = {
+      size: 10000,
+      query: {
+        bool: {
+          must: [
+            {
+              term: {
+                'storeId.keyword': inputData.storeId,
+              },
+            },
+            {
+              term: {
+                'dateString': inputData.dateString,
+              },
+            },
+          ],
+        },
+      },
+    };
+    let findTicket = await getOpenSearchData( openSearch.footfallDirectory, findQuery );
+    let Ticket = findTicket.body?.hits?.hits;
+
+    if ( Ticket.length === 0 ) {
+      return res.sendError( 'Ticket not found', 400 );
+    }
+    const getTicket = {
+      size: 10000,
+      query: {
+        bool: {
+          must: [
+            {
+              term: {
+                'storeId.keyword': inputData.storeId,
+              },
+            },
+            {
+              term: {
+                'dateString': inputData.dateString,
+              },
+            },
+
+          ],
+        },
+      },
+    };
+    if ( Ticket[0]?._source?.type != 'internal' ) {
+      getTicket.query.bool.must.push(
+          {
+            nested: {
+              path: 'mappingInfo',
+              query: {
+                bool: {
+                  must: [
+                    {
+                      term: {
+                        'mappingInfo.type': 'tangoreview',
+                      },
+                    },
+
+                  ],
+                },
+              },
+            },
+          },
+      );
+    }
+    const getFootfallticketData = await getOpenSearchData( openSearch.footfallDirectory, getTicket );
+    const ticketData = getFootfallticketData?.body?.hits?.hits;
+
+    if ( !ticketData || ticketData?.length == 0 ) {
+      return res.sendError( 'You don’t have any tagged images right now', 400 );
+    }
+
+    const record = {
+
+      status: parseInt( inputData?.mappingInfo?.[0]?.revicedPerc || 0 ) < parseInt( getConfig?.footfallDirectoryConfigs?.tangoReview|| 0 ) ? 'Open - Accuracy Issue' : 'Closed',
+      revicedFootfall: inputData.mappingInfo?.[0]?.revicedFootfall,
+      revicedPerc: inputData.mappingInfo?.[0]?.revicedPerc,
+      mappingInfo: ticketData?.[0]?._source?.mappingInfo,
+      createdByEmail: req?.user?.email,
+      createdByUserName: req?.user?.userName,
+      createdByRole: req?.user?.role,
+
+    };
+
+
+    // Retrieve client footfallDirectoryConfigs revision
+    let isAutoCloseEnable = getConfig.footfallDirectoryConfigs.isAutoCloseEnable;
+    let autoCloseAccuracy = getConfig?.footfallDirectoryConfigs?.autoCloseAccuracy;
+
+    const getNumber = autoCloseAccuracy.split( '%' )[0];
+
+    let autoCloseAccuracyValue = parseFloat( ( autoCloseAccuracy || getNumber ).replace( '%', '' ) );
+    let revisedPercentage = inputData.mappingInfo?.revicedPerc;
+    const revised = Number( revisedPercentage?.split( '%' )[0] );
+    const tangoReview = Number( getConfig?.footfallDirectoryConfigs?.tangoReview?.split( '%' )[0] );
+    // If autoclose enabled and revisedPercentage meets/exceeds threshold, close ticket and skip revision
+    if (
+      isAutoCloseEnable === true &&
+      revisedPercentage >= autoCloseAccuracyValue
+    ) {
+      record.status = 'Closed';
+      // Only keep or modify mappingInfo items with type "review"
+      if ( Array.isArray( record.mappingInfo ) ) {
+        const temp = record.mappingInfo
+            .filter( ( item ) => item.type === 'tangoreview' )
+            .map( ( item ) => ( {
+              ...item,
+
+              mode: inputData.mappingInfo?.mode,
+              revicedFootfall: inputData.mappingInfo?.revicedFootfall,
+              revicedPerc: inputData.mappingInfo?.revicedPerc,
+              count: inputData.mappingInfo?.count,
+              revisedDetail: inputData.mappingInfo?.revisedDetail,
+              status: 'Closed',
+              createdByEmail: req?.user?.email,
+              createdByUserName: req?.user?.userName,
+              createdByRole: req?.user?.role,
+            } ) );
+
+        record.mappingInfo = [ ...ticketData?.[0]?._source?.mappingInfo.slice( 0, -1 ),
+          ...temp ];
+        // If updating the mapping config to mark [i].status as 'Closed'
+        // Make sure all relevant mappingInfo items of type 'approve' are set to status 'Closed'
+        if ( Array.isArray( record.mappingInfo ) ) {
+          record.mappingInfo = record.mappingInfo.map( ( item ) => {
+            return {
+              ...item,
+              status: 'Closed',
+            };
+          } );
+        }
+        // If no review mapping existed, push a new one
+        // if ( record.mappingInfo.length === 0 ) {
+        //   record.mappingInfo.push( {
+        //     type: 'tangoreview',
+        //     mode: inputData.mappingInfo?.mode,
+        //     revicedFootfall: inputData.mappingInfo?.revicedFootfall,
+        //     revicedPerc: inputData.mappingInfo?.revicedPerc,
+        //     count: inputData.mappingInfo?.count,
+        //     revisedDetail: inputData.mappingInfo?.revisedDetail,
+        //     status: 'Closed',
+        //     createdByEmail: req?.user?.email,
+        //     createdByUserName: req?.user?.userName,
+        //     createdByRole: req?.user?.role,
+        //   } );
+        // }
+      }
+      record.mappingInfo.push(
+          {
+            type: 'finalRevision',
+            mode: inputData.mappingInfo?.mode,
+            revicedFootfall: revisedFootfall,
+            revicedPerc: inputData.mappingInfo?.revicedPerc,
+            count: inputData.mappingInfo?.count,
+            revisedDetail: inputData.mappingInfo?.revisedDetail,
+            status: 'Closed',
+            createdByEmail: req?.user?.email,
+            createdByUserName: req?.user?.userName,
+            createdByRole: req?.user?.role,
+            createdAt: new Date(),
+          },
+      );
+    } else if ( revised < tangoReview ) {
+      // If ticket is closed, do not proceed with revision mapping
+
+      record.status = 'Closed - Accuracy Issue';
+      // Only keep or modify mappingInfo items with type "review"
+      if ( Array.isArray( record.mappingInfo ) ) {
+        const temp = record.mappingInfo
+            .filter( ( item ) => item.type === 'tangoreview' )
+            .map( ( item ) => ( {
+              ...item,
+              mode: inputData.mappingInfo?.mode,
+              revicedFootfall: inputData.mappingInfo?.revicedFootfall,
+              revicedPerc: inputData.mappingInfo?.revicedPerc,
+              count: inputData.mappingInfo?.count,
+              revisedDetail: inputData.mappingInfo?.revisedDetail,
+              status: 'Closed',
+              createdByEmail: req?.user?.email,
+              createdByUserName: req?.user?.userName,
+              createdByRole: req?.user?.role,
+            } ) );
+
+        record.mappingInfo = [ ...ticketData?.[0]?._source?.mappingInfo.slice( 0, -1 ),
+          ...temp ];
+        if ( Array.isArray( record.mappingInfo ) ) {
+          record.mappingInfo = record.mappingInfo.map( ( item ) => {
+            return {
+              ...item,
+              status: 'Closed',
+            };
+          } );
+        }
+        // If no review mapping existed, push a new one
+        // if ( record.mappingInfo.length === 0 ) {
+        //   record.mappingInfo.push( {
+        //     type: 'tangoreview',
+        //     mode: inputData.mappingInfo?.mode,
+        //     revicedFootfall: inputData.mappingInfo?.revicedFootfall,
+        //     revicedPerc: inputData.mappingInfo?.revicedPerc,
+        //     count: inputData.mappingInfo?.count,
+        //     revisedDetail: inputData.mappingInfo?.revisedDetail,
+        //     status: 'Closed',
+        //     createdByEmail: req?.user?.email,
+        //     createdByUserName: req?.user?.userName,
+        //     createdByRole: req?.user?.role,
+        //   } );
+        // }
+      }
+    } else {
+      if ( Array.isArray( record.mappingInfo ) ) {
+        const temp = record.mappingInfo
+            .filter( ( item ) => item.type === 'tangoreview' )
+            .map( ( item ) => ( {
+              ...item,
+              mode: inputData.mappingInfo?.mode,
+              revicedFootfall: inputData.mappingInfo?.revicedFootfall,
+              revicedPerc: inputData.mappingInfo?.revicedPerc,
+              count: inputData.mappingInfo?.count,
+              revisedDetail: inputData.mappingInfo?.revisedDetail,
+              status: 'Closed',
+              createdByEmail: req?.user?.email,
+              createdByUserName: req?.user?.userName,
+              createdByRole: req?.user?.role,
+            } ) );
+
+        record.mappingInfo = [ ...ticketData?.[0]?._source?.mappingInfo.slice( 0, -1 ),
+          ...temp ];
+        if ( Array.isArray( record.mappingInfo ) ) {
+          record.mappingInfo = record.mappingInfo.map( ( item ) => {
+            return {
+              ...item,
+              status: 'Closed',
+            };
+          } );
+        }
+        // If no review mapping existed, push a new one
+        // if ( record.mappingInfo.length === 0 ) {
+        //   record.mappingInfo.push( {
+        //     type: 'tangoreview',
+        //     mode: inputData.mappingInfo?.mode,
+        //     revicedFootfall: inputData.mappingInfo?.revicedFootfall,
+        //     revicedPerc: inputData.mappingInfo?.revicedPerc,
+        //     count: inputData.mappingInfo?.count,
+        //     revisedDetail: inputData.mappingInfo?.revisedDetail,
+        //     status: 'Closed',
+        //     createdByEmail: req?.user?.email,
+        //     createdByUserName: req?.user?.userName,
+        //     createdByRole: req?.user?.role,
+        //   } );
+        // }
+      }
+      record.mappingInfo.push(
+          {
+            type: 'finalRevision',
+            mode: inputData.mappingInfo?.mode,
+            revicedFootfall: inputData.mappingInfo?.revicedFootfall,
+            revicedPerc: inputData.mappingInfo?.revicedPerc,
+            count: inputData.mappingInfo?.count,
+            revisedDetail: inputData.mappingInfo?.revisedDetail,
+            status: 'Closed',
+            createdByEmail: req?.user?.email,
+            createdByUserName: req?.user?.userName,
+            createdByRole: req?.user?.role,
+            createdAt: new Date(),
+          },
+      );
+    }
+
+    if ( Ticket[0]?._source?.type==='store' ) {
+      let findTagging = Ticket[0]?._source?.mappingInfo.filter( ( data ) => data.type==='tagging' );
+      if ( findTagging?.length>0&&findTagging[0].createdByEmail!='' ) {
+        let userData = await findOneUser( { email: findTagging[0]?.createdByEmail } );
+        let title = `Received response for the Footfall ticket raised.`;
+        let createdOn = dayjs( Ticket[0]?._source?.dateString ).format( 'DD MMM YYYY' );
+        let description = `Raised on ${createdOn}`;
+
+        let Data = {
+          'title': title,
+          'body': description,
+          'type': 'closed',
+          'date': Ticket[0]?._source?.dateString,
+          'storeId': Ticket[0]?._source?.storeId,
+          'clientId': Ticket[0]?._source?.clientId,
+          'ticketId': Ticket[0]?._source?.ticketId,
+        };
+        if ( userData && userData.fcmToken ) {
+          const fcmToken = userData.fcmToken;
+          await sendPushNotification( title, description, fcmToken, Data );
+        }
+      }
+    }
+    // return;
+
+    let id = `${inputData.storeId}_${inputData.dateString}_footfall-directory-tagging`;
+    if ( inputData.ticketType === 'internal' ) {
+      id = `${inputData.storeId}_${inputData.dateString}_internal_footfall-directory-tagging`;
+    }
+
+    const insertResult = await updateOpenSearchData( openSearch.footfallDirectory, id, { doc: record } );
+
+    if ( insertResult && ( insertResult.statusCode === 201 || insertResult.statusCode === 200 ) ) {
+      return res.sendSuccess( 'Ticket closed successfully' );
+    } else {
+      return res.sendError( 'Internal Server Error', 500 );
+    }
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { error: err, funtion: 'tangoReviewTicket' } );
+    return res.sendError( err, 500 );
+  }
+}
+
 async function bulkUpdateStatusToPending( indexName, inputData ) {
   const bulkBody = [];
 
@@ -1053,7 +1408,7 @@ export async function ticketList( req, res ) {
       }
     }
 
-    if ( req?.user?.userType == 'tango' && inputData.tangoType !== 'internal' ) {
+    if ( req?.user?.userType === 'tango' && inputData.tangoType !== 'internal' ) {
       searchQuery.query.bool.must.push(
           {
             term: {
@@ -1081,7 +1436,7 @@ export async function ticketList( req, res ) {
 
 
       );
-    } else if ( req?.user?.userType == 'client' && inputData.tangoType !== 'internal' ) {
+    } else if ( req?.user?.userType === 'client' && inputData.tangoType !== 'internal' ) {
       searchQuery.query.bool.must.push(
           {
             term: {
@@ -1173,8 +1528,8 @@ export async function ticketList( req, res ) {
     const ticketListData = searchResult?.body?.hits?.hits?.map( ( hit ) => hit._source ) || [];
 
     let temp = [];
-    if ( req.user.userType == 'tango' ) {
-      if ( inputData.tangotype == 'store' ) {
+    if ( req.user.userType === 'tango' ) {
+      if ( inputData.tangoType === 'store' ) {
         for ( let item of ticketListData ) {
           temp.push( {
 
@@ -1189,7 +1544,7 @@ export async function ticketList( req, res ) {
             reviewerRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.revicedPerc || '--',
             approverRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.revicedPerc || '--',
             tangoRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.revicedPerc || '--',
-            status: item?.status,
+            status: item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.status || '--',
 
           } );
         }
@@ -1211,7 +1566,7 @@ export async function ticketList( req, res ) {
             approverRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.revicedPerc || '--',
             tangoRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.revicedPerc || '--',
             status: item?.status,
-            tangoStatus: item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.revicedPerc || '--',
+            tangoStatus: item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.status || '--',
 
           } );
         }

package/src/dtos/footfallDirectory.dtos.js

@@ -72,6 +72,17 @@ export const tangoReviewTicketSchema = Joi.object().keys( {
 export const tangoReviewTicketValid = {
   body: tangoReviewTicketSchema,
 };
+export const tangoReviewAccuracyClosedTicketSchema = Joi.object().keys( {
+  storeId: Joi.string().required(),
+  dateString: Joi.string().required(),
+  comments: Joi.string().required(),
+  subComment: Joi.string().required(),
+
+} );
+
+export const tangoReviewAccuracyClosedTicketValid = {
+  body: tangoReviewAccuracyClosedTicketSchema,
+};
 
 export const ticketSummarySchema = Joi.object().keys( {
   clientId: Joi.string().required(),

package/src/routes/footfallDirectory.routes.js

@@ -1,7 +1,7 @@
 import express from 'express';
 import { getClusters, getConfig, isGrantedUsers, isTicketExists, ticketApprove, ticketCreation, ticketReview } from '../validations/footfallDirectory.validation.js';
-import { assignTicket, createTicket, downloadTickets, getTaggedStores, getTickets, multiCloseTicket, openTicketList, reviewerList, tangoReviewTicket, ticketList, ticketSummary, updateStatus, updateTempStatus, updateUserTicketStatus, createinternalTicket, checkTicketExists } from '../controllers/footfallDirectory.controllers.js';
-import { createTicketValid, downloadTicketsValid, getTaggedStoresValid, getTicketsValid, openTicketListValid, reviewerListValid, ticketListValid, ticketSummaryValid, updateStatusValid, assignTicketValid, updateTempStatusValid, updateTicketStatusValid, tangoReviewTicketValid, multiCloseTicketValid } from '../dtos/footfallDirectory.dtos.js';
+import { assignTicket, createTicket, downloadTickets, getTaggedStores, getTickets, multiCloseTicket, openTicketList, reviewerList, tangoReviewTicket, ticketList, ticketSummary, updateStatus, updateTempStatus, updateUserTicketStatus, createinternalTicket, checkTicketExists, tangoReviewAccuracyClosedTicket } from '../controllers/footfallDirectory.controllers.js';
+import { createTicketValid, downloadTicketsValid, getTaggedStoresValid, getTicketsValid, openTicketListValid, reviewerListValid, ticketListValid, ticketSummaryValid, updateStatusValid, assignTicketValid, updateTempStatusValid, updateTicketStatusValid, tangoReviewTicketValid, multiCloseTicketValid, tangoReviewAccuracyClosedTicketValid } from '../dtos/footfallDirectory.dtos.js';
 import { bulkValidate, getAssinedStore, isAllowedSessionHandler, validate } from 'tango-app-api-middleware';
 
 export const footfallDirectoryRouter = express.Router();
@@ -11,6 +11,7 @@ footfallDirectoryRouter.post( '/create-internalticket', isAllowedSessionHandler,
 footfallDirectoryRouter.post( '/checkTicketExists', isAllowedSessionHandler, checkTicketExists );
 
 footfallDirectoryRouter.post( '/tango-review-ticket', isAllowedSessionHandler, validate( tangoReviewTicketValid ), tangoReviewTicket );
+footfallDirectoryRouter.post( '/tango-review-ticket', isAllowedSessionHandler, validate( tangoReviewAccuracyClosedTicketValid ), tangoReviewAccuracyClosedTicket );
 
 footfallDirectoryRouter.get( '/ticket-summary', isAllowedSessionHandler, bulkValidate( ticketSummaryValid ), ticketSummary );