tango-app-api-infra 3.0.4 → 3.0.6

package/app.js

@@ -0,0 +1,36 @@
+
+import express from 'express';
+import { infraRouter } from './index.js';
+import dotenv from 'dotenv';
+import { logger } from './config/logger/logger.js';
+import responseMiddleware from './config/response/response.js';
+import errorMiddleware from './config/response/error.js';
+import { connectdb } from './config/database/database.js';
+import pkg from 'body-parser';
+const { json, urlencoded } = pkg;
+
+const env=dotenv.config();
+
+const app = express();
+const PORT = process.env.PORT || 3000;
+
+
+if ( env.error ) {
+  logger.error( '.env not found' );
+  process.exit( 1 );
+}
+app.use( json( { limit: '500mb' } ) );
+app.use(
+    urlencoded( {
+      extended: true,
+    } ),
+);
+app.use( responseMiddleware );
+app.use( errorMiddleware );
+app.use( '/api', infraRouter );
+
+app.listen( PORT, () => {
+  console.log( `server is running on port= ${PORT} ` );
+  connectdb();
+} );
+

package/index.js

@@ -2,6 +2,8 @@
 
 import { infraRouter } from './src/routes/infra.routes.js';
 import { internalInfraRouter } from './src/routes/internalInfra.routes.js';
-export { infraRouter, internalInfraRouter };
+import { userInfraRouter } from './src/routes/userinfra.routes.js';
+
+export { infraRouter, internalInfraRouter, userInfraRouter };
 
 

package/package.json

@@ -1,11 +1,11 @@
 {
     "name": "tango-app-api-infra",
-    "version": "3.0.4",
+    "version": "3.0.6",
     "description": "infra",
-    "main": "index.js",
+    "main": "app.js",
     "type": "module",
     "scripts": {
-        "start": "nodemon --exec \"eslint --fix . && node index.js\""
+        "start": "nodemon --exec \"eslint --fix . && node app.js\""
     },
     "engines": {
         "node": ">=18.10.0"
@@ -20,7 +20,7 @@
         "handlebars": "^4.7.8",
         "mongodb": "^6.4.0",
         "nodemon": "^3.1.0",
-        "tango-api-schema": "^2.0.14",
+        "tango-api-schema": "^2.0.23",
         "tango-app-api-middleware": "^1.0.15",
         "winston": "^3.12.0",
         "winston-daily-rotate-file": "^5.0.0"

package/src/controllers/infra.controllers.js

@@ -1,15 +1,20 @@
 
 
-import dataModel from 'tango-api-schema';
+import { createTangoTicket, updateOneTangoTicket } from '../services/tangoTicket.service.js';
+import { createinfraReason, findinfraReason } from '../services/infraReason.service.js';
 import { logger } from 'tango-app-api-middleware';
 export async function createTicket( req, res ) {
   try {
-    req.body.ticketId = 'TE_INF_' + new Date().valueOf();
     req.body.issueDate = new Date( req.body.Date );
-    req.body.infraTicketDetails = {
-      filesCount: req.body.filesCount,
-    };
-    let create = await dataModel.tangoTicket.create( req.body );
+    req.body.infraTicketDetails.filesCount = req.body.filesCount;
+    if ( req.body.issueType == 'infra' ) {
+      req.body.ticketId = 'TE_INF_' + new Date().valueOf();
+      req.body.infraActivity = [ {
+        actionType: 'defaultInfra',
+        actionBy: 'Tango',
+      } ];
+    }
+    let create = await createTangoTicket( req.body );
     if ( create ) {
       res.sendSuccess( 'Ticket Created Successfully' );
     }
@@ -20,26 +25,92 @@ export async function createTicket( req, res ) {
 }
 
 
-export async function updateTicket( req, res ) {
+export async function updateStatus( req, res ) {
   try {
     let infraTicketDetails = {};
     if ( req.body.status == 'close' ) {
-      infraTicketDetails.ticketClosingtime = new Date();
+      req.body.infraActivity.push( {
+        actionType: 'dataRecived',
+        actionBy: 'Tango',
+      } );
     }
-
-    let updateTicket = await dataModel.tangoTicket.updateOne( { ticketId: req.body.ticketId },
+    if ( req.body.status == 'inprogress' ) {
+      req.body.infraActivity.push( {
+        actionType: 'statusChange',
+        actionBy: 'User',
+      } );
+    }
+    let updateTicket = await updateOneTangoTicket( { ticketId: req.body.ticketId },
         {
-          $set: {
-            status: req.body.status,
-            infraTicketDetails: infraTicketDetails,
-          },
+          status: req.body.status,
+          infraTicketDetails: infraTicketDetails,
+          infraActivity: req.body.infraActivity,
         },
     );
     if ( updateTicket ) {
       res.sendSuccess( 'Ticket Updated Successfully' );
     }
   } catch ( error ) {
-    logger.error( { error: error, function: 'updateTicket' } );
+    logger.error( { error: error, function: 'updateStatus' } );
+    return res.sendError( error, 500 );
+  }
+}
+
+
+export async function createReason( req, res ) {
+  try {
+    let create = await createinfraReason( req.body );
+    if ( create ) {
+      res.sendSuccess( 'Reason Created Successfully' );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, function: 'createReason' } );
+    return res.sendError( error, 500 );
+  }
+}
+
+
+export async function PrimaryReasons( req, res ) {
+  try {
+    let list = await findinfraReason( { parentId: { $exists: false } }, { name: 1, order: 1 } );
+    if ( list.length > 0 ) {
+      res.send( {
+        count: list.length,
+        result: list,
+      } );
+    } else {
+      res.sendError( 'No data found', 204 );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, function: 'PrimaryReasons' } );
+    return res.sendError( error, 500 );
+  }
+}
+
+export async function secondaryReason( req, res ) {
+  try {
+    let list = await findinfraReason( { parentName: req.body.primaryIssue }, { name: 1, order: 1 } );
+    if ( list.length > 0 ) {
+      res.send( {
+        count: list.length,
+        result: list,
+      } );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, function: 'secondaryReason' } );
+    return res.sendError( error, 500 );
+  }
+}
+
+
+export async function updateTicketIssue( req, res ) {
+  try {
+    let updateTicket = await updateOneTangoTicket( { ticketId: req.body.ticketId }, { 'infraActivity': req.body.infraActivity, 'infraTicketDetails.issueStatus': 'identified' } );
+    if ( updateTicket ) {
+      res.sendSuccess( 'Ticket Updated  Successfully' );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, function: 'updateTicketIssue' } );
     return res.sendError( error, 500 );
   }
 }

package/src/controllers/internalInfra.controller.js

@@ -1,7 +1,10 @@
 
 import { logger } from 'tango-app-api-middleware';
-import dataModel from 'tango-api-schema';
 import dayjs from 'dayjs';
+import { createClient, findClient } from '../services/client.service.js';
+import { createStore, findStore, updateOneStore } from '../services/store.service.js';
+import { findTangoTicket, updateOneTangoTicket } from '../services/tangoTicket.service.js';
+
 
 export async function migrateClient() {
   try {
@@ -24,7 +27,7 @@ export async function migrateClient() {
           reTrain: 1,
         },
       };
-      await dataModel.clientModel.create( framedClient );
+      await createClient( framedClient );
     };
   } catch ( error ) {
     logger.error( { error: error, function: 'migrateClient' } );
@@ -51,7 +54,8 @@ export async function migrateStores() {
 
 
       };
-      await dataModel.storeModel.create( framedStores );
+
+      await createStore( framedStores );
     };
   } catch ( error ) {
     logger.error( { error: error, function: 'migrateStores' } );
@@ -60,7 +64,7 @@ export async function migrateStores() {
 }
 export async function clientList( req, res ) {
   try {
-    let storeList = await dataModel.clientModel.find( { status: 'active' },
+    let storeList = await findClient( { status: 'active' },
         { 'clientName': 1, 'clientId': 1, 'ticketConfigs': 1 } );
     res.sendSuccess( storeList );
   } catch ( error ) {
@@ -71,7 +75,7 @@ export async function clientList( req, res ) {
 
 export async function basicList( req, res ) {
   try {
-    let storeList = await dataModel.storeModel.find( { status: 'active' },
+    let storeList = await findStore( { status: 'active' },
         { 'storeName': 1, 'storeId': 1, 'clientId': 1, 'storeProfile.open': 1, 'storeProfile.close': 1, 'storeProfile.timeZone': 1 } );
     res.sendSuccess( storeList );
   } catch ( error ) {
@@ -85,7 +89,7 @@ export async function setTicketTime( req, res ) {
   try {
     let input = req.body;
     for ( let i = 0; i < input.stores.length; i++ ) {
-      await dataModel.storeModel.updateOne( { storeId: input.stores[i].storeId }, { 'ticketConfigs.nextTicektGenerationTime': new Date( input.stores[i].nextTicektGenerationTime ) } );
+      await updateOneStore( { storeId: input.stores[i].storeId }, { 'ticketConfigs.nextTicektGenerationTime': new Date( input.stores[i].nextTicektGenerationTime ) } );
     };
     res.sendSuccess( 'Updated Suceessfully' );
   } catch ( error ) {
@@ -97,8 +101,12 @@ export async function setTicketTime( req, res ) {
 export async function downStoresList( req, res ) {
   try {
     let getCurrentHour = dayjs().startOf( 'hour' ).format( 'YYYY-MM-DDTHH:mm' );
-    let storesList = await dataModel.storeModel.find( { 'ticketConfigs.nextTicektGenerationTime': new Date( getCurrentHour ) }, { storeId: 1, storeName: 1, storeProfile: 1, ticketConfigs: 1 } );
-    res.sendSuccess( storesList );
+    let storesList = await findStore( { 'ticketConfigs.nextTicektGenerationTime': new Date( getCurrentHour ) }, { storeId: 1, storeName: 1, storeProfile: 1, ticketConfigs: 1 } );
+    if ( storesList.length > 0 ) {
+      res.sendSuccess( storesList );
+    } else {
+      res.sendError( 'No data found', 204 );
+    }
   } catch ( error ) {
     logger.error( { error: error, function: 'downStoresList' } );
     res.sendError( error, 500 );
@@ -106,11 +114,15 @@ export async function downStoresList( req, res ) {
 }
 export async function openTicketList( req, res ) {
   try {
-    let openTicketList = await dataModel.tangoTicketModel.find( { status: { $ne: 'closed' } }, { ticketId: 1, basicDetails: 1 } );
-    res.send( {
-      count: openTicketList.length,
-      data: openTicketList,
-    } );
+    let openTicketList = await findTangoTicket( { status: { $ne: 'closed' } }, { ticketId: 1, basicDetails: 1, createdAt: 1, updateAt: 1, infraTicketDetails: 1 } );
+    if ( openTicketList.length ) {
+      res.send( {
+        count: openTicketList.length,
+        data: openTicketList,
+      } );
+    } else {
+      res.sendError( 'No data found', 204 );
+    }
   } catch ( error ) {
     logger.error( { error: error, function: 'openTicketList' } );
     res.sendError( error, 500 );
@@ -119,10 +131,19 @@ export async function openTicketList( req, res ) {
 
 export async function assigntoUser( req, res ) {
   try {
-    await dataModel.tangoTicketModel.updateOne( { ticketId: req.body.ticketId }, { $set: { 'infraTicketDetails.assigntoUser': true } } );
+    await updateOneTangoTicket( { ticketId: req.body.ticketId }, { 'infraTicketDetails.assigntoUser': true } );
     res.sendSuccess( 'assigntoUser Successfully' );
   } catch ( error ) {
     logger.error( { error: error, function: 'assigntoUser' } );
     res.sendError( error, 500 );
   }
 }
+export async function updateRefreshTicket( req, res ) {
+  try {
+    await updateOneTangoTicket( { ticketId: req.body.ticketId }, { 'infraTicketDetails.ticketType': 'refreshticket' } );
+    res.sendSuccess( 'updated Successfully' );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'updateRefreshTicket' } );
+    res.sendError( error, 500 );
+  }
+}

package/src/controllers/userinfra.controller.js

@@ -0,0 +1,97 @@
+
+import { findOneTangoTicket, updateOneTangoTicket, aggregateTangoTicket, countDocumentsTangoTicket } from '../services/tangoTicket.service.js';
+import { logger } from 'tango-app-api-middleware';
+import { findOneUser } from '../services/user.service.js';
+import mongoose from 'mongoose';
+export async function userTakeTicket( req, res ) {
+  try {
+    let userTicket = await findOneTangoTicket( { 'status': { $ne: 'closed' }, 'infraTicketDetails.assigntoUser': true } );
+    if ( userTicket ) {
+      let assignTicket = await updateOneTangoTicket( { ticketId: userTicket.ticketId }, { 'infraTicketDetails.addressingUser': req.body.userId } );
+      if ( assignTicket ) {
+        res.sendSuccess( 'Ticket Assigned Successfully' );
+      }
+    } else {
+      res.sendError( 'Ticket Not Found', 204 );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, function: 'userTakeTicket' } );
+    return res.sendError( error, 500 );
+  }
+}
+export async function userTicketList( req, res ) {
+  try {
+    let query = [ {
+      $match: {
+        'status': req.body.status,
+        'infraTicketDetails.addressingUser': new mongoose.Types.ObjectId( req.body.userId ),
+      },
+    },
+    {
+      $project: {
+        storeId: '$basicDetails.storeId',
+        Date: { $dateToString: { format: '%d-%m-%Y', date: '$issueDate' } },
+        ticketId: 1,
+        issueStatus: '$infraTicketDetails.issueStatus',
+        ticketType: '$infraTicketDetails.ticketType',
+        primaryIssue: {
+          $filter: {
+            input: '$infraActivity',
+            as: 'item',
+            cond: { $eq: [ '$$item.actionType', 'issueUpdate' ] },
+          },
+        },
+      },
+    },
+    {
+      $unwind: {
+        path: '$primaryIssue', preserveNullAndEmptyArrays: true },
+    },
+    {
+      $unwind: {
+        path: '$primaryIssue.reasons', preserveNullAndEmptyArrays: true },
+    }, {
+      $project: {
+        storeId: 1,
+        Date: 1,
+        ticketId: 1,
+        issueStatus: 1,
+        ticketType: 1,
+        infraIssue: '$primaryIssue.reasons.primaryIssue',
+      },
+    } ];
+    let ticketList = await aggregateTangoTicket( query );
+    res.sendSuccess( {
+      count: ticketList.length,
+      data: ticketList,
+    } );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'userTicketList' } );
+    return res.sendError( error, 500 );
+  }
+}
+export async function basicDetails( req, res ) {
+  try {
+    let user = await findOneUser( { _id: new mongoose.Types.ObjectId( req.body.userId ) }, { userName: 1, userType: 1 } );
+
+    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' } );
+    res.sendSuccess( {
+      userName: user.userName,
+      userType: user.userType,
+      total: infraCount+installationCount,
+      infraCount: infraCount,
+      installationCount: installationCount,
+      dataMismatchCount: 0,
+      auditCount: 0,
+      employeeTrainingCount: 0,
+    } );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'userTakeTicket' } );
+    return res.sendError( error, 500 );
+  }
+}
+

package/src/routes/infra.routes.js

@@ -1,12 +1,16 @@
 
 import express from 'express';
-import { validateDetails, validateTicket } from '../middleware/infra.middleware.js';
-import { createTicket, updateTicket } from '../controllers/infra.controllers.js';
+import { validateDetails, validateTicket, ticketExists, infraReasonExists, InfrastepstoResolve } from '../validations/infra.validation.js';
+import { createTicket, updateStatus, createReason, PrimaryReasons, secondaryReason, updateTicketIssue } from '../controllers/infra.controllers.js';
 
 
 export const infraRouter = express.Router();
 
 infraRouter.post( '/createTicket', validateDetails, validateTicket, createTicket );
-infraRouter.post( '/updateTicket', updateTicket );
+infraRouter.post( '/updateStatus', ticketExists, updateStatus );
+infraRouter.post( '/createReason', createReason );
+infraRouter.get( '/PrimaryReasons', PrimaryReasons );
+infraRouter.post( '/secondaryReason', secondaryReason );
+infraRouter.post( '/updateTicketIssue', ticketExists, infraReasonExists, InfrastepstoResolve, updateTicketIssue );
 
 

package/src/routes/internalInfra.routes.js

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

package/src/routes/userinfra.routes.js

@@ -0,0 +1,9 @@
+import express from 'express';
+import { userTakeTicket, userTicketList, basicDetails } from '../controllers/userinfra.controller.js';
+
+export const userInfraRouter = express.Router();
+
+userInfraRouter.post( '/userTakeTicket', userTakeTicket );
+userInfraRouter.post( '/userTicketList', userTicketList );
+userInfraRouter.post( '/basicDetails', basicDetails );
+

package/src/services/client.service.js

@@ -0,0 +1,12 @@
+
+import dataModel from 'tango-api-schema';
+
+export async function createClient( inputData ) {
+  return await dataModel.clientModel.create( inputData );
+}
+export async function findClient( query, project ) {
+  return await dataModel.clientModel.find( query, project );
+}
+export async function findOneClient( query, project ) {
+  return await dataModel.clientModel.findOne( query, project );
+}

package/src/services/infraReason.service.js

@@ -0,0 +1,11 @@
+import dataModel from 'tango-api-schema';
+
+export async function createinfraReason( inputData ) {
+  return await dataModel.infraReasonsModel.create( inputData );
+}
+export async function findinfraReason( query, project ) {
+  return await dataModel.infraReasonsModel.find( query, project );
+}
+export async function findOneinfraReason( query, project ) {
+  return await dataModel.infraReasonsModel.findOne( query, project );
+}

package/src/services/store.service.js

@@ -0,0 +1,15 @@
+
+import dataModel from 'tango-api-schema';
+
+export async function createStore( inputData ) {
+  return await dataModel.storeModel.create( inputData );
+}
+export async function findStore( query, project ) {
+  return await dataModel.storeModel.find( query, project );
+}
+export async function findOneStore( query, project ) {
+  return await dataModel.storeModel.findOne( query, project );
+}
+export async function updateOneStore( query, data ) {
+  return await dataModel.storeModel.updateOne( query, { $set: data } );
+}

package/src/services/tangoTicket.service.js

@@ -0,0 +1,21 @@
+
+import dataModel from 'tango-api-schema';
+
+export async function createTangoTicket( inputData ) {
+  return await dataModel.tangoTicketModel.create( inputData );
+}
+export async function findTangoTicket( query, project ) {
+  return await dataModel.tangoTicketModel.find( query, project );
+}
+export async function findOneTangoTicket( query, project ) {
+  return await dataModel.tangoTicketModel.findOne( query, project );
+}
+export async function updateOneTangoTicket( query, data ) {
+  return await dataModel.tangoTicketModel.updateOne( query, { $set: data } );
+}
+export async function countDocumentsTangoTicket( query, data ) {
+  return await dataModel.tangoTicketModel.countDocuments( query );
+}
+export async function aggregateTangoTicket( query ) {
+  return await dataModel.tangoTicketModel.aggregate( query );
+}

package/src/services/user.service.js

@@ -0,0 +1,7 @@
+import dataModel from 'tango-api-schema';
+
+
+export async function findOneUser( query, project ) {
+  return await dataModel.userModel.findOne( query, project );
+}
+

package/src/validations/infra.validation.js

@@ -0,0 +1,142 @@
+import dayjs from 'dayjs';
+import { findOneTangoTicket } from '../services/tangoTicket.service.js';
+import { findOneClient } from '../services/client.service.js';
+import { findOneStore } from '../services/store.service.js';
+import { findOneinfraReason } from '../services/infraReason.service.js';
+import { logger } from 'tango-app-api-middleware';
+
+export async function validateDetails( req, res, next ) {
+  try {
+    let store = await findOneStore( { storeId: req.body.storeId } );
+    if ( !store ) {
+      return res.sendError( 'StoreID Not Available' );
+    }
+    let client = await findOneClient( { clientId: store.clientId } );
+    if ( !client ) {
+      return res.sendError( 'Client Not Available' );
+    }
+    req.body.basicDetails = {
+      storeId: req.body.storeId,
+      storeName: store.storeName,
+      clientId: store.clientId,
+      clientName: client.clientName,
+    };
+    req.body.infraTicketDetails = {
+      ticketRefreshTime: dayjs().add( client.ticketConfigs.refreshAlert, 'days' ),
+    };
+
+    next();
+  } catch ( error ) {
+    logger.error( { error: error, function: 'validateDetails' } );
+    return res.sendError( error, 500 );
+  }
+};
+
+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' );
+    }
+    next();
+  } catch ( error ) {
+    logger.error( { error: error, function: 'validateTicket' } );
+    return res.sendError( error, 500 );
+  }
+};
+export async function ticketExists( req, res, next ) {
+  try {
+    let Ticket = await findOneTangoTicket(
+        {
+          ticketId: req.body.ticketId,
+        },
+    );
+    if ( !Ticket ) {
+      return res.sendError( 'Ticket Not Found', 204 );
+    }
+    req.body.infraActivity = Ticket.infraActivity;
+    next();
+  } catch ( error ) {
+    logger.error( { error: error, function: 'ticketExists' } );
+    return res.sendError( error, 500 );
+  }
+};
+
+export async function infraReasonExists( req, res, next ) {
+  try {
+    let primaryReason = await findOneinfraReason( { name: req.body.primary } );
+    if ( !primaryReason ) {
+      return res.sendError( 'Primary Reason Not exists in database', 500 );
+    }
+    const secondary = [];
+    const steptoReslove = [];
+    for ( let i = 0; i < req.body.secondary.length; i++ ) {
+      let secondaryReason = await findOneinfraReason( { name: req.body.secondary[i] } );
+      if ( !secondaryReason ) {
+        return res.sendError( `secondary Reason - ${req.body.secondary[i]} Not exists in database`, 500 );
+      }
+      secondary.push( {
+        name: secondaryReason.name,
+      } );
+      let resolveSteps = [];
+      for ( let i = 0; i < secondaryReason.stepstoResolve.length; i++ ) {
+        resolveSteps.push( {
+          name: secondaryReason.stepstoResolve[i].name,
+        } );
+      }
+      steptoReslove.push( {
+        primaryIssue: secondaryReason.name,
+        secondaryIsssue: [ ...resolveSteps ],
+      } );
+    }
+    req.body.infraActivity.push( {
+      actionType: 'issueUpdate',
+      actionBy: 'User',
+      comment: req.body.comment,
+      reasons: [ {
+        primaryIssue: primaryReason.name,
+        secondaryIssue: secondary,
+      } ],
+    },
+    );
+    next();
+  } catch ( error ) {
+    logger.error( { error: error, function: 'infraReasonExists' } );
+    return res.sendError( error, 500 );
+  }
+};
+export async function InfrastepstoResolve( req, res, next ) {
+  try {
+    const steptoReslove = [];
+    for ( let i = 0; i < req.body.secondary.length; i++ ) {
+      let secondaryReason = await findOneinfraReason( { name: req.body.secondary[i] } );
+      if ( !secondaryReason ) {
+        return res.sendError( `secondary Reason - ${req.body.secondary[i]} Not exists in database`, 500 );
+      }
+      steptoReslove.push( {
+        primaryIssue: secondaryReason.name,
+        secondaryIsssue: [ ...secondaryReason.stepstoResolve ],
+      } );
+    }
+
+    req.body.infraActivity.push( {
+      actionType: 'stepsToResolve',
+      actionBy: 'Tango',
+      reasons: steptoReslove.map( ( item ) => ( {
+        primaryIssue: item.primaryIssue,
+        secondaryIssue: item.secondaryIsssue.map( ( issue ) => ( {
+          name: issue.name, // Assuming each object has a 'name' property
+        } ) ),
+      } ) ),
+    } );
+    next();
+  } catch ( error ) {
+    logger.error( { error: error, function: 'infraReasonExists' } );
+    return res.sendError( error, 500 );
+  }
+};

package/src/middleware/infra.middleware.js

@@ -1,43 +0,0 @@
-import dataModel from 'tango-api-schema';
-import { logger } from 'tango-app-api-middleware';
-
-export async function validateDetails( req, res, next ) {
-  try {
-    let store = await dataModel.storeModel.findOne( { storeId: req.body.storeId } );
-    if ( !store ) {
-      return res.sendError( 'StoreID Not Available' );
-    }
-    let client = await dataModel.clientModel.findOne( { clientId: store.clientId } );
-    if ( !client ) {
-      return res.sendError( 'Client Not Available' );
-    }
-    req.body.basicDetails = {
-      storeId: req.body.storeId,
-      storeName: store.storeName,
-      clientId: store.clientId,
-      clientName: client.clientName,
-    };
-    next();
-  } catch ( error ) {
-    logger.error( { error: error, function: 'validateDetails' } );
-    return res.sendError( error, 500 );
-  }
-};
-
-export async function validateTicket( req, res, next ) {
-  try {
-    let Ticket = await dataModel.tangoTicket.findOne(
-        {
-          'basicDetails.storeId': req.body.basicDetails.storeId,
-          'issueDate': new Date( req.body.Date ),
-        },
-    );
-    if ( Ticket ) {
-      return res.sendSuccess( 'Ticket Already Exists for the day' );
-    }
-    next();
-  } catch ( error ) {
-    logger.error( { error: error, function: 'validateTicket' } );
-    return res.sendError( error, 500 );
-  }
-};