tango-app-api-client 3.3.2 → 3.3.3-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-client",
-    "version": "3.3.2",
+    "version": "3.3.3-beta.1",
     "description": "client",
     "main": "index.js",
     "type": "module",
@@ -19,14 +19,16 @@
         "express": "^4.18.2",
         "express-fileupload": "^1.4.3",
         "handlebars": "^4.7.8",
+        "i": "^0.3.7",
         "joi": "^17.12.1",
         "joi-to-swagger": "^6.2.0",
         "lodash": "^4.17.21",
         "mongodb": "^6.3.0",
         "nodemon": "^3.0.3",
+        "npm": "^10.9.1",
         "swagger-ui-express": "^5.0.0",
-        "tango-api-schema": "^2.1.59",
-        "tango-app-api-middleware": "^3.1.45",
+        "tango-api-schema": "^2.1.92",
+        "tango-app-api-middleware": "^3.1.43-alpha.10",
         "winston": "^3.11.0",
         "winston-daily-rotate-file": "^5.0.0"
     },

package/src/controllers/client.controllers.js

@@ -14,7 +14,8 @@ import { countDocumentsGroup, createGroupModel, findOneGroup } from '../service/
 // import { deleteOneAuthentication } from '../service/authentication.service.js';
 import { createBilling } from '../service/billing.service.js';
 import { createPaymentAccount } from '../service/paymentAccount.service.js';
-
+import { countDocumentsClusters, createclusterModel } from '../service/cluster.service.js';
+import { countDocumentsTeams } from '../service/teams.service.js';
 
 export async function create( req, res ) {
   try {
@@ -42,7 +43,7 @@ export async function create( req, res ) {
     const tangoId = count + 1;
     const generatedName = inputData.clientName.replace( /[^A-Z0-9]+/ig, '' );
     const product = leadRecord?.planDetails?.product.map( ( value ) => ( { productName: value } ) );
-    const getPermission = await findOneStandaredRole( { roleName: 'superadmin', userType: 'client' }, { permission: 1 } );
+    const getPermission = await findOneStandaredRole( { roleName: 'superadmin', userType: 'client' }, { permission: 1, rolespermission: 1 } );
     const userQuery = {
       email: leadRecord?.corporateEmail,
     };
@@ -78,9 +79,26 @@ export async function create( req, res ) {
       'auditConfigs.traxQueueName.uniformDetection': `${generatedName}-uniformDetection`,
       'auditConfigs.traxQueueName.mobileDetection': `${generatedName}-mobileDetection`,
       'auditConfigs.traxQueueName.cameraAngleChange': `${generatedName}-cameraAngleChange`,
+    };
 
+    record.featureConfigs = {};
+    if ( product && product.length > 0 ) {
+      for ( let data of product ) {
+        record.featureConfigs.isNewDashboard = true;
+
+        if ( data.productName === 'tangoTraffic' ) {
+          record.featureConfigs.isNewTraffic = true;
+          record.featureConfigs.isNewReports = true;
+        }
+        if ( data.productName === 'tangoZone' ) {
+          record.featureConfigs.isNewZone = true;
+        }
+        if ( data.productName === 'tangoTrax' ) {
+          record.featureConfigs. isTrax= true;
+        }
+      }
+    }
 
-    };
 
     const insertClient = await insert( record );
 
@@ -88,8 +106,10 @@ export async function create( req, res ) {
 
     const customer = await createCustomer( { name: user.userName, email: user.email, clientId: insertedClientRecord.clientId } );
 
-    const virtualAccount = await createVirtualAccount( { receiverTypes: [ 'bank_account' ], description: `Virtual Account for ${insertedClientRecord.clientId}`,
-      customerId: customer.id, notes: { createdAt: new Date(), createdBy: req.user?.email } } );
+    const virtualAccount = await createVirtualAccount( {
+      receiverTypes: [ 'bank_account' ], description: `Virtual Account for ${insertedClientRecord.clientId}`,
+      customerId: customer.id, notes: { createdAt: new Date(), createdBy: req.user?.email },
+    } );
 
     const paymentAccount = {
       clientId: insertedClientRecord.clientId,
@@ -111,6 +131,17 @@ export async function create( req, res ) {
 
     await createPaymentAccount( paymentAccount );
 
+    const defaultcluster = {
+      'clusterName': 'All stores',
+      'description': 'Contains all the onboarded stores',
+      'stores': [],
+      'Teamlead': [],
+      'clientId': insertedClientRecord.clientId,
+      'isDefaults': true,
+    };
+
+    await createclusterModel( defaultcluster );
+
 
     const defaultGroup = {
       'groupName': 'All stores',
@@ -293,6 +324,7 @@ export async function create( req, res ) {
         userType: 'client',
         refreshToken: null,
         permission: getPermission?.permission,
+        rolespermission: getPermission?.rolespermission,
         clientId: String( tangoId ),
       };
       // await deleteOneAuthentication( { user: user?._id, type: 'retail' } );
@@ -515,7 +547,44 @@ export async function clientDetails( req, res ) {
 }
 export async function detailedAllClientCount( req, res ) {
   try {
+    const field = { clientName: 1, clientId: 1 };
+    let Assinedclient = [];
+    if ( req?.user?.role === 'superadmin' ) {
+      Assinedclient = await findClient( {}, field );
+      Assinedclient = Assinedclient.map( ( data ) => data.clientId );
+    } else {
+      const clientQuery = [
+        {
+          $match: {
+            userEmail: req?.user?.email,
+            assignedType: { $eq: 'client' },
+          },
+        },
+        {
+          $group: {
+            _id: null,
+            clientId: { $addToSet: '$assignedValue' },
+          },
+        },
+        {
+          $project: {
+            _id: 0,
+            clientId: 1,
+          },
+        },
+
+      ];
+      const clientList = await aggregateUserAssignedStore( clientQuery );
+      if ( clientList[0]?.clientId?.length != 0 ) {
+        Assinedclient = clientList[0]?.clientId;
+      }
+    }
     const query = [
+      {
+        $match: {
+          clientId: { $in: Assinedclient },
+        },
+      },
       {
         $project: {
           activeClient: { $cond: [ { $eq: [ '$status', 'active' ] }, 1, 0 ] },
@@ -579,11 +648,15 @@ export async function detailedAllClientCount( req, res ) {
       },
     ];
     const result = await aggregateClient( query );
-    const activeStores = await findStore( { 'status': 'active' }, { storeId: 1 } );
+    const activeStores = await findStore( {
+      'clientId': { $in: Assinedclient },
+      'status': 'active',
+    }, { storeId: 1 } );
     let yettoInstallCount = await aggregateTickets( [
       {
         $match: {
           $and: [
+            { 'basicDetails.clientId': { $in: Assinedclient } },
             { issueType: 'installation' },
             { 'status': { $ne: 'closed' } },
           ],
@@ -599,7 +672,7 @@ export async function detailedAllClientCount( req, res ) {
     if ( result.length == 0 ) {
       return res.sendError( 'No Data Found', 204 );
     }
-    result[0].activeStoresCount = activeStores.length-yettoInstallCount.length;
+    result[0].activeStoresCount = activeStores.length>0?Math.abs( activeStores.length - yettoInstallCount.length ):0;
     result[0].activeCameraCount = activeCameras;
     return res.sendSuccess( { result: result } );
   } catch ( error ) {
@@ -861,65 +934,66 @@ export async function updateFeatureConfiguration( req, res ) {
   try {
     const openSearch = JSON.parse( process.env.OPENSEARCH );
     const url = JSON.parse( process.env.URL );
-    const updateAck = await featureConfigurationUpdate( {
-      clientId: req.params?.id, billableCalculation: req.body?.billableCalculation, bouncedLimitCondition: req.body?.bouncedLimitCondition, bouncedLimitValue: req.body?.bouncedLimitValue,
-      close: req.body?.close, conversionCalculation: req.body?.conversionCalculation, conversionCondition: req.body?.conversionCondition,
-      conversionValue: req.body?.conversionValue, infraAlertCondition: req.body?.infraAlertCondition, infraAlertValue: req.body?.infraAlertValue, isFootfallDirectory: req.body?.isFootfallDirectory,
-      isNormalized: req.body?.isNormalized, isPasserByData: req.body?.isPasserByData, missedOpportunityCalculation: req.body?.missedOpportunityCalculation, open: req.body?.open,
-      isExcludedArea: req.body?.isExcludedArea, isCameraDisabled: req.body?.isCameraDisabled, isbillingDisabled: req.body?.isbillingDisabled, isNewDashboard: req.body?.isNewDashboard,
-      isFootfallAuditStores: req.body?.isFootfallAuditStores, isNewTraffic: req.body?.isNewTraffic, isNewZone: req.body?.isNewZone, isNewReports: req.body?.isNewReports, isNOB: req.body?.isNOB, isNewZoneV2: req.body?.isNewZoneV2, isTrax: req.body?.isTrax,
-    } );
+    const inputData = req.body;
+    if ( inputData?.bouncedLimitValue ) {
+      inputData.missedOpportunityFromValue = inputData?.bouncedLimitValue;
+    }
+
+    if ( inputData?.conversionValue ) {
+      inputData.missedOpportunityToValue = inputData?.conversionValue;
+    }
+    const updateAck = await featureConfigurationUpdate( { clientId: req.params?.id }, inputData );
 
     let updateKeys = [];
 
-    if ( Object.keys( req.body ).length > 0 ) {
-      Object.keys( req.body ).forEach( ( element ) => {
+    if ( Object.keys( inputData ).length > 0 ) {
+      Object.keys( inputData ).forEach( ( element ) => {
         updateKeys.push( camelCaseToWords( element ) );
       } );
     }
 
-    const user = await getUserNameEmailById( req.userId );
+    const user = req.user;
 
     const { data } = await getApi( `${url.oldapidomain}/oldBrandGet/${req.params?.id}` );
 
-    if ( req.body?.open ) {
-      data.brandConfigs.storeOpenTime = req.body?.open;
+    if ( inputData?.open ) {
+      data.brandConfigs.storeOpenTime = inputData?.open;
     }
 
-    if ( req.body?.close ) {
-      data.brandConfigs.storeCloseTime = req.body?.open;
+    if ( inputData?.close ) {
+      data.brandConfigs.storeCloseTime = inputData?.open;
     }
 
-    if ( req.body?.missedOpportunityCalculation ) {
-      data.brandConfigs.missedOpportunityCalculate = req.body?.missedOpportunityCalculation;
+    if ( inputData?.missedOpportunityCalculation ) {
+      data.brandConfigs.missedOpportunityCalculate = inputData?.missedOpportunityCalculation;
     }
 
-    if ( req.body?.conversionCalculation ) {
-      data.brandConfigs.conversionCalculate = req.body?.conversionCalculation;
+    if ( inputData?.conversionCalculation ) {
+      data.brandConfigs.conversionCalculate = inputData?.conversionCalculation;
     }
 
-    if ( req.body?.billableCalculation ) {
-      data.brandConfigs.billableCalculate = req.body?.billableCalculation;
+    if ( inputData?.billableCalculation ) {
+      data.brandConfigs.billableCalculate = inputData?.billableCalculation;
     }
 
-    if ( req.body?.bouncedLimitCondition ) {
-      data.brandConfigs.bouncedConfigTime = data.brandConfigs.bouncedConfigTime.replace( /^.+(?=\d)/, req.body?.bouncedLimitCondition );
-      data.brandConfigs.missedOpportunityEndTime = data.brandConfigs.missedOpportunityEndTime.replace( /^.+(?=\d)/, req.body?.bouncedLimitCondition );
+    if ( inputData?.bouncedLimitCondition ) {
+      data.brandConfigs.bouncedConfigTime = data.brandConfigs.bouncedConfigTime.replace( /^.+(?=\d)/, inputData?.bouncedLimitCondition );
+      data.brandConfigs.missedOpportunityEndTime = data.brandConfigs.missedOpportunityEndTime.replace( /^.+(?=\d)/, inputData?.bouncedLimitCondition );
     }
 
-    if ( req.body?.bouncedLimitValue ) {
-      data.brandConfigs.bouncedConfigTime = data.brandConfigs.bouncedConfigTime.replace( /\d+/, req.body?.bouncedLimitValue );
-      data.brandConfigs.missedOpportunityStartTime = data.brandConfigs.missedOpportunityStartTime.replace( /\d+/, req.body?.bouncedLimitValue );
+    if ( inputData?.bouncedLimitValue ) {
+      data.brandConfigs.bouncedConfigTime = data.brandConfigs.bouncedConfigTime.replace( /\d+/, inputData?.bouncedLimitValue );
+      data.brandConfigs.missedOpportunityStartTime = data.brandConfigs.missedOpportunityStartTime.replace( /\d+/, inputData?.bouncedLimitValue );
     }
 
-    if ( req.body?.conversionCondition ) {
-      data.brandConfigs.conversionConfigTime = data.brandConfigs.conversionConfigTime.replace( /^.+(?=\d)/, req.body?.conversionCondition );
-      data.brandConfigs.missedOpportunityStartTime = data.brandConfigs.missedOpportunityStartTime.replace( /^.+(?=\d)/, req.body?.conversionCondition );
+    if ( inputData?.conversionCondition ) {
+      data.brandConfigs.conversionConfigTime = data.brandConfigs.conversionConfigTime.replace( /^.+(?=\d)/, inputData?.conversionCondition );
+      data.brandConfigs.missedOpportunityStartTime = data.brandConfigs.missedOpportunityStartTime.replace( /^.+(?=\d)/, inputData?.conversionCondition );
     }
 
-    if ( req.body?.conversionValue ) {
-      data.brandConfigs.conversionConfigTime = data.brandConfigs.conversionConfigTime.replace( /\d+/, req.body?.conversionValue );
-      data.brandConfigs.missedOpportunityEndTime = data.brandConfigs.missedOpportunityEndTime.replace( /\d+/, req.body?.conversionValue );
+    if ( inputData?.conversionValue ) {
+      data.brandConfigs.conversionConfigTime = data.brandConfigs.conversionConfigTime.replace( /\d+/, inputData?.conversionValue );
+      data.brandConfigs.missedOpportunityEndTime = data.brandConfigs.missedOpportunityEndTime.replace( /\d+/, inputData?.conversionValue );
     }
 
     await postApi( `${url.oldapidomain}/oldBrandUpdate/${data?._id}`, { brandConfigs: data.brandConfigs } );
@@ -944,8 +1018,9 @@ export async function updateFeatureConfiguration( req, res ) {
       res.sendSuccess( { result: 'Updated Successfully' } );
     }
   } catch ( error ) {
-    logger.error( { error: error, message: req.params, function: 'updateTicketConfiguration' } );
-    return res.sendError( 'Internal Server Error', 500 );
+    const err = error.message || 'Internal Server Error';
+    logger.error( { error: error, message: req.params, function: 'updateFeatureConfiguration' } );
+    return res.sendError( err, 500 );
   }
 }
 
@@ -1112,7 +1187,7 @@ export async function updateDocuments( req, res ) {
 
 export async function getAuditConfiguration( req, res ) {
   try {
-    const query ={
+    const query = {
       clientId: req.params?.id,
     };
     const fields = {
@@ -1139,14 +1214,14 @@ export async function auditConfiguration( req, res ) {
   try {
     const inputData = req.body;
     const openSearch = JSON.parse( process.env.OPENSEARCH );
-    const query ={
+    const query = {
       clientId: req.params?.id,
     };
-    const fields ={
+    const fields = {
       auditConfigs: 1, _id: 0,
     };
     const previousClient = await findOneClient( query, fields );
-    const record ={
+    const record = {
       'auditConfigs.count': inputData.count,
       'auditConfigs.audit': inputData.audit,
       'auditConfigs.ratio': Number( normalizeNumber( inputData.ratio, 0, 100 ) ),
@@ -1760,10 +1835,12 @@ export async function clientListV1( req, res ) {
         clientId: { $toInt: '$clientId' },
         onboardedStores: 1,
         installedStore: 1,
-        activeStores: { $max: [
-          { $subtract: [ '$activeStores', '$installedPending' ] },
-          0,
-        ] },
+        activeStores: {
+          $max: [
+            { $subtract: [ '$activeStores', '$installedPending' ] },
+            0,
+          ],
+        },
         InactiveStores: 1,
         ProcessingStatus: 1,
         clientName: 1,
@@ -1805,8 +1882,8 @@ export async function clientListV1( req, res ) {
       return res.sendError( 'No Data Found', 204 );
     }
 
-    if ( inputData.sortColumName&&inputData.sortColumName!=''&& req.body.sortBy&&req.body.sortBy!='' ) {
-      if ( inputData.sortColumName==='clientName' ) {
+    if ( inputData.sortColumName && inputData.sortColumName != '' && req.body.sortBy && req.body.sortBy != '' ) {
+      if ( inputData.sortColumName === 'clientName' ) {
         clientQuery.push(
             {
               $project: {
@@ -1858,15 +1935,15 @@ export async function clientListV1( req, res ) {
         exportResult.push( {
           'Brand Name': client.clientName,
           'Brand ID': client.clientId,
-          'Onboarded Stores': client.onboardedStores||0,
+          'Onboarded Stores': client.onboardedStores || 0,
           'Installed Stores': client.installedStore || 0,
-          'Progress Status': client.ProgressBar||0,
+          'Progress Status': client.ProgressBar || 0,
           'Active Stores': client.activeStores || 0,
           'In-Active Stores': client.InactiveStores || 0,
           'Pending Configuration': client.installedPending || 0,
-          'Payment Plan': client.PaymentPlan == 'free'?'Lifetime Free':client.PaymentPlan,
+          'Payment Plan': client.PaymentPlan == 'free' ? 'Lifetime Free' : client.PaymentPlan,
           'Subscription Plan': client.subscriptionPlan,
-          'Processing Status': client.ProcessingStatus=='active'?'Activated':client.ProcessingStatus=='deactive'?'Deactivated':client.ProcessingStatus,
+          'Processing Status': client.ProcessingStatus == 'active' ? 'Activated' : client.ProcessingStatus == 'deactive' ? 'Deactivated' : client.ProcessingStatus,
         } );
       }
       await download( exportResult, res );
@@ -1903,6 +1980,8 @@ export async function detailedClientCount( req, res ) {
     };
     result['totalStoreCount'] = await countDocumentsStore( { clientId: inputData.clientId } );
     result['totalGroupCount'] = await countDocumentsGroup( { clientId: inputData.clientId, isActive: true } );
+    result['totalclusterCount'] = await countDocumentsClusters( { clientId: inputData.clientId } );
+    result['totalTeamsCount'] = await countDocumentsTeams( { clientId: inputData.clientId } );
     result['totalCameraCount'] = await countDocumentsCamera( { clientId: inputData.clientId } );
     result['totalUserCount'] = await countDocumentsUser( { clientId: inputData.clientId, userType: 'client' } );
 
@@ -1929,7 +2008,7 @@ export async function detailedClientCount( req, res ) {
       },
     ] );
 
-    if ( findCsm&&findCsm.length>0 ) {
+    if ( findCsm && findCsm.length > 0 ) {
       let finduser = await findOneUser( { email: findCsm[0].userEmail }, { userName: 1, email: 1, countryCode: 1, mobileNumber: 1 } );
       result['csm'] = finduser;
     }

package/src/dtos/client.dtos.js

@@ -120,6 +120,7 @@ export const featureConfigurationSchemaBody = joi.object(
       isNOB: joi.boolean().optional(),
       isNewZoneV2: joi.boolean().optional(),
       isTrax: joi.boolean().optional(),
+      isControlCenter: joi.boolean().optional(),
     },
 );
 

package/src/service/client.service.js

@@ -128,43 +128,39 @@ export function ticketConfigurationUpdate( {
       } );
 }
 
-export function featureConfigurationUpdate( {
-  clientId, billableCalculation, bouncedLimitCondition, bouncedLimitValue,
-  close, conversionCalculation, conversionCondition,
-  conversionValue, infraAlertCondition, infraAlertValue, isFootfallDirectory,
-  isNormalized, isPasserByData, missedOpportunityCalculation, open, isExcludedArea,
-  isCameraDisabled, isbillingDisabled, isNewDashboard, isFootfallAuditStores, isNewTraffic,
-  isNewZone, isNewReports, isNOB, isNewZoneV2, isTrax,
-} ) {
-  return clientModel.updateOne( { clientId: clientId },
+export function featureConfigurationUpdate( query, inputData ) {
+  return clientModel.updateOne( query,
       {
         $set: {
-          'featureConfigs.open': open,
-          'featureConfigs.close': close,
-          'featureConfigs.infraAlert.condition': infraAlertCondition,
-          'featureConfigs.infraAlert.value': infraAlertValue,
-          'featureConfigs.bouncedLimit.condition': bouncedLimitCondition,
-          'featureConfigs.bouncedLimit.value': bouncedLimitValue,
-          'featureConfigs.conversion.condition': conversionCondition,
-          'featureConfigs.conversion.value': conversionValue,
-          'featureConfigs.billableCalculation': billableCalculation,
-          'featureConfigs.missedOpportunityCalculation': missedOpportunityCalculation,
-          'featureConfigs.conversionCalculation': conversionCalculation,
-          'featureConfigs.isNormalized': isNormalized,
-          'featureConfigs.isPasserByData': isPasserByData,
-          'featureConfigs.isFootfallDirectory': isFootfallDirectory,
-          'featureConfigs.isExcludedArea': isExcludedArea,
+          'featureConfigs.open': inputData?.open,
+          'featureConfigs.close': inputData?.close,
+          'featureConfigs.infraAlert.condition': inputData?.infraAlertCondition,
+          'featureConfigs.infraAlert.value': inputData?.infraAlertValue,
+          'featureConfigs.bouncedLimit.condition': inputData?.bouncedLimitCondition,
+          'featureConfigs.bouncedLimit.value': inputData?.bouncedLimitValue,
+          'featureConfigs.conversion.condition': inputData?.conversionCondition,
+          'featureConfigs.conversion.value': inputData?.conversionValue,
+          'featureConfigs.missedOpportunityFrom.value': inputData?.missedOpportunityFromValue,
+          'featureConfigs.missedOpportunityTo.value': inputData?.missedOpportunityToValue,
+          'featureConfigs.billableCalculation': inputData?.billableCalculation,
+          'featureConfigs.missedOpportunityCalculation': inputData?.missedOpportunityCalculation,
+          'featureConfigs.conversionCalculation': inputData?.conversionCalculation,
+          'featureConfigs.isNormalized': inputData?.isNormalized,
+          'featureConfigs.isPasserByData': inputData?.isPasserByData,
+          'featureConfigs.isFootfallDirectory': inputData?.isFootfallDirectory,
+          'featureConfigs.isExcludedArea': inputData?.isExcludedArea,
           'featureConfigs.updateFeatureConfig': false,
-          'featureConfigs.isCameraDisabled': isCameraDisabled,
-          'featureConfigs.isbillingDisabled': isbillingDisabled,
-          'featureConfigs.isNewDashboard': isNewDashboard,
-          'featureConfigs.isFootfallAuditStores': isFootfallAuditStores,
-          'featureConfigs.isNewTraffic': isNewTraffic,
-          'featureConfigs.isNewZone': isNewZone,
-          'featureConfigs.isNewReports': isNewReports,
-          'featureConfigs.isNOB': isNOB,
-          'featureConfigs.isNewZoneV2': isNewZoneV2,
-          'featureConfigs.isTrax': isTrax,
+          'featureConfigs.isCameraDisabled': inputData?.isCameraDisabled,
+          'featureConfigs.isbillingDisabled': inputData?.isbillingDisabled,
+          'featureConfigs.isNewDashboard': inputData?.isNewDashboard,
+          'featureConfigs.isFootfallAuditStores': inputData?.isFootfallAuditStores,
+          'featureConfigs.isNewTraffic': inputData?.isNewTraffic,
+          'featureConfigs.isNewZone': inputData?.isNewZone,
+          'featureConfigs.isNewReports': inputData?.isNewReports,
+          'featureConfigs.isNOB': inputData?.isNOB,
+          'featureConfigs.isNewZoneV2': inputData?.isNewZoneV2,
+          'featureConfigs.isTrax': inputData?.isTrax,
+          'featureConfigs.isControlCenter': inputData?.isControlCenter,
         },
       } );
 }

package/src/service/cluster.service.js

@@ -0,0 +1,27 @@
+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 function countDocumentsClusters( query ) {
+  return clusterModel.countDocuments( query );
+}

package/src/service/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 );
+}