tango-app-api-infra 3.0.13 → 3.0.15

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-infra",
-    "version": "3.0.13",
+    "version": "3.0.15",
     "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.38",
-        "tango-app-api-middleware": "^1.0.18",
+        "tango-api-schema": "^2.0.44",
+        "tango-app-api-middleware": "^1.0.21",
         "winston": "^3.12.0",
         "winston-daily-rotate-file": "^5.0.0"
     },

package/src/controllers/clientInfra.controller.js

@@ -1,6 +1,6 @@
 
 import { countDocumentsStore, findStorewithpagination } from '../services/store.service.js';
-import { logger } from 'tango-app-api-middleware';
+import { logger, download } from 'tango-app-api-middleware';
 import { aggregateTangoTicket } from '../services/tangoTicket.service.js';
 import { findinfraReason } from '../services/infraReason.service.js';
 import { findClientwithpagination } from '../services/client.service.js';
@@ -13,15 +13,20 @@ 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 ) } },
+          ],
         },
       },
       {
         $project: {
           storeId: '$basicDetails.storeId',
           identifiedcount: {
-            $cond: [ { $eq: [ '$infraTicketDetails.issueStatus', 'identified' ] }, 1, 0 ],
+            $cond: [ { $eq: [ '$ticketDetails.issueStatus', 'identified' ] }, 1, 0 ],
           },
         },
       },
@@ -42,17 +47,24 @@ 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 } },
+          { 'ticketDetails.issueStatus': 'identified' },
+          { createdAt: { $gte: new Date( req.body.fromDate ) } },
+          { createdAt: { $lte: new Date( req.body.toDate ) } },
+        ],
       },
     },
     {
       $project: {
         ticketId: 1,
-        issueStatus: '$infraTicketDetails.issueStatus',
+        issueStatus: '$ticketDetails.issueStatus',
+        issueIdentifiedBy: '$ticketDetails.issueIdentifiedBy',
         primaryIssue: {
           $filter: {
-            input: '$infraActivity',
+            input: '$ticketActivity',
             as: 'item',
             cond: { $eq: [ '$$item.actionType', 'issueUpdate' ] },
           },
@@ -74,10 +86,20 @@ export async function infraCard( req, res ) {
         ticketId: 1,
         issueStatus: 1,
         ticketType: 1,
+        issueIdentifiedBy: 1,
         primaryIssue: '$primaryIssue.reasons.primaryIssue',
       },
     },
     ];
+    if ( req.body.filter&&req.body.filter.length>0 ) {
+      query.push(
+          {
+            $match: {
+              issueIdentifiedBy: { $in: req.body.filter },
+            },
+          },
+      );
+    }
     let ticketList = await aggregateTangoTicket( query );
     let issueList = await findinfraReason( { parentId: { '$exists': false } } );
     const categoryCounts = {};
@@ -114,13 +136,116 @@ export async function infraCard( req, res ) {
     return res.sendError( error, 500 );
   }
 }
+export async function installationCard( req, res ) {
+  try {
+    let onboardedCount = await countDocumentsStore( { clientId: { $in: req.body.clientId } } );
+    let installedCount = await countDocumentsStore( { 'clientId': { $in: req.body.clientId }, 'edge.deployed': true } );
 
-
+    let yettoInstallCount = await aggregateTangoTicket( [
+      {
+        $match: {
+          $and: [
+            { issueType: 'installation' },
+            { 'status': { $ne: 'closed' } },
+            { 'ticketDetails.issueStatus': 'notidentified' },
+            { 'basicDetails.clientId': { $in: req.body.clientId } },
+            { createdAt: { $gte: new Date( req.body.fromDate ) } },
+          ],
+        },
+      },
+    ] );
+    let query = [ {
+      $match: {
+        $and: [
+          { issueType: 'installation' },
+          { 'status': { $ne: 'closed' } },
+          { 'basicDetails.clientId': { $in: req.body.clientId } },
+          { 'ticketDetails.issueStatus': 'identified' },
+          { createdAt: { $gte: new Date( req.body.fromDate ) } },
+        ],
+      },
+    },
+    {
+      $project: {
+        ticketId: 1,
+        issueStatus: '$ticketDetails.issueStatus',
+        issueIdentifiedBy: '$ticketDetails.issueIdentifiedBy',
+        primaryIssue: {
+          $filter: {
+            input: '$ticketActivity',
+            as: 'item',
+            cond: { $eq: [ '$$item.actionType', 'issueUpdate' ] },
+          },
+        },
+      },
+    },
+    {
+      $unwind: {
+        path: '$primaryIssue', preserveNullAndEmptyArrays: true,
+      },
+    },
+    {
+      $unwind: {
+        path: '$primaryIssue.reasons', preserveNullAndEmptyArrays: true,
+      },
+    },
+    {
+      $project: {
+        ticketId: 1,
+        issueStatus: 1,
+        ticketType: 1,
+        issueIdentifiedBy: 1,
+        primaryIssue: '$primaryIssue.reasons.primaryIssue',
+      },
+    },
+    ];
+    let installFailedCount = await aggregateTangoTicket( query );
+    let issueList = await findinfraReason( { parentId: { '$exists': false } } );
+    const categoryCounts = {};
+    let response;
+    if ( installFailedCount.length > 0 ) {
+      installFailedCount.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,
+      } ) );
+    }
+    res.sendSuccess( {
+      onboardedStoresCount: onboardedCount,
+      installedStoresCount: installedCount,
+      yettoInstallCount: yettoInstallCount.length,
+      installFailedCount: installFailedCount.length,
+      infraIssues: response,
+    } );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'infraCard' } );
+    return res.sendError( error, 500 );
+  }
+}
 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 } },
+          { 'ticketDetails.issueStatus': 'identified' },
+          { createdAt: { $gte: new Date( req.body.fromDate ) } },
+          { createdAt: { $lte: new Date( req.body.toDate ) } },
+        ],
       },
     },
     {
@@ -129,11 +254,11 @@ export async function infraIssuesTable( req, res ) {
         storeName: '$basicDetails.storeName',
         status: 1,
         createdAt: { $dateToString: { format: '%d-%m-%Y', date: '$createdAt' } },
-        issueIdentifiedDate: { $dateToString: { format: '%d-%m-%Y', date: '$infraTicketDetails.issueIdentifiedDate' } },
+        issueIdentifiedDate: { $dateToString: { format: '%d-%m-%Y', date: '$ticketDetails.issueIdentifiedDate' } },
         issueClosedDate: { $dateToString: { format: '%d-%m-%Y', date: '$issueClosedDate' } },
         primaryIssue: {
           $filter: {
-            input: '$infraActivity',
+            input: '$ticketActivity',
             as: 'item',
             cond: { $eq: [ '$$item.actionType', 'issueUpdate' ] },
           },
@@ -149,7 +274,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 +288,46 @@ 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',
+        storeId: { $first: '$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 +336,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: 1,
+        },
+      },
+    ];
+    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;
@@ -245,7 +508,7 @@ export async function livecountCheck( data, inputData ) {
         timewise.push( obj );
       }
       const mergedData = {
-        brandName: data.brandName,
+        clientName: data.clientName,
       };
       timewise.forEach( ( obj ) => {
         for ( const key in obj ) {

package/src/controllers/infra.controllers.js

@@ -6,14 +6,17 @@ import { logger } from 'tango-app-api-middleware';
 export async function createTicket( req, res ) {
   try {
     req.body.issueDate = new Date( req.body.Date );
-    req.body.infraTicketDetails.filesCount = req.body.filesCount;
+    req.body.ticketDetails.filesCount = req.body.filesCount;
     if ( req.body.issueType == 'infra' ) {
       req.body.ticketId = 'TE_INF_' + new Date().valueOf();
-      req.body.infraActivity = [ {
+      req.body.ticketActivity = [ {
         actionType: 'defaultInfra',
         actionBy: 'Tango',
       } ];
     }
+    if ( req.body.issueType == 'installation' ) {
+      req.body.ticketId = 'TE_INS_' + new Date().valueOf();
+    }
     let create = await createTangoTicket( req.body );
     if ( create ) {
       res.sendSuccess( 'Ticket Created Successfully' );
@@ -27,7 +30,7 @@ export async function createTicket( req, res ) {
 export async function updateStatus( req, res ) {
   try {
     if ( req.body.status == 'inprogress' ) {
-      req.body.infraActivity.push( {
+      req.body.ticketActivity.push( {
         actionType: 'statusChange',
         actionBy: 'User',
       } );
@@ -91,7 +94,7 @@ export async function secondaryReason( req, res ) {
 
 export async function updateTicketIssue( req, res ) {
   try {
-    let updateTicket = await updateOneTangoTicket( { ticketId: req.body.ticketId }, { 'infraActivity': req.body.infraActivity, 'infraTicketDetails.issueIdentifiedDate': new Date(), 'infraTicketDetails.issueIdentifiedBy': req.body.issueIdentifiedBy, 'infraTicketDetails.issueStatus': 'identified' } );
+    let updateTicket = await updateOneTangoTicket( { ticketId: req.body.ticketId }, { 'ticketActivity': req.body.ticketActivity, 'ticketDetails.issueIdentifiedDate': new Date(), 'ticketDetails.issueIdentifiedBy': req.body.issueIdentifiedBy, 'ticketDetails.issueStatus': 'identified' } );
     if ( updateTicket ) {
       res.sendSuccess( 'Ticket Updated  Successfully' );
     }
@@ -103,7 +106,7 @@ export async function updateTicketIssue( req, res ) {
 
 export async function viewTicket( req, res ) {
   try {
-    let ticket = await findOneTangoTicket( { ticketId: req.body.ticketId }, { ticketId: 1, status: 1, infraActivity: 1 } );
+    let ticket = await findOneTangoTicket( { ticketId: req.body.ticketId }, { ticketId: 1, status: 1, ticketActivity: 1 } );
     if ( ticket ) {
       res.sendSuccess( ticket );
     }
@@ -114,11 +117,12 @@ export async function viewTicket( req, res ) {
 }
 export async function AlertTicketReply( req, res ) {
   try {
-    req.body.infraActivity = req.body.infraActivity.filter( ( data ) => data.action !='statusCheck' );
-    req.body.infraActivity.push( {
+    req.body.ticketActivity = req.body.ticketActivity.filter( ( data ) => data.action !='statusCheck' );
+    req.body.ticketActivity.push( {
       actionType: 'statusCheckReply',
       actionBy: 'Tango',
-
+      statusCheckReply: req.body.statusCheckReply,
+      hibernationDays: req.body.hibernationDays,
     } );
   } catch ( error ) {
     logger.error( { error: error, function: 'AlertTicketReply' } );

package/src/controllers/internalInfra.controller.js

@@ -112,7 +112,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, infraTicketDetails: 1 } );
+    let openTicketList = await findTangoTicket( { status: { $ne: 'closed' } }, { ticketId: 1, basicDetails: 1, createdAt: 1, updateAt: 1, ticketDetails: 1 } );
     if ( openTicketList.length ) {
       res.sendSuccess( {
         count: openTicketList.length,
@@ -129,7 +129,7 @@ export async function openTicketList( req, res ) {
 
 export async function assigntoUser( req, res ) {
   try {
-    await updateOneTangoTicket( { ticketId: req.body.ticketId }, { 'infraTicketDetails.assigntoUser': true } );
+    await updateOneTangoTicket( { ticketId: req.body.ticketId }, { 'ticketDetails.assigntoUser': true } );
     res.sendSuccess( 'assigntoUser Successfully' );
   } catch ( error ) {
     logger.error( { error: error, function: 'assigntoUser' } );
@@ -138,7 +138,7 @@ export async function assigntoUser( req, res ) {
 }
 export async function updateRefreshTicket( req, res ) {
   try {
-    await updateOneTangoTicket( { ticketId: req.body.ticketId }, { 'infraTicketDetails.ticketType': 'refreshticket' } );
+    await updateOneTangoTicket( { ticketId: req.body.ticketId }, { 'ticketDetails.ticketType': 'refreshticket' } );
     res.sendSuccess( 'updated Successfully' );
   } catch ( error ) {
     logger.error( { error: error, function: 'updateRefreshTicket' } );
@@ -150,7 +150,7 @@ export async function closeTicket( req, res ) {
     for ( let ticket of req.body.TicketList ) {
       let getTicket = await findOneTangoTicket( { ticketId: ticket.ticketId } );
       if ( ticket.status == 'closed' ) {
-        getTicket.infraActivity.push( {
+        getTicket.ticketActivity.push( {
           actionType: 'dataRecived',
           actionBy: 'Tango',
         } );
@@ -158,7 +158,7 @@ export async function closeTicket( req, res ) {
       await updateOneTangoTicket( { ticketId: ticket.ticketId },
           {
             status: ticket.status,
-            infraActivity: getTicket.infraActivity,
+            ticketActivity: getTicket.ticketActivity,
             issueClosedDate: new Date(),
           },
       );

package/src/controllers/storeInfra.controlller.js

@@ -18,11 +18,11 @@ export async function storeTicketList( req, res ) {
         Date: { $dateToString: { format: '%d-%m-%Y', date: '$issueDate' } },
         issueClosedDate: 1,
         ticketId: 1,
-        issueStatus: '$infraTicketDetails.issueStatus',
-        ticketType: '$infraTicketDetails.ticketType',
+        issueStatus: '$ticketDetails.issueStatus',
+        ticketType: '$ticketDetails.ticketType',
         primaryIssue: {
           $filter: {
-            input: '$infraActivity',
+            input: '$ticketActivity',
             as: 'item',
             cond: { $eq: [ '$$item.actionType', 'issueUpdate' ] },
           },
@@ -73,16 +73,16 @@ export async function storeTicketcard( req, res ) {
     let query = [ {
       $match: {
         'basicDetails.storeId': req.body.storeId,
-        'infraTicketDetails.issueStatus': 'identified',
+        'ticketDetails.issueStatus': 'identified',
       },
     },
     {
       $project: {
         ticketId: 1,
-        issueStatus: '$infraTicketDetails.issueStatus',
+        issueStatus: '$ticketDetails.issueStatus',
         primaryIssue: {
           $filter: {
-            input: '$infraActivity',
+            input: '$ticketActivity',
             as: 'item',
             cond: { $eq: [ '$$item.actionType', 'issueUpdate' ] },
           },

package/src/controllers/userInfra.controller.js

@@ -1,6 +1,6 @@
 
 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';
 
@@ -8,9 +8,14 @@ import mongoose from 'mongoose';
 
 export async function userTakeTicket( req, res ) {
   try {
-    let userTicket = await findOneTangoTicket( { 'status': { $ne: 'closed' }, 'infraTicketDetails.assigntoUser': true, 'infraTicketDetails.addressingUser': { $exists: false } } );
+    let userTicket = '';
+    if ( req.body.issueType == 'infra' ) {
+      userTicket = await findOneTangoTicket( { 'status': { $ne: 'closed' }, 'issueType': 'infra', 'ticketDetails.assigntoUser': true, 'ticketDetails.addressingUser': { $exists: false } } );
+    } else if ( req.body.issueType == 'installation' ) {
+      userTicket = await findOneTangoTicket( { 'status': { $ne: 'closed' }, 'issueType': 'installation', 'ticketDetails.addressingUser': { $exists: false } } );
+    }
     if ( userTicket ) {
-      let assignTicket = await updateOneTangoTicket( { ticketId: userTicket.ticketId }, { 'infraTicketDetails.addressingUser': req.body.userId } );
+      let assignTicket = await updateOneTangoTicket( { ticketId: userTicket.ticketId }, { 'ticketDetails.addressingUser': req.body.userId } );
       if ( assignTicket ) {
         res.sendSuccess( 'Ticket Assigned Successfully' );
       }
@@ -26,20 +31,44 @@ 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 },
+          { issueType: req.body.issueType },
+          { 'ticketDetails.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' } },
         ticketId: 1,
-        issueStatus: '$infraTicketDetails.issueStatus',
-        ticketType: '$infraTicketDetails.ticketType',
+        issueStatus: '$ticketDetails.issueStatus',
+        ticketType: '$ticketDetails.ticketType',
         primaryIssue: {
           $filter: {
-            input: '$infraActivity',
+            input: '$ticketActivity',
             as: 'item',
             cond: { $eq: [ '$$item.actionType', 'issueUpdate' ] },
           },
@@ -64,7 +93,7 @@ export async function userTicketList( req, res ) {
         ticketType: 1,
         infraIssue: '$primaryIssue.reasons.primaryIssue',
       },
-    } ];
+    } );
     let ticketList = await aggregateTangoTicket( query );
     if ( ticketList.length ) {
       res.sendSuccess( {
@@ -86,8 +115,8 @@ export async function basicDetails( req, res ) {
     if ( !user ) {
       return res.sendError( 'User Not Found', 500 );
     }
-    let infraCount = await countDocumentsTangoTicket( { 'infraTicketDetails.addressingUser': new mongoose.Types.ObjectId( req.body.userId ), 'issueType': 'infra' } );
-    let installationCount = await countDocumentsTangoTicket( { 'infraTicketDetails.addressingUser': new mongoose.Types.ObjectId( req.body.userId ), 'issueType': 'installation' } );
+    let infraCount = await countDocumentsTangoTicket( { 'ticketDetails.addressingUser': new mongoose.Types.ObjectId( req.body.userId ), 'issueType': 'infra' } );
+    let installationCount = await countDocumentsTangoTicket( { 'ticketDetails.addressingUser': new mongoose.Types.ObjectId( req.body.userId ), 'issueType': 'installation' } );
     res.sendSuccess( {
       userName: user.userName,
       userType: user.userType,
@@ -108,8 +137,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' },
+          { 'ticketDetails.addressingUser': new mongoose.Types.ObjectId( req.body.userId ) },
+          { createdAt: { $gte: new Date( req.body.fromDate ) } },
+          { createdAt: { $lte: new Date( req.body.toDate ) } },
+        ],
       },
     },
     {
@@ -120,12 +153,13 @@ 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: '$ticketDetails.issueIdentifiedDate' } },
         ticketId: 1,
-        issueStatus: '$infraTicketDetails.issueStatus',
-        ticketType: '$infraTicketDetails.ticketType',
+        issueStatus: '$ticketDetails.issueStatus',
+        ticketType: '$ticketDetails.ticketType',
         primaryIssue: {
           $filter: {
-            input: '$infraActivity',
+            input: '$ticketActivity',
             as: 'item',
             cond: { $eq: [ '$$item.actionType', 'issueUpdate' ] },
           },
@@ -148,6 +182,7 @@ export async function workHistory( req, res ) {
         clientId: 1,
         clientName: 1,
         issueDate: 1,
+        issueIdentifiedDate: 1,
         issueClosedDate: 1,
         ticketId: 1,
         issueStatus: 1,
@@ -155,6 +190,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(
@@ -163,6 +217,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,
@@ -179,7 +255,10 @@ export async function storeInfraList( req, res ) {
     let query = [
       {
         $match: {
-          clientId: { $in: req.body.clientId },
+          $and: [
+            { clientId: { $in: req.body.clientId } },
+            { createdAt: { $lte: new Date( req.body.toDate ) } },
+          ],
         },
       },
       {
@@ -205,12 +284,33 @@ export async function storeInfraList( req, res ) {
           city: { $first: '$storeProfile.city' },
           state: { $first: '$storeProfile.state' },
           country: { $first: '$storeProfile.country' },
-          spocName: { $first: { $ifNull: [ '$spocDetails.name', '' ] } },
+          spocEmail: { $first: { $ifNull: [ '$spocDetails.email', '' ] } },
           spocContact: { $first: { $ifNull: [ '$spocDetails.contact', '' ] } },
         },
       },
     ];
-
+    if ( req.body.storeId && req.body.storeId.length>0 ) {
+      query.push( {
+        $match: {
+          storeId: { $in: req.body.storeId },
+        },
+      } );
+    }
+    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(
@@ -219,6 +319,9 @@ export async function storeInfraList( req, res ) {
       );
     }
     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';
@@ -228,15 +331,33 @@ export async function storeInfraList( req, res ) {
       } else {
         if ( store.status == 'active' ) {
           store.status = 'Live';
-          store.statusDetail='Connected';
+          store.statusDetail = 'Connected';
         } else {
-          store.statusDetail='Disconnected';
+          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,

package/src/routes/clientInfra.routes.js

@@ -1,15 +1,16 @@
 
 import express from 'express';
-
-
-import { infraCard, infraIssuesTable, hourWiseDownClients, hourWiseDownstores } from '../controllers/clientInfra.controller.js';
+import { isAllowedSessionHandler } from 'tango-app-api-middleware';
+import { infraCard, installationCard, 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( '/installationCard', isAllowedSessionHandler, installationCard );
+clientInfraRouter.post( '/InstallationIssuesTable', isAllowedSessionHandler, InstallationIssuesTable );
+clientInfraRouter.post( '/hourWiseDownClients', isAllowedSessionHandler, hourWiseDownClients );
+clientInfraRouter.post( '/hourWiseDownstores', isAllowedSessionHandler, hourWiseDownstores );
 
 

package/src/routes/infra.routes.js

@@ -1,5 +1,6 @@
 
 import express from 'express';
+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';
 
@@ -7,12 +8,12 @@ import { createTicket, updateStatus, createReason, PrimaryReasons, secondaryReas
 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, InfraAlert, updateTicketIssue );
-infraRouter.post( '/viewTicket', ticketExists, viewTicket );
-infraRouter.post( '/AlertTicketReply', ticketExists, AlertTicketReply );
+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/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,13 +1,14 @@
 import express from 'express';
+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( '/storeInfraList', storeInfraList );
+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/validations/infra.validation.js

@@ -21,9 +21,16 @@ export async function validateDetails( req, res, next ) {
       clientId: store.clientId,
       clientName: client.clientName,
     };
-    req.body.infraTicketDetails = {
-      ticketRefreshTime: dayjs().add( client.ticketConfigs.refreshAlert, 'days' ),
-    };
+
+    if ( req.body.issueType == 'infra' ) {
+      req.body.ticketDetails = {
+        ticketRefreshTime: dayjs().add( client.ticketConfigs.refreshAlert, 'days' ),
+      };
+    } else if ( req.body.issueType == 'installation' ) {
+      req.body.ticketDetails = {
+        ticketRefreshTime: dayjs().add( client.ticketConfigs.installationReAssign, 'days' ),
+      };
+    }
 
     next();
   } catch ( error ) {
@@ -34,14 +41,27 @@ 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,
+            'issueType': 'infra',
+            'issueDate': new Date( req.body.Date ),
+          },
+      );
+      if ( Ticket ) {
+        return res.sendSuccess( 'Ticket Already Exists for the day' );
+      }
+    } else if ( req.body.issueType == 'installation' ) {
+      let Ticket = await findOneTangoTicket(
+          {
+            'basicDetails.storeId': req.body.basicDetails.storeId,
+            'issueType': req.body.issueType,
+          },
+      );
+      if ( Ticket ) {
+        return res.sendSuccess( 'Ticket Already Exists' );
+      }
     }
     next();
   } catch ( error ) {
@@ -60,7 +80,7 @@ export async function ticketExists( req, res, next ) {
       return res.sendError( 'Ticket Not Found', 204 );
     }
     req.body.basicDetails = Ticket.basicDetails;
-    req.body.infraActivity = Ticket.infraActivity;
+    req.body.ticketActivity = Ticket.ticketActivity;
     next();
   } catch ( error ) {
     logger.error( { error: error, function: 'ticketExists' } );
@@ -95,7 +115,7 @@ export async function infraReasonExists( req, res, next ) {
         secondaryIsssue: [ ...resolveSteps ],
       } );
     }
-    req.body.infraActivity.push( {
+    req.body.ticketActivity.push( {
       actionType: 'issueUpdate',
       actionBy: 'User',
       comment: req.body.comment,
@@ -125,7 +145,7 @@ export async function InfrastepstoResolve( req, res, next ) {
       } );
     }
 
-    req.body.infraActivity.push( {
+    req.body.ticketActivity.push( {
       actionType: 'stepsToResolve',
       actionBy: 'Tango',
       reasons: steptoReslove.map( ( item ) => ( {
@@ -148,7 +168,7 @@ export async function InfraAlert( req, res, next ) {
     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( {
+      req.body.ticketActivity.push( {
         actionType: 'statusCheckReply',
         actionBy: 'Tango',
         hibernationDays: req.body.hibernationDays,
@@ -157,7 +177,7 @@ export async function InfraAlert( req, res, next ) {
     } 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( {
+      req.body.ticketActivity.push( {
         actionType: 'statusCheck',
         actionBy: 'Tango',
         statusCheckAlertTime: statusCheckAlertTime,