tango-app-api-infra 3.1.5 → 3.1.7

package/index.js

@@ -5,6 +5,8 @@ import { internalInfraRouter } from './src/routes/internalInfra.routes.js';
 import { userInfraRouter } from './src/routes/userInfra.routes.js';
 import { storeInfraRouter } from './src/routes/storeInfra.routes.js';
 import { clientInfraRouter } from './src/routes/clientInfra.routes.js';
-export { infraRouter, internalInfraRouter, userInfraRouter, storeInfraRouter, clientInfraRouter };
+import { employeeTrainigRouter } from './src/routes/employeetrainig.routes.js';
+
+export { infraRouter, internalInfraRouter, userInfraRouter, storeInfraRouter, clientInfraRouter, employeeTrainigRouter };
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-infra",
-    "version": "3.1.5",
+    "version": "3.1.7",
     "description": "infra",
     "main": "index.js",
     "type": "module",
@@ -24,8 +24,8 @@
         "html-pdf-node": "^1.0.8",
         "mongodb": "^6.4.0",
         "nodemon": "^3.1.0",
-        "tango-api-schema": "^2.0.90",
-        "tango-app-api-middleware": "^3.1.3",
+        "tango-api-schema": "^2.0.93",
+        "tango-app-api-middleware": "^3.1.7",
         "winston": "^3.12.0",
         "winston-daily-rotate-file": "^5.0.0"
     },

package/src/controllers/clientInfra.controller.js

@@ -211,10 +211,10 @@ export async function installationCard( req, res ) {
       $group: {
         _id: '$ticketId',
         ticketId: { $first: '$ticketId' },
-        issueStatus: { $first: '$issueStatus' },
-        ticketType: { $first: '$ticketType' },
-        issueIdentifiedBy: { $first: '$issueIdentifiedBy' },
-        primaryIssue: { $first: '$primaryIssue' },
+        issueStatus: { $last: '$issueStatus' },
+        ticketType: { $last: '$ticketType' },
+        issueIdentifiedBy: { $last: '$issueIdentifiedBy' },
+        primaryIssue: { $last: '$primaryIssue' },
       },
     },
     ];
@@ -461,8 +461,8 @@ export async function InstallationIssuesTable( req, res ) {
           storeId: { $first: '$storeId' },
           clientId: { $first: '$clientId' },
           storeName: { $first: '$storeName' },
-          status: { $first: '$status' },
-          primaryIssue: { $first: '$primaryIssue' },
+          status: { $last: '$status' },
+          primaryIssue: { $last: '$primaryIssue' },
         },
       },
     ];

package/src/controllers/employeeTraning.controller.js

@@ -0,0 +1,54 @@
+
+import { createTangoTicket, findOneTangoTicket, updateOneTangoTicket } from '../services/tangoTicket.service.js';
+import { logger } from 'tango-app-api-middleware';
+export async function createTicket( req, res ) {
+  console.log( req.body );
+  try {
+    let ticketExist = await findOneTangoTicket( { 'issueType': req.body.issueType, 'basicDetails.storeId': req.body.storeId } );
+    if ( ticketExist ) {
+      return res.sendSuccess( 'MAT Ticket Already Exists for the store' );
+    }
+
+    req.body.issueDate = new Date( req.body.Date );
+    req.body.ticketId = 'TE_MAT_' + new Date().valueOf();
+    let create = await createTangoTicket( req.body );
+    console.log( create );
+    if ( create ) {
+      res.sendSuccess( 'Ticket Created Successfully' );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, function: 'createTicket mat' } );
+    return res.sendError( error, 500 );
+  }
+}
+
+export async function updatecomment( req, res ) {
+  console.log( req.body );
+  try {
+    if ( req.body.comment != '' ) {
+      req.body.ticketActivity.push( {
+        actionType: 'comment',
+        actionBy: 'Tango',
+        timeStamp: new Date(),
+        IdentifiedBy: req.user.userName,
+        comment: req.body.comment,
+      } );
+    }
+    let updateTicket = await updateOneTangoTicket( { ticketId: req.body.ticketId }, { ticketActivity: req.body.ticketActivity } );
+    if ( updateTicket ) {
+      res.sendSuccess( 'Ticket Updated  Successfully' );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, function: 'updatecomment mat' } );
+    return res.sendError( error, 500 );
+  }
+}
+export async function activityLog( req, res ) {
+  console.log( req.body );
+  try {
+    res.sendSuccess( req.body );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'activityLog mat' } );
+    return res.sendError( error, 500 );
+  }
+}

package/src/controllers/infra.controllers.js

@@ -1,9 +1,9 @@
 
 
-import { createTangoTicket, findOneTangoTicket, updateOneTangoTicket } from '../services/tangoTicket.service.js';
+import { aggregateTangoTicket, createTangoTicket, findOneTangoTicket, updateOneTangoTicket, updateManyTangoTicket, findTangoTicket } from '../services/tangoTicket.service.js';
 import { createinfraReason, findinfraReason } from '../services/infraReason.service.js';
 import { updateOneStore, findStore } from '../services/store.service.js';
-import { logger, fileUpload, signedUrl, sendEmailWithSES, getOpenSearchData, appConfig } from 'tango-app-api-middleware';
+import { logger, fileUpload, signedUrl, sendEmailWithSES, getOpenSearchData, download, appConfig, getUTC } from 'tango-app-api-middleware';
 import { aggregateUser, updateOneUser } from '../services/user.service.js';
 import { updateoneClient } from '../services/client.service.js';
 import dayjs from 'dayjs';
@@ -75,7 +75,7 @@ export async function createTicket( req, res ) {
     let Uidomain = `${appConfig.url.domain}/manage/stores/infra-ticket?storeId=${req.body.basicDetails.storeId}`;
 
     const html = htmlContent( { ...req.body, Uidomain: Uidomain, domain: appConfig.url.apiDomain, date: dayjs( req.body.issueDate ).format( 'YYYY-MM-DD' ), downtimetotal: downtimetotal, Timestamp: Timestamp } );
-    if ( req.body.emailAlert&&req.body.spocEmail&&req.body.issueType == 'infra'&&isValidEmail( req.body.spocEmail ) ) {
+    if ( req.body.emailAlert && req.body.spocEmail && req.body.issueType == 'infra' && isValidEmail( req.body.spocEmail ) ) {
       await sendEmailWithSES( req.body.spocEmail, subject, html, attachments, appConfig.cloud.aws.ses.adminEmail );
     }
     if ( create ) {
@@ -621,3 +621,666 @@ function inWords( num ) {
 
   return str.toLowerCase().split( ' ' ).map( ( word ) => word.charAt( 0 ).toUpperCase() + word.slice( 1 ) ).join( ' ' );
 }
+
+
+export async function infraTable( req, res ) {
+  try {
+    let query = [];
+    let date = await getUTC( new Date( req.body.fromDate ), new Date( req.body.toDate ) );
+    if ( req.body.clientId && req.body.clientId.length > 0 ) {
+      query.push( {
+        $match: {
+          'basicDetails.clientId': { $in: req.body.clientId },
+        },
+      } );
+    }
+    query.push( {
+      $match: {
+        $and: [
+          { issueType: 'infra' },
+          { createdAt: { $gte: date.start } },
+          { createdAt: { $lte: date.end } },
+        ],
+      },
+    }, {
+      $project: {
+        storeId: '$basicDetails.storeId',
+        clientId: '$basicDetails.clientId',
+        ticketId: 1,
+        storeName: '$basicDetails.storeName',
+        clientName: '$basicDetails.clientName',
+        status: 1,
+        createdAt: 1,
+        issueDate: 1,
+        addressingUser: { $toObjectId: '$ticketDetails.addressingUser' },
+        primaryIssue: {
+          $filter: {
+            input: '$ticketActivity',
+            as: 'item',
+            cond: { $eq: [ '$$item.actionType', 'issueUpdate' ] },
+          },
+        },
+      },
+    },
+    {
+      $unwind: {
+        path: '$primaryIssue', preserveNullAndEmptyArrays: true,
+      },
+    },
+    {
+      $unwind: {
+        path: '$primaryIssue.reasons', preserveNullAndEmptyArrays: true,
+      },
+    },
+    {
+      $unwind: {
+        path: '$primaryIssue.reasons.secondaryIssue', preserveNullAndEmptyArrays: true,
+      },
+    },
+    {
+      $project: {
+        storeId: 1,
+        clientId: 1,
+        storeName: 1,
+        clientName: 1,
+        createdAt: 1,
+        addressingUser: 1,
+        ticketId: 1,
+        issueDate: { $ifNull: [ '$issueDate', '' ] },
+        status: 1,
+        primaryIssue: { $ifNull: [ '$primaryIssue.reasons.primaryIssue', '-' ] },
+        secondaryIssue: { $ifNull: [ '$primaryIssue.reasons.secondaryIssue.name', '-' ] },
+      },
+    },
+    {
+      '$lookup': {
+        'from': 'users',
+        'let': { 'userId': '$addressingUser' },
+        'pipeline': [
+          {
+            '$match': {
+              '$expr': {
+                '$eq': [ '$_id', '$$userId' ],
+              },
+            },
+          },
+          {
+            '$project': {
+              'userName': 1,
+              'email': 1,
+              'role': 1,
+            },
+          },
+        ],
+        'as': 'user',
+      },
+    },
+
+    {
+      $unwind: {
+        path: '$user',
+        preserveNullAndEmptyArrays: true,
+      },
+    },
+    {
+      $group: {
+        _id: '$ticketId',
+        storeId: { $first: '$storeId' },
+        clientId: { $first: '$clientId' },
+        ticketId: { $first: '$ticketId' },
+        storeName: { $first: '$storeName' },
+        userName: { $first: { $ifNull: [ '$user.userName', '-' ] } },
+        userEmail: { $first: { $ifNull: [ '$user.email', '-' ] } },
+        clientName: { $first: '$clientName' },
+        createdAt: { $first: '$createdAt' },
+        issueDate: { $last: '$issueDate' },
+        status: { $last: '$status' },
+        primaryIssue: { $last: '$primaryIssue' },
+        secondaryIssue: { $last: '$secondaryIssue' },
+      },
+    },
+    );
+    if ( req.body.sortColumName && req.body.sortColumName !== '' && req.body.sortBy ) {
+      query.push( {
+        $sort: { [req.body.sortColumName]: req.body.sortBy },
+      } );
+    }
+    if ( req.body.storeIdFilter && req.body.storeIdFilter.length > 0 ) {
+      query.push( {
+        $match: {
+          storeId: { $in: req.body.storeIdFilter },
+        },
+      } );
+    }
+    if ( req.body.statusFilter && req.body.statusFilter.length > 0 ) {
+      query.push( {
+        $match: {
+          status: { $in: req.body.statusFilter },
+        },
+      } );
+    }
+    if ( req.body.userFilter && req.body.userFilter.length > 0 ) {
+      query.push( {
+        $match: {
+          userEmail: { $in: req.body.userFilter },
+        },
+      } );
+    }
+    let ticketList = await aggregateTangoTicket( query );
+    let issueList = await findinfraReason( { parentId: { '$exists': false } } );
+    const categoryCounts = {};
+    let response;
+    if ( ticketList.length > 0 ) {
+      ticketList.forEach( ( item ) => {
+        const categoryName = item.primaryIssue;
+        if ( categoryCounts[categoryName] ) {
+          categoryCounts[categoryName]++;
+        } else {
+          categoryCounts[categoryName] = 1;
+        }
+      } );
+      response = issueList.map( ( category ) => ( {
+        name: category.name,
+        count: categoryCounts[category.name] || 0,
+      } ) );
+    } else {
+      response = issueList.map( ( category ) => ( {
+        name: category.name,
+        count: 0,
+      } ) );
+    }
+    response.push( {
+      'name': 'total',
+      'count': ticketList.length,
+
+    } );
+    if ( req.body.filterIssue && req.body.filterIssue != '' && req.body.filterIssue != 'total' ) {
+      query.push( {
+        $match: {
+          primaryIssue: req.body.filterIssue,
+        },
+      } );
+    }
+
+    if ( req.body.searchValue && req.body.searchValue != '' ) {
+      query.push( {
+        $match: {
+          $or: [
+            { storeId: { $regex: req.body.searchValue, $options: 'i' } },
+            { storeName: { $regex: req.body.searchValue, $options: 'i' } },
+          ],
+        },
+      } );
+    }
+    let count = await aggregateTangoTicket( query );
+
+    if ( req.body.limit && req.body.offset && !req.body.export ) {
+      query.push(
+          { $skip: ( req.body.offset - 1 ) * req.body.limit },
+          { $limit: Number( req.body.limit ) },
+      );
+    }
+    let result = await aggregateTangoTicket( query );
+    if ( req.body.export && result.length > 0 ) {
+      const exportdata = [];
+      result.forEach( ( element ) => {
+        exportdata.push( {
+          'ticketId': element.ticketId,
+          'issueDate': 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.status,
+          'StatusDetails': element.primaryIssue,
+          'SubIssue': element.secondaryIssue,
+        } );
+      } );
+      await download( exportdata, res );
+      return;
+    }
+    if ( result.length > 0 ) {
+      res.sendSuccess( {
+        response: response,
+        count: count.length,
+        result: result,
+      } );
+    } else {
+      res.sendError( 'no data', 204 );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, function: 'infraTable' } );
+    return res.sendError( error, 500 );
+  }
+}
+export async function installationTable( req, res ) {
+  try {
+    let query = [];
+    let date = await getUTC( new Date( req.body.fromDate ), new Date( req.body.toDate ) );
+    if ( req.body.clientId && req.body.clientId.length > 0 ) {
+      query.push( {
+        $match: {
+          'basicDetails.clientId': { $in: req.body.clientId },
+        },
+      } );
+    }
+
+    query.push( {
+      $match: {
+        $and: [
+          { issueType: 'installation' },
+          { createdAt: { $gte: date.start } },
+          { createdAt: { $lte: date.end } },
+        ],
+      },
+    },
+    {
+      $project: {
+        storeId: '$basicDetails.storeId',
+        clientId: '$basicDetails.clientId',
+        ticketId: 1,
+        storeName: '$basicDetails.storeName',
+        clientName: '$basicDetails.clientName',
+        status: 1,
+        createdAt: 1,
+        addressingUser: '$ticketDetails.addressingUser',
+        installationStatus: '$ticketDetails.installationStatus',
+        issueDate: 1,
+        primaryIssue: {
+          $filter: {
+            input: '$ticketActivity',
+            as: 'item',
+            cond: { $eq: [ '$$item.actionType', 'issueUpdate' ] },
+          },
+        },
+      },
+    },
+    {
+      $unwind: {
+        path: '$primaryIssue', preserveNullAndEmptyArrays: true,
+      },
+    },
+    {
+      $unwind: {
+        path: '$primaryIssue.reasons', preserveNullAndEmptyArrays: true,
+      },
+    },
+    {
+      $unwind: {
+        path: '$primaryIssue.reasons.secondaryIssue', preserveNullAndEmptyArrays: true,
+      },
+    },
+    {
+      $project: {
+        storeId: 1,
+        clientId: 1,
+        storeName: 1,
+        clientName: 1,
+        createdAt: 1,
+        ticketId: 1,
+        addressingUser: 1,
+        installationStatus: { $ifNull: [ '$installationStatus', '-' ] },
+        issueDate: { $ifNull: [ '$issueDate', '' ] },
+        status: 1,
+        primaryIssue: { $ifNull: [ '$primaryIssue.reasons.primaryIssue', '-' ] },
+        secondaryIssue: { $ifNull: [ '$primaryIssue.reasons.secondaryIssue.name', '-' ] },
+      },
+    },
+    {
+      '$lookup': {
+        'from': 'users',
+        'let': { 'userId': '$addressingUser' },
+        'pipeline': [
+          {
+            '$match': {
+              '$expr': {
+                '$eq': [ '$_id', '$$userId' ],
+              },
+            },
+          },
+          {
+            '$project': {
+              'userName': 1,
+              'email': 1,
+              'role': 1,
+            },
+          },
+        ],
+        'as': 'user',
+      },
+    },
+
+    {
+      $unwind: {
+        path: '$user',
+        preserveNullAndEmptyArrays: true,
+      },
+    },
+    {
+      $group: {
+        _id: '$ticketId',
+        storeId: { $first: '$storeId' },
+        clientId: { $first: '$clientId' },
+        ticketId: { $first: '$ticketId' },
+        storeName: { $first: '$storeName' },
+        userName: { $first: { $ifNull: [ '$user.userName', '-' ] } },
+        userEmail: { $first: { $ifNull: [ '$user.email', '-' ] } },
+        clientName: { $first: '$clientName' },
+        createdAt: { $first: '$createdAt' },
+        issueDate: { $last: '$issueDate' },
+        installationStatus: { $last: '$installationStatus' },
+        status: { $last: '$status' },
+        primaryIssue: { $last: '$primaryIssue' },
+        secondaryIssue: { $last: '$secondaryIssue' },
+      },
+    },
+    );
+    if ( req.body.sortColumName && req.body.sortColumName !== '' && req.body.sortBy ) {
+      query.push( {
+        $sort: { [req.body.sortColumName]: req.body.sortBy },
+      } );
+    }
+    if ( req.body.storeIdFilter && req.body.storeIdFilter.length > 0 ) {
+      query.push( {
+        $match: {
+          storeId: { $in: req.body.storeIdFilter },
+        },
+      } );
+    }
+    if ( req.body.statusFilter && req.body.statusFilter.length > 0 ) {
+      query.push( {
+        $match: {
+          installationStatus: { $in: req.body.statusFilter },
+        },
+      } );
+    }
+    if ( req.body.userFilter && req.body.userFilter.length > 0 ) {
+      query.push( {
+        $match: {
+          userEmail: { $in: req.body.userFilter },
+        },
+      } );
+    }
+    let ticketList = await aggregateTangoTicket( query );
+    let issueList = await findinfraReason( { parentId: { '$exists': false } } );
+    const categoryCounts = {};
+    let response;
+    if ( ticketList.length > 0 ) {
+      ticketList.forEach( ( item ) => {
+        const categoryName = item.primaryIssue;
+        if ( categoryCounts[categoryName] ) {
+          categoryCounts[categoryName]++;
+        } else {
+          categoryCounts[categoryName] = 1;
+        }
+      } );
+      response = issueList.map( ( category ) => ( {
+        name: category.name,
+        count: categoryCounts[category.name] || 0,
+      } ) );
+    } else {
+      response = issueList.map( ( category ) => ( {
+        name: category.name,
+        count: 0,
+      } ) );
+    }
+    response.push( {
+      'name': 'total',
+      'count': ticketList.length,
+
+    } );
+    if ( req.body.filterIssue && req.body.filterIssue != '' && req.body.filterIssue != 'total' ) {
+      query.push( {
+        $match: {
+          primaryIssue: req.body.filterIssue,
+        },
+      } );
+    }
+    if ( req.body.searchValue && req.body.searchValue != '' ) {
+      query.push( {
+        $match: {
+          $or: [
+            { storeId: { $regex: req.body.searchValue, $options: 'i' } },
+            { storeName: { $regex: req.body.searchValue, $options: 'i' } },
+          ],
+        },
+      } );
+    }
+    let count = await aggregateTangoTicket( query );
+    if ( req.body.limit && req.body.offset && !req.body.export ) {
+      query.push(
+          { $skip: ( req.body.offset - 1 ) * req.body.limit },
+          { $limit: Number( req.body.limit ) },
+      );
+    }
+    let result = await aggregateTangoTicket( query );
+
+    if ( req.body.export && result.length > 0 ) {
+      const exportdata = [];
+      result.forEach( ( element ) => {
+        exportdata.push( {
+          'ticketId': element.ticketId,
+          'issueDate': 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,
+          'StatusDetails': element.primaryIssue,
+          'SubIssue': element.secondaryIssue,
+        } );
+      } );
+      await download( exportdata, res );
+      return;
+    }
+    if ( result.length > 0 ) {
+      res.sendSuccess( {
+        response: response,
+        count: count.length,
+        result: result,
+      } );
+    } else {
+      res.sendError( 'no data', 204 );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, function: 'installationTable' } );
+    return res.sendError( error, 500 );
+  }
+}
+export async function matTable( req, res ) {
+  try {
+    let query = [];
+    let date = await getUTC( new Date( req.body.fromDate ), new Date( req.body.toDate ) );
+    if ( req.body.clientId && req.body.clientId.length > 0 ) {
+      query.push( {
+        $match: {
+          'basicDetails.clientId': { $in: req.body.clientId },
+        },
+      } );
+    }
+
+    query.push( {
+      $match: {
+        $and: [
+          { issueType: 'mat' },
+          { createdAt: { $gte: date.start } },
+          { createdAt: { $lte: date.end } },
+        ],
+      },
+    },
+    {
+      $project: {
+        storeId: '$basicDetails.storeId',
+        clientId: '$basicDetails.clientId',
+        ticketId: 1,
+        storeName: '$basicDetails.storeName',
+        clientName: '$basicDetails.clientName',
+        status: 1,
+        createdAt: 1,
+        addressingUser: '$ticketDetails.addressingUser',
+        issueDate: 1,
+      },
+    },
+
+    {
+      '$lookup': {
+        'from': 'users',
+        'let': { 'userId': '$addressingUser' },
+        'pipeline': [
+          {
+            '$match': {
+              '$expr': {
+                '$eq': [ '$_id', '$$userId' ],
+              },
+            },
+          },
+          {
+            '$project': {
+              'userName': 1,
+              'email': 1,
+              'role': 1,
+            },
+          },
+        ],
+        'as': 'user',
+      },
+    },
+
+    {
+      $unwind: {
+        path: '$user',
+        preserveNullAndEmptyArrays: true,
+      },
+    },
+    {
+      $group: {
+        _id: '$ticketId',
+        storeId: { $first: '$storeId' },
+        clientId: { $first: '$clientId' },
+        ticketId: { $first: '$ticketId' },
+        storeName: { $first: '$storeName' },
+        userName: { $first: { $ifNull: [ '$user.userName', '-' ] } },
+        userEmail: { $first: { $ifNull: [ '$user.email', '-' ] } },
+        clientName: { $first: '$clientName' },
+        createdAt: { $first: '$createdAt' },
+        issueDate: { $last: '$issueDate' },
+        status: { $last: '$status' },
+      },
+    },
+    );
+    if ( req.body.sortColumName && req.body.sortColumName !== '' && req.body.sortBy ) {
+      query.push( {
+        $sort: { [req.body.sortColumName]: req.body.sortBy },
+      } );
+    }
+    if ( req.body.storeIdFilter && req.body.storeIdFilter.length > 0 ) {
+      query.push( {
+        $match: {
+          storeId: { $in: req.body.storeIdFilter },
+        },
+      } );
+    }
+    if ( req.body.statusFilter && req.body.statusFilter.length > 0 ) {
+      query.push( {
+        $match: {
+          status: { $in: req.body.statusFilter },
+        },
+      } );
+    }
+    if ( req.body.userFilter && req.body.userFilter.length > 0 ) {
+      query.push( {
+        $match: {
+          userEmail: { $in: req.body.userFilter },
+        },
+      } );
+    }
+
+    if ( req.body.filterIssue && req.body.filterIssue != '' && req.body.filterIssue != 'total' ) {
+      query.push( {
+        $match: {
+          primaryIssue: req.body.filterIssue,
+        },
+      } );
+    }
+    if ( req.body.searchValue && req.body.searchValue != '' ) {
+      query.push( {
+        $match: {
+          $or: [
+            { storeId: { $regex: req.body.searchValue, $options: 'i' } },
+            { storeName: { $regex: req.body.searchValue, $options: 'i' } },
+          ],
+        },
+      } );
+    }
+    let count = await aggregateTangoTicket( query );
+    if ( req.body.limit && req.body.offset && !req.body.export ) {
+      query.push(
+          { $skip: ( req.body.offset - 1 ) * req.body.limit },
+          { $limit: Number( req.body.limit ) },
+      );
+    }
+    let result = await aggregateTangoTicket( query );
+
+    if ( req.body.export && result.length > 0 ) {
+      const exportdata = [];
+      result.forEach( ( element ) => {
+        exportdata.push( {
+          'ticketId': element.ticketId,
+          'issueDate': 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,
+        } );
+      } );
+      await download( exportdata, res );
+      return;
+    }
+    if ( result.length > 0 ) {
+      res.sendSuccess( {
+        count: count.length,
+        result: result,
+      } );
+    } else {
+      res.sendError( 'no data', 204 );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, function: 'installationTable' } );
+    return res.sendError( error, 500 );
+  }
+}
+export async function assignTicket( req, res ) {
+  try {
+    let tickets = await updateManyTangoTicket( { ticketId: { $in: req.body.tickets } }, { 'ticketDetails.assigntoUser': true, 'ticketDetails.addressingUser': req.body.user } );
+    if ( tickets ) {
+      res.sendSuccess( 'Ticket Assigned Successfully' );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, function: 'assignTicket' } );
+    return res.sendError( error, 500 );
+  }
+}
+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 uniqueStoreIds = [ ...new Set( stores.map( ( store ) => store.basicDetails.storeId ) ) ];
+    const uniqueStoreObjects = uniqueStoreIds.map( ( storeId ) => ( { 'storeId': storeId } ) );
+
+    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

@@ -17,7 +17,7 @@ import { findOneGroup } from '../services/group.service.js';
 import { findinfraReason } from '../services/infraReason.service.js';
 import { findOneUser } from '../services/user.service.js';
 import xl from 'excel4node';
-
+import { findOneinfraReason } from '../services/infraReason.service.js';
 export async function migrateClient() {
   try {
     let oldclient = [];
@@ -123,7 +123,7 @@ export async function downStoresList( req, res ) {
 }
 export async function openTicketList( req, res ) {
   try {
-    let openTicketList = await findTangoTicket( { status: { $ne: 'closed' } }, { ticketId: 1, basicDetails: 1, createdAt: 1, updateAt: 1, ticketDetails: 1 } );
+    let openTicketList = await findTangoTicket( { 'issueType': 'infra', 'status': { $ne: 'closed' } }, { issueType: 1, ticketId: 1, basicDetails: 1, createdAt: 1, updateAt: 1, ticketDetails: 1 } );
     if ( openTicketList.length ) {
       res.sendSuccess( {
         count: openTicketList.length,
@@ -446,11 +446,11 @@ 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' );
-    };
+    // 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 query = [ {
       $match: {
         $and: [
@@ -697,14 +697,14 @@ export async function camAngleChangeReport( req, res ) {
         content: buffer,
         contentType: 'application/xlsx', // e.g., 'application/pdf'
       };
-      let subject =`Camera Angle Modified - ${formattedPreviousDay}`;
+      let subject = `Camera Angle Modified - ${formattedPreviousDay}`;
       let html = `<div>We wanted to inform you that the camera angle in your stores has been adjusted recently.</div>`;
       let result = await sendEmailWithSES( req.body.toMail, subject, html, attachments, appConfig.cloud.aws.ses.adminEmail );
       if ( result ) {
         res.sendSuccess( 'Email send successfully' );
       }
     } else {
-      res.sendSuccess( 'No changes' );
+      res.sendSuccess( 'No changes in camera Angle' );
     }
   } catch ( error ) {
     logger.error( { error: error, function: 'camAngleChangeList' } );
@@ -737,3 +737,329 @@ export async function download( data ) {
   }
   return await wb.writeToBuffer();
 }
+export async function edgeApplogsCheck( req, res ) {
+  try {
+    let finalresult= [];
+    let ticketList = await findTangoTicket( { 'issueDate': new Date( req.body.issueDate ), 'status': { $ne: 'closed' }, 'ticketDetails.issueStatus': 'notidentified', 'issueType': 'infra' } );
+    for ( let ticket of ticketList ) {
+      req.body.date = dayjs( ticket.createdAt ).format( 'YYYY-MM-DD' );
+      let errorLog = {
+        'size': 500,
+        'query': {
+          'bool': {
+            'must': [
+              {
+                'range': {
+                  'log_code': {
+                    'gte': 1000,
+                  },
+                },
+              },
+              {
+                'term': {
+                  'store_date.keyword': dayjs( ticket.createdAt ).format( 'DD-MM-YYYY' ),
+                },
+              },
+              {
+                'term': {
+                  'storeId.keyword': ticket.basicDetails.storeId,
+                },
+              },
+
+            ],
+
+          },
+        },
+        'sort': [
+          { 'timestamp': { 'order': 'desc' } },
+        ],
+      };
+      const errorLogList = await getOpenSearchData( 'edgeapp_systemlogs', errorLog );
+
+      let result = [];
+
+      for ( let error of errorLogList.body.hits.hits ) {
+        if ( error._source.log_code == '1003' ) {
+          let logCheck = {
+            code: error._source.log_code,
+            edgelog: error._source.data,
+          };
+          result.push( logCheck );
+        }
+        // if ( error._source.log_code == '1001' ) {
+        //   let logCheck = {
+        //     code: error._source.log_code,
+        //     edgelog: error._source.data,
+        //   };
+        //   result.push( logCheck );
+        // }
+
+        // if ( error._source.log_code == '1004' ) {
+        //   let logCheck = {
+        //     code: error._source.log_code,
+        //     edgelog: error._source.data,
+
+        //   };
+        //   result.push( logCheck );
+        // }
+        if ( error._source.log_code == '1005' ) {
+          const bytes = error._source.data.upload_Speed.split( '.' )[0];
+          const megabytes = bytesToMB( bytes );
+          if ( megabytes < 2 ) {
+            let logCheck = {
+              code: error._source.log_code,
+              edgelog: error._source.data,
+
+            };
+            result.push( logCheck );
+          }
+        }
+
+
+        if ( error._source.log_code == '1011' ) {
+          let logCheck = {
+            code: error._source.log_code,
+            edgelog: error._source.data,
+
+          };
+          result.push( logCheck );
+        }
+        if ( error._source.log_code == '1022' ) {
+          let logCheck = {
+            code: error._source.log_code,
+            edgelog: error._source.data,
+
+          };
+          result.push( logCheck );
+        }
+        if ( error._source.log_code == '1024' ) {
+          let logCheck = {
+            code: error._source.log_code,
+            edgelog: error._source.data,
+
+          };
+          result.push( logCheck );
+        }
+        if ( error._source.log_code == '1025' ) {
+          let logCheck = {
+            code: error._source.log_code,
+            edgelog: error._source.data,
+
+          };
+          result.push( logCheck );
+        }
+
+        if ( error._source.log_code == '1000' ) {
+          let logCheck = {
+            code: error._source.log_code,
+            edgelog: error._source.data,
+
+          };
+          result.push( logCheck );
+        }
+
+        if ( error._source.log_code == '1007' ) {
+          let logCheck = {
+            code: error._source.log_code,
+            edgelog: error._source.data,
+
+          };
+          result.push( logCheck );
+        }
+        if ( error._source.log_code == '1034' ) {
+          let logCheck = {
+            code: error._source.log_code,
+            edgelog: error._source.data,
+
+          };
+          result.push( logCheck );
+        }
+
+        if ( Number( error._source.log_code ) > 2000 ) {
+          let logCheck = {
+            code: error._source.log_code,
+            edgelog: error._source.data,
+          };
+          result.push( logCheck );
+        }
+      }
+      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 );
+            if ( isOccurringTimeEarlier ) {
+              findissueEdgeApp = {
+                ticketId: ticket.ticketId,
+                edgelog: findissue,
+                storeId: ticket.basicDetails.storeId,
+                primary: 'System Issues',
+                secondary: [ 'Malware or Viruses' ],
+              };
+              updateIssue( findissueEdgeApp );
+              finalresult.push( findissueEdgeApp );
+            // console.log( findissueEdgeApp );
+            }
+          } else if ( findissue.code == '1024' ) {
+            const occurringTimeParsed = dayjs( `${req.body.date} ${findissue.edgelog.data.occuringTime}` );
+            const ticketCreatedParsed = dayjs( `${req.body.date} ${istTimestamp}` );
+            const isOccurringTimeEarlier = occurringTimeParsed.isBefore( ticketCreatedParsed );
+
+            const existsInArray = finalresult.some( ( item ) =>
+              item.ticketId === ticket.ticketId,
+            );
+            if ( isOccurringTimeEarlier&&!existsInArray ) {
+              findissueEdgeApp = {
+                ticketId: ticket.ticketId,
+                storeId: ticket.basicDetails.storeId,
+                edgelog: findissue.edgelog.data,
+                primary: 'Camera Issues',
+                secondary: [ 'Camera Not working/RTSP port not working' ],
+              };
+              updateIssue( findissueEdgeApp );
+              finalresult.push( findissueEdgeApp );
+            }
+          } else if ( findissue.code == '1011' ) {
+            const occurringTimeParsed = dayjs( `${req.body.date} ${findissue.edgelog.occuringTime}` );
+            const ticketCreatedParsed = dayjs( `${req.body.date} ${istTimestamp}` );
+            const isOccurringTimeEarlier = occurringTimeParsed.isBefore( ticketCreatedParsed );
+
+            if ( isOccurringTimeEarlier ) {
+              findissueEdgeApp = {
+                ticketId: ticket.ticketId,
+                edgelog: findissue,
+                storeId: ticket.basicDetails.storeId,
+                primary: 'System Issues',
+                secondary: [ 'System is in Sleep Mode' ],
+              };
+              updateIssue( findissueEdgeApp );
+              finalresult.push( findissueEdgeApp );
+            // console.log( findissueEdgeApp );
+            }
+          } else if ( findissue.code ==='1005' ) {
+            const occurringTimeParsed = dayjs( `${req.body.date} ${findissue.edgelog.occuringTime}` );
+            const ticketCreatedParsed = dayjs( `${req.body.date} ${istTimestamp}` );
+            const isOccurringTimeEarlier = occurringTimeParsed.isBefore( ticketCreatedParsed );
+            if ( isOccurringTimeEarlier ) {
+              findissueEdgeApp = {
+                ticketId: ticket.ticketId,
+                edgelog: findissue,
+                storeId: ticket.basicDetails.storeId,
+                primary: 'Internet Issues',
+                secondary: [ 'Slow Internet Speed' ],
+              };
+              updateIssue( findissueEdgeApp );
+              finalresult.push( findissueEdgeApp );
+            // console.log( findissueEdgeApp );
+            }
+          }
+        }
+      }
+    }
+    res.sendSuccess( { count: finalresult.length, result: finalresult } );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'camAngleChangeList' } );
+    res.sendError( error, 500 );
+  }
+}
+function bytesToMB( bytes ) {
+  return bytes / ( 1024 * 1024 );
+}
+
+export async function updateIssue( data ) {
+  try {
+    let Ticket = await findOneTangoTicket(
+        {
+          ticketId: data.ticketId,
+        },
+    );
+
+    data.issueType = Ticket.issueType;
+    data.basicDetails = Ticket.basicDetails;
+    data.ticketDetails = Ticket.ticketDetails;
+    data.ticketActivity = Ticket.ticketActivity;
+    if ( data.primary && data.secondary && data.secondary.length ) {
+      let primaryReason = await findOneinfraReason( { name: data.primary } );
+      if ( !primaryReason ) {
+        return res.sendError( 'Primary Reason Not exists in database', 500 );
+      }
+      const secondary = [];
+      const steptoReslove = [];
+      for ( let i = 0; i < data.secondary.length; i++ ) {
+        let secondaryReason = await findOneinfraReason( { name: data.secondary[i] } );
+        if ( !secondaryReason ) {
+          return res.sendError( `secondary Reason - ${data.secondary[i]} Not exists in database`, 500 );
+        }
+        secondary.push( {
+          name: secondaryReason.name,
+        } );
+        let resolveSteps = [];
+        for ( let i = 0; i < secondaryReason.stepstoResolve.length; i++ ) {
+          resolveSteps.push( {
+            name: secondaryReason.stepstoResolve[i].name,
+          } );
+        }
+        steptoReslove.push( {
+          primaryIssue: secondaryReason.name,
+          secondaryIsssue: [ ...resolveSteps ],
+        } );
+      }
+
+      data.ticketActivity.push( {
+        actionType: 'issueUpdate',
+        actionBy: 'automated',
+        IdentifiedBy: 'Tango',
+        timeStamp: new Date(),
+        reasons: [ {
+          primaryIssue: primaryReason.name,
+          secondaryIssue: secondary,
+        } ],
+      },
+      );
+    } else {
+      if ( data.primary == 'Application Issues' ) {
+        data.ticketActivity.push( {
+          actionType: 'issueUpdate',
+          actionBy: 'automated',
+          timeStamp: new Date(),
+          IdentifiedBy: 'Tango',
+          reasons: [ {
+            primaryIssue: data.primary,
+            secondaryIssue: [],
+          } ],
+        },
+        );
+      }
+    }
+    if ( data.issueType == 'infra' ) {
+      let client = await findOneClient( { clientId: data.basicDetails.clientId }, { ticketConfigs: 1 } );
+      let statusCheckAlertTime = dayjs().add( client.ticketConfigs.statusCheckAlert, 'hours' ).format( 'YYYY-MM-DD hh:mm' );
+      data.ticketActivity.push( {
+        actionType: 'statusCheck',
+        timeStamp: statusCheckAlertTime,
+        actionBy: 'Tango',
+        IdentifiedBy: 'Tango',
+        timeStamp: new Date(),
+        statusCheckAlertTime: statusCheckAlertTime,
+      } );
+    }
+    let query = {
+      'ticketActivity': data.ticketActivity,
+      'ticketDetails.issueIdentifiedDate': new Date(),
+      'ticketDetails.issueStatus': 'identified',
+      '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

@@ -330,6 +330,7 @@ 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;
@@ -337,7 +338,7 @@ export async function edgeAppLogTable( req, res ) {
         const average = sum / streamwiseDowntime.length;
         obj.downtime = Math.round( average );
       } else {
-        obj.downtime = 0;
+        obj.downtime ='';
       }
       let appStatusQuery = {
         'size': 1,

package/src/controllers/userInfra.controller.js

@@ -71,6 +71,15 @@ export async function userTakeTicket( req, res ) {
         }
         userTicket = await findOneTangoTicket( query );
       }
+    } else if ( req.body.issueType == 'mat' ) {
+      let query = {
+        'status': { $ne: 'closed' },
+        'issueType': 'mat',
+      };
+      if ( assignedClients.length > 0 ) {
+        query =( { ...query, ...{ 'basicDetails.clientId': { $in: assignedClients } } } );
+      }
+      userTicket = await findOneTangoTicket( query );
     }
     if ( userTicket ) {
       let assignTicket = await updateOneTangoTicket( { ticketId: userTicket.ticketId }, { 'ticketDetails.addressingUser': req.body.userId } );
@@ -202,6 +211,7 @@ export async function userTicketList( req, res ) {
       } );
     }
     let ticketList = await aggregateTangoTicket( query );
+    console.log( ticketList );
     if ( req.body.export ) {
       const exportdata = [];
       ticketList.forEach( ( element ) => {
@@ -437,16 +447,16 @@ export async function workHistory( req, res ) {
       const exportdata = [];
       result.forEach( ( element ) => {
         exportdata.push( {
-          'CREATED ON': element.createdAt,
+          '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,
-          'CREATED STATUS': element.status,
           'ISSUE IDENTIFIED DATE': element.issueIdentifiedDate,
           'CLOSED ON': element.issueClosedDate,
-          'STATUS': element.status,
+          'ISSUE': element.infraIssue?element.infraIssue:'-',
+
         } );
       } );
       await download( exportdata, res );
@@ -591,7 +601,7 @@ export async function storeInfraList( req, res ) {
       if ( installationcheck ) {
         store.ticketId = installationcheck.ticketId;
         store.status = installationcheck.ticketDetails.installationStatus;
-        if ( store.status === 'onboareded' ) {
+        if ( store.status === 'onboarded' ) {
           store.statusDetail = 'Ready to pair';
         }
         if ( store.status === 'paired' ) {

package/src/routes/employeetrainig.routes.js

@@ -0,0 +1,17 @@
+import { createTicket, updatecomment, activityLog } 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';
+export const employeeTrainigRouter = express.Router();
+
+
+employeeTrainigRouter.post( '/createTicket', validateDetails, createTicket );
+employeeTrainigRouter.post( '/updatecomment', isAllowedSessionHandler, authorize( {
+  userType: [ 'tango' ], access: [
+    { featureName: 'manage', name: 'tickets', permissions: [ 'isEdit' ] } ],
+} ), ticketExists, updatecomment );
+
+employeeTrainigRouter.post( '/activityLog', isAllowedSessionHandler, authorize( {
+  userType: [ 'tango' ], access: [
+    { featureName: 'manage', name: 'tickets', permissions: [ 'isView' ] } ],
+} ), ticketExists, activityLog );

package/src/routes/infra.routes.js

@@ -2,9 +2,9 @@
 import express from 'express';
 import { isAllowedSessionHandler, authorize } from 'tango-app-api-middleware';
 import { validateDetails, bulkvalidateDetails, validateTicket, bulkvalidateTicket, ticketExists, infraReasonExists, InfrastepstoResolve, InfraAlert } from '../validations/infra.validation.js';
-import { createTicket, bulkcreateTicket, updateStatus, createReason, PrimaryReasons,
+import { createTicket, bulkcreateTicket, updateStatus, createReason, PrimaryReasons, matTable,
   secondaryReason, updateTicketIssue, viewTicket, AlertTicketReply, uploadAttachments,
-  updateInstallationTicket, emailUserList, saveInfraEmailConfig, invoice } from '../controllers/infra.controllers.js';
+  updateInstallationTicket, emailUserList, saveInfraEmailConfig, invoice, infraTable, storeFilter, assignTicket, installationTable } from '../controllers/infra.controllers.js';
 
 
 export const infraRouter = express.Router();
@@ -55,3 +55,23 @@ infraRouter.post( '/saveInfraEmailConfig', isAllowedSessionHandler, authorize( {
     { featureName: 'settings', name: 'configuration', permissions: [ 'isEdit', 'isView' ] } ],
 } ), saveInfraEmailConfig );
 infraRouter.post( '/invoice', invoice );
+infraRouter.post( '/infraTable', isAllowedSessionHandler, authorize( {
+  userType: [ 'client', 'tango' ], access: [
+    { featureName: 'manage', name: 'tickets', permissions: [ 'isView' ] } ],
+} ), infraTable );
+infraRouter.post( '/installationTable', isAllowedSessionHandler, authorize( {
+  userType: [ 'client', 'tango' ], access: [
+    { featureName: 'manage', name: 'tickets', permissions: [ 'isView' ] } ],
+} ), installationTable );
+infraRouter.post( '/matTable', isAllowedSessionHandler, authorize( {
+  userType: [ 'client', 'tango' ], access: [
+    { featureName: 'manage', name: 'tickets', permissions: [ 'isView' ] } ],
+} ), matTable );
+infraRouter.post( '/assignTicket', isAllowedSessionHandler, authorize( {
+  userType: [ 'client', 'tango' ], access: [
+    { featureName: 'manage', name: 'tickets', permissions: [ 'isEdit', 'isView' ] } ],
+} ), assignTicket );
+infraRouter.post( '/storeFilter', isAllowedSessionHandler, authorize( {
+  userType: [ 'client', 'tango' ], access: [
+    { featureName: 'manage', name: 'tickets', permissions: [ 'isView' ] } ],
+} ), storeFilter );

package/src/routes/internalInfra.routes.js

@@ -2,7 +2,7 @@
 import express from 'express';
 import {
   migrateClient, migrateStores, basicList, clientList, setTicketTime, downStoresList,
-  openTicketList, assigntoUser, updateRefreshTicket, closeTicket, camAngleChangeReport, spocmailchange, emailUserList, infraReportSent,
+  openTicketList, assigntoUser, updateRefreshTicket, closeTicket, edgeApplogsCheck, camAngleChangeReport, spocmailchange, emailUserList, infraReportSent,
 } from '../controllers/internalInfra.controller.js';
 
 export const internalInfraRouter = express.Router();
@@ -21,5 +21,6 @@ internalInfraRouter.get( '/emailUserList', emailUserList );
 internalInfraRouter.post( '/infraReportSent', infraReportSent );
 internalInfraRouter.post( '/spocmailchange', spocmailchange );
 internalInfraRouter.post( '/camAngleChangeReport', camAngleChangeReport );
+internalInfraRouter.post( '/edgeApplogsCheck', edgeApplogsCheck );
 
 

package/src/services/tangoTicket.service.js

@@ -13,6 +13,9 @@ export async function findOneTangoTicket( query, project ) {
 export async function updateOneTangoTicket( query, data ) {
   return await dataModel.tangoTicketModel.updateOne( query, { $set: data } );
 }
+export async function updateManyTangoTicket( query, data ) {
+  return await dataModel.tangoTicketModel.updateMany( query, { $set: data } );
+}
 export async function countDocumentsTangoTicket( query, data ) {
   return await dataModel.tangoTicketModel.countDocuments( query );
 }

package/src/validations/infra.validation.js

@@ -325,7 +325,6 @@ export async function InfraAlert( req, res, next ) {
       await updateOneStore( { storeId: req.body.basicDetails.storeId }, { 'ticketConfigs.hibernation': new Date( req.body.hibernationDays ) } );
 
       await updateOneTangoTicket( { ticketId: req.body.ticketId }, { 'hibernation': new Date( req.body.hibernationDays ) } );
-      console.log( req.body.ticketActivity );
     } else {
       if ( req.body.issueType == 'infra' ) {
         let client = await findOneClient( { clientId: req.body.basicDetails.clientId }, { ticketConfigs: 1 } );