- Sistemato problema del Circuito ITALIA, quando veniva fatta la richiesta di entrare, ancora non si era entrati nel circuito territoriale.

- Ora pertanto viene inviata la richiesta agli admin solo dopo che l'utente viene abilitato al Circuito provinciale.

admin_scripts/3_DATABASE/dati_users.js

@@ -165,6 +165,7 @@ db.users.insertMany([
             "noNameSurname": false,
             "noCircuit": false,
             "noCircIta": false,
+            "insert_circuito_ita": false,
             "noFoto": false,
             "resid_province": "",
             "resid_card": "",
@@ -282,6 +283,7 @@ db.users.insertMany([
             "noNameSurname": false,
             "noCircuit": false,
             "noCircIta": false,
+            "insert_circuito_ita": false,
             "noFoto": false,
             "resid_province": "",
             "resid_card": "",

filelog.txt

@@ -6,3 +6,25 @@ Lun 10/03 ORE 15:52: USER [surya1977]: ciao
 Lun 10/03 ORE 15:56: USER [surya1977]: ciao
 
 Lun 07/07 ORE 10:45: USER [surya1977]: ciao
+
+Gio 09/10 ORE 20:42: USER [surya1977]: ciao
+
+Sab 11/10 ORE 16:11: USER [surya1977]: ciao
+
+Sab 11/10 ORE 16:32: USER [surya1977]: ciao
+
+Sab 11/10 ORE 16:36: USER [surya1977]: ciao
+
+Sab 11/10 ORE 16:43: USER [surya1977]: ciao
+
+Sab 11/10 ORE 16:53: USER [surya1977]: ciao
+
+Sab 11/10 ORE 17:29: USER [surya1977]: ciao
+
+Sab 11/10 ORE 17:30: USER [surya1977]: ciao
+
+Sab 11/10 ORE 17:30: USER [surya1977]: ciao
+
+Sab 11/10 ORE 18:01: USER [surya1977]: ciao
+
+Sab 11/10 ORE 18:15: USER [surya1977]: ciao

logevents.txt

@@ -837,4 +837,6 @@ Il gruppo dei Facilitatori Territoriali RISO
 Mer 24/04 ORE 22:02: 🤖: Da Sùrya (Paolo) (paoloar77): 
 ✅  la regolarizzazione può avv
 Lun 07/07 ORE 10:50: 🤖: Da Sùrya undefined (surya1977): 
-✅ provatest7 è stato Ammesso correttamente (da surya1977)!
+✅ provatest7 è stato Ammesso correttamente (da surya1977)!
+Gio 09/10 ORE 20:45: 🤖: Da Sùrya undefined (surya1977): 
+✅ prova123 è stato Ammesso correttamente (da surya1977)!

src/server/models/account.js

@@ -12,11 +12,10 @@ const tools = require('../tools/general');
 
 const { ObjectId } = require('mongodb');
 
-
 const shared_consts = require('../tools/shared_nodejs');
 
 // Resolving error Unknown modifier: $pushAll
-mongoose.plugin(schema => {
+mongoose.plugin((schema) => {
   schema.options.usePushEach = true;
 });
 
@@ -36,13 +35,16 @@ const AccountSchema = new Schema({
   username: {
     type: String,
   },
-  groupname: {  // For the Groups
+  groupname: {
+    // For the Groups
     type: String,
   },
-  contocom: {  // For the Conto Comunitario dei Circuiti
+  contocom: {
+    // For the Conto Comunitario dei Circuiti
     type: String,
   },
-  circuitId: {  // ----- REF TO Circuit
+  circuitId: {
+    // ----- REF TO Circuit
     type: String,
   },
   name: {
@@ -116,7 +118,6 @@ AccountSchema.statics.getFieldsForSearch = function () {
     { field: 'groupname', type: tools.FieldType.string },
     { field: 'contocom', type: tools.FieldType.string },
   ];
-
 };
 
 AccountSchema.statics.executeQueryTable = function (idapp, params) {
@@ -127,16 +128,14 @@ AccountSchema.statics.executeQueryTable = function (idapp, params) {
 AccountSchema.statics.getAccountsByUsername = async function (idapp, username) {
   const Account = this;
 
-  if (username === undefined)
+  if (username === undefined) return false;
-    return false;
 
   const myquery = {
-    'idapp': idapp,
+    idapp: idapp,
-    'username': username,
+    username: username,
   };
 
   return await Account.find(myquery).lean();
-
 };
 
 AccountSchema.statics.calcTotCircolante = async function (idapp, circuitId) {
@@ -147,17 +146,15 @@ AccountSchema.statics.calcTotCircolante = async function (idapp, circuitId) {
       {
         $match: { idapp, circuitId, saldo: { $gt: 0 } },
       },
-      { $group: { _id: null, count: { $sum: '$saldo' } } }
+      { $group: { _id: null, count: { $sum: '$saldo' } } },
     ];
 
     const ris = await Account.aggregate(aggr1);
 
     return ris ? ris[0].count : 0;
-
   } catch (e) {
     console.error('err', e);
   }
-
 };
 AccountSchema.methods.calcPending = async function (mittente) {
   try {
@@ -175,7 +172,12 @@ AccountSchema.methods.calcPending = async function (mittente) {
       let transatopending = 0;
 
       if (mittente) {
-        let pendingtransactionsMittente = await SendNotif.getSumPendingTransactionsMittente(account.idapp, account.username, circuit.name, account.groupname);
+        let pendingtransactionsMittente = await SendNotif.getSumPendingTransactionsMittente(
+          account.idapp,
+          account.username,
+          circuit.name,
+          account.groupname
+        );
         let saldopendingMitt = pendingtransactionsMittente.reduce((sum, rec) => sum + rec.extrarec.qty, 0);
         transatopending = pendingtransactionsMittente.reduce((sum, rec) => sum + Math.abs(rec.extrarec.qty), 0);
 
@@ -192,34 +194,29 @@ AccountSchema.methods.calcPending = async function (mittente) {
       account.totTransato_pend = account.totTransato + transatopending;
 
       if (prec_saldo_pend !== account.saldo_pend || prec_totTransato_pend !== account.totTransato_pend) {
-
         const myaccountupdate = {
           saldo_pend: account.saldo_pend,
           totTransato_pend: account.totTransato_pend,
         };
 
         // Update Record
-        return await Account.findByIdAndUpdate(account.id,
+        return await Account.findByIdAndUpdate(account.id, {
-          {
+          $set: myaccountupdate,
-            $set: myaccountupdate
+        })
-          }).then((ris) => {
+          .then((ris) => {
             console.log('calcPending', ris);
-          }).catch((err) => {
+          })
+          .catch((err) => {
             console.error('calcPending', err);
           });
-
-
       }
     }
 
-
     // -----
-
   } catch (e) {
     console.error(e);
   }
-
+};
-}
 
 AccountSchema.statics.addtoSaldo = async function (myaccount, amount, mitt) {
   const Account = this;
@@ -234,8 +231,7 @@ AccountSchema.statics.addtoSaldo = async function (myaccount, amount, mitt) {
       }
       myaccount.totTransato += Math.abs(amount);
 
-      if (!myaccount.numtransactions)
+      if (!myaccount.numtransactions) myaccount.numtransactions = 0;
-        myaccount.numtransactions = 0;
       myaccount.numtransactions++;
 
       myaccount.date_updated = new Date();
@@ -245,10 +241,12 @@ AccountSchema.statics.addtoSaldo = async function (myaccount, amount, mitt) {
       myaccountupdate.numtransactions = myaccount.numtransactions;
       myaccountupdate.date_updated = myaccount.date_updated;
 
-      const ris = await Account.updateOne({ _id: myaccount.id },
+      const ris = await Account.updateOne(
+        { _id: myaccount.id },
         {
-          $set: myaccountupdate
+          $set: myaccountupdate,
-        });
+        }
+      );
 
       // Calcola Saldo Pendente !
       await myaccount.calcPending(true);
@@ -256,7 +254,6 @@ AccountSchema.statics.addtoSaldo = async function (myaccount, amount, mitt) {
       const recupdated = await Account.findOne({ _id: myaccount.id });
 
       return recupdated;
-
     }
   } catch (e) {
     console.error('error', e);
@@ -267,18 +264,24 @@ AccountSchema.statics.addtoSaldo = async function (myaccount, amount, mitt) {
 
 AccountSchema.pre('save', async function (next) {
   if (this.isNew) {
-    if (!this.date_created)
+    if (!this.date_created) this.date_created = new Date();
-      this.date_created = new Date();
   }
 
   next();
 });
 
-AccountSchema.statics.getAccountByUsernameAndCircuitId = async function (idapp, username, circuitId, createifnotexist, confido, groupname = '', contocom = "") {
+AccountSchema.statics.getAccountByUsernameAndCircuitId = async function (
+  idapp,
+  username,
+  circuitId,
+  createifnotexist,
+  confido,
+  groupname = '',
+  contocom = ''
+) {
   const Account = this;
 
   try {
-
     const { Circuit } = require('../models/circuit');
 
     // if (username === undefined)
@@ -306,7 +309,7 @@ AccountSchema.statics.getAccountByUsernameAndCircuitId = async function (idapp,
         myaccount = new Account({
           _id: new ObjectId().toString(),
           idapp,
-          username: (!groupname && !contocom) ? username : '',
+          username: !groupname && !contocom ? username : '',
           groupname,
           contocom,
           circuitId: mycircuit._id,
@@ -322,9 +325,10 @@ AccountSchema.statics.getAccountByUsernameAndCircuitId = async function (idapp,
         });
 
         if (contocom) {
-          myaccount.fidoConcesso = mycircuit.fido_scoperto_default_contocom || shared_consts.CIRCUIT_PARAMS.SCOPERTO_MIN_CONTO_COMUNITARIO;
+          myaccount.fidoConcesso =
-          myaccount.qta_maxConcessa = mycircuit.qta_max_default_contocom || shared_consts.CIRCUIT_PARAMS.SCOPERTO_MAX_CONTO_COMUNITARIO;
+            mycircuit.fido_scoperto_default_contocom || shared_consts.CIRCUIT_PARAMS.SCOPERTO_MIN_CONTO_COMUNITARIO;
-
+          myaccount.qta_maxConcessa =
+            mycircuit.qta_max_default_contocom || shared_consts.CIRCUIT_PARAMS.SCOPERTO_MAX_CONTO_COMUNITARIO;
         } else {
           if (!mycircuit.fido_scoperto_default_grp)
             mycircuit.fido_scoperto_default_grp = shared_consts.CIRCUIT_PARAMS.SCOPERTO_MIN_GRP;
@@ -356,22 +360,24 @@ AccountSchema.statics.getAccountByUsernameAndCircuitId = async function (idapp,
       return myaccount;
     }
     return null;
-
   } catch (e) {
     console.error('error', e);
   }
-
 };
 
-AccountSchema.statics.isExistAccountByUsernameAndCircuitId = async function (idapp, username, circuitId, groupname = '', contocom = "") {
+AccountSchema.statics.isExistAccountByUsernameAndCircuitId = async function (
+  idapp,
+  username,
+  circuitId,
+  groupname = '',
+  contocom = ''
+) {
   const Account = this;
 
   try {
-
     const { Circuit } = require('../models/circuit');
 
-    if (username === undefined)
+    if (username === undefined) return false;
-      return false;
 
     let myquery = {
       idapp,
@@ -390,25 +396,37 @@ AccountSchema.statics.isExistAccountByUsernameAndCircuitId = async function (ida
 
     if (mycircuit) {
       let myaccount = await Account.findOne(myquery);
-      return !!myaccount
+      return !!myaccount;
     }
 
     return false;
-
   } catch (e) {
     console.error('error', e);
   }
-
 };
 
-AccountSchema.statics.createAccount = async function (idapp, username, circuitName, confido, groupname = '', contocom = '') {
+AccountSchema.statics.createAccount = async function (
-
+  idapp,
+  username,
+  circuitName,
+  confido,
+  groupname = '',
+  contocom = ''
+) {
   const { Circuit } = require('../models/circuit');
 
   try {
     mycircuit = await Circuit.findOne({ name: circuitName }, { _id: 1 });
     if (mycircuit) {
-      return await Account.getAccountByUsernameAndCircuitId(idapp, username, mycircuit._id, true, confido, groupname, contocom);
+      return await Account.getAccountByUsernameAndCircuitId(
+        idapp,
+        username,
+        mycircuit._id,
+        true,
+        confido,
+        groupname,
+        contocom
+      );
     } else {
       return null;
     }
@@ -416,7 +434,6 @@ AccountSchema.statics.createAccount = async function (idapp, username, circuitNa
     console.error('error', e);
     return null;
   }
-
 };
 
 AccountSchema.statics.getUserAccounts = async function (idapp, username) {
@@ -463,10 +480,8 @@ AccountSchema.statics.getUserAccounts = async function (idapp, username) {
               },
             },
             {
-              $group:
+              $group: { _id: '$extrarec.notifIdToUpdate', result: { $first: '$$ROOT' } },
-                { _id: "$extrarec.notifIdToUpdate", result: { $first: "$$ROOT" } }
             },
-
           ],
         },
       },
@@ -502,11 +517,9 @@ AccountSchema.statics.getUserAccounts = async function (idapp, username) {
   } catch (e) {
     console.error('getUserAccounts', e);
   }
-
 };
 
 AccountSchema.statics.getGroupAccounts = async function (idapp, groupname) {
-
   if (!groupname) {
     return [];
   }
@@ -551,8 +564,7 @@ AccountSchema.statics.getGroupAccounts = async function (idapp, groupname) {
               },
             },
             {
-              $group:
+              $group: { _id: '$extrarec.notifIdToUpdate', result: { $first: '$$ROOT' } },
-                { _id: "$extrarec.notifIdToUpdate", result: { $first: "$$ROOT" } }
             },
           ],
         },
@@ -565,37 +577,36 @@ AccountSchema.statics.getGroupAccounts = async function (idapp, groupname) {
   } catch (e) {
     console.error('e', e);
   }
-
 };
 
 // Imposta a tutti i Conti Collettivi, i seguenti minimi e massimi
 AccountSchema.statics.SetMinMaxCollettivi = async function (idapp, valmin, valmax) {
   const Account = this;
 
-  const ris = await Account.updateMany({ idapp, groupname: { "$nin": [null, ""] } },
+  const ris = await Account.updateMany(
+    { idapp, groupname: { $nin: [null, ''] } },
     {
-      $set:
+      $set: {
-      {
         fidoConcesso: valmin,
         qta_maxConcessa: valmax,
-      }
+      },
-    });
+    }
-
+  );
 };
 
 // Imposta a tutti i Conti Comunitari, i seguenti minimi e massimi
 AccountSchema.statics.SetMinMaxComunitari = async function (idapp, valmin, valmax) {
   const Account = this;
 
-  const ris = await Account.updateMany({ idapp, contocom: { "$nin": [null, ""] } },
+  const ris = await Account.updateMany(
+    { idapp, contocom: { $nin: [null, ''] } },
     {
-      $set:
+      $set: {
-      {
         fidoConcesso: valmin,
         qta_maxConcessa: valmax,
-      }
+      },
-    });
+    }
-
+  );
 };
 
 // Imposta a tutti i Conti Personali, i seguenti minimi e massimi
@@ -603,76 +614,88 @@ AccountSchema.statics.SetMinMaxPersonali = async function (idapp, fidoConcesso,
   const Account = this;
 
   if (circuitId) {
-    const ris = await Account.updateMany({ idapp, circuitId, fidoConcesso: { $gt: 0 }, username: { "$nin": [null, ""] } },
+    const ris = await Account.updateMany(
+      { idapp, circuitId, fidoConcesso: { $gt: 0 }, username: { $nin: [null, ''] } },
       {
-        $set:
+        $set: {
-        {
           fidoConcesso,
           qta_maxConcessa,
-        }
+        },
-      });
+      }
+    );
 
     const circuit = await Circuit.findOne({ _id: circuitId });
 
     if (!circuit.circuitoIndipendente) {
       // Se aggiorno questi dati, e non è un Circuito Indipendente, allora devo aggiornare anche gli account del RIS Nazionale
-      await Account.updateAccountCircuitoNazionaleByLimiti(idapp, circuitId, fidoConcesso, qta_maxConcessa);
+      await Account.updateAccountCircuitoItaliaByLimiti(idapp, circuitId, fidoConcesso, qta_maxConcessa);
     }
-
   } else {
-    const ris = await Account.updateMany({ idapp, fidoConcesso: { $gt: 0 }, username: { "$nin": [null, ""] } },
+    const ris = await Account.updateMany(
+      { idapp, fidoConcesso: { $gt: 0 }, username: { $nin: [null, ''] } },
       {
-        $set:
+        $set: {
-        {
           fidoConcesso,
           qta_maxConcessa,
-        }
+        },
-      });
+      }
+    );
   }
-
 };
 
 AccountSchema.statics.updateFido = async function (idapp, username, groupname, circuitId, fido) {
-
   let paramstoupdate = {
     fidoConcesso: fido,
   };
   let risult = null;
-  if (groupname)
+  if (groupname) risult = await Account.updateOne({ idapp, circuitId, groupname }, { $set: paramstoupdate });
-    risult = await Account.updateOne({ idapp, circuitId, groupname }, { $set: paramstoupdate });
+  else risult = await Account.updateOne({ idapp, username, circuitId }, { $set: paramstoupdate });
-  else
-    risult = await Account.updateOne({ idapp, username, circuitId }, { $set: paramstoupdate });
 
   return risult;
 };
 
 AccountSchema.statics.updateQtaMax = async function (idapp, username, groupname, circuitId, qtamax) {
-
   let paramstoupdate = {
     qta_maxConcessa: qtamax,
   };
   let risult = null;
-  if (groupname)
+  if (groupname) risult = await Account.updateOne({ idapp, circuitId, groupname }, { $set: paramstoupdate });
-    risult = await Account.updateOne({ idapp, circuitId, groupname }, { $set: paramstoupdate });
+  else risult = await Account.updateOne({ idapp, username, circuitId }, { $set: paramstoupdate });
-  else
-    risult = await Account.updateOne({ idapp, username, circuitId }, { $set: paramstoupdate });
 
   return risult && risult.modifiedCount > 0;
 };
 
-AccountSchema.statics.getAccountsCircuitiNazionali = async function (idapp) {
+AccountSchema.statics.getAccountsCircuitiExtraProvinciali = async function (idapp) {
   const { Circuit } = require('../models/circuit');
 
-  const circuit = await Circuit.find({ idapp, showAlways: true });
+  const circuits = await Circuit.getCircuitiExtraProvinciali(idapp);
 
-  return Account.find({ idapp, circuitId: circuit.id });
+  if (circuits.length > 0) {
+    const circuitIds = circuits.map((circuit) => circuit._id);
+    return Account.find({ idapp, circuitId: { $in: circuitIds } });
+  }
 };
 
-AccountSchema.statics.updateAccountCircuitoNazionaleByLimiti = async function (idapp, circuitId, fidoConcesso, qta_maxConcessa) {
+AccountSchema.statics.getAccountsCircuitoItalia = async function (idapp) {
+  const { Circuit } = require('../models/circuit');
+
+  const circuit = await Circuit.getCircuitoItalia(idapp);
+
+  if (circuit) {
+    return Account.find({ idapp, circuitId: circuit._id });
+  }
+};
+
+AccountSchema.statics.updateAccountCircuitoItaliaByLimiti = async function (
+  idapp,
+  circuitId,
+  fidoConcesso,
+  qta_maxConcessa
+) {
   const { Circuit } = require('../models/circuit');
 
   try {
-    const accounts = await this.getAccountsCircuitiNazionali(idapp);
+    const accounts = await this.getAccountsCircuitoItalia(idapp);
 
     for (const account of accounts) {
       const circuitId = account.circuitId;
@@ -699,11 +722,10 @@ AccountSchema.statics.updateAccountCircuitoNazionaleByLimiti = async function (i
     }
     return risult;
   } catch (e) {
-    console.error('updateAccountCircuitoNazionaleByLimiti', e);
+    console.error('updateAccountCircuitoItaliaByLimiti', e);
   }
 
   return false;
-
 };
 
 AccountSchema.statics.canEditAccountAdmins = async function (username, id) {
@@ -721,49 +743,49 @@ AccountSchema.statics.canEditAccountAdmins = async function (username, id) {
 };
 
 AccountSchema.statics.addToPeopleOfMyAccount = async function (idapp, username, circuitId, person_username, perm) {
-
+  return await Account.updateOne(
-  return await Account.updateOne({ idapp, username, circuitId },
+    { idapp, username, circuitId },
     {
-      $push:
+      $push: {
-      {
         people: {
           username: person_username,
           perm,
           date: new Date(),
         },
       },
-    });
+    }
-
+  );
 };
 
 // Rimuovi dagli Admin del Account
 AccountSchema.statics.removeAdminOfAccount = async function (idapp, username, circuitId, person_username, perm) {
   const { Circuit } = require('../models/circuit');
 
-  return await Circuit.updateOne({ idapp, username, circuitId },
+  return await Circuit.updateOne(
-    { $pull: { people: { username: { $in: [person_username] } } } });
+    { idapp, username, circuitId },
+    { $pull: { people: { username: { $in: [person_username] } } } }
+  );
 };
 
 // Rimuovi l'account
 AccountSchema.statics.removeAccount = async function (accountId) {
-
   return await Account.deleteOne({ _id: accountId });
 };
 
 AccountSchema.statics.updateSaldoAndTransato_AllAccounts = async function (idapp) {
-
   const recaccounts = await Account.find({ idapp });
 
   for (const account of recaccounts) {
     await account.calcPending();
   }
-
 };
 
 const Account = mongoose.model('Account', AccountSchema);
 
 Account.createIndexes()
-  .then(() => { })
+  .then(() => {})
-  .catch((err) => { throw err; });
+  .catch((err) => {
+    throw err;
+  });
 
 module.exports = { Account };

src/server/models/circuit.js

@@ -223,10 +223,16 @@ const CircuitSchema = new Schema({
     type: Number,
     default: 0,
   },
-  showAlways: {
+  circuitiExtraProv: {
     type: Boolean,
     default: false,
   },
+  isCircItalia: {
+    type: Boolean,
+  },
+  enableOnlyIf1CircuitExist: {
+    type: Boolean,
+  },
   status: {
     type: Number,
     default: 0,
@@ -325,7 +331,9 @@ CircuitSchema.statics.getWhatToShow = function (idapp, username) {
     fido_scoperto_default_contocom: 1,
     qta_max_default_contocom: 1,
     deperimento: 1,
-    showAlways: 1,
+    circuitiExtraProv: 1,
+    isCircItalia: 1,
+    enableOnlyIf1CircuitExist: 1,
     ignoreLimits: 1,
     askManagerToEnter: 1,
     sendEmailAfterAskingToEnter: 1,
@@ -387,7 +395,9 @@ CircuitSchema.statics.getWhatToShow_Unknown = function (idapp, username) {
     longdescr: 1,
     regulation: 1,
     numMembers: 1,
-    showAlways: 1,
+    circuitiExtraProv: 1,
+    isCircItalia: 1,
+    enableOnlyIf1CircuitExist: 1,
     ignoreLimits: 1,
     askManagerToEnter: 1,
     sendEmailAfterAskingToEnter: 1,
@@ -1130,7 +1140,9 @@ CircuitSchema.statics.createCircuitIfNotExist = async function (req, idapp, prov
         photos: [],
         color: '#ff5500',
         deperimento: false,
-        showAlways: false,
+        circuitiExtraProv: false,
+        isCircItalia: false,
+        enableOnlyIf1CircuitExist: false,
         transactionsEnabled: true, // Abilita cmq il circuito dall'inizio
         status: shared_consts.CIRCUIT_STATUS.FASE1_CREAZIONE_GRUPPO,
         symbol: 'RIS',
@@ -1297,7 +1309,7 @@ CircuitSchema.statics.setFido = async function (idapp, username, circuitName, gr
       let variato = false;
       let variato2 = false;
 
-      if (mycircuit.showAlways) {
+      if (mycircuit.isCircItalia) {
 
         const { User } = require('../models/user');
 
@@ -1693,7 +1705,7 @@ CircuitSchema.statics.replaceAllCircuitNames = async function (idapp) {
 
       let path = '';
 
-      if (!circuit.showAlways) {
+      if (!circuit.circuitiExtraProv) {
         let newname = 'Circuito RIS ' + provincia;
 
         // Se newname contiene 'ROMA', allora non aggiorna
@@ -1797,6 +1809,23 @@ CircuitSchema.statics.addMovementByOrdersCart = async function (ordersCart, user
 
 };
 
+CircuitSchema.statics.getCircuitiExtraProvinciali = async function (idapp) {
+  const Circuit = this;
+
+  const circuits = await Circuit.find({ idapp, circuitiExtraProv: true });
+
+  return circuits;
+};
+
+CircuitSchema.statics.getCircuitoItalia = async function (idapp) {
+  const Circuit = this;
+
+  const circuit = await Circuit.findOne({ idapp, isCircItalia: true });
+
+  return circuit;
+};
+
+
 const Circuit = mongoose.model('Circuit', CircuitSchema);
 
 Circuit.createIndexes()

src/server/models/user.js

@@ -539,6 +539,7 @@ const UserSchema = new mongoose.Schema({
       },
     ],
     version: { type: Number },
+    insert_circuito_ita: { type: Boolean },
   },
 });
 
@@ -2850,31 +2851,45 @@ UserSchema.statics.sendCmd = async function (req, idapp, usernameOrig, usernameD
   try {
     if (cmd === shared_consts.CallFunz.ENTRA_RIS_ITALIA) {
       mycircuitOrig = await Circuit.getCircuitMyProvince(idapp, usernameOrig);
-      descr = i18n.__(
-        { phrase: 'SENDMSG_ENTRA_IN_RISO_ITALIA', locale: langdest },
-        usernameDest,
-        usernameOrig,
-        mycircuitOrig
-      );
-      msgtelegram = descr;
 
-      openUrl = '/circuit/ris_italia';
+      let enableOnlyIf1CircuitExist = false;
-      bottone = i18n.__({ phrase: 'CIRCUIT_OPEN_RISITALIA', locale: langdest });
+      let foundIfAlreadyCircuit = false;
-      tag = 'risitalia';
 
-      send_notif = true;
+      if (mycircuitOrig) {
-      send_msgTelegramBot = true;
+        // Fai la richiesta solo se appartieni già al tuo Circuito Territoriale
+        foundIfAlreadyCircuit = await User.ifAlreadyInCircuit(idapp, usernameOrig, mycircuitOrig);
+      }
 
-      keyb = cl.getInlineKeyboard(langdest, [
+      if (!foundIfAlreadyCircuit) {
-        {
+        // Se non sono dentro ad un circuito Provinciale, setto come flag la possibilità di inserire il Circuito ITA
-          text: bottone,
+        await User.setInseriscimiAncheInCircuitoITA(idapp, usernameOrig);
-          url: tools.getHostByIdApp(idapp) + openUrl,
+      } else {
-          // callback_data: InlineConferma.RISPOSTA_SI + myfunc + tools.SEP + myuser.username + tools.SEP + '' + tools.SEP + '' + tools.SEP +
+        descr = i18n.__(
-          //   groupid,
+          { phrase: 'SENDMSG_ENTRA_IN_RISO_ITALIA', locale: langdest },
-        },
+          usernameDest,
-      ]);
+          usernameOrig,
+          mycircuitOrig
+        );
+        msgtelegram = descr;
 
-      popupOnApp = 'Messaggio inviato al destinatario';
+        openUrl = '/circuit/ris_italia';
+        bottone = i18n.__({ phrase: 'CIRCUIT_OPEN_RISITALIA', locale: langdest });
+        tag = 'risitalia';
+
+        send_notif = true;
+        send_msgTelegramBot = true;
+
+        keyb = cl.getInlineKeyboard(langdest, [
+          {
+            text: bottone,
+            url: tools.getHostByIdApp(idapp) + openUrl,
+            // callback_data: InlineConferma.RISPOSTA_SI + myfunc + tools.SEP + myuser.username + tools.SEP + '' + tools.SEP + '' + tools.SEP +
+            //   groupid,
+          },
+        ]);
+
+        popupOnApp = 'Messaggio inviato al destinatario';
+      }
     }
 
     if (send_notif) {
@@ -2930,6 +2945,29 @@ UserSchema.statics.ifAlreadyInCircuit = async function (idapp, usernameOrig, cir
   }).lean();
 };
 
+UserSchema.statics.ifAlreadyInCircuitItalia = async function (idapp, usernameOrig) {
+  try {
+    const circuitoItalia = await Circuit.getCircuitoItalia(idapp);
+
+    if (circuitoItalia) {
+      const circuitname = circuitoItalia.name;
+
+      // Controllo se è stato già inserito in Circuito Italia
+      return await User.findOne({
+        idapp,
+        username: usernameOrig,
+        'profile.mycircuits': {
+          $elemMatch: { circuitname: { $eq: circuitname } },
+        },
+      }).lean();
+    }
+
+    return false;
+  } catch (e) {
+    console.error('ifAlreadyInCircuitItalia', e);
+  }
+};
+
 //** Get true if in 'profile.mycircuits' exist at least one circuit */
 UserSchema.statics.ExistAtLeastOneCircuit = async function (idapp, username) {
   // Controllo se è stato più inserito
@@ -3213,130 +3251,164 @@ UserSchema.statics.setCircuitCmd = async function (
             username_action,
             extrarec
           );
+
+          // Se gli è stato abilitato il Fido ad un Circuito Provinciale,
+          // se non è ancora dentro al Circuito Italia
+          const giainItalia = await User.ifAlreadyInCircuitItalia(idapp, usernameOrig);
+
+          if (!giainItalia) {
+            // allora ora attiva la richiesta per il circuito Italia
+            const inseriscimiInCircuitoItalia = await User.getInseriscimiAncheInCircuitoITA(idapp, usernameOrig);
+
+            const circuitItalia = await Circuit.getCircuitoItalia(idapp);
+
+            if (inseriscimiInCircuitoItalia) {
+              const mycmd = shared_consts.CIRCUITCMD.REQ;
+              await User.setCircuitCmd(idapp, usernameOrig, circuitItalia.name, mycmd, true, usernameOrig, {
+                groupname: groupname,
+                abilitaveramente: true,                
+              });
+            }
+          }
+
           outres.result = await Circuit.getInfoCircuitByName(idapp, circuitname);
         }
       } else {
         // errore !?
       }
     } else if (cmd === shared_consts.CIRCUITCMD.REQ) {
-      if (groupname) {
+      let abilitareq = true;
-        // Aggiungo la richiesta di Gruppo a me
-        const foundIfAlreadyAskCircuit = await Circuit.findOne({
-          idapp,
-          name: circuitname,
-          req_groups: {
-            $elemMatch: { groupname: { $eq: groupname } },
-          },
-        });
 
-        if (value) {
+      const thiscircuit = await Circuit.findOne({
-          ris = await this.addCircuitToUser(idapp, usernameOrig, circuitname, false, groupname, '');
+        idapp,
+        name: circuitname,
+      });
 
-          if (!foundIfAlreadyAskCircuit) {
+      // se è il circuito Italia e !extrarec.abilitoveramente allora
-            update = {
+      if (thiscircuit.isCircItalia && !extrarec.abilitaveramente) {
-              $push: {
+        abilitareq = false;
-                req_groups: {
+      }
-                  groupname,
+      // abilito il set
-                  date: new Date(),
+
+      if (abilitareq) {
+        if (groupname) {
+          // Aggiungo la richiesta di Gruppo a me
+          const foundIfAlreadyAskCircuit = await Circuit.findOne({
+            idapp,
+            name: circuitname,
+            req_groups: {
+              $elemMatch: { groupname: { $eq: groupname } },
+            },
+          });
+
+          if (value) {
+            ris = await this.addCircuitToUser(idapp, usernameOrig, circuitname, false, groupname, '');
+
+            if (!foundIfAlreadyAskCircuit) {
+              update = {
+                $push: {
+                  req_groups: {
+                    groupname,
+                    date: new Date(),
+                  },
                 },
-              },
+              };
-            };
+              ris = await Circuit.updateOne({ idapp, name: circuitname }, update);
-            ris = await Circuit.updateOne({ idapp, name: circuitname }, update);
+            }
-          }
+            if (ris) {
-          if (ris) {
+              // Invia una notifica alla persona
-            // Invia una notifica alla persona
+              await tools.sendNotificationByCircuit(
-            await tools.sendNotificationByCircuit(
+                idapp,
-              idapp,
+                usernameOrig,
-              usernameOrig,
+                circuitname,
-              circuitname,
+                cmd,
-              cmd,
+                true,
-              true,
+                true,
-              true,
+                username_action,
-              username_action,
+                extrarec
-              extrarec
+              );
-            );
+            }
+          } else {
+            if (foundIfAlreadyAskCircuit) {
+              outres.result = await MyGroup.removeCircuitFromGroup(idapp, groupname, circuitname); // Rimuovo il Circuito dal gruppo
+
+              // Invia una notifica alla persona
+              await tools.sendNotificationByCircuit(
+                idapp,
+                usernameOrig,
+                circuitname,
+                cmd,
+                false,
+                true,
+                username_action,
+                extrarec
+              );
+            }
           }
         } else {
-          if (foundIfAlreadyAskCircuit) {
+          // Aggiungo la richiesta di Circuito a me
-            outres.result = await MyGroup.removeCircuitFromGroup(idapp, groupname, circuitname); // Rimuovo il Circuito dal gruppo
+          const foundIfAlreadyAskCircuit = await Circuit.findOne({
+            idapp,
+            name: circuitname,
+            req_users: {
+              $elemMatch: { username: { $eq: usernameOrig } },
+            },
+          });
 
-            // Invia una notifica alla persona
+          if (value) {
-            await tools.sendNotificationByCircuit(
+            if (!thiscircuit.askManagerToEnter) {
-              idapp,
+              // Aggiungi intanto l'utente al Circuito (senza fido)
-              usernameOrig,
+              ris = await this.addCircuitToUser(idapp, usernameOrig, circuitname, false);
-              circuitname,
+            }
-              cmd,
+
-              false,
+            if (!foundIfAlreadyAskCircuit) {
-              true,
+              update = {
-              username_action,
+                $push: {
-              extrarec
+                  req_users: {
-            );
+                    username: usernameOrig,
+                    date: new Date(),
+                  },
+                },
+              };
+              // Aggiungi la richiesta per ottenere il fido (o per entrare nel circuito)
+              ris = await Circuit.updateOne({ idapp, name: circuitname }, update);
+            }
+
+            if (ris) {
+              // Invia una notifica alla persona
+              await tools.sendNotificationByCircuit(
+                idapp,
+                usernameOrig,
+                circuitname,
+                cmd,
+                true,
+                true,
+                username_action,
+                extrarec
+              );
+            }
+          } else {
+            if (foundIfAlreadyAskCircuit) {
+              outres.result = await this.removeFromCircuits(idapp, usernameOrig, circuitname); // Rimuovo il Gruppo da me
+
+              // Invia una notifica alla persona
+              await tools.sendNotificationByCircuit(
+                idapp,
+                usernameOrig,
+                circuitname,
+                cmd,
+                false,
+                true,
+                username_action,
+                extrarec
+              );
+            }
           }
         }
       } else {
-        // Aggiungo la richiesta di Circuito a me
+        // imposta che quando lo attiveranno al circuito territoriale, allora verrà fatta anche la richiesta per il circuito Italia
-        const foundIfAlreadyAskCircuit = await Circuit.findOne({
+        await User.setInseriscimiAncheInCircuitoITA(idapp, usernameOrig);
-          idapp,
+        ris = true;
-          name: circuitname,
-          req_users: {
-            $elemMatch: { username: { $eq: usernameOrig } },
-          },
-        });
-
-        const thiscircuit = await Circuit.findOne({
-          idapp,
-          name: circuitname,
-        });
-
-        if (value) {
-          if (!thiscircuit.askManagerToEnter) {
-            // Aggiungi intanto l'utente al Circuito (senza fido)
-            ris = await this.addCircuitToUser(idapp, usernameOrig, circuitname, false);
-          }
-
-          if (!foundIfAlreadyAskCircuit) {
-            update = {
-              $push: {
-                req_users: {
-                  username: usernameOrig,
-                  date: new Date(),
-                },
-              },
-            };
-            // Aggiungi la richiesta per ottenere il fido (o per entrare nel circuito)
-            ris = await Circuit.updateOne({ idapp, name: circuitname }, update);
-          }
-
-          if (ris) {
-            // Invia una notifica alla persona
-            await tools.sendNotificationByCircuit(
-              idapp,
-              usernameOrig,
-              circuitname,
-              cmd,
-              true,
-              true,
-              username_action,
-              extrarec
-            );
-          }
-        } else {
-          if (foundIfAlreadyAskCircuit) {
-            outres.result = await this.removeFromCircuits(idapp, usernameOrig, circuitname); // Rimuovo il Gruppo da me
-
-            // Invia una notifica alla persona
-            await tools.sendNotificationByCircuit(
-              idapp,
-              usernameOrig,
-              circuitname,
-              cmd,
-              false,
-              true,
-              username_action,
-              extrarec
-            );
-          }
-        }
       }
     } else if (cmd === shared_consts.CIRCUITCMD.REMOVE_FROM_MYLIST) {
       if (groupname) {
@@ -4074,6 +4146,44 @@ UserSchema.statics.NonVoglioImbarcarmi = async function (idapp, username) {
   });
 };
 
+UserSchema.statics.getInseriscimiAncheInCircuitoITA = async function (idapp, username) {
+  const User = this;
+
+  return await User.findOne(
+    {
+      idapp,
+      username,
+      $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
+    },
+    { 'profile.insert_circuito_ita': 1 }
+  )
+    .lean()
+    .then((rec) => {
+      return !!rec ? rec.profile.insert_circuito_ita : null;
+    })
+    .catch((e) => {
+      console.error('getInseriscimiAncheInCircuitoITA', e);
+    });
+};
+UserSchema.statics.setInseriscimiAncheInCircuitoITA = async function (idapp, username) {
+  const User = this;
+
+  const fields_to_update = {
+    'profile.insert_circuito_ita': true,
+  };
+
+  return await User.findOneAndUpdate(
+    {
+      idapp,
+      username,
+    },
+    { $set: fields_to_update },
+    { new: false }
+  ).then((record) => {
+    return !!record;
+  });
+};
+
 UserSchema.statics.SetTelegramIdSuccess = async function (idapp, id, teleg_id) {
   const User = this;
 

src/server/telegram/telegrambot.js

@@ -937,10 +937,13 @@ const MyTelegramBot = {
             i18n.__({ phrase: 'CIRCUIT_ACCEPT_NEWENTRY_BYGROUP', locale: langdest }, groupname) +
             '<br>' +
             struserinfomsg;
+          
+          let textentrato = '';
+          
 
           keyb = cl.getInlineKeyboard(myuser.lang, [
             {
-              text: '✅ Abilita fiducia a ' + groupname,
+              text: textentrato + '✅ Abilita fiducia a ' + groupname,
               callback_data:
                 InlineConferma.RISPOSTA_SI +
                 myfunc +

src/server/tools/general.js

@@ -1600,7 +1600,17 @@ module.exports = {
       } else {
         const groupOrig = ''; //++Todo: extrarec.groupOrig
 
-        for (const singleadmin of this.getAdminsByCircuit(circuit)) {
+        let arradmins = this.getAdminsByCircuit(circuit);
+        console.log('arradmins', arradmins);
+
+        const mapByUsername = arradmins.reduce((map, item) => {
+          map[item.username] = item;
+          return map;
+        }, {});
+
+        arradmins = Object.values(mapByUsername);
+
+        for (const singleadmin of arradmins) {
           try {
             if (singleadmin.username) {
               if (usernameOrig === singleadmin.username) giainviato = true;

src/server/tools/shared_nodejs.js

@@ -867,7 +867,9 @@ module.exports = {
         nome_valuta: 1,
         fido_scoperto_default: 1,
         deperimento: 1,
-        showAlways: 1,
+        circuitiExtraProv: 1,
+        isCircItalia: 1,
+        enableOnlyIf1CircuitExist: 1,
         ignoreLimits: 1,
         askManagerToEnter: 1,
         sendEmailAfterAskingToEnter: 1,