tango-app-api-infra 3.1.11 → 3.1.13

package/index.js

@@ -6,9 +6,10 @@ import { userInfraRouter } from './src/routes/userInfra.routes.js';
 import { storeInfraRouter } from './src/routes/storeInfra.routes.js';
 import { clientInfraRouter } from './src/routes/clientInfra.routes.js';
 import { employeeTrainigRouter } from './src/routes/employeetrainig.routes.js';
-import { dataMismatchRouter } from './src/routes/dataMismatch.routes.js';
+import { dataMismatchTicketRouter } from './src/routes/dataMismatch.routes.js';
+import { infraDocs } from './src/docs/infra.docs.js';
 
 
-export { infraRouter, internalInfraRouter, userInfraRouter, storeInfraRouter, dataMismatchRouter, clientInfraRouter, employeeTrainigRouter };
+export { infraRouter, internalInfraRouter, userInfraRouter, storeInfraRouter, dataMismatchTicketRouter, clientInfraRouter, employeeTrainigRouter, infraDocs };
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-infra",
-    "version": "3.1.11",
+    "version": "3.1.13",
     "description": "infra",
     "main": "index.js",
     "type": "module",
@@ -22,10 +22,12 @@
         "express-fileupload": "^1.5.0",
         "handlebars": "^4.7.8",
         "html-pdf-node": "^1.0.8",
+        "joi-to-swagger": "^6.2.0",
         "mongodb": "^6.4.0",
         "nodemon": "^3.1.0",
-        "tango-api-schema": "^2.0.94",
-        "tango-app-api-middleware": "^3.1.7",
+        "swagger-ui-express": "^5.0.0",
+        "tango-api-schema": "^2.0.103",
+        "tango-app-api-middleware": "^3.1.10",
         "winston": "^3.12.0",
         "winston-daily-rotate-file": "^5.0.0"
     },

package/src/controllers/clientInfra.controller.js

@@ -156,7 +156,8 @@ export async function installationCard( req, res ) {
     } );
     let installedCount = await countDocumentsStore( { 'clientId': { $in: req.body.clientId },
       'edge.firstFile': true, 'status': 'active' } );
-
+    let deactiveCount = await countDocumentsStore( { 'clientId': { $in: req.body.clientId },
+      'status': 'deactive' } );
     let yettoInstallCount = await aggregateTangoTicket( [
       {
         $match: {
@@ -250,6 +251,7 @@ export async function installationCard( req, res ) {
     }
     res.sendSuccess( {
       onboardedStoresCount: onboardedCount,
+      inactiveStoresCount: deactiveCount,
       installedStoresCount: installedCount,
       yettoInstallCount: yettoInstallCount.length,
       installFailedCount: installFailedCount.length,

package/src/controllers/dataMismatch.controller.js

@@ -1,14 +1,234 @@
 
+import { findOneTangoTicket, createTangoTicket, updateOneTangoTicket, aggregateTangoTicket, countDocumentsTangoTicket } from '../services/tangoTicket.service.js';
+import { logger, getUTC, appConfig, fileUpload, signedUrl, sendMessageToQueue } from 'tango-app-api-middleware';
+import dayjs from 'dayjs';
 
-export async function createTicket() {
+export async function createTicket( req, res ) {
   try {
-    let ticketExist = await findOneTangoTicket( { 'issueType': req.body.issueType, 'basicDetails.storeId': req.body.storeId } );
+    let ticketExist = await findOneTangoTicket( { 'issueType': req.body.issueType, 'issueDate': ( new Date( req.body.Date ) ), 'basicDetails.storeId': req.body.storeId } );
 
     if ( ticketExist ) {
       return res.sendSuccess( 'MAT Ticket Already Exists for the store' );
     }
+    let actionBy = '';
+    if ( req.user.userType == 'tango' ) {
+      actionBy = 'Tango';
+    } else if ( req.user.userType == 'client' ) {
+      actionBy = 'User';
+    }
+    req.body.ticketDetails = {};
+    req.body.dataMismatch ={
+      actualCount: req.body.actualCount,
+      expectedCount: req.body.expectedCount,
+      contactEmail: req.body.contactEmail,
+    };
+    req.body.issueDate = new Date( req.body.Date );
+    req.body.ticketId = 'TE_DM_' + new Date().valueOf();
+    let create = await createTangoTicket( req.body );
+    let getObject = {};
+    if ( req.files ) {
+      let params = {
+        Bucket: appConfig.cloud.aws.bucket.ticket,
+        Key: create.ticketId + '/',
+        ContentType: 'multipart/form-data',
+        body: req.files.img.data,
+        fileName: req.files.img.name,
+      };
+      let upload = await fileUpload( params );
+      if ( upload ) {
+        getObject = {
+          fileName: req.files.img.name,
+          filePath: create.ticketId + '/' + req.files.img.name,
+        };
+      }
+    }
+    req.body.ticketActivity = [ {
+      actionType: 'Created',
+      timeStamp: new Date(),
+      actionBy: actionBy,
+      IdentifiedBy: req.user.userName,
+      description: req.body.description,
+      attachments: [ getObject ],
+    } ];
+    await updateOneTangoTicket( { ticketId: create.ticketId }, { ticketActivity: req.body.ticketActivity } );
+
+    const ticket = await findOneTangoTicket( { ticketId: req.body.ticketId }, { 'issueDate': 1, 'basicDetails': 1, 'issueType': 1, 'dataMismatch.contactEmail': 1, '_id': 0 } );
+
+    const obj = {
+      storeId: ticket.basicDetails.storeId,
+      issueDate: dayjs( ticket.issueDate ).format( 'DD-MM-YYYY' ),
+    };
+
+    if ( req.body.issueType === 'highcount' ) {
+      await sendMessageToQueue( `${appConfig.cloud.aws.sqs.url}${appConfig.cloud.aws.sqs.highcountTopic}`, JSON.stringify( obj ) );
+    }
+    if ( create ) {
+      res.sendSuccess( 'Ticket Created Successfully' );
+    }
   } catch ( error ) {
     logger.error( { error: error, function: 'createTicket Data Mismatch' } );
     return res.sendError( error, 500 );
   }
 }
+
+export async function updateMat( req, res ) {
+  try {
+    let updateValue = {};
+    if ( req.body.actionType && req.body.actionType != '' ) {
+      let actionBy = '';
+      if ( req.user.userType == 'tango' ) {
+        actionBy = 'Tango';
+      } else if ( req.user.userType == 'client' ) {
+        actionBy = 'User';
+      }
+      req.body.ticketActivity.push( {
+        actionType: req.body.actionType,
+        actionBy: actionBy,
+        timeStamp: new Date(),
+        IdentifiedBy: req.user.userName,
+        description: req.body.description,
+        attachments: req.body.attachments,
+      } );
+      updateValue = { ticketActivity: req.body.ticketActivity };
+    }
+
+    let updateTicket = await updateOneTangoTicket( { ticketId: req.body.ticketId }, updateValue );
+    if ( updateTicket ) {
+      res.sendSuccess( 'Ticket Updated  Successfully' );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, function: 'updateMat' } );
+    return res.sendError( error, 500 );
+  }
+}
+
+
+export async function activityList( req, res ) {
+  try {
+    let date = await getUTC( new Date( req.body.fromDate ), new Date( req.body.toDate ) );
+    let query = [ {
+      $match: {
+        $and: [
+          { 'basicDetails.storeId': req.body.storeId },
+          { issueType: { $in: [ 'lowcount', 'highcount' ] } },
+          { createdAt: { $gte: date.start } },
+          { createdAt: { $lte: date.end } },
+        ],
+      },
+    },
+    {
+      $project: {
+        storeId: '$basicDetails.storeId',
+        status: 1,
+        issueDate: '$issueDate',
+        Date: { $dateToString: { format: '%d-%m-%Y', date: '$createdAt' } },
+        issueClosedDate: 1,
+        ticketId: 1,
+        issueType: 1,
+        ticketActivity: 1,
+        comments: { $size: '$ticketActivity' },
+      },
+    },
+    {
+      $unwind: {
+        path: '$ticketActivity', preserveNullAndEmptyArrays: true,
+      },
+    },
+    {
+      $group: {
+        _id: '$ticketId',
+        storeId: { $first: '$storeId' },
+        Date: { $first: '$Date' },
+        issueClosedDate: { $first: '$issueClosedDate' },
+        status: { $first: '$status' },
+        issueDate: { $first: '$issueDate' },
+        ticketId: { $first: '$ticketId' },
+        issueType: { $first: '$issueType' },
+        comments: { $first: '$comments' },
+        description: { $last: '$ticketActivity.description' },
+      },
+    },
+    {
+      $sort: {
+        issueDate: -1,
+      },
+    },
+    ];
+
+    if ( req.body.filter && req.body.filter !== '' ) {
+      query.push( {
+        $match: {
+          issueType: req.body.filter,
+        },
+      } );
+    }
+    let ticketList = await aggregateTangoTicket( query );
+    if ( req.body.export && ticketList.length > 0 ) {
+      const exportdata = [];
+      ticketList.forEach( ( element ) => {
+        exportdata.push( {
+          'STORE ID': element.storeId,
+          'TICKET ID': element.ticketId,
+          'DATE': element.Date,
+          'ISSUE CLOSED DATE': element.issueClosedDate,
+          'STATUS': element.status,
+          'COMMENT': element.description,
+        } );
+      } );
+      await download( exportdata, res );
+      return;
+    }
+    if ( ticketList.length ) {
+      let highCount = await countDocumentsTangoTicket( {
+        $and: [
+          { 'basicDetails.storeId': req.body.storeId },
+          { issueType: 'highcount' },
+          { createdAt: { $gte: date.start } },
+          { createdAt: { $lte: date.end } },
+        ],
+      } );
+      let lowCount = await countDocumentsTangoTicket( {
+        $and: [
+          { 'basicDetails.storeId': req.body.storeId },
+          { issueType: 'lowcount' },
+          { createdAt: { $gte: date.start } },
+          { createdAt: { $lte: date.end } },
+        ],
+      } );
+
+      res.sendSuccess( {
+        count: ticketList.length,
+        data: ticketList,
+        highCount: highCount,
+        lowCount: lowCount,
+      } );
+    } else {
+      return res.sendError( 'NO data', 204 );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, function: 'activityList' } );
+    return res.sendError( error, 500 );
+  }
+}
+
+
+export async function showActivity( req, res ) {
+  try {
+    for ( let activity of req.body.ticketActivity ) {
+      if ( activity.attachments&&activity.attachments.length>0 ) {
+        for ( let attchment of activity.attachments ) {
+          let params = {
+            Bucket: appConfig.cloud.aws.bucket.ticket,
+            file_path: attchment.filePath,
+          };
+          let attachments = await signedUrl( params );
+          attchment.signedUrl = attachments;
+        }
+      }
+    }
+    res.sendSuccess( req.body );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'showActivity' } );
+    return res.sendError( error, 500 );
+  }
+}

package/src/controllers/employeeTraning.controller.js

@@ -48,3 +48,16 @@ export async function activityLog( req, res ) {
     return res.sendError( error, 500 );
   }
 }
+
+
+export async function updateMatStatus( req, res ) {
+  try {
+    let update = await updateOneTangoTicket( { ticketId: req.body.ticketId }, { 'ticketDetails.matStatus': req.body.matStatus } );
+    if ( update ) {
+      res.sendSuccess( 'Updated Successfully' );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, function: 'updateMatStatus' } );
+    return res.sendError( error, 500 );
+  }
+}

package/src/controllers/infra.controllers.js

@@ -13,10 +13,11 @@ import handlebars from 'handlebars';
 import { findOneGroup } from '../services/group.service.js';
 import htmlpdf from 'html-pdf-node';
 import mongoose from 'mongoose';
+import _ from 'lodash';
+import { aggregateCamera } from '../services/camera.service.js';
 export async function createTicket( req, res ) {
   try {
     req.body.issueDate = new Date( req.body.Date );
-    req.body.ticketDetails.filesCount = req.body.filesCount;
     if ( req.body.issueType == 'infra' ) {
       req.body.ticketId = 'TE_INF_' + new Date().valueOf();
       req.body.ticketActivity = [ {
@@ -126,28 +127,27 @@ export async function bulkcreateTicket( req, res ) {
 export async function updateStatus( req, res ) {
   try {
     if ( req.user.userType == 'tango' ) {
-      if ( req.body.status == 'inprogress' ) {
-        req.body.ticketActivity.push( {
-          actionType: 'statusChange',
-          timeStamp: new Date(),
-          actionBy: 'Tango',
-          IdentifiedBy: req.user.userName,
-        } );
-      }
+      req.body.ticketActivity.push( {
+        actionType: 'statusChange',
+        timeStamp: new Date(),
+        actionBy: 'Tango',
+        IdentifiedBy: req.user.userName,
+      } );
+      req.body.status = 'inprogress';
       req.body.ticketDetails.addressingUser = req.user._id;
       let updateTicket = await updateOneTangoTicket( { ticketId: req.body.ticketId }, req.body );
       if ( updateTicket ) {
         res.sendSuccess( 'Ticket Updated Successfully' );
       }
     } else if ( req.user.userType == 'client' ) {
-      if ( req.body.status == 'inprogress' ) {
-        req.body.ticketActivity.push( {
-          actionType: 'statusChange',
-          timeStamp: new Date(),
-          actionBy: 'User',
-          IdentifiedBy: req.user.userName,
-        } );
-      }
+      req.body.ticketActivity.push( {
+        actionType: 'statusChange',
+        timeStamp: new Date(),
+        actionBy: 'User',
+        IdentifiedBy: req.user.userName,
+      } );
+      req.body.status = 'inprogress';
+
       req.body.ticketDetails.addressingClient = req.user._id;
       let updateTicket = await updateOneTangoTicket( { ticketId: req.body.ticketId }, req.body );
       if ( updateTicket ) {
@@ -607,6 +607,217 @@ export async function invoice( req, res ) {
   } );
 }
 
+export async function getInfraIssues( req, res ) {
+  try {
+    const inputData = req.body;
+    const query=[
+      {
+        $match: {
+          $and: [
+            {
+              'issueType': { $eq: 'infra' },
+
+            },
+            {
+              'basicDetails.storeId': { $eq: inputData.storeId },
+
+            },
+            {
+              'issueDate': { $gte: new Date( inputData.fromDate ) },
+
+            },
+            {
+              'issueDate': { $lte: new Date( inputData.toDate ) },
+
+            },
+            {
+              'ticketDetails.issueStatus': { $eq: 'identified' },
+
+            },
+
+          ],
+        },
+      },
+      {
+        $project: {
+          issueType: 1,
+          issueDate: { $dateToString: { format: '%Y-%m-%d', date: '$issueDate' } },
+          ticketActivity: {
+            $filter: {
+              input: '$ticketActivity',
+              as: 'item',
+              cond: { $eq: [ '$$item.actionType', 'issueUpdate' ] },
+            },
+          },
+        },
+      },
+
+      {
+        $unwind: {
+          path: '$ticketActivity', preserveNullAndEmptyArrays: true,
+        },
+      },
+      {
+        $unwind: {
+          path: '$ticketActivity.reasons', preserveNullAndEmptyArrays: true,
+        },
+      },
+      {
+        $group: {
+          _id: { reason: '$ticketActivity.reasons', issueDate: '$issueDate' },
+          issueDate: { $first: '$issueDate' },
+          primaryIssue: { $last: '$ticketActivity.reasons.primaryIssue' },
+          secondaryIssue: { $last: '$ticketActivity.reasons.secondaryIssue' },
+
+        },
+      },
+      {
+        $unwind: {
+          path: '$secondaryIssue', preserveNullAndEmptyArrays: true,
+        },
+      },
+      {
+        $group: {
+          _id: { issue: '$primaryIssue', issueDate: '$issueDate' },
+          issueDate: { $first: '$issueDate' },
+          primaryIssue: { $last: '$primaryIssue' },
+          secondaryReason: { $push: '$secondaryIssue.name' },
+
+        },
+      },
+      {
+        $project: {
+          _id: 0,
+          issueDate: 1,
+          primaryIssue: 1,
+          secondaryReason: 1,
+          downTime: { $ifNull: [ 0, 0 ] },
+          speedTest: { $ifNull: [ 0.5, 0.5 ] },
+        },
+
+      },
+    ];
+
+
+    let retVal = [];
+    let current = new Date( inputData.fromDate );
+    let end = new Date( inputData.toDate );
+
+    while ( current <= end ) {
+      retVal.push( { issueDate: dayjs( current ).format( 'YYYY-MM-DD' ), downTime: 0, speedTest: 0.6 } );
+      current.setDate( current.getDate() + 1 );
+    }
+
+    const result = await aggregateTangoTicket( query );
+
+    const mergeValue =_.values(
+        _.merge(
+            _.keyBy( retVal, 'issueDate' ),
+            _.keyBy( result, 'issueDate' ),
+        ),
+    );
+    logger.info( { message: mergeValue, value1: result } );
+
+    if ( mergeValue.length == 0 ) {
+      return res.sendError( 'NO Data Found', 204 );
+    }
+    for ( let i =0; i< mergeValue.length; i++ ) {
+      const downTime = await getOpenSearchData( 'live_downtime_hourly',
+          {
+            'size': 100,
+            'query': {
+              'bool': {
+                'must': [
+                  {
+                    'term': {
+                      'doc.date.keyword': dayjs( mergeValue[i].issueDate ).format( 'DD-MM-YYYY' ),
+                    },
+                  },
+                  {
+                    'term': {
+                      'doc.store_id.keyword': inputData.storeId,
+                    },
+                  },
+
+                ],
+
+              },
+            },
+
+          } );
+      let streamwiseDowntime = [];
+      logger.info( { streamwiseDowntime: downTime.body.hits.hits.length } );
+      if ( downTime.body.hits.hits.length > 0 ) {
+        for ( let i = 0; i< downTime.body.hits.hits.length; i++ ) {
+          const sum = streamwiseDowntime.reduce( ( accumulator, currentValue ) => {
+            return accumulator + currentValue.down_time;
+          }, 0 );
+          const average = sum / streamwiseDowntime.length;
+          mergeValue.downTime = Math.round( average );
+          // streamwiseDowntime.push( ...downTime.body.hits.hits[i]._source.doc.streamwise_downtime );
+        }
+      }
+    }
+    const camQuery = [
+      {
+        $match: {
+          $and: [
+            { isUp: { $eq: true } },
+            { isActivated: { $eq: true } },
+            { storeId: inputData.storeId },
+          ],
+        },
+      },
+      {
+        $project: {
+          _id: 0,
+          streamName: 1,
+          cameraNumber: 1,
+          thumbnailImage: await signedUrl( { Bucket: appConfig.cloud.aws.bucket.baseImage, file_path: '$thumbnailImage' } ),
+        },
+      },
+    ];
+
+    const highCountQuery =[
+      {
+        $match: {
+          $and: [
+            { 'basicDetails.storeId': inputData.storeId },
+            { issueType: { $in: [ 'highcount', 'lowcount' ] } },
+
+          ],
+        },
+      },
+      {
+        $group: {
+          _id: null,
+          total: { $sum: 1 },
+          successRate: { $avg: '$dataMismatch.successPercentage' },
+        },
+      },
+      {
+        $project: {
+          _id: 0,
+          total: 1,
+          successRate: 1,
+        },
+      },
+    ];
+    const defaultValue= {
+      total: 0,
+      successRate: 0,
+    };
+    const getHighCountTicket = await aggregateTangoTicket( highCountQuery );
+    logger.info( { getHighCountTicket: getHighCountTicket } );
+    const camera = await aggregateCamera( camQuery );
+    logger.info( { message: camera } );
+    return res.sendSuccess( { result: mergeValue, streams: camera, highCountTicketDetails: getHighCountTicket[0] || defaultValue } );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'getInfraIssues' } );
+    return res.sendError( error, 500 );
+  }
+}
+
 
 function inWords( num ) {
   let a = [ '', 'one ', 'two ', 'three ', 'four ', 'five ', 'six ', 'seven ', 'eight ', 'nine ', 'ten ', 'eleven ', 'twelve ', 'thirteen ', 'fourteen ', 'fifteen ', 'sixteen ', 'seventeen ', 'eighteen ', 'nineteen ' ]; let b = [ '', '', 'twenty', 'thirty', 'forty', 'fifty', 'sixty', 'seventy', 'eighty', 'ninety' ];
@@ -1233,14 +1444,14 @@ export async function matTable( req, res ) {
       result.forEach( ( element ) => {
         exportdata.push( {
           'ticketId': element.ticketId,
-          'issueDate': dayjs( element.issueDate ).format( 'DD-MM-YYYY' ),
+          'Date': dayjs( element.issueDate ).format( 'DD-MM-YYYY' ),
           'storeId': element.storeId,
           'storeName': element.storeName,
           'clientId': element.clientId,
           'clientName': element.clientName,
           'userName': element.userName,
           'userEmail': element.userEmail,
-          'Status': element.installationStatus,
+          'Status': element.status,
         } );
       } );
       await download( exportdata, res );
@@ -1272,18 +1483,25 @@ export async function assignTicket( req, res ) {
 }
 export async function storeFilter( req, res ) {
   try {
-    let stores = await findTangoTicket( { 'issueType': req.body.issueType, 'basicDetails.clientId': req.body.clientId, 'basicDetails.storeId': { $exists: true } }, { 'basicDetails.storeId': 1 } );
+    const inputData = req.body;
+    let query = { 'issueType': inputData.issueType, 'basicDetails.clientId': inputData.clientId, 'basicDetails.storeId': { $exists: true } };
+    if ( inputData.issueType == 'dataMismatch' ) {
+      query ={
+        'issueType': { '$in': [ 'highcount', 'lowcount' ] }, 'basicDetails.clientId': inputData.clientId, 'basicDetails.storeId': { $exists: true },
+      };
+    }
+    let stores = await findTangoTicket( query, { 'basicDetails.storeId': 1 } );
     const uniqueStoreIds = [ ...new Set( stores.map( ( store ) => store.basicDetails.storeId ) ) ];
     const uniqueStoreObjects = uniqueStoreIds.map( ( storeId ) => ( { 'storeId': storeId } ) );
 
-    if ( uniqueStoreObjects.length>0 ) {
+    if ( uniqueStoreObjects.length > 0 ) {
       res.sendSuccess( { count: uniqueStoreObjects.length, data: uniqueStoreObjects } );
     } else {
       res.sendError( 'No data', 204 );
     }
   } catch ( error ) {
-    // console.log( error );
     logger.error( { error: error, function: 'storeFilter' } );
     return res.sendError( error, 500 );
   }
 }
+

package/src/controllers/internalInfra.controller.js

@@ -445,11 +445,10 @@ export async function emailUserList( req, res ) {
 }
 export async function infraReportSent( req, res ) {
   try {
-    let date;
     // if ( req.body.type == 'start' ) {
     //   date = dayjs().subtract( 1, 'day' ).format( 'YYYY-MM-DD' );
     // } else if ( req.body.type == 'end' ) {
-    date = dayjs().format( 'YYYY-MM-DD' );
+    let date = dayjs( ).format( 'YYYY-MM-DD' );
     // };
     let query = [ {
       $match: {
@@ -468,6 +467,13 @@ export async function infraReportSent( req, res ) {
         status: 1,
         ticketDetails: 1,
         issueClosedDate: 1,
+        otherscomment: {
+          $filter: {
+            input: '$ticketActivity',
+            as: 'item',
+            cond: { $eq: [ '$$item.actionType', 'comment' ] },
+          },
+        },
         primaryIssue: {
           $filter: {
             input: '$ticketActivity',
@@ -477,6 +483,11 @@ export async function infraReportSent( req, res ) {
         },
       },
     },
+    {
+      $unwind: {
+        path: '$otherscomment', preserveNullAndEmptyArrays: true,
+      },
+    },
     {
       $unwind: {
         path: '$primaryIssue', preserveNullAndEmptyArrays: true,
@@ -500,6 +511,8 @@ export async function infraReportSent( req, res ) {
         status: 1,
         ticketDetails: 1,
         issueClosedDate: 1,
+        ommentText: { $ifNull: [ '$primaryIssue.comment', '-' ] },
+        otherscomment: { $ifNull: [ '$otherscomment.comment', '-' ] },
         primaryIssue: { $ifNull: [ '$primaryIssue.reasons.primaryIssue', '-' ] },
         secondaryIssue: { $ifNull: [ '$primaryIssue.reasons.secondaryIssue.name', '-' ] },
       },
@@ -510,11 +523,12 @@ export async function infraReportSent( req, res ) {
         ticketDetails: { $first: '$ticketDetails' },
         issueClosedDate: { $first: '$issueClosedDate' },
         basicDetails: { $first: '$basicDetails' },
+        commentText: { $last: '$commentText' },
         primaryIssue: { $last: '$primaryIssue' },
         secondaryIssue: { $last: '$secondaryIssue' },
+        otherscomment: { $last: '$otherscomment' },
         createdAt: { $first: '$createdAt' },
         status: { $last: '$status' },
-
       },
     },
     ];
@@ -527,7 +541,7 @@ export async function infraReportSent( req, res ) {
       exportdata.push( {
         'Client ID': element.basicDetails.clientId,
         'Client Name': element.basicDetails.clientName,
-        'Ticket Created Date & Time': dayjs( element.createdAt ).format( 'YYYY-MM-DD HH:mm A' ),
+        'Ticket Created Date & Time': dayjs( element.createdAt ).tz( 'Asia/Kolkata' ).format( 'YYYY-MM-DD HH:mm A' ),
         'Store ID': element.basicDetails.storeId,
         'Store Name': element.basicDetails.storeName,
         'Issue ': element.primaryIssue,
@@ -535,9 +549,12 @@ export async function infraReportSent( req, res ) {
         'Status ': element.status,
         'Responded By': clientuser && clientuser.userName ? clientuser.userName : '-',
         'Resolved By': tangouser && tangouser.userName ? tangouser.userName : '-',
-        'Ticket Closed Date & Time': element.issueClosedDate ? dayjs( element.issueClosedDate ).format( 'YYYY-MM-DD HH:mm A' ) : '-',
-        'Latest Comment': '',
-        'Activity Log': `${appConfig.url.domain+'/manage/stores/infra-ticket?storeId='+element.basicDetails.storeId}`,
+        'Ticket Closed Date & Time': element.issueClosedDate ? dayjs( element.issueClosedDate ).tz( 'Asia/Kolkata' ).format( 'YYYY-MM-DD HH:mm A' ) : '-',
+        'Latest Comment': element.otherscomment?element.otherscomment:element.commentText,
+        'Activity Log': {
+          label: 'Link',
+          url: `${appConfig.url.domain+'/manage/stores/infra-ticket?storeId='+element.basicDetails.storeId}`,
+        },
       } );
     }
 
@@ -572,40 +589,23 @@ export async function infraReportSent( req, res ) {
         count: 0,
       } ) );
     }
-    let reportdate = dayjs().format( 'YYYY-MM-DD' );
+
     let attachments = null;
-    if ( exportdata.length > 0 ) {
-      const wb = new xl.Workbook();
-      const ws = wb.addWorksheet( 'Daily report' );
-      const headers = Object.keys( exportdata[0] );
+    let buffer = await download( exportdata );
+    attachments = {
+      filename: `dailyInfraReport- ${date}.xlsx`,
+      content: buffer,
+      contentType: 'application/xlsx', // e.g., 'application/pdf'
+    };
 
-      for ( let i = 0; i < headers.length; i++ ) {
-        ws.cell( 1, i + 1 ).string( headers[i] );
-      };
-      for ( let i = 0; i < exportdata.length; i++ ) {
-        const dataRow = exportdata[i];
-        for ( let j = 0; j < headers.length; j++ ) {
-          const header = headers[j];
-          const value = dataRow[header];
-          ws.cell( i + 2, j + 1 ).string( value?.toString() );
-        }
-      }
-      let buffer = await wb.writeToBuffer();
 
-      attachments = {
-        filename: `dailyInfraReport- ${reportdate}.xlsx`,
-        content: buffer,
-        contentType: 'application/xlsx', // e.g., 'application/pdf'
-      };
-    }
-
-    const subject = `Daily Digest - Infra Downtime Report - ${reportdate}`;
+    const subject = `Daily Digest - Infra Downtime Report - ${date}`;
     const fileContent = readFileSync( join() + '/src/hbs/dailyInfraReport.hbs', 'utf8' );
     const htmlContent = handlebars.compile( fileContent );
     let Uidomain = `${appConfig.url.domain}`;
 
 
-    const html = htmlContent( { ...req.body, Uidomain: Uidomain, issueCount: issueCount, avgDownTime: avgDownTime, reportdate: reportdate, content: response, date: date, domain: appConfig.url.apiDomain } );
+    const html = htmlContent( { ...req.body, Uidomain: Uidomain, issueCount: issueCount, avgDownTime: avgDownTime, reportdate: date, content: response, date: date, domain: appConfig.url.apiDomain } );
     if ( isValidEmail( req.body.email ) ) {
       const result = await sendEmailWithSES( req.body.email, subject, html, attachments, appConfig.cloud.aws.ses.adminEmail );
       res.sendSuccess( result );
@@ -724,8 +724,7 @@ export async function download( data ) {
     for ( let j = 0; j < headers.length; j++ ) {
       const header = headers[j];
       const value = dataRow[header];
-
-      if ( typeof value === 'object' && value.hasOwnProperty( 'label' ) && value.hasOwnProperty( 'url' ) ) {
+      if ( value&& typeof value === 'object' && value.hasOwnProperty( 'label' ) && value.hasOwnProperty( 'url' ) ) {
         ws.cell( i + 2, j + 1 ).link( value.url );
         ws.cell( i + 2, j + 1 ).string( value.label );
       } else {
@@ -884,11 +883,9 @@ export async function edgeApplogsCheck( req, res ) {
       let findissueEdgeApp = {};
       if ( result.length>0 ) {
         for ( let findissue of result ) {
-          // console.log( ticket.ticketId );
           const istTimestamp = dayjs.utc( ticket.createdAt ).tz( 'Asia/Kolkata' ).format( 'HH:mm:ss' );
 
           if ( findissue.code == '1003' ) {
-          // Compare the times
             const occurringTimeParsed = dayjs( `${req.body.date} ${findissue.edgelog.occuringTime}` );
             const ticketCreatedParsed = dayjs( `${req.body.date} ${istTimestamp}` );
             const isOccurringTimeEarlier = occurringTimeParsed.isBefore( ticketCreatedParsed );
@@ -902,7 +899,6 @@ export async function edgeApplogsCheck( req, res ) {
               };
               updateIssue( findissueEdgeApp );
               finalresult.push( findissueEdgeApp );
-            // console.log( findissueEdgeApp );
             }
           } else if ( findissue.code == '1024' ) {
             const occurringTimeParsed = dayjs( `${req.body.date} ${findissue.edgelog.data.occuringTime}` );
@@ -938,7 +934,6 @@ export async function edgeApplogsCheck( req, res ) {
               };
               updateIssue( findissueEdgeApp );
               finalresult.push( findissueEdgeApp );
-            // console.log( findissueEdgeApp );
             }
           } else if ( findissue.code ==='1005' ) {
             const occurringTimeParsed = dayjs( `${req.body.date} ${findissue.edgelog.occuringTime}` );
@@ -954,7 +949,6 @@ export async function edgeApplogsCheck( req, res ) {
               };
               updateIssue( findissueEdgeApp );
               finalresult.push( findissueEdgeApp );
-            // console.log( findissueEdgeApp );
             }
           }
         }
@@ -1054,7 +1048,6 @@ export async function updateIssue( data ) {
       'status': 'inprogress',
     };
     await updateOneTangoTicket( { ticketId: data.ticketId }, query );
-    // console.log( data );
   } catch ( error ) {
     logger.error( { error: error, function: 'updateAutomaticIssue' } );
     res.sendError( error, 500 );

package/src/controllers/storeInfra.controlller.js

@@ -28,7 +28,20 @@ export async function storeTicketList( req, res ) {
         ticketId: 1,
         issueStatus: '$ticketDetails.issueStatus',
         ticketType: '$ticketDetails.ticketType',
-        comments: { $size: '$ticketActivity' },
+        otherscomment: {
+          $filter: {
+            input: '$ticketActivity',
+            as: 'item',
+            cond: { $eq: [ '$$item.actionType', 'comment' ] },
+          },
+        },
+        comments: {
+          $filter: {
+            input: '$ticketActivity',
+            as: 'item',
+            cond: { $ne: [ '$$item.actionType', 'statusChange' ] },
+          },
+        },
         primaryIssue: {
           $filter: {
             input: '$ticketActivity',
@@ -43,11 +56,21 @@ export async function storeTicketList( req, res ) {
         path: '$primaryIssue', preserveNullAndEmptyArrays: true,
       },
     },
+    {
+      $unwind: {
+        path: '$otherscomment', preserveNullAndEmptyArrays: true,
+      },
+    },
     {
       $unwind: {
         path: '$primaryIssue.reasons', preserveNullAndEmptyArrays: true,
       },
     },
+    {
+      $unwind: {
+        path: '$primaryIssue.reasons.secondaryIssue', preserveNullAndEmptyArrays: true,
+      },
+    },
     {
       $project: {
         storeId: 1,
@@ -57,10 +80,12 @@ export async function storeTicketList( req, res ) {
         ticketId: 1,
         issueStatus: 1,
         ticketType: 1,
-        comments: 1,
+        comments: { $size: '$comments' },
         issueDate: 1,
+        commentText: '$primaryIssue.comment',
         primaryIssue: '$primaryIssue.reasons.primaryIssue',
-        secondaryIssue: '$primaryIssue.reasons.secondaryIssue',
+        secondaryIssue: '$primaryIssue.reasons.secondaryIssue.name',
+        otherscomment: '$otherscomment.comment',
       },
     },
     {
@@ -75,8 +100,11 @@ export async function storeTicketList( req, res ) {
         issueStatus: { $first: '$issueStatus' },
         ticketType: { $first: '$ticketType' },
         comments: { $first: '$comments' },
+        commentText: { $last: '$commentText' },
         primaryIssue: { $last: '$primaryIssue' },
         secondaryIssue: { $last: '$secondaryIssue' },
+        otherscomment: { $last: '$otherscomment' },
+
       },
     },
     {
@@ -102,8 +130,10 @@ export async function storeTicketList( req, res ) {
           'TICKET ID': element.ticketId,
           'DATE': element.Date,
           'ISSUE CLOSED DATE': element.issueClosedDate,
-          'ISSUE': element.primaryIssue,
+          'PRIMARY ISSUE': element.primaryIssue,
+          'SECONDARY ISSUE': element.secondaryIssue,
           'STATUS': element.status,
+          'COMMENT': element.otherscomment?element.otherscomment:element.commentText,
         } );
       } );
       await download( exportdata, res );
@@ -330,7 +360,6 @@ export async function edgeAppLogTable( req, res ) {
       };
       const downtime = await getOpenSearchData( 'live_downtime_hourly', downTimeQuery );
       let streamwiseDowntime = downtime.body.hits.hits.length > 0 ? downtime.body.hits.hits[0]._source.doc.streamwise_downtime : [];
-      // console.log( obj.hour, streamwiseDowntime );
       if ( streamwiseDowntime.length > 0 ) {
         const sum = streamwiseDowntime.reduce( ( accumulator, currentValue ) => {
           return accumulator + currentValue.down_time;

package/src/controllers/userInfra.controller.js

@@ -75,13 +75,24 @@ export async function userTakeTicket( req, res ) {
       let query = {
         'status': { $ne: 'closed' },
         'issueType': 'mat',
+        'ticketDetails.addressingUser': { $exists: false },
+      };
+      if ( assignedClients.length > 0 ) {
+        query =( { ...query, ...{ 'basicDetails.clientId': { $in: assignedClients } } } );
+      }
+      userTicket = await findOneTangoTicket( query );
+    } else if ( req.body.issueType == 'dataMismatch' ) {
+      let query = {
+        'status': { $ne: 'closed' },
+        'issueType': { $in: [ 'highcount', 'lowcount' ] },
+        'ticketDetails.addressingUser': { $exists: false },
       };
       if ( assignedClients.length > 0 ) {
         query =( { ...query, ...{ 'basicDetails.clientId': { $in: assignedClients } } } );
       }
       userTicket = await findOneTangoTicket( query );
     }
-    if ( userTicket ) {
+    if ( userTicket&&userTicket.ticketId ) {
       let assignTicket = await updateOneTangoTicket( { ticketId: userTicket.ticketId }, { 'ticketDetails.addressingUser': req.body.userId } );
       if ( assignTicket ) {
         res.sendSuccess( 'Ticket Assigned Successfully' );
@@ -97,15 +108,28 @@ export async function userTakeTicket( req, res ) {
 export async function userTicketList( req, res ) {
   try {
     let date = await getUTC( new Date( req.body.fromDate ), new Date( req.body.toDate ) );
-    let query = [ {
-      $match: {
-        $and: [
-
-          { issueType: req.body.issueType },
-          { 'ticketDetails.addressingUser': new mongoose.Types.ObjectId( req.body.userId ) },
-        ],
-      },
-    } ];
+    let query = [];
+    if ( req.body.issueType!='dataMismatch' ) {
+      query.push( {
+        $match: {
+          $and: [
+            { 'basicDetails.clientId': { $in: req.body.clientId } },
+            { issueType: req.body.issueType },
+            { 'ticketDetails.addressingUser': new mongoose.Types.ObjectId( req.body.userId ) },
+          ],
+        },
+      } );
+    } else {
+      query.push( {
+        $match: {
+          $and: [
+            { 'basicDetails.clientId': { $in: req.body.clientId } },
+            { issueType: { $in: [ 'highcount', 'lowcount' ] } },
+            { 'ticketDetails.addressingUser': new mongoose.Types.ObjectId( req.body.userId ) },
+          ],
+        },
+      } );
+    }
     if ( req.body.status != 'closed' || req.body.export ) {
       query.push( {
         $match: {
@@ -132,6 +156,7 @@ export async function userTicketList( req, res ) {
     query.push( {
       $project: {
         storeId: '$basicDetails.storeId',
+        storeName: '$basicDetails.storeName',
         Date: { $dateToString: { format: '%d-%m-%Y', date: '$issueDate' } },
         updatedAt: 1,
         ticketId: 1,
@@ -140,6 +165,7 @@ export async function userTicketList( req, res ) {
         issueStatus: '$ticketDetails.issueStatus',
         ticketType: '$ticketDetails.ticketType',
         installationStatus: '$ticketDetails.installationStatus',
+        matStatus: '$ticketDetails.matStatus',
         primaryIssue: {
           $filter: {
             input: '$ticketActivity',
@@ -162,6 +188,7 @@ export async function userTicketList( req, res ) {
     {
       $project: {
         storeId: 1,
+        storeName: 1,
         updatedAt: 1,
         Date: 1,
         ticketId: 1,
@@ -170,6 +197,7 @@ export async function userTicketList( req, res ) {
         status: 1,
         issueType: 1,
         installationStatus: 1,
+        matStatus: 1,
         infraIssue: '$primaryIssue.reasons.primaryIssue',
       },
     },
@@ -177,12 +205,14 @@ export async function userTicketList( req, res ) {
       $group: {
         _id: '$ticketId',
         storeId: { $first: '$storeId' },
+        storeName: { $first: '$storeName' },
         updatedAt: { $first: '$updatedAt' },
         Date: { $first: '$Date' },
         ticketId: { $first: '$ticketId' },
         issueType: { $first: '$issueType' },
         status: { $first: '$status' },
         installationStatus: { $first: '$installationStatus' },
+        matStatus: { $first: '$matStatus' },
         issueStatus: { $first: '$issueStatus' },
         ticketType: { $first: '$ticketType' },
         infraIssue: { $last: '$infraIssue' },
@@ -196,6 +226,7 @@ export async function userTicketList( req, res ) {
           $or: [
             { storeId: { $regex: req.body.searchValue, $options: 'i' } },
             { infraIssue: { $regex: req.body.searchValue, $options: 'i' } },
+            { storeName: { $regex: req.body.searchValue, $options: 'i' } },
           ],
         },
       } );
@@ -206,6 +237,7 @@ export async function userTicketList( req, res ) {
           $or: [
             { issueStatus: req.body.filter },
             { infraIssue: req.body.filter },
+            { issueType: req.body.filter },
           ],
         },
       } );
@@ -214,13 +246,23 @@ export async function userTicketList( req, res ) {
     if ( req.body.export ) {
       const exportdata = [];
       ticketList.forEach( ( element ) => {
-        exportdata.push( {
+        let data = {
           'DATE': element.Date,
           'TICKET ID': element.ticketId,
           'STORE ID': element.storeId,
-          'ISSUE': element.issueStatus,
+          'STORE NAME': element.storeName,
           'STATUS': element.status,
-        } );
+        };
+        if ( req.body.issueType ==='infra' ) {
+          data = { ...data, ...{ 'ISSUE': element.issueStatus } };
+        }
+        if ( req.body.issueType ==='installation' ) {
+          data = { ...data, ...{ 'ISSUE': element.issueStatus } };
+        }
+        if ( req.body.issueType ==='dataMismatch' ) {
+          data = { ...data, ...{ 'ISSUE TYPE': element.issueType } };
+        }
+        exportdata.push( data );
       } );
       await download( exportdata, res );
       return;
@@ -303,16 +345,30 @@ export async function basicDetails( req, res ) {
 export async function workHistory( req, res ) {
   try {
     let date = await getUTC( new Date( req.body.fromDate ), new Date( req.body.toDate ) );
-    let query = [ {
-      $match: {
-        $and: [
-          { 'status': 'closed' },
-          { issueType: req.body.issueType },
-          { 'ticketDetails.addressingUser': new mongoose.Types.ObjectId( req.body.userId ) },
-        ],
-      },
-    } ];
-
+    let query = [ ];
+    if ( req.body.issueType!='dataMismatch' ) {
+      query.push( {
+        $match: {
+          $and: [
+            { 'basicDetails.clientId': { $in: req.body.clientId } },
+            { 'status': 'closed' },
+            { issueType: req.body.issueType },
+            { 'ticketDetails.addressingUser': new mongoose.Types.ObjectId( req.body.userId ) },
+          ],
+        },
+      } );
+    } else {
+      query.push( {
+        $match: {
+          $and: [
+            { 'basicDetails.clientId': { $in: req.body.clientId } },
+            { 'status': 'closed' },
+            { issueType: { $in: [ 'highcount', 'lowcount' ] } },
+            { 'ticketDetails.addressingUser': new mongoose.Types.ObjectId( req.body.userId ) },
+          ],
+        },
+      } );
+    }
     if ( req.body.dateFilter && req.body.dateFilter != '' ) {
       if ( req.body.dateFilter === 'issueIdentifiedDate' ) {
         query.push(
@@ -335,6 +391,18 @@ export async function workHistory( req, res ) {
                   { 'issueClosedDate': { $lte: date.end } },
                 ],
 
+              },
+            },
+        );
+      } else if ( req.body.dateFilter === 'issueDate' ) {
+        query.push(
+            {
+              $match: {
+                $and: [
+                  { 'issueDate': { $gte: date.start } },
+                  { 'issueDate': { $lte: date.end } },
+                ],
+
               },
             },
         );
@@ -369,6 +437,7 @@ export async function workHistory( req, res ) {
             storeName: '$basicDetails.storeName',
             clientId: '$basicDetails.clientId',
             clientName: '$basicDetails.clientName',
+            issueType: 1,
             issueDate: { $dateToString: { format: '%Y-%m-%d', date: '$createdAt' } },
             issueClosedDate: { $dateToString: { format: '%Y-%m-%d', date: '$issueClosedDate' } },
             issueIdentifiedDate: { $dateToString: { format: '%Y-%m-%d', date: '$ticketDetails.issueIdentifiedDate' } },
@@ -398,6 +467,7 @@ export async function workHistory( req, res ) {
           $project: {
             storeId: 1,
             storeName: 1,
+            issueType: 1,
             clientId: 1,
             clientName: 1,
             issueDate: 1,
@@ -405,17 +475,25 @@ export async function workHistory( req, res ) {
             issueClosedDate: 1,
             ticketId: 1,
             issueStatus: 1,
+            status: 1,
             ticketType: 1,
             infraIssue: { $ifNull: [ '$primaryIssue.reasons.primaryIssue', '' ] },
           },
         } );
-    if ( req.body.issueFilter && req.body.issueFilter.length>0 ) {
+    if ( req.body.issueFilter && req.body.issueFilter.length>0&&req.body.issueType!='dataMismatch' ) {
       query.push( {
         $match: {
           infraIssue: { $in: req.body.issueFilter },
         },
       } );
     }
+    if ( req.body.issueFilter && req.body.issueFilter.length>0&&req.body.issueType==='dataMismatch' ) {
+      query.push( {
+        $match: {
+          issueType: { $in: req.body.issueFilter },
+        },
+      } );
+    }
     if ( req.body.searchValue && req.body.searchValue !== '' ) {
       query.push( {
         $match: {
@@ -446,19 +524,25 @@ export async function workHistory( req, res ) {
     if ( req.body.export ) {
       const exportdata = [];
       result.forEach( ( element ) => {
-        exportdata.push( {
+        let data ={
           'CREATED ON': dayjs( element.issueDate ).format( 'DD-MM-YYYY' ),
           'TICKET ID': element.ticketId,
           'STORE ID': element.storeId,
           'STORE NAME': element.storeName,
           'CLIENT ID': element.clientId,
           'CLIENT NAME': element.clientName,
-          'ISSUE IDENTIFIED DATE': element.issueIdentifiedDate,
           'CLOSED ON': element.issueClosedDate,
-          'ISSUE': element.infraIssue?element.infraIssue:'-',
           'STATUS': element.status,
-        } );
+        };
+        if ( req.body.issueType==='infra'||req.body.issueType==='installation' ) {
+          data = { ...data, ...{ 'ISSUE': element.infraIssue?element.infraIssue:'-', 'ISSUE IDENTIFIED DATE': element.issueIdentifiedDate } };
+        }
+        if ( req.body.issueType==='dataMismatch' ) {
+          data = { ...data, ...{ 'issueType': element.issueType?element.issueType:'-' } };
+        }
+        exportdata.push( data );
       } );
+
       await download( exportdata, res );
       return;
     }

package/src/docs/infra.docs.js

@@ -0,0 +1,28 @@
+import j2s from 'joi-to-swagger';
+import { getInfraIssueSchema } from '../dtos/infra.dtos.js';
+
+export const infraDocs = {
+
+  '/v3/infra/get-infra-issues': {
+    post: {
+      tags: [ 'infra' ],
+      description: `Get infra issues against store`,
+      operationId: 'get-infra-issues',
+      parameters: {},
+      requestBody: {
+        content: {
+          'application/json': {
+            schema: j2s( getInfraIssueSchema ).swagger,
+          },
+        },
+      },
+      responses: {
+        200: { description: 'Group has been created successfully' },
+        401: { description: 'Unauthorized User' },
+        422: { description: 'Field Error' },
+        500: { description: 'Server Error' },
+        204: { description: 'Not Found' },
+      },
+    },
+  },
+};

package/src/dtos/infra.dtos.js

@@ -0,0 +1,12 @@
+import Joi from 'joi';
+
+export const getInfraIssueSchema = Joi.object().keys( {
+  fromDate: Joi.string().required(),
+  toDate: Joi.string().required(),
+  storeId: Joi.string().required(),
+
+} );
+
+export const getInfraIssueValid = {
+  body: getInfraIssueSchema,
+};

package/src/routes/dataMismatch.routes.js

@@ -1,10 +1,22 @@
 import express from 'express';
 import { isAllowedSessionHandler, authorize } from 'tango-app-api-middleware';
-import { createTicket } from '../controllers/dataMismatch.controller.js';
-import { validateDetails } from '../validations/infra.validation.js';
-export const dataMismatchRouter = express.Router();
+import { createTicket, updateMat, activityList, showActivity } from '../controllers/dataMismatch.controller.js';
+import { ticketExists, validateDetails } from '../validations/infra.validation.js';
+export const dataMismatchTicketRouter = express.Router();
 
-dataMismatchRouter.post( '/createTicket', isAllowedSessionHandler, authorize( {
+dataMismatchTicketRouter.post( '/createTicket', isAllowedSessionHandler, authorize( {
   userType: [ 'client', 'tango' ], access: [
     { featureName: 'manage', name: 'tickets', permissions: [ 'isView', 'isEdit' ] } ],
 } ), validateDetails, createTicket );
+dataMismatchTicketRouter.post( '/updateMat', isAllowedSessionHandler, authorize( {
+  userType: [ 'client', 'tango' ], access: [
+    { featureName: 'manage', name: 'tickets', permissions: [ 'isView' ] } ],
+} ), ticketExists, updateMat );
+dataMismatchTicketRouter.post( '/activityList', isAllowedSessionHandler, authorize( {
+  userType: [ 'client', 'tango' ], access: [
+    { featureName: 'manage', name: 'tickets', permissions: [ 'isView' ] } ],
+} ), activityList );
+dataMismatchTicketRouter.post( '/showActivity', isAllowedSessionHandler, authorize( {
+  userType: [ 'client', 'tango' ], access: [
+    { featureName: 'manage', name: 'tickets', permissions: [ 'isView' ] } ],
+} ), ticketExists, showActivity );

package/src/routes/employeetrainig.routes.js

@@ -1,4 +1,4 @@
-import { createTicket, updatecomment, activityLog } from '../controllers/employeeTraning.controller.js';
+import { createTicket, updatecomment, activityLog, updateMatStatus } from '../controllers/employeeTraning.controller.js';
 import { ticketExists, validateDetails } from '../validations/infra.validation.js';
 import express from 'express';
 import { isAllowedSessionHandler, authorize } from 'tango-app-api-middleware';
@@ -15,3 +15,7 @@ employeeTrainigRouter.post( '/activityLog', isAllowedSessionHandler, authorize(
   userType: [ 'tango' ], access: [
     { featureName: 'manage', name: 'tickets', permissions: [ 'isView' ] } ],
 } ), ticketExists, activityLog );
+employeeTrainigRouter.post( '/updateMatStatus', isAllowedSessionHandler, authorize( {
+  userType: [ 'tango' ], access: [
+    { featureName: 'manage', name: 'tickets', permissions: [ 'isView' ] } ],
+} ), ticketExists, updateMatStatus );

package/src/routes/infra.routes.js

@@ -1,10 +1,11 @@
 
 import express from 'express';
-import { isAllowedSessionHandler, authorize } from 'tango-app-api-middleware';
+import { isAllowedSessionHandler, authorize, validate } from 'tango-app-api-middleware';
 import { validateDetails, bulkvalidateDetails, validateTicket, bulkvalidateTicket, validateTicketstatus, ticketExists, infraReasonExists, InfrastepstoResolve, InfraAlert } from '../validations/infra.validation.js';
 import { createTicket, bulkcreateTicket, updateStatus, createReason, PrimaryReasons, matTable,
-  secondaryReason, updateTicketIssue, viewTicket, AlertTicketReply, uploadAttachments,
+  secondaryReason, updateTicketIssue, viewTicket, AlertTicketReply, uploadAttachments, getInfraIssues,
   updateInstallationTicket, emailUserList, saveInfraEmailConfig, invoice, infraTable, storeFilter, assignTicket, installationTable } from '../controllers/infra.controllers.js';
+import { getInfraIssueValid } from '../dtos/infra.dtos.js';
 
 
 export const infraRouter = express.Router();
@@ -75,3 +76,8 @@ infraRouter.post( '/storeFilter', isAllowedSessionHandler, authorize( {
   userType: [ 'client', 'tango' ], access: [
     { featureName: 'manage', name: 'tickets', permissions: [ 'isView' ] } ],
 } ), storeFilter );
+infraRouter.post( '/get-infra-issues', isAllowedSessionHandler, authorize( {
+  userType: [ 'client', 'tango' ], access: [
+    { featureName: 'manage', name: 'tickets', permissions: [ 'isView' ] } ],
+} ), validate( getInfraIssueValid ), getInfraIssues );
+

package/src/services/camera.service.js

@@ -0,0 +1,5 @@
+import cameraModel from 'tango-api-schema/schema/camera.model.js';
+
+export async function aggregateCamera( query ) {
+  return await cameraModel.aggregate( query );
+}

package/src/validations/infra.validation.js

@@ -9,11 +9,11 @@ export async function validateDetails( req, res, next ) {
   try {
     let store = await findOneStore( { storeId: req.body.storeId } );
     if ( !store ) {
-      return res.sendError( 'Store Not Available' );
+      return res.sendError( 'Store Not Available', 500 );
     }
     let client = await findOneClient( { clientId: store.clientId } );
     if ( !client ) {
-      return res.sendError( 'Client Not Available' );
+      return res.sendError( 'Client Not Available', 500 );
     }
 
     if ( store.spocDetails && store.spocDetails.length > 0 ) {
@@ -186,7 +186,7 @@ export async function ticketExists( req, res, next ) {
     req.body.ticketActivity = Ticket.ticketActivity;
     req.body.status = Ticket.status;
     req.body.issueDate = Ticket.issueDate;
-
+    req.body.dataMismatch = Ticket.dataMismatch;
 
     next();
   } catch ( error ) {
@@ -202,8 +202,6 @@ export async function validateTicketstatus( req, res, next ) {
         if ( req.body.status == 'closed' ) {
           return res.sendSuccess( 'Ticket already closed' );
         }
-        console.log( req.body.ticketDetails );
-
         if ( req.body.ticketDetails.ticketType==='firsttimeticket'&&req.body.ticketDetails.issueStatus==='identified' ) {
           return res.sendSuccess( 'Ticket already Addressed' );
         }