tango-app-api-infra 3.0.12 → 3.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-infra",
-    "version": "3.0.12",
+    "version": "3.0.14",
     "description": "infra",
     "main": "index.js",
     "type": "module",
@@ -20,8 +20,8 @@
         "handlebars": "^4.7.8",
         "mongodb": "^6.4.0",
         "nodemon": "^3.1.0",
-        "tango-api-schema": "^2.0.33",
-        "tango-app-api-middleware": "^1.0.18",
+        "tango-api-schema": "^2.0.39",
+        "tango-app-api-middleware": "^1.0.21",
         "winston": "^3.12.0",
         "winston-daily-rotate-file": "^5.0.0"
     },

package/src/controllers/clientInfra.controller.js

@@ -13,8 +13,13 @@ export async function infraCard( req, res ) {
     let infraStoreCount = await aggregateTangoTicket( [
       {
         $match: {
-          'status': { $ne: 'closed' },
-          'basicDetails.clientId': { $in: req.body.clientId },
+          $and: [
+            { issueType: 'infra' },
+            { 'status': { $ne: 'closed' } },
+            { 'basicDetails.clientId': { $in: req.body.clientId } },
+            { createdAt: { $gte: new Date( req.body.fromDate ) } },
+            { createdAt: { $lte: new Date( req.body.toDate ) } },
+          ],
         },
       },
       {
@@ -42,8 +47,14 @@ export async function infraCard( req, res ) {
     ] );
     let query = [ {
       $match: {
-        'basicDetails.clientId': { $in: req.body.clientId },
-        'infraTicketDetails.issueStatus': 'identified',
+        $and: [
+          { issueType: 'infra' },
+          { 'status': { $ne: 'closed' } },
+          { 'basicDetails.clientId': { $in: req.body.clientId } },
+          { 'infraTicketDetails.issueStatus': 'identified' },
+          { createdAt: { $gte: new Date( req.body.fromDate ) } },
+          { createdAt: { $lte: new Date( req.body.toDate ) } },
+        ],
       },
     },
     {
@@ -115,12 +126,18 @@ export async function infraCard( req, res ) {
   }
 }
 
-
 export async function infraIssuesTable( req, res ) {
   try {
     let query = [ {
       $match: {
-        'basicDetails.clientId': { $in: req.body.clientId },
+        $and: [
+          { issueType: 'infra' },
+          { status: { $ne: 'closed' } },
+          { 'basicDetails.clientId': { $in: req.body.clientId } },
+          { 'infraTicketDetails.issueStatus': 'identified' },
+          { createdAt: { $gte: new Date( req.body.fromDate ) } },
+          { createdAt: { $lte: new Date( req.body.toDate ) } },
+        ],
       },
     },
     {
@@ -149,7 +166,13 @@ export async function infraIssuesTable( req, res ) {
       $unwind: {
         path: '$primaryIssue.reasons', preserveNullAndEmptyArrays: true,
       },
-    }, {
+    },
+    {
+      $unwind: {
+        path: '$primaryIssue.reasons.secondaryIssue', preserveNullAndEmptyArrays: true,
+      },
+    },
+    {
       $project: {
         storeId: 1,
         storeName: 1,
@@ -157,9 +180,45 @@ export async function infraIssuesTable( req, res ) {
         issueIdentifiedDate: { $ifNull: [ '$issueIdentifiedDate', '-' ] },
         issueClosedDate: { $ifNull: [ '$issueClosedDate', '-' ] },
         status: 1,
-        infraIssue: { $ifNull: [ '$primaryIssue.reasons.primaryIssue', '-' ] },
+        primaryIssue: { $ifNull: [ '$primaryIssue.reasons.primaryIssue', '-' ] },
+        secondaryIssue: { $ifNull: [ '$primaryIssue.reasons.secondaryIssue.name', '-' ] },
+      },
+    },
+    {
+      $group: {
+        _id: '$storeId',
+        storeName: { $first: '$storeName' },
+        createdAt: { $first: '$createdAt' },
+        issueIdentifiedDate: { $first: '$issueIdentifiedDate' },
+        issueClosedDate: { $first: '$issueClosedDate' },
+        status: { $first: '$status' },
+        primaryIssue: { $first: '$primaryIssue' },
+        secondaryIssue: { $first: '$secondaryIssue' },
       },
-    } ];
+    },
+    ];
+    if ( req.body.filterIssue && req.body.filterIssue !== '' ) {
+      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' } },
+          ],
+        },
+      } );
+    }
+    if ( req.body.sortColumName && req.body.sortColumName !== '' && req.body.sortBy ) {
+      query.push( {
+        $sort: { [req.body.sortColumName]: req.body.sortBy },
+      } );
+    }
     let count = await aggregateTangoTicket( query );
     if ( req.body.limit && req.body.offset && !req.body.export ) {
       query.push(
@@ -168,17 +227,112 @@ export async function infraIssuesTable( req, res ) {
       );
     }
     let result = await aggregateTangoTicket( query );
+    if ( req.body.export ) {
+      const exportdata = [];
+      result.forEach( ( element ) => {
+        exportdata.push( {
+          'STORE ID': element.storeId,
+          'STORE NAME': element.storeName,
+          'STATUS': element.status,
+          'CITY': element.city,
+          'STATE': element.state,
+          'COUNTRY': element.country,
+          'SPOC EMAIL': element.spocEmail,
+          'SPOC CONTACT': element.spocContact,
+          'DOWNTIME': element.downTime,
+          'STATUS DETAIL': element.statusDetail,
+        } );
+      } );
+      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: 'infraIssuesTable' } );
+    return res.sendError( error, 500 );
+  }
+}
+export async function InstallationIssuesTable( req, res ) {
+  try {
+    let query = [
+      {
+        $match: {
+          $and: [
+            { issueType: 'installation' },
+            { 'basicDetails.clientId': { $in: req.body.clientId } },
+            { createdAt: { $gte: new Date( req.body.fromDate ) } },
+            // { createdAt: { $lte: new Date( req.body.toDate ) } },
+          ],
+        },
+      },
+      {
+        $project: {
+          createdAt: 1,
+          clientName: '$basicDetails.clientName',
+          storeId: '$basicDetails.storeId',
+          storeName: '$basicDetails.storeName',
+          status: '$basicDetails.status',
+        },
+      },
+    ];
+    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' } },
+            { clientName: { $regex: req.body.searchValue, $options: 'i' } },
+            { status: { $regex: req.body.searchValue, $options: 'i' } },
+          ],
+        },
+      } );
+    }
+    if ( req.body.sortColumName && req.body.sortColumName !== '' && req.body.sortBy ) {
+      query.push( {
+        $sort: { [req.body.sortColumName]: req.body.sortBy },
+      } );
+    }
+    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 storesList = await aggregateTangoTicket( query );
+    if ( storesList.length == 0 ) {
+      return res.sendError( 'no data', 204 );
+    }
+    if ( req.body.export ) {
+      const exportdata = [];
+      infrastoreList.forEach( ( element ) => {
+        exportdata.push( {
+          'CLIENT NAME': element.clientName,
+          'STORE ID': element.storeId,
+          'STORE NAME': element.storeName,
+          'STATUS': element.status,
+        } );
+      } );
+      await download( exportdata, res );
+      return;
+    }
     res.sendSuccess( {
       count: count.length,
-      result: result,
+      result: storesList,
     } );
   } catch ( error ) {
-    logger.error( { error: error, function: 'infraIssuesTable' } );
+    logger.error( { error: error, function: 'InstallationIssuesTable' } );
     return res.sendError( error, 500 );
   }
 }
 
-
 export async function hourWiseDownClients( req, res ) {
   try {
     let inputData = req.body;

package/src/controllers/infra.controllers.js

@@ -24,16 +24,8 @@ export async function createTicket( req, res ) {
   }
 }
 
-
 export async function updateStatus( req, res ) {
   try {
-    if ( req.body.status == 'closed' ) {
-      req.body.issueClosedDate = new Date();
-      req.body.infraActivity.push( {
-        actionType: 'dataRecived',
-        actionBy: 'Tango',
-      } );
-    }
     if ( req.body.status == 'inprogress' ) {
       req.body.infraActivity.push( {
         actionType: 'statusChange',
@@ -68,7 +60,7 @@ export async function PrimaryReasons( req, res ) {
   try {
     let list = await findinfraReason( { parentId: { $exists: false } }, { name: 1, order: 1 } );
     if ( list.length > 0 ) {
-      res.send( {
+      res.sendSuccess( {
         count: list.length,
         result: list,
       } );
@@ -120,3 +112,17 @@ export async function viewTicket( req, res ) {
     return res.sendError( error, 500 );
   }
 }
+export async function AlertTicketReply( req, res ) {
+  try {
+    req.body.infraActivity = req.body.infraActivity.filter( ( data ) => data.action !='statusCheck' );
+    req.body.infraActivity.push( {
+      actionType: 'statusCheckReply',
+      actionBy: 'Tango',
+      statusCheckReply: req.body.statusCheckReply,
+      hibernationDays: req.body.hibernationDays,
+    } );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'AlertTicketReply' } );
+    return res.sendError( error, 500 );
+  }
+}

package/src/controllers/internalInfra.controller.js

@@ -3,7 +3,7 @@ import { logger } from 'tango-app-api-middleware';
 import dayjs from 'dayjs';
 import { createClient, findClient } from '../services/client.service.js';
 import { createStore, findStore, updateOneStore } from '../services/store.service.js';
-import { findTangoTicket, updateOneTangoTicket } from '../services/tangoTicket.service.js';
+import { findTangoTicket, findOneTangoTicket, updateOneTangoTicket } from '../services/tangoTicket.service.js';
 
 
 export async function migrateClient() {
@@ -51,8 +51,6 @@ export async function migrateStores() {
           close: oldstores[i].configuration.storeCloseTime,
           timeZone: oldstores[i].timezone,
         },
-
-
       };
 
       await createStore( framedStores );
@@ -116,7 +114,7 @@ export async function openTicketList( req, res ) {
   try {
     let openTicketList = await findTangoTicket( { status: { $ne: 'closed' } }, { ticketId: 1, basicDetails: 1, createdAt: 1, updateAt: 1, infraTicketDetails: 1 } );
     if ( openTicketList.length ) {
-      res.send( {
+      res.sendSuccess( {
         count: openTicketList.length,
         data: openTicketList,
       } );
@@ -147,3 +145,27 @@ export async function updateRefreshTicket( req, res ) {
     res.sendError( error, 500 );
   }
 }
+export async function closeTicket( req, res ) {
+  try {
+    for ( let ticket of req.body.TicketList ) {
+      let getTicket = await findOneTangoTicket( { ticketId: ticket.ticketId } );
+      if ( ticket.status == 'closed' ) {
+        getTicket.infraActivity.push( {
+          actionType: 'dataRecived',
+          actionBy: 'Tango',
+        } );
+      }
+      await updateOneTangoTicket( { ticketId: ticket.ticketId },
+          {
+            status: ticket.status,
+            infraActivity: getTicket.infraActivity,
+            issueClosedDate: new Date(),
+          },
+      );
+    }
+    res.sendSuccess( 'updated Successfully' );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'closeTicket' } );
+    res.sendError( error, 500 );
+  }
+}

package/src/controllers/userInfra.controller.js

@@ -1,7 +1,9 @@
 
 import { findOneTangoTicket, updateOneTangoTicket, aggregateTangoTicket, countDocumentsTangoTicket } from '../services/tangoTicket.service.js';
-import { logger } from 'tango-app-api-middleware';
+import { logger, download } from 'tango-app-api-middleware';
 import { findOneUser } from '../services/user.service.js';
+import { aggregateStore } from '../services/store.service.js';
+
 import mongoose from 'mongoose';
 
 export async function userTakeTicket( req, res ) {
@@ -24,11 +26,34 @@ export async function userTicketList( req, res ) {
   try {
     let query = [ {
       $match: {
-        'status': req.body.status,
-        'infraTicketDetails.addressingUser': new mongoose.Types.ObjectId( req.body.userId ),
+        $and: [
+          { 'status': req.body.status },
+          { 'infraTicketDetails.addressingUser': new mongoose.Types.ObjectId( req.body.userId ) },
+        ],
       },
-    },
-    {
+    } ];
+
+    if ( req.body.status != 'closed' ) {
+      query.push( {
+        $match: {
+          $and: [
+            { createdAt: { $gte: new Date( req.body.fromDate ) } },
+            { createdAt: { $lte: new Date( req.body.toDate ) } },
+          ],
+        },
+      } );
+    } else {
+      query.push( {
+        $match: {
+          $and: [
+            { createdAt: { $gte: new Date() } },
+          ],
+        },
+      } );
+    }
+
+
+    query.push( {
       $project: {
         storeId: '$basicDetails.storeId',
         Date: { $dateToString: { format: '%d-%m-%Y', date: '$issueDate' } },
@@ -62,7 +87,7 @@ export async function userTicketList( req, res ) {
         ticketType: 1,
         infraIssue: '$primaryIssue.reasons.primaryIssue',
       },
-    } ];
+    } );
     let ticketList = await aggregateTangoTicket( query );
     if ( ticketList.length ) {
       res.sendSuccess( {
@@ -106,8 +131,12 @@ export async function workHistory( req, res ) {
   try {
     let query = [ {
       $match: {
-        'status': 'closed',
-        'infraTicketDetails.addressingUser': new mongoose.Types.ObjectId( req.body.userId ),
+        $and: [
+          { 'status': 'closed' },
+          { 'infraTicketDetails.addressingUser': new mongoose.Types.ObjectId( req.body.userId ) },
+          { createdAt: { $gte: new Date( req.body.fromDate ) } },
+          { createdAt: { $lte: new Date( req.body.toDate ) } },
+        ],
       },
     },
     {
@@ -118,6 +147,7 @@ export async function workHistory( req, res ) {
         clientName: '$basicDetails.clientName',
         issueDate: { $dateToString: { format: '%d-%m-%Y', date: '$issueDate' } },
         issueClosedDate: { $dateToString: { format: '%d-%m-%Y', date: '$issueClosedDate' } },
+        issueIdentifiedDate: { $dateToString: { format: '%d-%m-%Y', date: '$infraTicketDetails.issueIdentifiedDate' } },
         ticketId: 1,
         issueStatus: '$infraTicketDetails.issueStatus',
         ticketType: '$infraTicketDetails.ticketType',
@@ -146,6 +176,7 @@ export async function workHistory( req, res ) {
         clientId: 1,
         clientName: 1,
         issueDate: 1,
+        issueIdentifiedDate: 1,
         issueClosedDate: 1,
         ticketId: 1,
         issueStatus: 1,
@@ -153,6 +184,25 @@ export async function workHistory( req, res ) {
         infraIssue: { $ifNull: [ '$primaryIssue.reasons.primaryIssue', '' ] },
       },
     } ];
+    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' } },
+            { clientId: { $regex: req.body.searchValue, $options: 'i' } },
+            { clientName: { $regex: req.body.searchValue, $options: 'i' } },
+            { ticketId: { $regex: req.body.searchValue, $options: 'i' } },
+            { infraIssue: { $regex: req.body.searchValue, $options: 'i' } },
+          ],
+        },
+      } );
+    }
+    if ( req.body.sortColumName && req.body.sortColumName !== '' && req.body.sortBy ) {
+      query.push( {
+        $sort: { [req.body.sortColumName]: req.body.sortBy },
+      } );
+    }
     let count = await aggregateTangoTicket( query );
     if ( req.body.limit && req.body.offset && !req.body.export ) {
       query.push(
@@ -161,6 +211,28 @@ export async function workHistory( req, res ) {
       );
     }
     let result = await aggregateTangoTicket( query );
+    if ( req.body.export ) {
+      const exportdata = [];
+      result.forEach( ( element ) => {
+        exportdata.push( {
+          'CREATED ON': element.createdAt,
+          '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,
+        } );
+      } );
+      await download( exportdata, res );
+      return;
+    }
+    if ( result.length == 0 ) {
+      return res.sendError( 'no data', 204 );
+    }
     res.sendSuccess( {
       count: count.length,
       result: result,
@@ -171,3 +243,115 @@ export async function workHistory( req, res ) {
   }
 }
 
+
+export async function storeInfraList( req, res ) {
+  try {
+    let query = [
+      {
+        $match: {
+          $and: [
+            { clientId: { $in: req.body.clientId } },
+            { createdAt: { $lte: new Date( req.body.toDate ) } },
+          ],
+        },
+      },
+      {
+        $project: {
+          storeId: 1,
+          storeName: 1,
+          storeProfile: 1,
+          status: 1,
+          spocDetails: 1,
+        },
+      },
+      {
+        $unwind: {
+          path: '$spocDetails', preserveNullAndEmptyArrays: true,
+        },
+      },
+      {
+        $group: {
+          _id: '$storeId',
+          storeId: { $first: '$storeId' },
+          storeName: { $first: '$storeName' },
+          status: { $first: '$status' },
+          city: { $first: '$storeProfile.city' },
+          state: { $first: '$storeProfile.state' },
+          country: { $first: '$storeProfile.country' },
+          spocEmail: { $first: { $ifNull: [ '$spocDetails.email', '' ] } },
+          spocContact: { $first: { $ifNull: [ '$spocDetails.contact', '' ] } },
+        },
+      },
+    ];
+
+    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' } },
+          ],
+        },
+      } );
+    }
+    if ( req.body.sortColumName && req.body.sortColumName !== '' && req.body.sortBy ) {
+      query.push( {
+        $sort: { [req.body.sortColumName]: req.body.sortBy },
+      } );
+    }
+    let count = await aggregateStore( 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 storesList = await aggregateStore( query );
+    if ( storesList.length == 0 ) {
+      return res.sendError( 'no data', 204 );
+    }
+    let infrastoreList = [];
+    for ( let store of storesList ) {
+      store.downTime = 'NA';
+      let infracheck = await findOneTangoTicket( { 'basicDetails.storeId': store.storeId, 'issueDate': new Date() } );
+      if ( infracheck ) {
+        store.status = 'Infra Issue';
+      } else {
+        if ( store.status == 'active' ) {
+          store.status = 'Live';
+          store.statusDetail = 'Connected';
+        } else {
+          store.statusDetail = 'Disconnected';
+          store.status = 'Deactivated';
+        }
+      }
+      infrastoreList.push( store );
+    }
+    if ( req.body.export ) {
+      const exportdata = [];
+      infrastoreList.forEach( ( element ) => {
+        exportdata.push( {
+          'STORE ID': element.storeId,
+          'STORE NAME': element.storeName,
+          'STATUS': element.status,
+          'CITY': element.city,
+          'STATE': element.state,
+          'COUNTRY': element.country,
+          'SPOC EMAIL': element.spocEmail,
+          'SPOC CONTACT': element.spocContact,
+          'DOWNTIME': element.downTime,
+          'STATUS DETAIL': element.statusDetail,
+        } );
+      } );
+      await download( exportdata, res );
+      return;
+    }
+    res.sendSuccess( {
+      count: count.length,
+      result: infrastoreList,
+    } );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'storeInfraList' } );
+    return res.sendError( error, 500 );
+  }
+}

package/src/routes/clientInfra.routes.js

@@ -1,15 +1,15 @@
 
 import express from 'express';
-
-
-import { infraCard, infraIssuesTable, hourWiseDownClients, hourWiseDownstores } from '../controllers/clientInfra.controller.js';
+import { isAllowedSessionHandler } from 'tango-app-api-middleware';
+import { infraCard, InstallationIssuesTable, infraIssuesTable, hourWiseDownClients, hourWiseDownstores } from '../controllers/clientInfra.controller.js';
 
 export const clientInfraRouter = express.Router();
 
 
-clientInfraRouter.post( '/infraCard', infraCard );
-clientInfraRouter.post( '/infraIssuesTable', infraIssuesTable );
-clientInfraRouter.post( '/hourWiseDownClients', hourWiseDownClients );
-clientInfraRouter.post( '/hourWiseDownstores', hourWiseDownstores );
+clientInfraRouter.post( '/infraCard', isAllowedSessionHandler, infraCard );
+clientInfraRouter.post( '/infraIssuesTable', isAllowedSessionHandler, infraIssuesTable );
+clientInfraRouter.post( '/InstallationIssuesTable', isAllowedSessionHandler, InstallationIssuesTable );
+clientInfraRouter.post( '/hourWiseDownClients', isAllowedSessionHandler, hourWiseDownClients );
+clientInfraRouter.post( '/hourWiseDownstores', isAllowedSessionHandler, hourWiseDownstores );
 
 

package/src/routes/infra.routes.js

@@ -1,17 +1,19 @@
 
 import express from 'express';
-import { validateDetails, validateTicket, ticketExists, infraReasonExists, InfrastepstoResolve } from '../validations/infra.validation.js';
-import { createTicket, updateStatus, createReason, PrimaryReasons, secondaryReason, updateTicketIssue, viewTicket } from '../controllers/infra.controllers.js';
+import { isAllowedSessionHandler } from 'tango-app-api-middleware';
+import { validateDetails, validateTicket, ticketExists, infraReasonExists, InfrastepstoResolve, InfraAlert } from '../validations/infra.validation.js';
+import { createTicket, updateStatus, createReason, PrimaryReasons, secondaryReason, updateTicketIssue, viewTicket, AlertTicketReply } from '../controllers/infra.controllers.js';
 
 
 export const infraRouter = express.Router();
 
 infraRouter.post( '/createTicket', validateDetails, validateTicket, createTicket );
-infraRouter.post( '/updateStatus', ticketExists, updateStatus );
+infraRouter.post( '/updateStatus', isAllowedSessionHandler, ticketExists, updateStatus );
 infraRouter.post( '/createReason', createReason );
-infraRouter.get( '/PrimaryReasons', PrimaryReasons );
-infraRouter.post( '/secondaryReason', secondaryReason );
-infraRouter.post( '/updateTicketIssue', ticketExists, infraReasonExists, InfrastepstoResolve, updateTicketIssue );
-infraRouter.post( '/viewTicket', ticketExists, viewTicket );
+infraRouter.get( '/PrimaryReasons', isAllowedSessionHandler, PrimaryReasons );
+infraRouter.post( '/secondaryReason', isAllowedSessionHandler, secondaryReason );
+infraRouter.post( '/updateTicketIssue', isAllowedSessionHandler, ticketExists, infraReasonExists, InfrastepstoResolve, InfraAlert, updateTicketIssue );
+infraRouter.post( '/viewTicket', isAllowedSessionHandler, ticketExists, viewTicket );
+infraRouter.post( '/AlertTicketReply', isAllowedSessionHandler, ticketExists, AlertTicketReply );
 
 

package/src/routes/internalInfra.routes.js

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

package/src/routes/storeInfra.routes.js

@@ -1,11 +1,12 @@
 
 import express from 'express';
+import { isAllowedSessionHandler } from 'tango-app-api-middleware';
 import { storeTicketList, storeTicketcard, edgeAppLogTable, viewedgeAppLog } from '../controllers/storeInfra.controlller.js';
 export const storeInfraRouter = express.Router();
 
-storeInfraRouter.post( '/storeTicketList', storeTicketList );
-storeInfraRouter.post( '/storeTicketcard', storeTicketcard );
-storeInfraRouter.post( '/edgeAppLogTable', edgeAppLogTable );
-storeInfraRouter.post( '/viewedgeAppLog', viewedgeAppLog );
+storeInfraRouter.post( '/storeTicketList', isAllowedSessionHandler, storeTicketList );
+storeInfraRouter.post( '/storeTicketcard', isAllowedSessionHandler, storeTicketcard );
+storeInfraRouter.post( '/edgeAppLogTable', isAllowedSessionHandler, edgeAppLogTable );
+storeInfraRouter.post( '/viewedgeAppLog', isAllowedSessionHandler, viewedgeAppLog );
 
 

package/src/routes/userInfra.routes.js

@@ -1,12 +1,14 @@
 import express from 'express';
-import { userTakeTicket, userTicketList, basicDetails, workHistory } from '../controllers/userInfra.controller.js';
+import { isAllowedSessionHandler } from 'tango-app-api-middleware';
+import { userTakeTicket, userTicketList, basicDetails, workHistory, storeInfraList } from '../controllers/userInfra.controller.js';
 
 export const userInfraRouter = express.Router();
 
 
-userInfraRouter.post( '/userTakeTicket', userTakeTicket );
-userInfraRouter.post( '/userTicketList', userTicketList );
-userInfraRouter.post( '/basicDetails', basicDetails );
-userInfraRouter.post( '/workHistory', workHistory );
+userInfraRouter.post( '/userTakeTicket', isAllowedSessionHandler, userTakeTicket );
+userInfraRouter.post( '/userTicketList', isAllowedSessionHandler, userTicketList );
+userInfraRouter.post( '/basicDetails', isAllowedSessionHandler, basicDetails );
+userInfraRouter.post( '/workHistory', isAllowedSessionHandler, workHistory );
+userInfraRouter.post( '/storeInfraList', isAllowedSessionHandler, storeInfraList );
 
 

package/src/services/store.service.js

@@ -20,3 +20,6 @@ export async function updateOneStore( query, data ) {
 export async function countDocumentsStore( query ) {
   return await dataModel.storeModel.countDocuments( query );
 }
+export async function aggregateStore( query ) {
+  return await dataModel.storeModel.aggregate( query );
+}

package/src/validations/infra.validation.js

@@ -1,7 +1,7 @@
 import dayjs from 'dayjs';
-import { findOneTangoTicket } from '../services/tangoTicket.service.js';
+import { findOneTangoTicket, updateOneTangoTicket } from '../services/tangoTicket.service.js';
 import { findOneClient } from '../services/client.service.js';
-import { findOneStore } from '../services/store.service.js';
+import { findOneStore, updateOneStore } from '../services/store.service.js';
 import { findOneinfraReason } from '../services/infraReason.service.js';
 import { logger } from 'tango-app-api-middleware';
 
@@ -34,14 +34,16 @@ export async function validateDetails( req, res, next ) {
 
 export async function validateTicket( req, res, next ) {
   try {
-    let Ticket = await findOneTangoTicket(
-        {
-          'basicDetails.storeId': req.body.basicDetails.storeId,
-          'issueDate': new Date( req.body.Date ),
-        },
-    );
-    if ( Ticket ) {
-      return res.sendSuccess( 'Ticket Already Exists for the day' );
+    if ( req.body.issueType == 'infra' ) {
+      let Ticket = await findOneTangoTicket(
+          {
+            'basicDetails.storeId': req.body.basicDetails.storeId,
+            'issueDate': new Date( req.body.Date ),
+          },
+      );
+      if ( Ticket ) {
+        return res.sendSuccess( 'Ticket Already Exists for the day' );
+      }
     }
     next();
   } catch ( error ) {
@@ -59,6 +61,7 @@ export async function ticketExists( req, res, next ) {
     if ( !Ticket ) {
       return res.sendError( 'Ticket Not Found', 204 );
     }
+    req.body.basicDetails = Ticket.basicDetails;
     req.body.infraActivity = Ticket.infraActivity;
     next();
   } catch ( error ) {
@@ -136,7 +139,37 @@ export async function InfrastepstoResolve( req, res, next ) {
     } );
     next();
   } catch ( error ) {
-    logger.error( { error: error, function: 'infraReasonExists' } );
+    logger.error( { error: error, function: 'InfrastepstoResolve' } );
     return res.sendError( error, 500 );
   }
 };
+
+
+export async function InfraAlert( req, res, next ) {
+  try {
+    if ( req.body.hibernationDays ) {
+      req.body.hibernationDays = dayjs().add( req.body.hibernationDays, 'days' ).format( 'YYYY-MM-DD' );
+      await updateOneStore( { storeId: req.body.basicDetails.storeId }, { 'ticketConfigs.hibernation': new Date( req.body.hibernationDays ) } );
+      req.body.infraActivity.push( {
+        actionType: 'statusCheckReply',
+        actionBy: 'Tango',
+        hibernationDays: req.body.hibernationDays,
+      } );
+      await updateOneTangoTicket( { ticketId: req.body.ticketId }, { 'hibernation': new Date( req.body.hibernationDays ) } );
+    } else {
+      let client = await findOneClient( { clientId: req.body.basicDetails.clientId }, { ticketConfigs: 1 } );
+      let statusCheckAlertTime = dayjs().add( client.ticketConfigs.statusCheckAlert, 'hours' ).format( 'YYYY-MM-DD hh:mm' );
+      req.body.infraActivity.push( {
+        actionType: 'statusCheck',
+        actionBy: 'Tango',
+        statusCheckAlertTime: statusCheckAlertTime,
+      } );
+    }
+
+    next();
+  } catch ( error ) {
+    logger.error( { error: error, function: 'InfraAlert' } );
+    return res.sendError( error, 500 );
+  }
+};
+