tango-app-api-infra 3.1.34-beta.35 → 3.1.34-beta.37

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-infra",
-    "version": "3.1.34-beta.35",
+    "version": "3.1.34-beta.37",
     "description": "infra",
     "main": "index.js",
     "type": "module",

package/src/controllers/clientInfra.controller.js

@@ -1,5 +1,5 @@
 
-import { aggregateStore, countDocumentsStore } from '../services/store.service.js';
+import { aggregateStore, countDocumentsStore, findStore } 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';
@@ -17,7 +17,11 @@ export async function infraCard( req, res ) {
     if ( req.user&&req.user.userType ==='client'&&req.user.role!='superadmin' ) {
       storecountQuery = { ...storecountQuery, ...{ storeId: { $in: req.body.assignedStores } } };
     }
+
     let storeCount = await countDocumentsStore( storecountQuery );
+    let stores = await findStore( { 'clientId': { $in: req.body.clientId }, 'status': 'active' } );
+    let storelist = stores.map( ( data ) => data.storeId );
+
     let yetToInstallQuery = [
       {
         $match: {
@@ -25,6 +29,7 @@ export async function infraCard( req, res ) {
             { issueType: 'installation' },
             { 'status': { $ne: 'closed' } },
             { 'basicDetails.clientId': { $in: req.body.clientId } },
+            { 'basicDetails.storeId': { $in: storelist } },
             { createdAt: { $lte: date.end } },
           ],
         },
@@ -239,6 +244,8 @@ export async function installationCard( req, res ) {
     let onboardedCount = await countDocumentsStore( onboardQuery );
     let installedCount = await countDocumentsStore( installedQuery );
     let deactiveCount = await countDocumentsStore( deactiveQuery );
+    let stores = await findStore( { 'clientId': { $in: req.body.clientId }, 'status': 'active' } );
+    let storelist = stores.map( ( data ) => data.storeId );
 
 
     let ticketbaseQuery = [
@@ -248,6 +255,7 @@ export async function installationCard( req, res ) {
             { issueType: 'installation' },
             { 'status': { $ne: 'closed' } },
             { 'basicDetails.clientId': { $in: req.body.clientId } },
+            { 'basicDetails.storeId': { $in: storelist } },
             { createdAt: { $lte: date.end } },
           ],
         },

package/src/controllers/infra.controllers.js

@@ -16,7 +16,10 @@ import mongoose from 'mongoose';
 import _ from 'lodash';
 import { aggregateUserAssignedStore, findUserAssignedStore } from '../services/userAssignedStore.service.js';
 import { aggregateCamera } from '../services/camera.service.js';
-import { aggregatemailonlyuser, createmailonlyuser, updateonemailonlyuser, findOnemailonlyuser } from '../services/mailonlyusers.service.js';
+import { aggregatemailonlyuser, createmailonlyuser, updateonemailonlyuser, findOnemailonlyuser, deletemailonlyuser } from '../services/mailonlyusers.service.js';
+import { findcluster } from '../services/cluster.service.js';
+import { findteams } from '../services/teams.service.js';
+
 export async function createTicket( req, res ) {
   try {
     req.body.issueDate = new Date( req.body.Date );
@@ -551,6 +554,134 @@ export async function emailUserList( req, res ) {
     return res.sendError( error, 500 );
   }
 }
+
+export async function emailUserListv2( req, res ) {
+  try {
+    let inputData = req.body;
+    let query = [
+      {
+        $match: {
+          userType: 'client',
+          clientId: inputData.clientId,
+          role: inputData.role,
+          isActive: true,
+        },
+      },
+      {
+        $project: {
+          userName: 1,
+          email: 1,
+          role: 1,
+          emailAlert: 1,
+          infraAlert: { $ifNull: [ '$emailAlert.infra', false ] },
+          isActive: 1,
+          mobileNumber: 1,
+          assignedStores: 1,
+        },
+      },
+
+    ];
+    if ( req.body.searchValue && req.body.searchValue != '' ) {
+      query.push( {
+        $match: {
+          $or: [
+            { userName: { $regex: req.body.searchValue, $options: 'i' } },
+            { email: { $regex: req.body.searchValue, $options: 'i' } },
+          ],
+        },
+      } );
+    }
+    if ( req.body.sortColumName && req.body.sortColumName !== '' && req.body.sortBy ) {
+      query.push( {
+        $sort: { [req.body.sortColumName]: req.body.sortBy },
+      } );
+    }
+    const count = await aggregateUser( 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 result = await aggregateUser( query );
+    for ( let user of result ) {
+      if ( user.role !== 'superadmin' ) {
+        let storeIds =new Set();
+        if ( user.assignedStores ) {
+          storeIds = new Set( user.assignedStores.map( ( store ) => store.storeId ) );
+        }
+
+        // Fetch clusters and teams in parallel
+        const [ clustersList, teamsList ] = await Promise.all( [
+          findcluster( { clientId: inputData.clientId, Teamlead: { $elemMatch: { email: user.email } } } ),
+          findteams( { clientId: inputData.clientId, Teamlead: { $elemMatch: { email: user.email } } } ),
+        ] );
+
+        // Process clusters
+        if ( clustersList.length > 0 ) {
+          for ( let cluster of clustersList ) {
+            cluster.stores.forEach( ( store ) => storeIds.add( store.storeId ) );
+          }
+        }
+
+        // Process teams
+        if ( teamsList.length > 0 ) {
+          for ( let team of teamsList ) {
+            for ( let user of team.users ) {
+              let findUser = await findOneUser( { _id: user.userId } );
+              if ( findUser && findUser.assignedStores?.length > 0 ) {
+                findUser.assignedStores.forEach( ( store ) => storeIds.add( store.storeId ) );
+              }
+
+              // Fetch clusters for the user
+              let userClustersList = await findcluster( { clientId: inputData.clientId, Teamlead: { $elemMatch: { email: findUser.email } } } );
+              if ( userClustersList.length > 0 ) {
+                for ( let cluster of userClustersList ) {
+                  cluster.stores.forEach( ( store ) => storeIds.add( store.storeId ) );
+                }
+              }
+            }
+          }
+        }
+        let TeamMember = await findteams( { clientId: inputData.clientId, users: { $elemMatch: { email: user.email } } } );
+        if ( TeamMember&&TeamMember.length>0 ) {
+          for ( let team of TeamMember ) {
+            let clusterList = await findcluster( { clientId: inputData.clientId, teams: { $elemMatch: { name: team.teamName } } } );
+            if ( clusterList.length > 0 ) {
+              for ( let cluster of clusterList ) {
+                cluster.stores.forEach( ( store ) => storeIds.add( store.storeId ) );
+              }
+            }
+          }
+        }
+        let TeamLeader = await findteams( { clientId: inputData.clientId, Teamlead: { $elemMatch: { email: user.email } } } );
+        if ( TeamLeader&&TeamLeader.length>0 ) {
+          for ( let team of TeamLeader ) {
+            let clusterList = await findcluster( { clientId: inputData.clientId, teams: { $elemMatch: { name: team.teamName } } } );
+            if ( clusterList.length > 0 ) {
+              for ( let cluster of clusterList ) {
+                cluster.stores.forEach( ( store ) => storeIds.add( store.storeId ) );
+              }
+            }
+          }
+        }
+        user.assigned = Array.from( storeIds );
+        let storeList = await findStore( { clientId: inputData.clientId, storeId: { $in: user.assigned }, status: 'active' }, { storeId: 1, storeName: 1 } );
+        user.assigned = storeList.length;
+        user.assignedValue = storeList;
+      } else {
+        let storeList = await findStore( { clientId: inputData.clientId, status: 'active' }, { storeId: 1, storeName: 1 } );
+        user.assigned = storeList.length;
+        user.assignedValue = storeList;
+      }
+    }
+    res.sendSuccess( { count: count.length, result: result } );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'emailUserList' } );
+    return res.sendError( error, 500 );
+  }
+}
+
 export async function OutsideUserList( req, res ) {
   try {
     let inputData = req.body;
@@ -657,7 +788,114 @@ export async function OutsideUserList( req, res ) {
     return res.sendError( error, 500 );
   }
 }
+export async function OutsideUserListv2( req, res ) {
+  try {
+    let inputData = req.body;
+    let query = [
+      {
+        $match: {
+          clientId: inputData.clientId,
+        },
+      },
+      {
+        $unwind: {
+          path: '$clusters', preserveNullAndEmptyArrays: true,
+        },
+      },
+      {
+        $lookup: {
+          from: 'clusters',
+          let: { cluster: '$clusters' },
+          pipeline: [
+            {
+              $match: {
+                $expr: {
+                  $and: [
+                    { $eq: [ '$_id', '$$cluster' ] },
+                    { $eq: [ '$clientId', inputData.clientId ] },
+                  ],
+                },
+              },
+            },
+            {
+              $project: {
+                stores: 1,
+              },
+            },
+          ], as: 'clusters',
+        },
+      },
+      {
+        $unwind: {
+          path: '$clusters', preserveNullAndEmptyArrays: true,
+        },
+      },
+      {
+        $project: {
+          name: 1,
+          email: 1,
+          emailAlert: 1,
+          stores: { $ifNull: [ '$stores', [] ] },
+          infraAlert: { $ifNull: [ '$emailAlert.infra', false ] },
+          clusters: { $ifNull: [ '$clusters.stores', [] ] },
+        },
+      },
+      {
+        $group: {
+          _id: '$_id',
+          name: { $first: '$name' },
+          email: { $first: '$email' },
+          emailAlert: { $first: '$emailAlert' },
+          stores: { $first: '$stores' },
+          infraAlert: { $first: '$infraAlert' },
+          clusters: { $first: '$clusters' },
+        },
+      },
+
+    ];
+    if ( req.body.searchValue && req.body.searchValue != '' ) {
+      query.push( {
+        $match: {
+          $or: [
+            { userName: { $regex: req.body.searchValue, $options: 'i' } },
+            { email: { $regex: req.body.searchValue, $options: 'i' } },
+          ],
+        },
+      } );
+    }
+    if ( req.body.sortColumName && req.body.sortColumName !== '' && req.body.sortBy ) {
+      query.push( {
+        $sort: { [req.body.sortColumName]: req.body.sortBy },
+      } );
+    }
+    const count = await aggregatemailonlyuser( 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 result = await aggregatemailonlyuser( query );
 
+    for ( let data of result ) {
+      console.log( data.clusters );
+      let storelist = data.clusters.map( ( data ) => data.storeId );
+      data.Finalstores = [ ...data.stores, ...storelist ];
+      data.Finalstores = [ ...new Set( data.Finalstores ) ];
+      data.assigned = data.Finalstores.length;
+      data.assignedValue=[];
+      for ( let store of data.Finalstores ) {
+        let obj = { storeName: store };
+        data.assignedValue.push( obj );
+      }
+    }
+
+    res.sendSuccess( { count: count.length, result: result } );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'OutsideUserList' } );
+    return res.sendError( error, 500 );
+  }
+}
 export async function AddemailUser( req, res ) {
   try {
     let userExist = await findOneUser( { email: req.body.data.email, clientId: req.body.clientId } );
@@ -682,6 +920,93 @@ export async function AddemailUser( req, res ) {
     return res.sendError( error, 500 );
   }
 }
+export async function AddemailUserv2( req, res ) {
+  try {
+    let userExist = await findOneUser( { email: req.body.data.email, clientId: req.body.clientId } );
+    if ( userExist ) {
+      return res.sendError( 'Email Already Exist', 500 );
+    }
+    let userMailExist = await findOnemailonlyuser( { email: req.body.data.email, clientId: req.body.clientId } );
+    if ( userMailExist ) {
+      return res.sendError( 'Email Already Exist', 500 );
+    }
+    let clusterList = [];
+
+    if ( req.body.data.clusters&&req.body.data.clusters.length>0 ) {
+      let cluster = await findcluster( { clientId: req.body.clientId, clusterName: { $in: req.body.data.clusters } } );
+      clusterList = cluster.map( ( data ) => data._id );
+    }
+
+    let data = {
+      clientId: req.body.clientId,
+      email: req.body.data.email,
+      name: req.body.data.userName,
+      stores: req.body.data.stores,
+      clusters: clusterList,
+    };
+    let mailOnlyUsers = await createmailonlyuser( data );
+    res.sendSuccess( mailOnlyUsers );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'AddemailUserv2' } );
+    return res.sendError( error, 500 );
+  }
+}
+
+export async function getOutsideUser( req, res ) {
+  try {
+    let response= {};
+    let finduser = await findOnemailonlyuser( { _id: req.body.userId } );
+    response.name = finduser.name;
+    response.email = finduser.email;
+    if ( finduser&&finduser.stores&&finduser.stores.length>0 ) {
+      let storeslist = await findStore( { storeId: { $in: finduser.stores } }, { storeId: 1, storeName: 1 } );
+      response.stores = storeslist;
+    }
+    if ( finduser&&finduser.clusters&&finduser.clusters.length>0 ) {
+      let result = await findcluster( { _id: { $in: finduser.clusters } }, { clusterName: 1 } );
+      response.clusters = result;
+      return res.sendSuccess( response );
+    } else {
+      return res.sendSuccess( response );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, function: 'getOutsideUser' } );
+    return res.sendError( error, 500 );
+  }
+}
+
+export async function deleteOutsideUser( req, res ) {
+  try {
+    let deletedata = await deletemailonlyuser( { _id: new mongoose.Types.ObjectId( req.body.userId ) } );
+    if ( deletedata ) {
+      res.sendSuccess( 'deleted successfully' );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, function: 'deleteOutsideUser' } );
+    return res.sendError( error, 500 );
+  }
+}
+export async function editemailUser( req, res ) {
+  try {
+    let userExist = await findOneUser( { email: req.body.email, clientId: req.body.clientId } );
+    if ( userExist ) {
+      return res.sendError( 'Email Already Exist', 500 );
+    }
+    let userMailExist = await findOnemailonlyuser( { email: req.body.email, _id: { $ne: new mongoose.Types.ObjectId( req.body.userId ) }, clientId: req.body.clientId } );
+    if ( userMailExist ) {
+      return res.sendError( 'Email Already Exist', 500 );
+    }
+    console.log( req.body );
+
+    let update = await updateonemailonlyuser( { _id: new mongoose.Types.ObjectId( req.body.userId ) }, req.body );
+    if ( update ) {
+      res.sendSuccess( 'deleted successfully' );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, function: 'editemailUser' } );
+    return res.sendError( error, 500 );
+  }
+}
 
 export async function saveInfraEmailConfig( req, res ) {
   try {

package/src/controllers/internalInfra.controller.js

@@ -501,9 +501,11 @@ export async function emailUserList( req, res ) {
         if ( user.assignedType == 'group' ) {
           user.storeList = [];
           for ( let group of user.assignedValue ) {
-            let groupdata = await findOneGroup( { 'groupName': group, 'clientId': user.clientId } );
-            let storelist = await findStore( { 'storeId': { $in: groupdata.storeList }, 'status': 'active', 'edge.firstFile': true }, { 'storeId': 1, 'storeProfile.timeZone': 1 } );
-            user.storeList = [ ...user.storeList, ...storelist ];
+            let groupdata = await findOneGroup( { '_id': group, 'clientId': user.clientId } );
+            if ( groupdata&&groupdata.storeList ) {
+              let storelist = await findStore( { 'storeId': { $in: groupdata.storeList }, 'status': 'active', 'edge.firstFile': true }, { 'storeId': 1, 'storeProfile.timeZone': 1 } );
+              user.storeList = [ ...user.storeList, ...storelist ];
+            }
           }
         }
       }

package/src/routes/infra.routes.js

@@ -3,7 +3,7 @@ import express from 'express';
 import { isAllowedSessionHandler, validate, getAssinedStore } from 'tango-app-api-middleware';
 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, AddemailUser, OutsideUserList,
+  secondaryReason, updateTicketIssue, viewTicket, AlertTicketReply, uploadAttachments, getInfraIssues, AddemailUser, OutsideUserList, emailUserListv2, OutsideUserListv2, AddemailUserv2, getOutsideUser, deleteOutsideUser, editemailUser,
   updateInstallationTicket, emailUserList, saveInfraEmailConfig, invoice, allCounts, infraTable, dataMismatchTable, storeFilter, assignTicket, installationTable } from '../controllers/infra.controllers.js';
 import { getInfraIssueValid } from '../dtos/infra.dtos.js';
 
@@ -23,9 +23,20 @@ infraRouter.put( '/uploadAttachments/:ticketId', isAllowedSessionHandler, ticket
 infraRouter.put( '/removeAttachment/:ticketId', isAllowedSessionHandler, ticketExists, removeAttachment );
 infraRouter.post( '/updateInstallationTicket', isAllowedSessionHandler, ticketExists, updateInstallationTicket );
 infraRouter.post( '/emailUserList', isAllowedSessionHandler, emailUserList );
+infraRouter.post( '/emailUserListv2', isAllowedSessionHandler, emailUserListv2 );
+
 infraRouter.post( '/OutsideUserList', isAllowedSessionHandler, OutsideUserList );
+infraRouter.post( '/OutsideUserListv2', isAllowedSessionHandler, OutsideUserListv2 );
+
 
 infraRouter.post( '/AddemailUser', isAllowedSessionHandler, AddemailUser );
+infraRouter.post( '/AddemailUserv2', isAllowedSessionHandler, AddemailUserv2 );
+infraRouter.post( '/getOutsideUser', isAllowedSessionHandler, getOutsideUser );
+infraRouter.post( '/editemailUser', isAllowedSessionHandler, editemailUser );
+
+infraRouter.post( '/deleteOutsideUser', isAllowedSessionHandler, deleteOutsideUser );
+
+
 infraRouter.post( '/saveInfraEmailConfig', isAllowedSessionHandler, saveInfraEmailConfig );
 infraRouter.post( '/invoice', invoice );
 infraRouter.post( '/allCounts', isAllowedSessionHandler, getAssinedStore, allCounts );

package/src/routes/userInfra.routes.js

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

package/src/services/cluster.service.js

@@ -0,0 +1,31 @@
+import clusterModel from 'tango-api-schema/schema/cluster.model.js';
+
+export async function updateOneCluster( query, record ) {
+  return await clusterModel.updateOne( query, { $set: record } );
+};
+
+export async function updateCluster( query, record ) {
+  return await clusterModel.updateMany( query, record );
+};
+
+export async function aggregateCluster( query ) {
+  return await clusterModel.aggregate( query );
+};
+
+export async function findOneCluster( query ={}, field={} ) {
+  return await clusterModel.findOne( query, field );
+};
+export async function deleteCluster( query ={} ) {
+  return await clusterModel.deleteOne( query );
+};
+
+export async function createclusterModel( data ) {
+  return await clusterModel.create( data );
+};
+
+export async function findcluster( query, project ) {
+  return await clusterModel.find( query, project );
+};
+export function countDocumentsClusters( query ) {
+  return clusterModel.countDocuments( query );
+}

package/src/services/mailonlyusers.service.js

@@ -19,3 +19,6 @@ export async function aggregatemailonlyuser( query ) {
 export async function updateonemailonlyuser( query, data ) {
   return await dataModel.mailOnlyuserModel.updateOne( query, { $set: data } );
 }
+export async function deletemailonlyuser( query ={} ) {
+  return await dataModel.mailOnlyuserModel.deleteOne( query );
+};

package/src/services/teams.service.js

@@ -0,0 +1,30 @@
+import teamsModel from 'tango-api-schema/schema/teams.model.js';
+
+
+export async function createTeamsModel( data ) {
+  return await teamsModel.create( data );
+};
+export async function updateOneTeams( query, record ) {
+  return await teamsModel.updateOne( query, { $set: record }, { upsert: true } );
+};
+
+export async function aggregateTeams( query ) {
+  return await teamsModel.aggregate( query );
+};
+export async function deleteTeams( query ={} ) {
+  return await teamsModel.deleteOne( query );
+};
+
+export async function findOneTeams( query ={}, field={} ) {
+  return await teamsModel.findOne( query, field );
+};
+export async function findteams( query ={}, field={} ) {
+  return await teamsModel.find( query, field );
+};
+
+export async function updateOneTeamModel( query, record ) {
+  return await teamsModel.updateOne( query, record );
+}
+export function countDocumentsTeams( query ) {
+  return teamsModel.countDocuments( query );
+}