tango-app-api-infra 3.0.92-dev → 3.0.93-dev

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-infra",
-    "version": "3.0.92-dev",
+    "version": "3.0.93-dev",
     "description": "infra",
     "main": "index.js",
     "type": "module",

package/src/controllers/clientInfra.controller.js

@@ -1,5 +1,5 @@
 
-import { countDocumentsStore } from '../services/store.service.js';
+import { aggregateStore, countDocumentsStore } from '../services/store.service.js';
 import { logger, download, getUTC } from 'tango-app-api-middleware';
 import { aggregateTangoTicket } from '../services/tangoTicket.service.js';
 import { findinfraReason } from '../services/infraReason.service.js';
@@ -11,6 +11,20 @@ export async function infraCard( req, res ) {
   try {
     let date = await getUTC( new Date( req.body.fromDate ), new Date( req.body.toDate ) );
     let storeCount = await countDocumentsStore( { 'clientId': { $in: req.body.clientId }, 'createdAt': { $lte: date.end }, 'edge.firstFile': true, 'status': 'active' } );
+    let totalstores = await aggregateStore( [ {
+      $match: {
+        '$and': [
+          { 'clientId': { $in: req.body.clientId } },
+          { 'edge.firstFile': true },
+          { 'status': 'active' },
+          { 'createdAt': { $lte: date.end } },
+        ],
+      },
+    } ] );
+    let totalnumberstores = [];
+    for ( let store of totalstores ) {
+      totalnumberstores.push( store.storeId );
+    }
     let infraStoreCount = await aggregateTangoTicket( [
       {
         $match: {
@@ -18,6 +32,7 @@ export async function infraCard( req, res ) {
             { issueType: 'infra' },
             { status: { $ne: 'closed' } },
             { 'basicDetails.clientId': { $in: req.body.clientId } },
+            { 'basicDetails.storeId': { $in: totalnumberstores } },
             // { createdAt: { $gte: date.start } },
             { createdAt: { $lte: date.end } },
           ],
@@ -54,6 +69,7 @@ export async function infraCard( req, res ) {
           { status: { $ne: 'closed' } },
           { 'ticketDetails.issueStatus': 'identified' },
           { 'basicDetails.clientId': { $in: req.body.clientId } },
+          { 'basicDetails.storeId': { $in: totalnumberstores } },
           // { createdAt: { $gte: date.start } },
           { createdAt: { $lte: date.end } },
         ],
@@ -171,11 +187,14 @@ export async function installationCard( req, res ) {
     } );
     let installedCount = await countDocumentsStore( {
       'clientId': { $in: req.body.clientId },
-      'edge.firstFile': true, 'status': 'active', 'createdAt': { $lte: date.end },
+      'edge.firstFile': true,
+      'status': 'active',
+      'createdAt': { $lte: date.end },
     } );
     let deactiveCount = await countDocumentsStore( {
       'clientId': { $in: req.body.clientId },
       'status': 'deactive',
+      'createdAt': { $lte: date.end },
     } );
     let yettoInstallCount = await aggregateTangoTicket( [
       {
@@ -285,18 +304,36 @@ export async function infraIssuesTable( req, res ) {
   try {
     let date = await getUTC( new Date( req.body.fromDate ), new Date( req.body.toDate ) );
     let issueStatus = [ 'identified' ];
-    if ( req.body.filterIssue == 'Issues Not Identified' ) {
+    if ( req.body.infrafilterIssue == 'Issues Not Identified' ) {
       issueStatus = [ 'notidentified' ];
     };
-    if ( req.body.filterIssue == 'All Issues' ) {
+    if ( req.body.infrafilterIssue == 'All Issues' ) {
       issueStatus = [ 'notidentified', 'identified' ];
     };
+    if ( req.body.infrafilterIssue == 'Live Stores' ) {
+      issueStatus = [ 'notidentified', 'identified' ];
+    };
+    let totalstores = await aggregateStore( [ {
+      $match: {
+        '$and': [
+          { 'clientId': { $in: req.body.clientId } },
+          { 'edge.firstFile': true },
+          { 'status': 'active' },
+          { 'createdAt': { $lte: date.end } },
+        ],
+      },
+    } ] );
+    let totalnumberstores = [];
+    for ( let store of totalstores ) {
+      totalnumberstores.push( store.storeId );
+    }
     let query = [ {
       $match: {
         $and: [
           { issueType: 'infra' },
           { status: { $ne: 'closed' } },
           { 'basicDetails.clientId': { $in: req.body.clientId } },
+          { 'basicDetails.storeId': { $in: totalnumberstores } },
           { 'ticketDetails.issueStatus': { $in: issueStatus } },
           // { createdAt: { $gte: date.start } },
           { createdAt: { $lte: date.end } },
@@ -369,10 +406,49 @@ export async function infraIssuesTable( req, res ) {
       },
     },
     ];
-    if ( req.body.filterIssue && req.body.filterIssue != '' && req.body.filterIssue != 'Identified Issues' && req.body.filterIssue != 'Issues Not Identified'&&req.body.filterIssue != 'All Issues' ) {
+    let storesQuery = [];
+    if ( req.body.infrafilterIssue == 'Total Stores' ) {
+      storesQuery.push( {
+        $match: {
+          '$and': [
+            { 'clientId': { $in: req.body.clientId } },
+            { 'edge.firstFile': true },
+            { 'status': 'active' },
+            { 'createdAt': { $lte: date.end } },
+          ],
+        },
+      },
+      );
+    }
+    if ( req.body.infrafilterIssue == 'Live Stores' ) {
+      let infrastores = await aggregateTangoTicket( query );
+      let infraissueStore = [];
+      for ( let store of infrastores ) {
+        infraissueStore.push( store.storeId );
+      }
+      let result = [];
+      for ( let data of totalnumberstores ) {
+        if ( infraissueStore.length > 0 && !infraissueStore.includes( data ) ) {
+          result.push( data );
+        }
+      }
+      storesQuery.push(
+          {
+            $match: {
+              '$and': [
+                { 'storeId': { $in: result } },
+              ],
+            },
+          },
+      );
+    }
+    if ( req.body.infrafilterIssue && req.body.infrafilterIssue != '' &&
+      req.body.infrafilterIssue != 'Identified Issues' &&
+      req.body.infrafilterIssue != 'Issues Not Identified' &&
+      req.body.infrafilterIssue != 'All Issues' ) {
       query.push( {
         $match: {
-          primaryIssue: req.body.filterIssue,
+          primaryIssue: req.body.infrafilterIssue,
         },
       } );
     }
@@ -385,6 +461,14 @@ export async function infraIssuesTable( req, res ) {
           ],
         },
       } );
+      storesQuery.push( {
+        $match: {
+          $or: [
+            { storeId: { $regex: req.body.searchValue, $options: 'i' } },
+            { storeName: { $regex: req.body.searchValue, $options: 'i' } },
+          ],
+        },
+      } );
     }
     if ( req.body.filter && req.body.filter.length > 0 ) {
       query.push(
@@ -399,16 +483,32 @@ export async function infraIssuesTable( req, res ) {
       query.push( {
         $sort: { [req.body.sortColumName]: req.body.sortBy },
       } );
+      storesQuery.push( {
+        $sort: { [req.body.sortColumName]: req.body.sortBy },
+      } );
+    }
+    let count;
+    if ( req.body.infrafilterIssue == 'Live Stores' || req.body.infrafilterIssue == 'Total Stores' ) {
+      count = await aggregateStore( storesQuery );
+    } else {
+      count = await aggregateTangoTicket( query );
     }
-    let count = await aggregateTangoTicket( query );
-    console.log( count.length );
     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 ) },
       );
+      storesQuery.push(
+          { $skip: ( req.body.offset - 1 ) * req.body.limit },
+          { $limit: Number( req.body.limit ) },
+      );
+    }
+    let result;
+    if ( req.body.infrafilterIssue == 'Live Stores' || req.body.infrafilterIssue == 'Total Stores' ) {
+      result = await aggregateStore( storesQuery );
+    } else {
+      result = await aggregateTangoTicket( query );
     }
-    let result = await aggregateTangoTicket( query );
     if ( req.body.export && result.length > 0 ) {
       const exportdata = [];
       result.forEach( ( element ) => {
@@ -440,69 +540,151 @@ export async function infraIssuesTable( req, res ) {
 }
 export async function InstallationIssuesTable( req, res ) {
   try {
-    let query = [
-      {
-        $match: {
-          $and: [
-            { issueType: 'installation' },
-            { 'status': { $ne: 'closed' } },
-            { 'basicDetails.clientId': { $in: req.body.clientId } },
-            // { createdAt: { $gte: new Date( req.body.fromDate ) } },
-            { createdAt: { $lte: new Date( req.body.toDate ) } },
-          ],
-        },
+    let date = await getUTC( new Date( req.body.fromDate ), new Date( req.body.toDate ) );
+    let query = [];
+    query.push( {
+      $match: {
+        $and: [
+          { issueType: 'installation' },
+          { 'status': { $ne: 'closed' } },
+
+          { 'basicDetails.clientId': { $in: req.body.clientId } },
+          { createdAt: { $lte: new Date( date.end ) } },
+        ],
       },
-      {
-        $project: {
-          createdAt: 1,
-          clientName: '$basicDetails.clientName',
-          storeId: '$basicDetails.storeId',
-          clientId: '$basicDetails.clientId',
-          storeName: '$basicDetails.storeName',
-          status: 1,
-          primaryIssue: {
-            $filter: {
-              input: '$ticketActivity',
-              as: 'item',
-              cond: { $eq: [ '$$item.actionType', 'issueUpdate' ] },
-            },
+    } );
+    if ( req.body.installtionfilterIssue == 'yettoInstallStores' ) {
+      query.push( { $match: { 'ticketDetails.issueStatus': 'notidentified' } } );
+    }
+    if ( req.body.installtionfilterIssue == 'installFailedStores' ) {
+      query.push( { $match: { 'ticketDetails.issueStatus': 'identified' } } );
+    }
+    query.push( {
+      $project: {
+        createdAt: 1,
+        clientName: '$basicDetails.clientName',
+        storeId: '$basicDetails.storeId',
+        clientId: '$basicDetails.clientId',
+        storeName: '$basicDetails.storeName',
+        status: 1,
+        primaryIssue: {
+          $filter: {
+            input: '$ticketActivity',
+            as: 'item',
+            cond: { $eq: [ '$$item.actionType', 'issueUpdate' ] },
           },
         },
       },
-      {
-        $unwind: {
-          path: '$primaryIssue', preserveNullAndEmptyArrays: true,
-        },
+    },
+    {
+      $unwind: {
+        path: '$primaryIssue', preserveNullAndEmptyArrays: true,
       },
-      {
-        $unwind: {
-          path: '$primaryIssue.reasons', preserveNullAndEmptyArrays: true,
+    },
+    {
+      $unwind: {
+        path: '$primaryIssue.reasons', preserveNullAndEmptyArrays: true,
+      },
+    },
+    {
+      $project: {
+        createdAt: 1,
+        clientName: 1,
+        storeId: 1,
+        clientId: 1,
+        storeName: 1,
+        status: 1,
+        primaryIssue: { $ifNull: [ '$primaryIssue.reasons.primaryIssue', '-' ] },
+      },
+    },
+    {
+      $group: {
+        _id: '$storeId',
+        createdAt: { $first: '$createdAt' },
+        clientName: { $first: '$clientName' },
+        storeId: { $first: '$storeId' },
+        clientId: { $first: '$clientId' },
+        storeName: { $first: '$storeName' },
+        status: { $last: '$status' },
+        primaryIssue: { $last: '$primaryIssue' },
+      },
+    },
+    );
+    let storesQuery = [];
+
+    if ( req.body.installtionfilterIssue == 'onboardedStores' ) {
+      storesQuery.push( {
+        $match: {
+          '$and': [
+            { 'clientId': { $in: req.body.clientId } },
+            { 'createdAt': { $lte: date.end } },
+          ],
         },
       },
-      {
-        $project: {
-          createdAt: 1,
-          clientName: 1,
-          storeId: 1,
-          clientId: 1,
-          storeName: 1,
-          status: 1,
-          primaryIssue: { $ifNull: [ '$primaryIssue.reasons.primaryIssue', '-' ] },
+      );
+    }
+    if ( req.body.installtionfilterIssue == 'installedStores' ) {
+      storesQuery.push( {
+        $match: {
+          '$and': [
+            { 'clientId': { $in: req.body.clientId } },
+            { 'edge.firstFile': true },
+            { 'status': 'active' },
+            { 'createdAt': { $lte: date.end } },
+          ],
         },
       },
-      {
-        $group: {
-          _id: '$storeId',
-          createdAt: { $first: '$createdAt' },
-          clientName: { $first: '$clientName' },
-          storeId: { $first: '$storeId' },
-          clientId: { $first: '$clientId' },
-          storeName: { $first: '$storeName' },
-          status: { $last: '$status' },
-          primaryIssue: { $last: '$primaryIssue' },
+      );
+    }
+    if ( req.body.installtionfilterIssue == 'inactiveStores' ) {
+      storesQuery.push( {
+        $match: {
+          '$and': [
+            { 'clientId': { $in: req.body.clientId } },
+            { 'status': 'deactive' },
+            { 'createdAt': { $lte: date.end } },
+          ],
         },
       },
-    ];
+      );
+    }
+    storesQuery.push( {
+      $lookup: {
+        from: 'clients',
+        let: { clientId: '$clientId' },
+        pipeline: [
+          {
+            $match: {
+              $expr: {
+                $and: [
+                  { $eq: [ '$clientId', '$$clientId' ] },
+                ],
+              },
+            },
+
+          },
+          {
+            $project: {
+              clientName: 1,
+            },
+          },
+        ], as: 'client',
+      },
+    },
+    {
+      $unwind: { path: '$client', preserveNullAndEmptyArrays: true },
+    },
+    {
+      $project: {
+        clientName: '$client.clientName',
+        storeId: 1,
+        clientId: 1,
+        storeName: 1,
+        status: 1,
+      },
+    },
+    );
+
     if ( req.body.searchValue && req.body.searchValue !== '' ) {
       query.push( {
         $match: {
@@ -514,11 +696,20 @@ export async function InstallationIssuesTable( req, res ) {
           ],
         },
       } );
+      storesQuery.push( {
+        $match: {
+          $or: [
+            { storeId: { $regex: req.body.searchValue, $options: 'i' } },
+            { storeName: { $regex: req.body.searchValue, $options: 'i' } },
+            { clientName: { $regex: req.body.searchValue, $options: 'i' } },
+          ],
+        },
+      } );
     }
-    if ( req.body.filterIssue && req.body.filterIssue != '' ) {
+    if ( req.body.installtionfilterIssue && req.body.installtionfilterIssue != '' && req.body.installtionfilterIssue != 'yettoInstallStores' && req.body.installtionfilterIssue != 'installFailedStores' ) {
       query.push( {
         $match: {
-          primaryIssue: req.body.filterIssue,
+          primaryIssue: req.body.installtionfilterIssue,
         },
       } );
     }
@@ -526,16 +717,34 @@ export async function InstallationIssuesTable( req, res ) {
       query.push( {
         $sort: { [req.body.sortColumName]: req.body.sortBy },
       } );
+      storesQuery.push( {
+        $sort: { [req.body.sortColumName]: req.body.sortBy },
+      } );
     }
-    let count = await aggregateTangoTicket( query );
+    let count;
+    if ( req.body.installtionfilterIssue != 'onboardedStores' && req.body.installtionfilterIssue != 'installedStores' && req.body.installtionfilterIssue != 'inactiveStores' ) {
+      count = await aggregateTangoTicket( query );
+    } else {
+      count = await aggregateStore( storesQuery );
+    }
+
     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 ) },
       );
+      storesQuery.push(
+          { $skip: ( req.body.offset - 1 ) * req.body.limit },
+          { $limit: Number( req.body.limit ) },
+      );
+    }
+    let storesList;
+    if ( req.body.installtionfilterIssue != 'onboardedStores' && req.body.installtionfilterIssue != 'installedStores' && req.body.installtionfilterIssue != 'inactiveStores' ) {
+      storesList = await aggregateTangoTicket( query );
+    } else {
+      storesList = await aggregateStore( storesQuery );
     }
 
-    let storesList = await aggregateTangoTicket( query );
     if ( storesList.length == 0 ) {
       return res.sendError( 'no data', 204 );
     }
@@ -725,10 +934,30 @@ export async function hourWiseDownstores( req, res ) {
     if ( req.body.filterIssue == 'All Issues' ) {
       issueStatus = [ 'notidentified', 'identified' ];
     };
+    if ( req.body.filterIssue == 'Live Stores' ) {
+      issueStatus = [ 'notidentified', 'identified' ];
+    };
+
+    let totalstores = await aggregateStore( [ {
+      $match: {
+        '$and': [
+          { 'clientId': req.body.clientId },
+          { 'edge.firstFile': true },
+          { 'status': 'active' },
+          { 'createdAt': { $lte: new Date( req.body.toDate ) } },
+        ],
+      },
+    } ] );
+
+    let totalnumberstores = [];
+    for ( let store of totalstores ) {
+      totalnumberstores.push( store.storeId );
+    }
     let query = [ {
       $match: {
         $and: [
           { 'basicDetails.clientId': req.body.clientId },
+          { 'basicDetails.storeId': { $in: totalnumberstores } },
           { 'status': { $ne: 'closed' } },
           { issueType: 'infra' },
           { 'ticketDetails.issueStatus': { $in: issueStatus } },
@@ -775,6 +1004,42 @@ export async function hourWiseDownstores( req, res ) {
       },
     },
     ];
+    let storesQuery = [];
+    if ( req.body.filterIssue == 'Total Stores' ) {
+      storesQuery.push( {
+        $match: {
+          '$and': [
+            { 'clientId': req.body.clientId },
+            { 'edge.firstFile': true },
+            { 'status': 'active' },
+            { 'createdAt': { $lte: new Date( req.body.toDate ) } },
+          ],
+        },
+      },
+      );
+    }
+    if ( req.body.filterIssue == 'Live Stores' ) {
+      let infrastores = await aggregateTangoTicket( query );
+      let infraissueStore = [];
+      for ( let store of infrastores ) {
+        infraissueStore.push( store.storeId );
+      }
+      let result = [];
+      for ( let data of totalnumberstores ) {
+        if ( infraissueStore.length > 0 && !infraissueStore.includes( data ) ) {
+          result.push( data );
+        }
+      }
+      storesQuery.push(
+          {
+            $match: {
+              '$and': [
+                { 'storeId': { $in: result } },
+              ],
+            },
+          },
+      );
+    }
     if ( req.body.searchValue && req.body.searchValue !== '' ) {
       query.push( {
         $match: {
@@ -784,33 +1049,63 @@ export async function hourWiseDownstores( req, res ) {
           ],
         },
       } );
+      storesQuery.push( {
+        $match: {
+          $or: [
+            { storeName: { $regex: req.body.searchValue, $options: 'i' } },
+            { storeId: { $regex: req.body.searchValue, $options: 'i' } },
+          ],
+        },
+      } );
     }
     if ( req.body.sortColumName && req.body.sortColumName != '' && req.body.sortBy && req.body.sortBy != '' ) {
       query.push( {
         $sort: { [req.body.sortColumName]: req.body.sortBy },
       } );
+      storesQuery.push( {
+        $sort: { [req.body.sortColumName]: req.body.sortBy },
+      } );
     }
-    if ( req.body.filterIssue && req.body.filterIssue != '' && req.body.filterIssue != 'Identified Issues' && req.body.filterIssue != 'Issues Not Identified'&&req.body.filterIssue != 'All Issues' ) {
+    if ( req.body.filterIssue && req.body.filterIssue != '' &&
+      req.body.filterIssue != 'Identified Issues' &&
+      req.body.filterIssue != 'Issues Not Identified' &&
+      req.body.filterIssue != 'All Issues' ) {
       query.push( {
         $match: {
           primaryIssue: req.body.filterIssue,
         },
       } );
     }
-    let count = await aggregateTangoTicket( query );
+
+    let count;
+    if ( req.body.filterIssue == 'Live Stores' || req.body.filterIssue == 'Total Stores' ) {
+      count = await aggregateStore( storesQuery );
+    } else {
+      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 ) },
       );
+      storesQuery.push(
+          { $skip: ( req.body.offset - 1 ) * req.body.limit },
+          { $limit: Number( req.body.limit ) },
+      );
+    }
+    let storesList;
+    if ( req.body.filterIssue == 'Live Stores' || req.body.filterIssue == 'Total Stores' ) {
+      storesList = await aggregateStore( storesQuery );
+    } else {
+      storesList = await aggregateTangoTicket( query );
     }
-    let storeslist = await aggregateTangoTicket( query );
-    if ( storeslist.length == 0 ) {
+
+    if ( storesList.length == 0 ) {
       return res.sendError( 'no data', 204 );
     }
     let data = {};
     let result = [];
-    for ( const store of storeslist ) {
+    for ( const store of storesList ) {
       data.storeId = store.storeId;
       data.storeName = store.storeName;
       data.primaryIssue = store.primaryIssue;
@@ -904,3 +1199,245 @@ function downStoresCheck( data, inputData ) {
     }
   } );
 }
+export async function ticketCountSplit( req, res ) {
+  try {
+    const inputData = req.body;
+    let filter = [
+      // { issueDate: { $gte: new Date( inputData.fromDate ) } },
+      { issueDate: { $lte: new Date( inputData.toDate ) } },
+      {
+        'basicDetails.clientId': { $in: inputData.clientId },
+      },
+      { issueType: { $in: [ 'highcount', 'lowcount' ] } },
+
+    ];
+    if ( inputData?.issueType && inputData?.issueType?.length > 0 ) {
+      filter.push( {
+        issueType: { $in: inputData.issueType },
+      } );
+    }
+    const query = [
+      {
+        $match: {
+          $and: filter,
+        },
+
+      },
+      {
+        $project: {
+          open: {
+            $cond: [
+              {
+                $eq: [ '$status', 'open' ],
+              }, 1, 0,
+            ],
+          },
+          inprogress: {
+            $cond: [
+              { $eq: [ '$status', 'inprogress' ] }, 1, 0,
+            ],
+          },
+          closed: {
+            $cond: [
+              { $eq: [ '$status', 'closed' ] }, 1, 0,
+            ],
+          },
+        },
+      },
+      {
+        $group: {
+          _id: null,
+          total: { $sum: 1 },
+          open: { $sum: '$open' },
+          inprogress: { $sum: '$inprogress' },
+          closed: { $sum: '$closed' },
+        },
+      },
+      {
+        $project: {
+          _id: 0,
+          open: { $ifNull: [ '$open', 0 ] },
+          inprogress: { $ifNull: [ '$inprogress', 0 ] },
+          closed: { $ifNull: [ '$closed', 0 ] },
+          total: 1,
+        },
+      },
+    ];
+    const result = await aggregateTangoTicket( query );
+    if ( result.length == 0 ) {
+      return res.sendError( 'No Data Found', 204 );
+    }
+    return res.sendSuccess( { result: result[0] } );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'ticketCountSplit' } );
+    res.sendError( 'Internal Server Error', 500 );
+  }
+};
+export async function overViewTable( req, res ) {
+  try {
+    const inputData = req.body;
+    const limit = inputData.limit || 10;
+    const offset = inputData.offset ? ( inputData.offset - 1 ) * limit : 0;
+    let filter = [
+      // { issueDate: { $gte: new Date( inputData.fromDate ) } },
+      { issueDate: { $lte: new Date( inputData.toDate ) } },
+      { issueType: { $in: [ 'highcount', 'lowcount' ] } },
+      {
+        'basicDetails.clientId': { $in: inputData.clientId },
+      },
+
+    ];
+    if ( inputData?.issueType && inputData?.issueType?.length > 0 ) {
+      filter.push( {
+        issueType: { $in: inputData.issueType },
+      } );
+    }
+    const query = [
+      {
+        $match: {
+          $and: filter,
+        },
+
+      },
+      {
+        $project: {
+          _id: 0,
+          clientName: '$basicDetails.clientName',
+          storeId: '$basicDetails.storeId',
+          storeName: '$basicDetails.storeName',
+          issueType: 1,
+          status: 1,
+          clientId: '$basicDetails.clientId',
+
+        },
+      },
+    ];
+    if ( inputData.searchValue ) {
+      filter.push( {
+
+        $or: [
+          { 'basicDetails.clientName': { $regex: req.body.searchValue, $options: 'i' } },
+          { 'basicDetails.storeId': { $regex: req.body.searchValue, $options: 'i' } },
+          { 'basicDetails.storeName': { $regex: req.body.searchValue, $options: 'i' } },
+          { 'status': { $regex: req.body.searchValue, $options: 'i' } },
+        ],
+
+      } );
+    }
+    if ( inputData.sortColumName ) {
+      const sortBy = inputData.sortBy || -1;
+      query.push( {
+        $sort: {
+          [inputData.sortColumName == 'storeId' ? 'basicDetails.storeId' :
+            inputData.sortColumName == 'clientName' ? 'basicDetails.clientName' :
+              inputData.sortColumName == 'storeName' ? 'basicDetails.storeName' : inputData.sortColumName]: sortBy,
+        },
+      } );
+    }
+
+
+    const count = await aggregateTangoTicket( query );
+
+    query.push(
+        { $skip: offset },
+        { $limit: limit },
+    );
+
+    const result = await aggregateTangoTicket( query );
+    if ( result.length == 0 ) {
+      return res.sendError( 'No Data Found', 204 );
+    }
+    if ( inputData.isExport ) {
+      const resultChunk = await chunkArray( count, 10 );
+      const promises = resultChunk.map( async ( chunk ) => {
+        const list = [];
+        for ( let i = 0; i < chunk.length; i++ ) {
+          list.push( {
+            'Client Name': chunk[i]?.clientName,
+            'Store ID': chunk[i]?.storeId,
+            'Store Name': chunk[i]?.storeName,
+            'Status': chunk[i]?.status,
+          } );
+        }
+        return list;
+      } );
+      const temp = await Promise.all( promises );
+      const exportResult = temp.flat();
+      await download( exportResult, res );
+      return;
+    }
+    return res.sendSuccess( { result: result, count: count.length } );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'overViewTable' } );
+    res.sendError( 'Internal Server Error', 500 );
+  }
+};
+export async function ticketCount( req, res ) {
+  try {
+    const inputData = req.body;
+
+    let filter = [
+      { issueDate: { $lte: new Date( inputData.toDate ) } },
+      {
+        issueType: { $in: [ 'highcount', 'lowcount' ] },
+      },
+
+    ];
+    if ( inputData.clientId && inputData?.clientId?.length > 0 ) {
+      filter.push( {
+        'basicDetails.clientId': { $in: inputData.clientId },
+      } );
+    }
+    const query = [
+      {
+        $match: {
+          $and: filter,
+        },
+
+      },
+      {
+        $project: {
+          high: {
+            $cond: [
+              {
+                $eq: [ '$issueType', 'highcount' ],
+              }, 1, 0,
+            ],
+          },
+          low: {
+            $cond: [
+              { $eq: [ '$issueType', 'lowcount' ] }, 1, 0,
+            ],
+          },
+        },
+      },
+      {
+        $group: {
+          _id: null,
+          highCount: { $sum: '$high' },
+          LowCount: { $sum: '$low' },
+          total: { $sum: 1 },
+
+        },
+      },
+      {
+        $project: {
+          _id: 0,
+          highCount: 1,
+          LowCount: 1,
+          total: 1,
+        },
+      },
+
+    ];
+
+    const result = await aggregateTangoTicket( query );
+    if ( result.length == 0 ) {
+      return res.sendError( 'No Data Found', 204 );
+    }
+    return res.sendSuccess( { result: result[0] } );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'ticketCount' } );
+    res.sendError( 'Internal Server Error', 500 );
+  }
+};

package/src/controllers/infra.controllers.js

@@ -921,7 +921,59 @@ function inWords( num ) {
 
   return str.toLowerCase().split( ' ' ).map( ( word ) => word.charAt( 0 ).toUpperCase() + word.slice( 1 ) ).join( ' ' );
 }
+export async function allCounts( req, res ) {
+  try {
+    let date = await getUTC( new Date( req.body.fromDate ), new Date( req.body.toDate ) );
+    let countQuery=[
+      {
+        $match: {
+          $and: [
+            { 'basicDetails.clientId': { $in: req.body.clientId } },
+            { createdAt: { $gte: date.start } },
+            { createdAt: { $lte: date.end } },
+          ],
+        },
+      },
+      {
+        $project: {
+          issueType: 1,
+          installationCount: {
+            $cond: [ { $and: [ { $eq: [ '$issueType', 'installation' ] } ] }, 1, 0,
+            ],
+          },
+          infraCount: {
+            $cond: [ { $and: [ { $eq: [ '$issueType', 'infra' ] } ] }, 1, 0,
+            ],
+          },
+          datamismatchCount: {
+            $cond: [ { $or: [ { $eq: [ '$issueType', 'highcount' ] }, { $eq: [ '$issueType', 'lowcount' ] } ] }, 1, 0,
+            ],
+          },
+          matCount: {
+            $cond: [ { $and: [ { $eq: [ '$issueType', 'mat' ] } ] }, 1, 0,
+            ],
+          },
+        },
+      },
+      {
+        $group: {
+          _id: null,
+          installationCount: { $sum: '$installationCount' },
+          infraCount: { $sum: '$infraCount' },
+          datamismatchCount: { $sum: '$datamismatchCount' },
+          matCount: { $sum: '$matCount' },
+
 
+        },
+      },
+    ];
+    let result = await aggregateTangoTicket( countQuery );
+    res.sendSuccess( result );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'allCounts' } );
+    return res.sendError( error, 500 );
+  }
+}
 
 export async function infraTable( req, res ) {
   try {

package/src/controllers/storeInfra.controlller.js

@@ -293,7 +293,6 @@ export async function edgeAppLogTable( req, res ) {
     for ( const obj of timeSlots ) {
       obj.startTime = dayjs( obj.from ).format( 'hh:mm A' );
       obj.endTime = dayjs( obj.to ).format( 'hh:mm A' );
-
       let internetSpeedQuery = {
         'size': 1,
         'query': {
@@ -306,7 +305,7 @@ export async function edgeAppLogTable( req, res ) {
               },
               {
                 'term': {
-                  'store_id.keyword': req.body.storeId,
+                  'storeId.keyword': req.body.storeId,
                 },
               },
               {
@@ -331,9 +330,9 @@ export async function edgeAppLogTable( req, res ) {
         ],
       };
       let speedTest = await getOpenSearchData( 'edgeapp_systemlogs', internetSpeedQuery );
-
       if ( speedTest.body.hits && speedTest.body.hits.hits.length > 0 && speedTest.body.hits.hits[0]._source ) {
-        obj.Internetspeed = speedTest.body.hits.hits[0]._source.data.upload_Speed;
+        const megabytes = bytesToMB( speedTest.body.hits.hits[0]._source.data.upload_Speed.split( '.' )[0] ).toFixed( 2 );
+        obj.Internetspeed = megabytes+ ' MB/sec';
       } else {
         obj.Internetspeed = '';
       }
@@ -420,7 +419,7 @@ export async function edgeAppLogTable( req, res ) {
               },
               {
                 'term': {
-                  'store_id.keyword': req.body.storeId,
+                  'storeId.keyword': req.body.storeId,
                 },
               },
               {
@@ -457,6 +456,9 @@ export async function edgeAppLogTable( req, res ) {
     return res.sendError( error, 500 );
   }
 }
+function bytesToMB( bytes ) {
+  return bytes / ( 1024 * 1024 );
+}
 function generateTimeSlots( startHour, endHour, interval, req ) {
   try {
     const timeSlots = [];
@@ -511,7 +513,7 @@ export async function viewedgeAppLog( req, res ) {
             },
             {
               'term': {
-                'store_id.keyword': req.body.storeId,
+                'storeId.keyword': req.body.storeId,
               },
             },
             {
@@ -572,6 +574,7 @@ export async function viewedgeAppLog( req, res ) {
       ],
     };
     const appQuitTime = await getOpenSearchData( 'edgeapp_systemlogs', appQuitTimeQuery );
+
     let appCrashTimeQuery = {
       'size': 1,
       'query': {
@@ -621,7 +624,7 @@ export async function viewedgeAppLog( req, res ) {
             },
             {
               'term': {
-                'store_id.keyword': req.body.storeId,
+                'storeId.keyword': req.body.storeId,
               },
             },
             {
@@ -724,7 +727,7 @@ export async function viewedgeAppLog( req, res ) {
                 },
                 {
                   'term': {
-                    'store_id.keyword': req.body.storeId,
+                    'storeId.keyword': req.body.storeId,
                   },
                 },
                 {
@@ -995,7 +998,6 @@ export async function streamwiseDowntime( req, res ) {
 
       let streamwiseDowntime = downtime.body.hits.hits.length > 0 ? downtime.body.hits.hits[0]._source.doc.streamwise_downtime : [];
       if ( streamwiseDowntime.length > 0 ) {
-        console.log( streamwiseDowntime );
         for ( let stream of streamwiseDowntime ) {
           if ( stream.stream === req.body.stream ) {
             obj.downTime= stream.down_time;

package/src/controllers/userInfra.controller.js

@@ -753,3 +753,55 @@ export async function storeInfraList( req, res ) {
     return res.sendError( error, 500 );
   }
 }
+export async function pendingTicket( req, res ) {
+  try {
+    let date = await getUTC( new Date( req.body.fromDate ), new Date( req.body.toDate ) );
+    let countQuery=[
+      {
+        $match: {
+          $and: [
+            { 'basicDetails.clientId': { $in: req.body.clientId } },
+            { createdAt: { $lte: date.end } },
+          ],
+        },
+      },
+      {
+        $project: {
+          issueType: 1,
+          installationCount: {
+            $cond: [ { $and: [ { $eq: [ '$issueType', 'installation' ] }, { $ne: [ '$status', 'closed' ] }, { $eq: [ '$ticketDetails.issueStatus', 'notidentified' ] } ] }, 1, 0,
+            ],
+          },
+          infraCount: {
+            $cond: [ { $and: [ { $eq: [ '$issueType', 'infra' ] }, { $ne: [ '$status', 'closed' ] }, { $eq: [ '$ticketDetails.issueStatus', 'notidentified' ] } ] }, 1, 0,
+            ],
+          },
+          datamismatchCount: {
+            $cond: [ { $and: [ { $or: [ { $eq: [ '$issueType', 'highcount' ] }, { $eq: [ '$issueType', 'lowcount' ] } ] }, { $eq: [ '$status', 'closed' ] } ] }, 1, 0,
+            ],
+          },
+          matCount: {
+            $cond: [ { $and: [ { $eq: [ '$issueType', 'mat' ] }, { $eq: [ '$status', 'open' ] } ] }, 1, 0,
+            ],
+          },
+        },
+      },
+      {
+        $group: {
+          _id: null,
+          installationCount: { $sum: '$installationCount' },
+          infraCount: { $sum: '$infraCount' },
+          datamismatchCount: { $sum: '$datamismatchCount' },
+          matCount: { $sum: '$matCount' },
+
+
+        },
+      },
+    ];
+    let result = await aggregateTangoTicket( countQuery );
+    res.sendSuccess( result );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'pendingTicket' } );
+    return res.sendError( error, 500 );
+  }
+}

package/src/routes/clientInfra.routes.js

@@ -1,7 +1,7 @@
 
 import express from 'express';
 import { isAllowedSessionHandler, authorize } from 'tango-app-api-middleware';
-import { infraCard, installationCard, InstallationIssuesTable, infraIssuesTable, hourWiseDownClients, hourWiseDownstores } from '../controllers/clientInfra.controller.js';
+import { infraCard, installationCard, InstallationIssuesTable, infraIssuesTable, hourWiseDownClients, hourWiseDownstores, ticketCountSplit, overViewTable, ticketCount } from '../controllers/clientInfra.controller.js';
 
 export const clientInfraRouter = express.Router();
 
@@ -31,4 +31,15 @@ clientInfraRouter.post( '/hourWiseDownstores', isAllowedSessionHandler, authoriz
     { featureName: 'manage', name: 'tickets', permissions: [ 'isView' ] } ],
 } ), hourWiseDownstores );
 
-
+clientInfraRouter.post( '/ticket-count', isAllowedSessionHandler, authorize( {
+  userType: [ 'client', 'tango' ], access: [
+    { featureName: 'manage', name: 'tickets', permissions: [ 'isView' ] } ],
+} ), ticketCount );
+clientInfraRouter.post( '/ticket-count-split', isAllowedSessionHandler, authorize( {
+  userType: [ 'client', 'tango' ], access: [
+    { featureName: 'manage', name: 'tickets', permissions: [ 'isView' ] } ],
+} ), ticketCountSplit );
+clientInfraRouter.post( '/overview-table', isAllowedSessionHandler, authorize( {
+  userType: [ 'client', 'tango' ], access: [
+    { featureName: 'manage', name: 'tickets', permissions: [ 'isView' ] } ],
+} ), overViewTable );

package/src/routes/infra.routes.js

@@ -4,7 +4,7 @@ import { isAllowedSessionHandler, authorize, validate } from 'tango-app-api-midd
 import { validateDetails, bulkvalidateDetails, validateTicket, bulkvalidateTicket, validateTicketstatus, ticketExists, infraReasonExists, InfrastepstoResolve, InfraAlert } from '../validations/infra.validation.js';
 import { createTicket, bulkcreateTicket, updateStatus, createReason, PrimaryReasons, matTable, removeAttachment,
   secondaryReason, updateTicketIssue, viewTicket, AlertTicketReply, uploadAttachments, getInfraIssues,
-  updateInstallationTicket, emailUserList, saveInfraEmailConfig, invoice, infraTable, storeFilter, assignTicket, installationTable } from '../controllers/infra.controllers.js';
+  updateInstallationTicket, emailUserList, saveInfraEmailConfig, invoice, allCounts, infraTable, storeFilter, assignTicket, installationTable } from '../controllers/infra.controllers.js';
 import { getInfraIssueValid } from '../dtos/infra.dtos.js';
 
 
@@ -60,6 +60,10 @@ infraRouter.post( '/saveInfraEmailConfig', isAllowedSessionHandler, authorize( {
     { featureName: 'settings', name: 'configuration', permissions: [ 'isEdit', 'isView' ] } ],
 } ), saveInfraEmailConfig );
 infraRouter.post( '/invoice', invoice );
+infraRouter.post( '/allCounts', isAllowedSessionHandler, authorize( {
+  userType: [ 'client', 'tango' ], access: [
+    { featureName: 'manage', name: 'tickets', permissions: [ 'isView' ] } ],
+} ), allCounts );
 infraRouter.post( '/infraTable', isAllowedSessionHandler, authorize( {
   userType: [ 'client', 'tango' ], access: [
     { featureName: 'manage', name: 'tickets', permissions: [ 'isView' ] } ],

package/src/routes/userInfra.routes.js

@@ -1,6 +1,6 @@
 import express from 'express';
 import { isAllowedSessionHandler, authorize } from 'tango-app-api-middleware';
-import { userTakeTicket, userTicketList, activeTicketList, basicDetails, workHistory, storeInfraList } from '../controllers/userInfra.controller.js';
+import { userTakeTicket, userTicketList, activeTicketList, basicDetails, workHistory, pendingTicket, storeInfraList } from '../controllers/userInfra.controller.js';
 
 export const userInfraRouter = express.Router();
 
@@ -30,5 +30,9 @@ userInfraRouter.post( '/storeInfraList', isAllowedSessionHandler, authorize( {
     { featureName: 'manage', name: 'tickets', permissions: [ 'isView' ] },
   ],
 } ), storeInfraList );
-
+userInfraRouter.post( '/pendingTicket', isAllowedSessionHandler, authorize( {
+  userType: [ 'tango', 'client' ], access: [
+    { featureName: 'manage', name: 'tickets', permissions: [ 'isView' ] },
+  ],
+} ), pendingTicket );