tango-app-api-infra 3.1.17 → 3.1.18

package/src/controllers/clientInfra.controller.js

@@ -314,21 +314,20 @@ export async function installationCard( req, res ) {
 export async function infraIssuesTable( req, res ) {
   try {
     let date = await getUTC( new Date( req.body.fromDate ), new Date( req.body.toDate ) );
-    let issueStatus = [ 'identified' ];
+    let issueStatus = [ 'notidentified', 'identified' ];
+
     if ( req.body.infrafilterIssue == 'Issues Not Identified' ) {
       issueStatus = [ 'notidentified' ];
     };
-    if ( req.body.infrafilterIssue == 'All Issues' ) {
-      issueStatus = [ 'notidentified', 'identified' ];
-    };
-    if ( req.body.infrafilterIssue == 'Live Stores' ) {
-      issueStatus = [ 'notidentified', 'identified' ];
+    if ( req.body.infrafilterIssue == 'Identified Issues' ) {
+      issueStatus = [ 'identified' ];
     };
+
+
     let totalstores = await aggregateStore( [ {
       $match: {
         '$and': [
           { 'clientId': { $in: req.body.clientId } },
-          { 'edge.firstFile': true },
           { 'status': 'active' },
           { 'createdAt': { $lte: date.end } },
         ],
@@ -338,96 +337,115 @@ export async function infraIssuesTable( req, res ) {
     for ( let store of totalstores ) {
       totalnumberstores.push( store.storeId );
     }
-    let query = [ {
+    let pendingquery = [];
+    pendingquery.push( {
       $match: {
         $and: [
-          { issueType: 'infra' },
-          { status: { $ne: 'closed' } },
+          { issueType: 'installation' },
+          { '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 } },
         ],
       },
-    },
-    {
-      $project: {
-        storeId: '$basicDetails.storeId',
-        clientId: '$basicDetails.clientId',
-        ticketId: 1,
-        storeName: '$basicDetails.storeName',
-        clientName: '$basicDetails.clientName',
-        status: 1,
-        createdAt: 1,
-        issueIdentifiedDate: '$ticketDetails.issueIdentifiedDate',
-        issueClosedDate: '$issueClosedDate',
-        primaryIssue: {
-          $filter: {
-            input: '$ticketActivity',
-            as: 'item',
-            cond: { $eq: [ '$$item.actionType', 'issueUpdate' ] },
+    } );
+    let pendingstorecount = await aggregateTangoTicket( pendingquery );
+    let installpendingticket = pendingstorecount.map( ( store ) => store.basicDetails.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: { $lte: date.end } },
+          ],
+        },
+      },
+      {
+        $project: {
+          storeId: '$basicDetails.storeId',
+          clientId: '$basicDetails.clientId',
+          ticketId: 1,
+          storeName: '$basicDetails.storeName',
+          clientName: '$basicDetails.clientName',
+          status: 1,
+          createdAt: 1,
+          issueIdentifiedDate: '$ticketDetails.issueIdentifiedDate',
+          issueClosedDate: '$issueClosedDate',
+          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,
+        },
       },
-    },
-    {
-      $unwind: {
-        path: '$primaryIssue.reasons.secondaryIssue', preserveNullAndEmptyArrays: true,
+      {
+        $unwind: {
+          path: '$primaryIssue.reasons.secondaryIssue',
+          preserveNullAndEmptyArrays: true,
+        },
       },
-    },
-    {
-      $project: {
-        storeId: 1,
-        clientId: 1,
-        storeName: 1,
-        createdAt: 1,
-        ticketId: 1,
-        clientName: 1,
-        actionBy: '$primaryIssue.actionBy',
-        issueIdentifiedDate: { $ifNull: [ '$issueIdentifiedDate', '' ] },
-        issueClosedDate: { $ifNull: [ '$issueClosedDate', '' ] },
-        status: 1,
-        primaryIssue: { $ifNull: [ '$primaryIssue.reasons.primaryIssue', '-' ] },
-        secondaryIssue: { $ifNull: [ '$primaryIssue.reasons.secondaryIssue.name', '-' ] },
+      {
+        $project: {
+          storeId: 1,
+          clientId: 1,
+          storeName: 1,
+          createdAt: 1,
+          ticketId: 1,
+          clientName: 1,
+          actionBy: '$primaryIssue.actionBy',
+          issueIdentifiedDate: { $ifNull: [ '$issueIdentifiedDate', '' ] },
+          issueClosedDate: { $ifNull: [ '$issueClosedDate', '' ] },
+          status: 1,
+          primaryIssue: { $ifNull: [ '$primaryIssue.reasons.primaryIssue', '-' ] },
+          secondaryIssue: { $ifNull: [ '$primaryIssue.reasons.secondaryIssue.name', '-' ] },
+        },
       },
-    },
-    {
-      $group: {
-        _id: '$ticketId',
-        storeId: { $first: '$storeId' },
-        clientId: { $first: '$clientId' },
-        ticketId: { $first: '$ticketId' },
-        actionBy: { $first: '$actionBy' },
-        storeName: { $first: '$storeName' },
-        clientName: { $first: '$clientName' },
-        createdAt: { $first: '$createdAt' },
-        issueIdentifiedDate: { $last: '$issueIdentifiedDate' },
-        issueClosedDate: { $last: '$issueClosedDate' },
-        status: { $last: '$status' },
-        primaryIssue: { $last: '$primaryIssue' },
-        secondaryIssue: { $last: '$secondaryIssue' },
+      {
+        $group: {
+          _id: '$ticketId',
+          storeId: { $first: '$storeId' },
+          clientId: { $first: '$clientId' },
+          ticketId: { $first: '$ticketId' },
+          actionBy: { $first: '$actionBy' },
+          storeName: { $first: '$storeName' },
+          clientName: { $first: '$clientName' },
+          createdAt: { $first: '$createdAt' },
+          issueIdentifiedDate: { $last: '$issueIdentifiedDate' },
+          issueClosedDate: { $last: '$issueClosedDate' },
+          status: { $last: '$status' },
+          primaryIssue: { $last: '$primaryIssue' },
+          secondaryIssue: { $last: '$secondaryIssue' },
+        },
       },
-    },
     ];
+
     let storesQuery = [];
     if ( req.body.infrafilterIssue == 'Total Stores' ) {
       storesQuery.push( {
         $match: {
           '$and': [
             { 'clientId': { $in: req.body.clientId } },
-            { 'edge.firstFile': true },
             { 'status': 'active' },
+            { 'storeId': { $nin: installpendingticket } },
             { 'createdAt': { $lte: date.end } },
           ],
         },
@@ -436,16 +454,14 @@ export async function infraIssuesTable( req, res ) {
     }
     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 );
-        }
-      }
+      let infraissueStore = infrastores.map( ( store ) => store.storeId );
+
+      let result = totalnumberstores.filter( ( data ) =>
+        infraissueStore.length > 0 &&
+        !infraissueStore.includes( data ) &&
+        !installpendingticket.includes( data ),
+      );
+
       storesQuery.push(
           {
             $match: {
@@ -456,34 +472,29 @@ export async function infraIssuesTable( req, res ) {
           },
       );
     }
-    if ( req.body.infrafilterIssue && req.body.infrafilterIssue != '' &&
-      req.body.infrafilterIssue != 'Identified Issues' &&
-      req.body.infrafilterIssue != 'Issues Not Identified' &&
-      req.body.infrafilterIssue != 'All Issues' ) {
+    const excludedIssues = [ 'Identified Issues', 'Issues Not Identified', 'All Issues' ];
+    if ( req.body.infrafilterIssue && !excludedIssues.includes( req.body.infrafilterIssue ) ) {
       query.push( {
         $match: {
           primaryIssue: req.body.infrafilterIssue,
         },
       } );
     }
-    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' } },
-          ],
-        },
-      } );
-      storesQuery.push( {
+
+    if ( req.body.searchValue && req.body.searchValue !== '' ) {
+      const searchCondition = {
         $match: {
           $or: [
             { storeId: { $regex: req.body.searchValue, $options: 'i' } },
             { storeName: { $regex: req.body.searchValue, $options: 'i' } },
           ],
         },
-      } );
+      };
+
+      query.push( searchCondition );
+      storesQuery.push( searchCondition );
     }
+
     if ( req.body.filter && req.body.filter.length > 0 ) {
       query.push(
           {
@@ -494,12 +505,13 @@ export async function infraIssuesTable( req, res ) {
       );
     }
     if ( req.body.sortColumName && req.body.sortColumName !== '' && req.body.sortBy ) {
-      query.push( {
-        $sort: { [req.body.sortColumName]: req.body.sortBy },
-      } );
-      storesQuery.push( {
-        $sort: { [req.body.sortColumName]: req.body.sortBy },
-      } );
+      const sortOption = { $sort: { [req.body.sortColumName]: req.body.sortBy } };
+      query.push( sortOption );
+      storesQuery.push( sortOption );
+    } else {
+      const sortOption = { $sort: { 'storeId': -1 } };
+      query.push( sortOption );
+      storesQuery.push( sortOption );
     }
     let count;
     if ( req.body.infrafilterIssue == 'Live Stores' || req.body.infrafilterIssue == 'Total Stores' ) {
@@ -508,52 +520,56 @@ export async function infraIssuesTable( req, res ) {
       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 ) },
-      );
+      const skipValue = ( req.body.offset - 1 ) * req.body.limit;
+      const limitValue = Number( req.body.limit );
+
+      const pagination = [
+        { $skip: skipValue },
+        { $limit: limitValue },
+      ];
+
+      query.push( ...pagination );
       storesQuery.push(
-          { $skip: ( req.body.offset - 1 ) * req.body.limit },
-          { $limit: Number( req.body.limit ) },
-      );
-      storesQuery.push( {
-        $lookup: {
-          from: 'clients',
-          let: { clientId: '$clientId' },
-          pipeline: [
-            {
-              $match: {
-                $expr: {
-                  $and: [
-                    { $eq: [ '$clientId', '$$clientId' ] },
-                  ],
+          ...pagination,
+          {
+            $lookup: {
+              from: 'clients',
+              let: { clientId: '$clientId' },
+              pipeline: [
+                {
+                  $match: {
+                    $expr: {
+                      $and: [
+                        { $eq: [ '$clientId', '$$clientId' ] },
+                      ],
+                    },
+                  },
                 },
-              },
-
+                {
+                  $project: {
+                    clientName: 1,
+                  },
+                },
+              ],
+              as: 'client',
             },
-            {
-              $project: {
-                clientName: 1,
-              },
+          },
+          {
+            $unwind: { path: '$client', preserveNullAndEmptyArrays: true },
+          },
+          {
+            $project: {
+              clientName: '$client.clientName',
+              storeId: 1,
+              clientId: 1,
+              storeName: 1,
+              status: 1,
+              createdAt: 1,
             },
-          ], as: 'client',
-        },
-      },
-      {
-        $unwind: { path: '$client', preserveNullAndEmptyArrays: true },
-      },
-      {
-        $project: {
-          clientName: '$client.clientName',
-          storeId: 1,
-          clientId: 1,
-          storeName: 1,
-          status: 1,
-          createdAt: 1,
-        },
-      },
+          },
       );
     }
+
     let result;
     if ( req.body.infrafilterIssue == 'Live Stores' || req.body.infrafilterIssue == 'Total Stores' ) {
       result = await aggregateStore( storesQuery );
@@ -561,21 +577,30 @@ export async function infraIssuesTable( req, res ) {
       result = await aggregateTangoTicket( query );
     }
     if ( req.body.export && result.length > 0 ) {
-      const exportdata = [];
-      result.forEach( ( element ) => {
-        exportdata.push( {
-          'Created On': element.createdAt,
-          'StoreID': element.storeId,
-          'StoreName': element.storeName,
-          'Primary Issue': element.primaryIssue,
-          'Sub Issue': element.secondaryIssue,
-          'Issue Identified on': element.issueIdentifiedDate? dayjs( element.issueIdentifiedDate ).tz( 'Asia/Kolkata' ).format( 'YYYY-MM-DD HH:mm A' ):'',
-          'Status': element.status,
-        } );
+      const exportdata = result.map( ( element ) => {
+        if ( req.body.infrafilterIssue === 'Live Stores' || req.body.infrafilterIssue === 'Total Stores' ) {
+          return {
+            'Created On': element.createdAt,
+            'StoreID': element.storeId,
+            'StoreName': element.storeName,
+            'Status': element.status,
+          };
+        } else {
+          return {
+            'Created On': element.createdAt,
+            'StoreID': element.storeId,
+            'StoreName': element.storeName,
+            'Primary Issue': element.primaryIssue,
+            'Sub Issue': element.secondaryIssue,
+            'Issue Identified on': element.issueIdentifiedDate ? dayjs( element.issueIdentifiedDate ).tz( 'Asia/Kolkata' ).format( 'YYYY-MM-DD HH:mm A' ) : '',
+            'Status': element.status,
+          };
+        }
       } );
       await download( exportdata, res );
       return;
     }
+
     if ( result.length > 0 ) {
       res.sendSuccess( {
         count: count.length,
@@ -981,111 +1006,155 @@ function generateTimeSlots( startHour, endHour, interval, time ) {
 };
 export async function hourWiseDownstores( req, res ) {
   try {
-    let inputData = req.body;
-    inputData.Date = dayjs( req.body.toDate ).format( 'YYYY-MM-DD' );
-    let issueStatus = [ 'identified' ];
-    if ( req.body.filterIssue == 'Issues Not Identified' ) {
+    let date = await getUTC( new Date( req.body.fromDate ), new Date( req.body.toDate ) );
+    let issueStatus = [ 'notidentified', 'identified' ];
+
+    if ( req.body.infrafilterIssue == 'Issues Not Identified' ) {
       issueStatus = [ 'notidentified' ];
     };
-    if ( req.body.filterIssue == 'All Issues' ) {
-      issueStatus = [ 'notidentified', 'identified' ];
-    };
-    if ( req.body.filterIssue == 'Live Stores' ) {
-      issueStatus = [ 'notidentified', 'identified' ];
+    if ( req.body.infrafilterIssue == 'Identified Issues' ) {
+      issueStatus = [ 'identified' ];
     };
 
+
     let totalstores = await aggregateStore( [ {
       $match: {
         '$and': [
-          { 'clientId': req.body.clientId },
-          { 'edge.firstFile': true },
+          { 'clientId': { $in: req.body.clientId } },
           { 'status': 'active' },
-          { 'createdAt': { $lte: new Date( req.body.toDate ) } },
+          { 'createdAt': { $lte: date.end } },
         ],
       },
     } ] );
-
     let totalnumberstores = [];
     for ( let store of totalstores ) {
       totalnumberstores.push( store.storeId );
     }
-    let query = [ {
+    let pendingquery = [];
+    pendingquery.push( {
       $match: {
         $and: [
-          { 'basicDetails.clientId': req.body.clientId },
-          { 'basicDetails.storeId': { $in: totalnumberstores } },
+          { issueType: 'installation' },
           { 'status': { $ne: 'closed' } },
-          { issueType: 'infra' },
-          { 'ticketDetails.issueStatus': { $in: issueStatus } },
-          { 'issueDate': { $lte: new Date( req.body.toDate ) } },
+          { 'basicDetails.clientId': { $in: req.body.clientId } },
+          { createdAt: { $lte: date.end } },
         ],
       },
-    },
-    {
-      $project: {
-        storeId: '$basicDetails.storeId',
-        storeName: '$basicDetails.storeName',
-        primaryIssue: {
-          $filter: {
-            input: '$ticketActivity',
-            as: 'item',
-            cond: { $eq: [ '$$item.actionType', 'issueUpdate' ] },
+    } );
+    let pendingstorecount = await aggregateTangoTicket( pendingquery );
+    let installpendingticket = pendingstorecount.map( ( store ) => store.basicDetails.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: { $lte: date.end } },
+          ],
+        },
+      },
+      {
+        $project: {
+          storeId: '$basicDetails.storeId',
+          clientId: '$basicDetails.clientId',
+          ticketId: 1,
+          storeName: '$basicDetails.storeName',
+          clientName: '$basicDetails.clientName',
+          status: 1,
+          createdAt: 1,
+          issueIdentifiedDate: '$ticketDetails.issueIdentifiedDate',
+          issueClosedDate: '$issueClosedDate',
+          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: {
-        storeId: 1,
-        storeName: 1,
-        primaryIssue: { $ifNull: [ '$primaryIssue.reasons.primaryIssue', 'NotIdentified' ] },
+      {
+        $unwind: {
+          path: '$primaryIssue.reasons.secondaryIssue',
+          preserveNullAndEmptyArrays: true,
+        },
       },
-    },
-    {
-      $group: {
-        _id: '$storeId',
-        storeId: { $first: '$storeId' },
-        storeName: { $first: '$storeName' },
-        primaryIssue: { $last: '$primaryIssue' },
+      {
+        $project: {
+          storeId: 1,
+          clientId: 1,
+          storeName: 1,
+          createdAt: 1,
+          ticketId: 1,
+          clientName: 1,
+          actionBy: '$primaryIssue.actionBy',
+          issueIdentifiedDate: { $ifNull: [ '$issueIdentifiedDate', '' ] },
+          issueClosedDate: { $ifNull: [ '$issueClosedDate', '' ] },
+          status: 1,
+          primaryIssue: { $ifNull: [ '$primaryIssue.reasons.primaryIssue', '-' ] },
+          secondaryIssue: { $ifNull: [ '$primaryIssue.reasons.secondaryIssue.name', '-' ] },
+        },
+      },
+      {
+        $group: {
+          _id: '$ticketId',
+          storeId: { $first: '$storeId' },
+          clientId: { $first: '$clientId' },
+          ticketId: { $first: '$ticketId' },
+          actionBy: { $first: '$actionBy' },
+          storeName: { $first: '$storeName' },
+          clientName: { $first: '$clientName' },
+          createdAt: { $first: '$createdAt' },
+          issueIdentifiedDate: { $last: '$issueIdentifiedDate' },
+          issueClosedDate: { $last: '$issueClosedDate' },
+          status: { $last: '$status' },
+          primaryIssue: { $last: '$primaryIssue' },
+          secondaryIssue: { $last: '$secondaryIssue' },
+        },
       },
-    },
     ];
+
     let storesQuery = [];
-    if ( req.body.filterIssue == 'Total Stores' ) {
+    if ( req.body.infrafilterIssue == 'Total Stores' ) {
       storesQuery.push( {
         $match: {
           '$and': [
-            { 'clientId': req.body.clientId },
-            { 'edge.firstFile': true },
+            { 'clientId': { $in: req.body.clientId } },
             { 'status': 'active' },
-            { 'createdAt': { $lte: new Date( req.body.toDate ) } },
+            { 'storeId': { $nin: installpendingticket } },
+            { 'createdAt': { $lte: date.end } },
           ],
         },
       },
       );
     }
-    if ( req.body.filterIssue == 'Live Stores' ) {
+    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 );
-        }
-      }
+      let infraissueStore = infrastores.map( ( store ) => store.storeId );
+
+      let result = totalnumberstores.filter( ( data ) =>
+        infraissueStore.length > 0 &&
+        !infraissueStore.includes( data ) &&
+        !installpendingticket.includes( data ),
+      );
+
       storesQuery.push(
           {
             $match: {
@@ -1096,71 +1165,116 @@ export async function hourWiseDownstores( req, res ) {
           },
       );
     }
-    if ( req.body.searchValue && req.body.searchValue !== '' ) {
+    const excludedIssues = [ 'Identified Issues', 'Issues Not Identified', 'All Issues' ];
+    if ( req.body.infrafilterIssue && !excludedIssues.includes( req.body.infrafilterIssue ) ) {
       query.push( {
         $match: {
-          $or: [
-            { storeName: { $regex: req.body.searchValue, $options: 'i' } },
-            { storeId: { $regex: req.body.searchValue, $options: 'i' } },
-          ],
+          primaryIssue: req.body.infrafilterIssue,
         },
       } );
-      storesQuery.push( {
+    }
+
+    if ( req.body.searchValue && req.body.searchValue !== '' ) {
+      const searchCondition = {
         $match: {
           $or: [
-            { storeName: { $regex: req.body.searchValue, $options: 'i' } },
             { storeId: { $regex: req.body.searchValue, $options: 'i' } },
+            { storeName: { $regex: req.body.searchValue, $options: 'i' } },
           ],
         },
-      } );
+      };
+
+      query.push( searchCondition );
+      storesQuery.push( searchCondition );
     }
-    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.filter && req.body.filter.length > 0 ) {
+      query.push(
+          {
+            $match: {
+              actionBy: { $in: req.body.filter },
+            },
+          },
+      );
     }
-    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,
-        },
-      } );
+    if ( req.body.sortColumName && req.body.sortColumName !== '' && req.body.sortBy ) {
+      const sortOption = { $sort: { [req.body.sortColumName]: req.body.sortBy } };
+      query.push( sortOption );
+      storesQuery.push( sortOption );
+    } else {
+      const sortOption = { $sort: { 'storeId': -1 } };
+      query.push( sortOption );
+      storesQuery.push( sortOption );
     }
-
     let count;
-    if ( req.body.filterIssue == 'Live Stores' || req.body.filterIssue == 'Total Stores' ) {
+    if ( req.body.infrafilterIssue == 'Live Stores' || req.body.infrafilterIssue == '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 ) },
-      );
+      const skipValue = ( req.body.offset - 1 ) * req.body.limit;
+      const limitValue = Number( req.body.limit );
+
+      const pagination = [
+        { $skip: skipValue },
+        { $limit: limitValue },
+      ];
+
+      query.push( ...pagination );
       storesQuery.push(
-          { $skip: ( req.body.offset - 1 ) * req.body.limit },
-          { $limit: Number( req.body.limit ) },
+          ...pagination,
+          {
+            $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,
+              createdAt: 1,
+            },
+          },
       );
     }
+
     let storesList;
-    if ( req.body.filterIssue == 'Live Stores' || req.body.filterIssue == 'Total Stores' ) {
+    if ( req.body.infrafilterIssue == 'Live Stores' || req.body.infrafilterIssue == 'Total Stores' ) {
       storesList = await aggregateStore( storesQuery );
     } else {
       storesList = await aggregateTangoTicket( query );
     }
-
     if ( storesList.length == 0 ) {
       return res.sendError( 'no data', 204 );
     }
     let data = {};
     let result = [];
+    let inputData = req.body;
     for ( const store of storesList ) {
       data.storeId = store.storeId;
       data.storeName = store.storeName;
@@ -1179,82 +1293,64 @@ export async function hourWiseDownstores( req, res ) {
   }
 }
 
+async function downStoresCheck( data, inputData ) {
+  try {
+    const TimeSlots = generateTimeSlots( 8, 22, 60, inputData.Date );
+    const formattedTimeSlots = TimeSlots.map( ( slot ) => ( {
+      ...slot,
+      startTime: dayjs( slot.from ).format( 'hh:mm A' ),
+      endTime: dayjs( slot.to ).format( 'hh:mm A' ),
+    } ) );
 
-function downStoresCheck( data, inputData ) {
-  return new Promise( async ( Resolve, Reject ) => {
-    try {
-      let TimeSlots = generateTimeSlots( 8, 22, 60, inputData.Date );
-      let timewise = [];
-      for ( const obj of TimeSlots ) {
-        obj.startTime = dayjs( obj.from ).format( 'hh:mm A' );
-        obj.endTime = dayjs( obj.to ).format( 'hh:mm A' );
-        const downTime = await getOpenSearchData( JSON.parse( process.env.OPENSEARCH ).downTimeHourly,
-            {
-              'size': 1,
-              'query': {
-                'bool': {
-                  'must': [
-                    {
-                      'term': {
-                        'doc.date.keyword': dayjs( inputData.Date ).format( 'DD-MM-YYYY' ),
-                      },
-                    },
-                    {
-                      'term': {
-                        'doc.store_id.keyword': data.storeId,
-                      },
-                    },
-                    {
-                      'terms': {
-                        'doc.hour.keyword': [ obj.hour ],
-                      },
-                    },
-                  ],
-
-                },
+    const downTimePromises = formattedTimeSlots.map( async ( obj ) => {
+      const downTime = await getOpenSearchData(
+          JSON.parse( process.env.OPENSEARCH ).downTimeHourly,
+          {
+            size: 1,
+            query: {
+              bool: {
+                must: [
+                  { term: { 'doc.date.keyword': dayjs( inputData.Date ).format( 'DD-MM-YYYY' ) } },
+                  { term: { 'doc.store_id.keyword': data.storeId } },
+                  { terms: { 'doc.hour.keyword': [ obj.hour ] } },
+                ],
               },
+            },
+          },
+      );
 
-            } );
-        let streamwiseDowntime = downTime.body.hits.hits.length > 0 ? downTime.body.hits.hits[0]._source.doc.streamwise_downtime : [];
-        if ( streamwiseDowntime.length > 0 ) {
-          const sum = streamwiseDowntime.reduce( ( accumulator, currentValue ) => {
-            return accumulator + currentValue.down_time;
-          }, 0 );
-
-          // Calculate the average
-          const average = sum / streamwiseDowntime.length;
-          obj[obj.startTime + '-' + obj.endTime] = Math.round( average );
-        } else {
-          obj[obj.startTime + '-' + obj.endTime] = '';
-        }
+      const streamwiseDowntime = downTime.body.hits.hits.length > 0 ?
+        downTime.body.hits.hits[0]._source.doc.streamwise_downtime :
+        [];
 
-        timewise.push( obj );
-      }
-      const mergedData = {
-        storeName: data.storeName,
-        storeId: data.storeId,
-        PrimaryIssue: data.primaryIssue,
-      };
-      timewise.forEach( ( obj ) => {
-        for ( const key in obj ) {
-          if ( key !== 'hour' && key !== 'from' && key !== 'to' && key !== 'startTime' && key !== 'endTime' && key !== 'clientId' ) {
-            if ( mergedData[key] ) {
-              mergedData[key] += obj[key];
-            } else {
-              mergedData[key] = obj[key];
-            }
-          }
+      const average = streamwiseDowntime.length ?
+        Math.round( streamwiseDowntime.reduce( ( acc, curr ) => acc + curr.down_time, 0 ) / streamwiseDowntime.length ) :
+        '';
+
+      return { ...obj, [`${obj.startTime}-${obj.endTime}`]: average };
+    } );
+
+    const timewise = await Promise.all( downTimePromises );
+
+    const mergedData = timewise.reduce( ( acc, obj ) => {
+      for ( const [ key, value ] of Object.entries( obj ) ) {
+        if ( ![ 'hour', 'from', 'to', 'startTime', 'endTime', 'clientId' ].includes( key ) ) {
+          acc[key] = ( acc[key] || 0 ) + value;
         }
-      } );
+      }
+      return acc;
+    }, {
+      storeName: data.storeName,
+      storeId: data.storeId,
+      PrimaryIssue: data.primaryIssue,
+    } );
 
-      // Create an array with the merged data.
-      const mergedArray = [ mergedData ];
-      Resolve( mergedArray );
-    } catch ( err ) {
-      Reject( err );
-    }
-  } );
+    return [ mergedData ];
+  } catch ( err ) {
+    throw err;
+  }
 }
+
 export async function ticketCountSplit( req, res ) {
   try {
     const inputData = req.body;