freeplanet_serverside/src/server/models/user.js

const bcrypt = require('bcryptjs');
const mongoose = require('mongoose');
const validator = require('validator');
const jwt = require('jsonwebtoken');
const _ = require('lodash');

const tools = require('../tools/general');

const { Flotta } = require('../models/flotta');
const { Settings } = require('../models/settings');
const { ListaIngresso } = require('../models/listaingresso');
const { Graduatoria } = require('../models/graduatoria');
const { Nave } = require('../models/nave');
const { NavePersistente } = require('../models/navepersistente');
// const { ExtraList } = require('../models/extralist');

const { ObjectID } = require('mongodb');

const shared_consts = require('../tools/shared_nodejs');
const queryclass = require('../classes/queryclass');

mongoose.Promise = global.Promise;

mongoose.level = "F";
// Resolving error Unknown modifier: $pushAll
mongoose.plugin(schema => {
  schema.options.usePushEach = true
});

mongoose.set('debug', process.env.DEBUG);

const UserSchema = new mongoose.Schema({
    userId: {
      type: String,
    },
    email: {
      type: String,
      required: true,
      trim: true,
      minlength: 1,
      unique: false,
      /*validate: {
        validator: validator.isEmail,
        message: '{VALUE} is not a valid email'
      }*/
    },
    idapp: {
      type: String,
      required: true,
    },
    index: {
      type: Number
    },
    ind_order: {
      type: Number
    },
    old_order: {
      type: Number
    },
    username: {
      type: String,
      required: true,
      trim: true,
      minlength: 6,
      unique: false,
    },
    name: {
      type: String,
      trim: true,
    },
    surname: {
      type: String,
      trim: true,
    },
    password: {
      type: String,
      require: true,
      minlength: 6,
    },
    lang: {
      type: String,
      require: true,
    },
    linkreg: {
      type: String,
      required: false
    },
    verified_email: {
      type: Boolean,
    },
    made_gift: {
      type: Boolean,
    },
    tokens: [{
      access: {
        type: String,
        required: true
      },
      browser: {
        type: String,
        required: true
      },
      token: {
        type: String,
        required: true
      },
      date_login: {
        type: Date
      },
    }],
    perm: {
      type: Number
    },
    ipaddr: {
      type: String,
    },
    date_reg: {
      type: Date,
    },
    date_deleted: {
      type: Date,
    },
    date_tokenforgot: {
      type: Date
    },
    tokenforgot: {
      type: String,
    },
    lasttimeonline: {
      type: Date
    },
    news_on: {
      type: Boolean
    },
    aportador_solidario: {  // da cancellare
      type: String,
    },
    aportador_iniziale: {
      type: String,
    },
    aportador_solidario_nome_completo: {
      type: String,
    },
    aportador_solidario_ind_order: {
      type: Number,
    },
    note: {
      type: String,
    },
    deleted: {
      type: Boolean,
      default: false
    },
    sospeso: {
      type: Boolean
    },
    non_voglio_imbarcarmi: {
      type: Boolean
    },
    navinonpresenti: {
      type: Boolean
    },
    subaccount: {
      type: Boolean
    },
    cart: {
      type: Object
    },
    profile: {
      img: {
        type: String
      },
      nationality: {
        type: String
      },
      intcode_cell: {
        type: String
      },
      iso2_cell: {
        type: String
      },
      cell: {
        type: String
      },
      country_pay: {
        type: String
      },
      email_paypal: {
        type: String
      },
      payeer_id: {
        type: String
      },
      advcash_id: {
        type: String
      },
      revolut: {
        type: String
      },
      link_payment: {
        type: String
      },
      note_payment: {
        type: String
      },
      paymenttypes: [],
      username_telegram: {
        type: String
      },
      teleg_id: {
        type: Number
      },
      teleg_id_old: {
        type: Number
      },
      teleg_checkcode: {
        type: Number
      },
      manage_telegram: {
        type: Boolean
      },
      resplist: {
        type: Boolean
      },
      workerslist: {
        type: Boolean
      },
      dateofbirth: {
        type: Date,
      },
      my_dream: {
        type: String,
      },
      saw_and_accepted: {
        type: Number,
      },
      saw_zoom_presentation: {
        type: Boolean
      },
      ask_zoom_partecipato: {
        type: Boolean
      },
      qualified: {
        type: Boolean
      },
      qualified_2invitati: {
        type: Boolean
      },
      special_req: {
        type: Boolean
      },
      sex: {
        type: Number,
      },
      motivazioni: {
        type: String
      },
      competenze_professionalita: {
        type: String
      },
      cosa_offrire: {
        type: String
      },
      cosa_ricevere: {
        type: String
      },
      altre_comunicazioni: {
        type: Boolean,
      },
      come_ci_hai_conosciuto: {
        type: Boolean,
      },
      socio: {
        type: Boolean,
      },
      socioresidente: {
        type: Boolean,
      },
      consiglio: {
        type: Boolean,
      },
      myshares: [{
        description: { type: String },
        rating: { type: Number },
      }]
    },

  })
;

UserSchema.methods.toJSON = function () {
  const user = this;
  const userObject = user.toObject();

  return _.pick(userObject, ['_id', ...shared_consts.fieldsUserToChange()]);
};

UserSchema.methods.generateAuthToken = function (req) {
  // console.log("GENERA TOKEN : ");
  const user = this;

  const useragent = req.get('User-Agent');
  // tools.mylog("GENERATE USER-AGENT = ", useragent);

  const access = 'auth';
  const browser = useragent;
  const token = jwt.sign({ _id: user._id.toHexString(), access }, process.env.SIGNCODE).toString();
  const date_login = new Date();

  // CANCELLA IL PRECEDENTE !
  user.tokens = user.tokens.filter(function (tok) {
    return (tok.access !== access) || ((tok.access === access) && (tok.browser !== browser));
  });
  user.tokens.push({ access, browser, token, date_login });

  user.lasttimeonline = new Date();

  return user.save()
    .then(() => {
      // console.log("TOKEN CREATO IN LOGIN : " + token);
      return token;
    })
    .catch(err => {
      console.log("Error", err.message);
    });
};

UserSchema.statics.setPermissionsById = function (id, perm) {
  const user = this;

  return user.findByIdAndUpdate(id, { $set: { perm } }).then((user) => {
    if (user)
      return res.send({ code: server_constants.RIS_CODE_OK, msg: '' });
    else
      return res.send({ code: server_constants.RIS_CODE_ERR, msg: '' });
  });

};

UserSchema.statics.setZoomPresenza = async function (idapp, id, presenza) {
  const User = this;

  const telegrambot = require('../telegram/telegrambot');

  let allData = {};
  allData.myuser = await User.getUserById(idapp, id);
  if (!!allData.myuser)
    allData.precDataUser = await User.getInfoUser(idapp, allData.myuser.username);

  return await User.findByIdAndUpdate(id, { $set: { 'profile.saw_zoom_presentation': presenza } })
    .then((rec) => {
      if (presenza) {
        const messaggio = tools.get__('ZOOM_CONFERMATO');
        telegrambot.sendMsgTelegram(rec.idapp, rec.username, messaggio);
        telegrambot.sendMsgTelegramToTheManagersAndZoomeri(idapp, `L\'utente ${rec.name} ${rec.surname} (${rec.username}) è stato confermato per aver visto lo Zoom di Benvenuto`);
      } else {
        telegrambot.sendMsgTelegramToTheManagersAndZoomeri(idapp, `L\'utente ${rec.name} ${rec.surname} (${rec.username}) è stato annullata la sua richiesta per aver visto lo Zoom di Benvenuto! (Non ci risulta)`);
      }

      return User.findByIdAndUpdate(id, { $set: { 'profile.ask_zoom_partecipato': false } })
        .then((user) => {


          User.checkIfSbloccatiRequisiti(idapp, allData, id);
        });
    });

};

UserSchema.statics.isAdmin = function (perm) {
  try {
    return ((perm & shared_consts.Permissions.Admin) === shared_consts.Permissions.Admin);
  } catch (e) {
    return false
  }
};

UserSchema.statics.isManager = function (perm) {
  try {
    return ((perm & shared_consts.Permissions.Manager) === shared_consts.Permissions.Manager);
  } catch (e) {
    return false
  }
};

UserSchema.statics.isEditor = function (perm) {
  try {
    return ((perm & shared_consts.Permissions.Editor) === shared_consts.Permissions.Editor);
  } catch (e) {
    return false
  }
};

UserSchema.statics.isZoomeri = function (perm) {
  try {
    return ((perm & shared_consts.Permissions.Zoomeri) === shared_consts.Permissions.Zoomeri);
  } catch (e) {
    return false
  }
};

UserSchema.statics.isDepartment = function (perm) {
  try {
    return ((perm & shared_consts.Permissions.Zoomeri) === shared_consts.Permissions.Department);
  } catch (e) {
    return false
  }
};

UserSchema.statics.isTutor = function (perm) {
  try {
    return ((perm & shared_consts.Permissions.Tutor) === shared_consts.Permissions.Tutor);
  } catch (e) {
    return false
  }
};

UserSchema.statics.findByToken = function (token, typeaccess) {
  const User = this;
  let decoded;

  try {
    decoded = jwt.verify(token, process.env.SIGNCODE);
  } catch (e) {
    return Promise.resolve(null);
  }

  return User.findOne({
    '_id': decoded._id,
    'tokens.token': token,
    'tokens.access': typeaccess,
  });
};

UserSchema.statics.findByTokenAnyAccess = function (token) {
  const User = this;
  let decoded;

  try {
    decoded = jwt.verify(token, process.env.SIGNCODE);
  } catch (e) {
    return Promise.resolve(null);
  }

  return User.findOne({
    '_id': decoded._id,
    'tokens.token': token,
  });
};

UserSchema.statics.findByCredentials = function (idapp, username, password) {
  const User = this;
  let pwd = "";

  return User.findOne({
    idapp, username: username,
    $or: [
      { deleted: { $exists: false } },
      { deleted: { $exists: true, $eq: false } },
      {
        $and: [
          { deleted: { $exists: true, $eq: true } },
          { subaccount: { $exists: true, $eq: true } }
        ]
      }
    ],

  }).then((user) => {
    if (!user) {
      // Check if with email:
      return User.findOne({
        idapp, email: username.toLowerCase(),
        $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }]
      })
    } else {
      return !user.deleted || (user.deleted && user.subaccount) ? user : null
    }
  }).then(user => {
    if (!user)
      return null;

    pwd = user.password;

    return new Promise((resolve, reject) => {
      // Use bcrypt.compare to compare password and user.password
      // console.log("pwd1 " + password);
      // console.log("pwd2 " + pwd);
      bcrypt.compare(password, pwd, (err, res) => {
        if (res) {
          resolve(user);
        } else {
          return resolve(null);
        }
      });
    });
  });
};


UserSchema.statics.findByUsername = async function (idapp, username, alsoemail) {
  const User = this;

  const regexusername = new RegExp(["^", username, "$"].join(""), "i");

  return await User.findOne({
    'idapp': idapp,
    'username': regexusername,
    $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
  }).then(async (ris) => {
    if ((!ris) && (alsoemail)) {
      regexemail = new RegExp(["^", username.toLowerCase(), "$"].join(""), "i");

      return User.findOne({
        'idapp': idapp,
        'email': regexemail,
        $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
      });
    }
    return ris;
  });
};

UserSchema.statics.getUserShortDataByUsername = async function (idapp, username) {
  const User = this;

  const myrec = await User.findOne({
    'idapp': idapp,
    'username': username,
    $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
  }, {
    idapp: 1,
    lang: 1,
    index: 1,
    ind_order: 1,
    username: 1,
    aportador_solidario: 1,
    name: 1,
    surname: 1,
    deleted: 1,
    sospeso: 1,
    verified_email: 1,
    'profile.teleg_id': 1,
    // 'profile.saw_zoom_presentation': 1,
    'profile.ask_zoom_partecipato': 1,
    'profile.qualified': 1,
    'profile.qualified_2invitati': 1,
    'profile.saw_and_accepted': 1,
    'profile.email_paypal': 1,
    'profile.payeer_id': 1,
    'profile.advcash_id': 1,
    'profile.revolut': 1,
    'profile.link_payment': 1,
    'profile.note_payment': 1,
    // 'profile.my_dream': 1,
    'profile.paymenttypes': 1,
    'profile.cell': 1,
    made_gift: 1,
    email: 1,
    date_reg: 1,
    img: 1
  }).then((ris) => {
    if (!!ris) {
      // console.log('ris', ris);
      if (!!ris._doc)
        return ris._doc;
      else
        return null;
    }
  });

  if (myrec) {
    myrec.qualified = await User.isUserQualified7(idapp, myrec.username);
    myrec.numNaviEntrato = await Nave.getnumNaviByUsername(idapp, myrec.username);
    myrec.numinvitati = await ListaIngresso.getnumInvitati(idapp, myrec.username);
    myrec.numinvitatiattivi = await ListaIngresso.getnumInvitatiAttivi(idapp, myrec.username);
  }

  return myrec
};

UserSchema.statics.getDownlineByUsername = async function (idapp, username, includemyself, onlynumber) {

  if (username === undefined)
    return null;

  let arrrec = await ListaIngresso.getInvitati(idapp, username, includemyself,
    {
      index: 1,
      lang: 1,
      invitante_username: 1,
      ind_order: 1,
      username: 1,
      name: 1,
      surname: 1,
      verified_email: 1,
      'profile.teleg_id': 1,
      // 'profile.saw_zoom_presentation': 1,
      'profile.ask_zoom_partecipato': 1,
      'profile.qualified': 1,
      'profile.qualified_2invitati': 1,
      'profile.saw_and_accepted': 1,
      'profile.email_paypal': 1,
      'profile.payeer_id': 1,
      'profile.advcash_id': 1,
      'profile.revolut': 1,
      'profile.link_payment': 1,
      'profile.note_payment': 1,
      // 'profile.my_dream': 1,
      'profile.paymenttypes': 1,
      'profile.cell': 1,
      made_gift: 1,
      email: 1,
      date_reg: 1,
      img: 1
    }
  );

  let myq = {
    idapp,
    aportador_solidario: username,
    $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }]
  };

  if (!includemyself) {
    myq = { ...myq, username: { $ne: username } }
  }

  // Ottieni gli invitati che ancora non hanno un'imbarco
  const arrinv = await User.find(myq);

  for (const inv of arrinv) {
    if (!arrrec.find((rec) => rec.username === inv.username))
      arrrec.push(inv._doc);
  }

  const arrusername = [];

  for (const inv of arrrec) {

    const rectrovato = arrusername.find((rec) => inv.username === rec.username);
    if (!!rectrovato) {
      rectrovato.quanti++;
    } else {
      const myrec = { ...inv };
      myrec.quanti = 1;
      arrusername.push(myrec)
    }

  }

  arrrec = arrusername;


  if (!onlynumber) {
    if (!!arrrec) {
      for (const rec of arrrec) {
        rec.qualified = await User.isUserQualified7(idapp, rec.username);
        rec.numNaviEntrato = await Nave.getnumNaviByUsername(idapp, rec.username);
        rec.numinvitati = await ListaIngresso.getnumInvitati(idapp, rec.username);
        rec.numinvitatiattivi = await ListaIngresso.getnumInvitatiAttivi(idapp, rec.username);
      }
    }
  }
  return arrrec;

};

UserSchema.statics.getQueryQualified = function () {
  return [
    {
      $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
    },
    {
      $or: [
        {
          'profile.special_req': true
        },
        {
          verified_email: true,
          'profile.teleg_id': { $gt: 1 },
          'profile.saw_and_accepted': shared_consts.ALL_SAW_AND_ACCEPTED,
          // 'profile.saw_zoom_presentation': true,
          $or: [
            { 'profile.link_payment': { $exists: true } },
            { 'profile.email_paypal': { $exists: true } },
            { 'profile.payeer_id': { $exists: true } },
            { 'profile.advcash_id': { $exists: true } },
            { 'profile.revolut': { $exists: true } },
          ],
          // 'profile.paymenttypes': { "$in": ['paypal'] },
          // $where: "this.profile.paymenttypes.length >= 1",
        }]
    }
  ];
}


UserSchema.statics.isUserQualified7 = async function (idapp, username) {
  const User = this;

  if (username === undefined)
    return false;

  const myquery = {
    'idapp': idapp,
    'username': username,
    $and: User.getQueryQualified(),
  };

  const myrec = await User.findOne(myquery);

  return !!myrec;
};

UserSchema.statics.isUserResidente = async function (idapp, username) {
  const User = this;

  if (username === undefined)
    return false;

  const myquery = {
    'idapp': idapp,
    'username': username,
  };

  const myrec = await User.findOne(myquery);
  if (!!myrec) {
    return myrec.profile.socioresidente;
  } else {
    return false;
  }


};

UserSchema.statics.isUserConsiglio = async function (idapp, username) {
  const User = this;

  if (username === undefined)
    return false;

  const myquery = {
    'idapp': idapp,
    'username': username,
  };

  const myrec = await User.findOne(myquery);
  if (!!myrec) {
    return myrec.profile.consiglio;
  } else {
    return false;
  }


};

UserSchema.statics.isUserVisuProjects = async function (idapp, username) {
  const User = this;

  if (username === undefined)
    return false;

  const myquery = {
    'idapp': idapp,
    'username': username,
  };

  const myrec = await User.findOne(myquery);
  if (!!myrec) {
    return myrec.profile.socioresidente;
  } else {
    return false;
  }


};

UserSchema.statics.isUserAlreadyQualified = async function (idapp, username) {
  const User = this;

  if (username === undefined)
    return false;

  const myquery = {
    'idapp': idapp,
    'username': username,
    'profile.qualified': { $exists: true, $eq: true },
  };

  const myrec = await User.findOne(myquery);

  return !!myrec;
};

UserSchema.statics.isUserAlreadyQualified_2Invitati = async function (idapp, username) {
  const User = this;

  if (username === undefined)
    return false;

  const myquery = {
    'idapp': idapp,
    'username': username,
    'profile.qualified_2invitati': { $exists: true, $eq: true },
  };

  const myrec = await User.findOne(myquery);

  return !!myrec;
};

UserSchema.statics.setUserQualified = async function (idapp, username) {
  const User = this;

  if (username === undefined)
    return false;

  const myquery = {
    'idapp': idapp,
    'username': username,
  };

  const myrec = await User.findOneAndUpdate(myquery, { $set: { 'profile.qualified': true } }, { new: false });

  return !!myrec;
};

UserSchema.statics.setUserQualified_2Invitati = async function (idapp, username) {
  const User = this;

  if (username === undefined)
    return false;

  const myquery = {
    'idapp': idapp,
    'username': username,
  };

  const myrec = await User.findOneAndUpdate(myquery, { $set: { 'profile.qualified_2invitati': true } }, { new: false });

  return !!myrec;
};

UserSchema.statics.isUserQualified9 = async function (idapp, username) {
  const User = this;

  if (username === undefined)
    return false;

  qualified = await User.isUserQualified7(idapp, username);
  numinvitatiattivi = await ListaIngresso.getnumInvitatiAttivi(idapp, username);

  return qualified && (numinvitatiattivi >= 2);

};

/*
UserSchema.statics.getnumPaymentOk = function (idapp) {
  const User = this;

  return User.count({
    idapp,
    $and: [
      {
        $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
        'profile.paymenttypes': { "$in": ['paypal'] },
      },
      {
        $or: [
          { 'profile.email_paypal': { $exists: true } },
          { 'profile.revolut': { $exists: true } },
        ]
      }
    ]
  });
};
*/

UserSchema.statics.getUsersNationalityQuery = function (idapp) {
  const query = [
    {
      $match: { idapp, $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }], }
    },
    {
      $group: { _id: "$profile.nationality", count: { $sum: 1 } }
    },
    {
      $sort: { count: -1 }
    }
  ];
  return query
};


UserSchema.statics.getindOrderDuplicate = function (idapp) {
  const User = this;

  return User.aggregate(User.getUsersNationalityQuery(idapp))
    .then(ris => {
      // console.table(ris);
      return JSON.stringify(ris);
    });
};

UserSchema.statics.findByLinkreg = function (idapp, linkreg) {
  const User = this;

  return User.findOne({
    'linkreg': linkreg,
    'idapp': idapp,
  });
};

UserSchema.statics.AportadorOrig = function (idapp, id) {
  const User = this;

  return User.findOne({
    '_id': id,
    'idapp': idapp,
  }).then((rec) => {
    if (rec)
      return rec.aportador_iniziale;
    else
      return '';
  });
};


UserSchema.statics.findByLinkTokenforgot = function (idapp, email, tokenforgot) {
  const User = this;

  return User.findOne({
    'email': email,
    'tokenforgot': tokenforgot,
    'date_tokenforgot': { $gte: tools.IncDateNow(-1000 * 60 * 60 * 4) },  // 4 ore fa!
    'idapp': idapp,
  });
};


UserSchema.statics.findByEmail = function (idapp, email) {
  const User = this;

  return User.findOne({
    'idapp': idapp,
    'email': email,
    $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
  });
};

UserSchema.statics.getLastUser = function (idapp) {
  const User = this;

  return User.findOne({
    idapp,
    $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
  }).sort({ index: -1 })
};

UserSchema.statics.findByIndOrder = function (idapp, ind_order) {
  const User = this;

  return User.getRecByIndOrder(idapp, ind_order);

};

UserSchema.statics.findByIndex = function (idapp, index) {
  const User = this;

  try {
    // ++Todo: non mettere tutti i campi !!
    return User.findOne({
      idapp,
      index,
      $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
    });
  } catch (e) {
    console.error(e.message);
  }
};

UserSchema.statics.findByOldOrder = function (idapp, old_order) {
  const User = this;

  try {
    return User.findOne({
      idapp,
      old_order,
      $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
    });
  } catch (e) {
    console.error(e.message);
  }
};


UserSchema.pre('save', async function (next) {

  try {
    if (this.isNew) {
      try {
        const myrec = await User.findOne({ idapp: this.idapp }).limit(1).sort({ index: -1 });

        if (!!myrec) {
          this.index = myrec._doc.index + 1;
        } else {
          this.index = 1;
        }
      } catch (e) {
        this.index = 2;
      }
    }

    /*
    if (user.isModified('password')) {
      bcrypt.genSalt(10, (err, salt) => {
        bcrypt.hash(user.password, salt, (err, hash) => {
          user.password = hash;
          next();
        });
      });
    } else {
      next();
    }
    */

    next();
  } catch (e) {
    console.error(e.message);
  }
});

UserSchema.methods.removeToken = function (token) {
  const user = this;

  return user.updateOne({
    $pull: {
      tokens: { token }
    }
  });
};

UserSchema.statics.getEmailByUsername = async function (idapp, username) {
  const User = this;

  return await User.findOne({
    idapp, username,
    $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }]
  })
    .then((arrrec) => {
      return ((arrrec) ? arrrec.email : '');
    }).catch((e) => {
      console.error('getEmailByUsername', e);
    });
};

UserSchema.statics.getUsernameById = async function (idapp, id) {
  const User = this;

  return await User.findOne({
    idapp, _id: id,
    $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }]
  }, { username: 1 })
    .then((myuser) => {
      return ((myuser) ? myuser.username : '');
    }).catch((e) => {

    });
};

UserSchema.statics.getUserById = function (idapp, id) {
  const User = this;

  return User.findOne({
    idapp, _id: id,
    $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }]
  })
};

UserSchema.statics.getAportadorSolidarioByUsername = async function (idapp, username) {
  const User = this;

  return await User.findOne({
    idapp, username,
    $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }]
  })
    .then((rec) => {
      return ((rec) ? rec.aportador_solidario : '');
    }).catch((e) => {
      console.error('getAportadorSolidarioByUsername', e);
    });
};

UserSchema.statics.UserByIdTelegram = async function (idapp, teleg_id) {
  const User = this;

  return await User.findOne({
    idapp, 'profile.teleg_id': teleg_id,
    $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
  })
    .then((rec) => {
      return (!!rec) ? rec._doc : null;
    }).catch((e) => {
      console.error('UserExistByIdTelegram', e);
    });
};

UserSchema.statics.UsersByIdTelegram = async function (idapp, teleg_id) {
  const User = this;

  return await User.find({
    idapp, 'profile.teleg_id': teleg_id,
    $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }]
  })
    .then((rec) => {
      return (!!rec) ? rec._doc : null;
    }).catch((e) => {
      console.error('UserExistByIdTelegram', e);
    });
};

UserSchema.statics.TelegIdByUsername = async function (idapp, username) {
  const User = this;

  return await User.findOne({
    idapp, username,
    $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }]
  }, { 'profile.teleg_id': 1 })
    .then((rec) => {
      return (!!rec) ? rec.profile.teleg_id : null;
    }).catch((e) => {
      console.error('TelegIdByUsername', e);
    });
};

UserSchema.statics.SetTelegramCheckCode = async function (idapp, id, teleg_checkcode) {
  const User = this;

  const fields_to_update = {
    'profile.teleg_checkcode': teleg_checkcode
  };

  return await User.findOneAndUpdate({
    _id: id
  }, { $set: fields_to_update }, { new: false }).then((record) => {
    return !!record;
  });

};

UserSchema.statics.NonVoglioImbarcarmi = async function (idapp, username) {
  const User = this;

  const fields_to_update = {
    non_voglio_imbarcarmi: 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;

  const fields_to_update = {
    'profile.teleg_id': teleg_id,
    'profile.teleg_id_old': 0,
    'profile.teleg_checkcode': 0
  };

  return await User.findOneAndUpdate({
    idapp,
    _id: id
  }, { $set: fields_to_update }, { new: false }).then((record) => {
    return record;
  });

};

UserSchema.statics.getLangByIndOrder = async function (idapp, ind_order) {
  const User = this;

  const rec = await User.getSmallRecByIndOrder(idapp, ind_order);
  return (!!rec) ? rec.lang : '';

};


UserSchema.statics.SetLang = async function (idapp, id, lang) {
  const User = this;

  const fields_to_update = {
    lang,
  };

  return await User.findOneAndUpdate({
    _id: id
  }, { $set: fields_to_update }, { new: false }).then((record) => {
    return record;
  });

};

UserSchema.statics.SetTelegramWasBlocked = async function (idapp, teleg_id) {
  const User = this;

  const fields_to_update = {
    'profile.teleg_id_old': teleg_id,
    'profile.teleg_id': 0,
  };

  if (process.env.PROD === "1") {

    const ris = await User.findOneAndUpdate({
      idapp,
      'profile.teleg_id': teleg_id
    }, { $set: fields_to_update }, { new: false }).then((record) => {
      return record;
    });
  }

};

UserSchema.statics.getNameSurnameByUsername = async function (idapp, username) {
  const User = this;

  return await User.findOne({
    idapp, username,
    $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }]
  }, { name: 1, surname: 1 })
    .then((rec) => {
      return (!!rec) ? `${rec.name} ${rec.surname}` : '';
    }).catch((e) => {
      console.error('getNameSurnameByUsername', e);
    });
};

UserSchema.statics.getNameSurnameById = async function (idapp, userId) {
  const User = this;

  return await User.findOne({
    idapp,
    _id: userId,
    $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }]
  }, { name: 1, surname: 1 })
    .then((rec) => {
      return (!!rec) ? `${rec.name} ${rec.surname}` : '';
    }).catch((e) => {
      console.error('getNameSurnameById', e);
    });
};

UserSchema.statics.getSmallRecByIndOrder = async function (idapp, ind_order) {

  try {
    const rec = await ListaIngresso.getarray(idapp,
      {
        idapp,
        ind_order,
        $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }]
      },
      {
        idapp: 1,
        index: 1,
        ind_order: 1,
        old_order: 1,
        username: 1,
        name: 1,
        lang: 1,
        surname: 1,
        'profile.teleg_id': 1,
      });

    if (!!rec)
      return rec[0];

    return null;

  } catch (e) {
    console.error('getSmallRecByIndOrder', e);
  }

};

UserSchema.statics.NuovoSistema = function (idapp) {
  const User = this;

  try {
    return User.findOne({ idapp, old_order: { $exists: true } })
      .then((ris) => {
        return !!ris;
      });
  } catch (e) {
    console.error('NuovoSistema', e.message);
  }

};


UserSchema.statics.getRecByIndOrder = async function (idapp, ind_order) {
  const User = this;

  try {

    let filters = {
      idapp: 1,
      index: 1,
      ind_order: 1,
      old_order: 1,
      username: 1,
      email: 1,
      name: 1,
      lang: 1,
      surname: 1,
      'profile.teleg_id': 1,
      'profile.email_paypal': 1,
      'profile.payeer_id': 1,
      'profile.advcash_id': 1,
      'profile.revolut': 1,
      'profile.link_payment': 1,
      'profile.note_payment': 1,
      'profile.paymenttypes': 1,
    };

    const rec = await ListaIngresso.getarray(idapp,
      {
        idapp,
        ind_order,
      },
      filters);

    if (!!rec)
      return rec[0];

    return null;

  } catch (e) {
    console.error('getRecByIndOrder', e);
  }

};


UserSchema.statics.getusersManagers = async function (idapp) {
  const User = this;

  return await User.find({ idapp, 'profile.manage_telegram': true }, { 'profile.teleg_id': 1, perm: 1 })
    .then((arrrec) => {
      return (!!arrrec) ? arrrec : null;
    }).catch((e) => {
      console.error('getusersManagers', e);
    });
};

UserSchema.statics.getusersRespList = async function (idapp) {
  const User = this;

  return await User.find({ idapp, 'profile.resplist': true }, { _id: 1, username: 1, name: 1, surname: 1 })
    .then((arrrec) => {
      return (!!arrrec) ? arrrec : null;
    }).catch((e) => {
      console.error('getusersRespList', e);
    });
};

UserSchema.statics.getusersWorkersList = async function (idapp) {
  const User = this;

  return await User.find({ idapp, 'profile.workerslist': true }, { _id: 1, username: 1, name: 1, surname: 1 })
    .then((arrrec) => {
      return (!!arrrec) ? arrrec : null;
    }).catch((e) => {
      console.error('getusersWorkersList', e);
    });
};

UserSchema.statics.getusersManagersAndZoomeri = async function (idapp) {
  const User = this;

  return await User.find(
    {
      idapp,
      or: [
        { 'profile.manage_telegram': true },
        {
          perm:
            {
              $bit:

                Number(shared_consts.Permissions.Zoomeri)

            }
        }
      ],
    },
    { 'profile.teleg_id': 1 })
    .then((arrrec) => {
      return (!!arrrec) ? arrrec : null;
    }).catch((e) => {
      console.error('getusersManagers', e);
    });
};

UserSchema.statics.getUsersTelegALL = async function (idapp, username) {
  const User = this;

  if (!!username) {
    return await User.find({ idapp, username, 'profile.teleg_id': { $gt: 0 } })
      .then((arrrec) => {
        return (!!arrrec) ? arrrec : null;
      }).catch((e) => {
        console.error('getUsersTelegALL', e);
      });
  } else {
    return await User.find({ idapp, 'profile.teleg_id': { $gt: 0 } })
      .then((arrrec) => {
        return (!!arrrec) ? arrrec : null;
      }).catch((e) => {
        console.error('getUsersTelegALL', e);
      });
  }

};

UserSchema.statics.isManagerByIdTeleg = async function (idapp, idtelegram) {
  const User = this;

  return await User.findOne({
    idapp,
    'profile.manage_telegram': true,
    'profile.teleg_id': idtelegram
  }, { 'profile.teleg_id': 1 })
    .then((rec) => {
      return (!!rec && rec.profile.teleg_id === idtelegram);
    }).catch((e) => {
      console.error('getusersManagers', e);
      return false
    });
};

UserSchema.statics.isAdminByIdTeleg = async function (idapp, idtelegram) {
  const User = this;

  return await User.findOne({
    idapp,
    username: 'paoloarcnm',
    'profile.manage_telegram': true,
    'profile.teleg_id': idtelegram
  }, { 'profile.teleg_id': 1 })
    .then((rec) => {
      return (!!rec && rec.profile.teleg_id === idtelegram);
    }).catch((e) => {
      console.error('getusersManagers', e);
      return false
    });
};

UserSchema.statics.getUsersList = function (idapp) {
  const User = this;

  return User.find({
      'idapp': idapp,
      $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }]
    },
    {
      username: 1,
      name: 1,
      surname: 1,
      verified_email: 1,
      made_gift: 1,
      perm: 1,
      email: 1,
      date_reg: 1,
      img: 1
    }
  )
};


UserSchema.statics.getUsersListByParams = function (params) {
  const User = this;

  myclParamQuery = new queryclass.CParamsQuery(params);

  const filterMatchBefore = `${myclParamQuery.filter}`;

  return User.find(
    { $match: filterMatchBefore },
    { 'idapp': idapp },
    {
      username: 1,
      name: 1,
      surname: 1,
      verified_email: 1,
      made_gift: 1,
      perm: 1,
      email: 1,
      date_reg: 1,
      img: 1,
      lasttimeonline: 1,
      news_on: 1
    })

};

/**
 * Query blog posts by user -> paginated results and a total count.
 * @returns {Object} Object -> `{ rows, count }`
 */

UserSchema.statics.getFieldsForSearch = function () {
  return [
    { field: 'username', type: tools.FieldType.string },
    { field: 'name', type: tools.FieldType.string },
    { field: 'index', type: tools.FieldType.number },
    { field: 'ind_order', type: tools.FieldType.number },
    { field: 'old_order', type: tools.FieldType.number },
    { field: 'surname', type: tools.FieldType.string },
    { field: 'email', type: tools.FieldType.string },
    { field: 'profile.cell', type: tools.FieldType.string },
    { field: 'profile.email_paypal', type: tools.FieldType.string },
    { field: 'profile.payeer_id', type: tools.FieldType.string },
    { field: 'profile.advcash_id', type: tools.FieldType.string },
    { field: 'profile.revolut', type: tools.FieldType.string },
    { field: 'profile.link_payment', type: tools.FieldType.string },
    { field: 'profile.teleg_id', type: tools.FieldType.number },
    { field: 'profile.username_telegram', type: tools.FieldType.string },
    { field: 'aportador_solidario', type: tools.FieldType.string }]
};

UserSchema.statics.executeQueryTable = function (idapp, params) {
  params.fieldsearch = this.getFieldsForSearch();
  return tools.executeQueryTable(this, idapp, params);
};

UserSchema.statics.findAllIdApp = function (idapp) {
  const User = this;

  const myfind = {
    idapp,
    $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }]
  };

  return User.find(myfind, (err, arrrec) => {
    return arrrec
  });
};

UserSchema.statics.DuplicateAllRecords = async function (idapporig, idappdest) {

  return tools.DuplicateAllRecords(this, idapporig, idappdest);

};

UserSchema.statics.getDashboard = async function (idapp, aportador_solidario, username, aportador_solidario_nome_completo) {
  try {

    // DATA: username, name, surname, email, intcode_cell, cell
    const dashboard = {
      aportador: {},
      arrposizioni: [],
      arrimbarchi: [],
      arrusers: {},
    };

    dashboard.myself = await User.getUserShortDataByUsername(idapp, username);
    // Data of my Aportador
    dashboard.aportador = await User.getUserShortDataByUsername(idapp, aportador_solidario);
    // if (dashboard.aportador === undefined) {
    //   dashboard.aportador = await ExtraList.getUserNotRegisteredByNameSurname(idapp, aportador_solidario_nome_completo);
    // }

    const arrap = await User.getDownlineByUsername(idapp, username, false, true);
    if (!!arrap)
      dashboard.numpeople_aportador = arrap.length;

    dashboard.arrimbarchi = await ListaIngresso.findAllByUsername(idapp, username);

    // dashboard.arrprofili = await Nave.getArrProfiliByIndOrder(idapp, dashboard.myself.ind_order);

    dashboard.arrposizioni = await Nave.getArrPosizioniByUsername(idapp, username);

    /* let arrrec = [];
    if (dashboard.arrimbarchi.length > 0) {
      arrrec = await ListaIngresso.getProssimiInLista(idapp, true);
    }*/

    for (let myimbarco of dashboard.arrimbarchi) {
      if (!!myimbarco.invitante_username)
        dashboard.arrusers[myimbarco.invitante_username] = await User.getUserShortDataByUsername(idapp, myimbarco.invitante_username);
      myimbarco._doc.posiz = await Graduatoria.getPosizioneInGraduatoria(idapp, myimbarco.ind_order, myimbarco.username, myimbarco.num_tess);
    }
    dashboard.navi_partenza = await NavePersistente.getListaNavi(idapp);

    dashboard.lastnave = await NavePersistente.getLastNave(idapp);

    for (let mypos of dashboard.arrposizioni) {
      mypos.rec = await Nave.getNaveByRigaCol(idapp, mypos.riga, mypos.col);
      mypos.nave_partenza = await NavePersistente.findByRigaColByDonatore(idapp, mypos.riga, mypos.col, 0);
      if (!!mypos.nave_partenza)
        mypos.flotta = await Flotta.getFlottaByNavePersistente(idapp, mypos.nave_partenza);
    }


    //for (let indriga = 0; indriga < 10; indriga++) {
    //  dashboard.navi_partenza.push(await Nave.getPrimaNaveByRiga(idapp, indriga));
    //}


    const arrnew = [];

    try {
      for (let mypos of dashboard.arrposizioni) {
        // Controlla se è presente la Nave con il num_tess pari

        let trovato = false;

        if (mypos.num_tess % 2 !== 0) {
          for (let myrec of dashboard.arrposizioni) {
            if (myrec.num_tess === mypos.num_tess + 1 && (myrec.ind_order === mypos.ind_order)) {
              // La Nave di Ritorno (numtess = 2) esiste nella lista !
              trovato = true;
              break;
            }
          }
        } else {
          trovato = true;
        }
        if (!trovato) {
          let myr = null;
          if (!!mypos._doc)
            myr = mypos._doc;
          else
            myr = mypos;

          if (!!myr && !!myr.rec.mediatore) {
            const mymediatore = myr.rec.mediatore.arrdonatori[7];
            if (!!mymediatore) {
              const myrec = {
                riga: mymediatore.riga,
                col: mymediatore.col,
                name: myr.rec.mediatore.recmediatore.name,
                surname: myr.rec.mediatore.recmediatore.surname,
                username: myr.rec.mediatore.recmediatore.username,
                num_tess: myr.rec.mediatore.recmediatore.num_tess + 1,
                rec: await Nave.getNaveByRigaCol(idapp, mymediatore.riga, mymediatore.col),
                nave_partenza: {},
              };

              myrec.nave_partenza = await NavePersistente.findByRigaColByDonatore(idapp, myrec.riga, myrec.col, 0);

              arrnew.push(myrec);
            }
          }
        }
      }
    } catch (e) {
      console.error(e.message);
    }

    dashboard.arrposizioni = [...dashboard.arrposizioni, ...arrnew];

    // console.table(dashboard.arrnavi);

    return dashboard;
  } catch (e) {
    console.error(e.message);
    return false;
  }
};

UserSchema.statics.getDownline = async function (idapp, aportador_solidario, username) {
  try {

    // DATA: username, name, surname, email, intcode_cell, cell
    let downline = {};

    downline.downline = [];

    // Data of my Downline
    const arrap = await User.getDownlineByUsername(idapp, username);
    if (!!arrap)
      downline.numpeople_aportador = arrap.length;

    downline.downline = await User.getDownlineByUsername(idapp, username, true);

    downline.downbyuser = {};

    for (const down of downline.downline) {
      downline.downbyuser[down.username] = await User.getDownlineByUsername(idapp, down.username, false);

      for (const down2 of downline.downbyuser[down.username]) {
        downline.downbyuser[down2.username] = await User.getDownlineByUsername(idapp, down2.username, false);
      }
    }

    return downline;
  } catch (e) {
    console.error(e.message);
    return false;
  }
};

/*
UserSchema.statics.fixUsername = async function (idapp, aportador_solidario_ind_order, username) {
  const User = this;

  // Check if somewhere there is my username
  return User.find({ idapp, aportador_solidario_ind_order }, async (err, arrrec) => {
    if (arrrec) {
      for (const myuser of arrrec) {
        if (!myuser.aportador_solidario || myuser.aportador_solidario === tools.APORTADOR_NONE) {
          myuser.aportador_solidario = username;
          await myuser.save()
        }
      }
    }
  });


};
*/

UserSchema.statics.findByCellAndNameSurname = function (idapp, cell, name, surname) {
  const User = this;

  return User.findOne({
    'idapp': idapp,
    'profile.cell': cell,
    'name': name,
    'surname': surname,
    $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }]
  });
};


UserSchema.statics.getUsersRegistered = async function (idapp) {
  const User = this;

  const myfind = {
    idapp,
    $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }]
  };

  return await User.count(myfind);
};

/*
UserSchema.statics.getUsersQualified = async function (idapp, numinvitati) {
  const User = this;

  const arrusers = await User.find({
    idapp,
    $and: [
      { $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }] },
      {
        $or: [
          {
            'profile.special_req': true
          },
          {
            verified_email: true,
            'profile.teleg_id': { $gt: 0 },
            'profile.paymenttypes': { "$in": ['paypal'] },
            'profile.saw_and_accepted': shared_consts.ALL_SAW_AND_ACCEPTED,
            'profile.saw_zoom_presentation': true,
            'profile.my_dream': { $exists: true },
            $and: [
              { "$expr": { "$gt": [{ "$strLenCP": "$profile.my_dream" }, 10] } },
              { "$expr": { "$gt": [{ "$strLenCP": "$profile.email_paypal" }, 6] } }
            ],
          }]
      }]

  }, {
    'username': 1,
  });


  if (numinvitati === 0)
    return arrusers;      // PRENDI TUTTI

  let arrris = [];

  for (const rec of arrusers) {
    rec.numinvitatiattivi = await ListaIngresso.getnumInvitatiAttivi(idapp, rec.username);
    if (rec.numinvitatiattivi >= numinvitati) {
      arrris.push(rec);
    }
  }

  return arrris

};
*/

UserSchema.statics.visuUtentiNonInNavi = async function (idapp) {
  const User = this;

  const arrusers = await User.find({
    idapp,
    $and: User.getQueryQualified()
  }, {
    name: 1,
    surname: 1,
    username: 1,
    ind_order: 1,
    deleted: 1,
    sospeso: 1,
  });


  let num = 0;
  let innave = 0;
  let noninnave = 0;
  let mystr = 'visuUtentiNonInNavi: ' + tools.ACAPO;
  let reg = 0;
  let num0inv = 0;
  let num1inv = 0;
  let num2inv = 0;
  let numnoinlista = 0;
  let numeliminati = 0;
  let numsospesi = 0;
  let strnavidoppie = '';
  let esiste = false;

  for (const user of arrusers) {
    esiste = true;
    if (!!user.deleted) {
      if (user.deleted) {
        numeliminati++;
        esiste = false;
      }
    }
    if (esiste) {

      let visualizza = false;

      // Controlla se ho un doppione nelle Navi !
      let mienavi = await Nave.find({ idapp, ind_order: user.ind_order }, { num_tess: 1 });

      let strnavidoppie = [];
      if (!!mienavi) {
        strnavidoppie = mienavi.reduce((acc, currentValue, index, array) => {
          if (array.indexOf(currentValue.num_tess) > -1 && !acc.includes(currentValue.num_tess))
            acc.push(currentValue.num_tess);
          return acc;
        }, []);
      }

      if (strnavidoppie.length > 1) {
        visualizza = true;
      }

      user.numinvitati = await ListaIngresso.getnumInvitati(idapp, user.username);
      reg++;
      let mianave = await Nave.findOne({ idapp, ind_order: user.ind_order });
      let mialistaingresso = await ListaIngresso.findOne({ idapp, ind_order: user.ind_order });
      let trovato = false;

      if (!mianave)
        visualizza = true;

      if (visualizza) {
        mystr += user.username + ' ' + user.name + ' ' + user.surname + ' [' + user.index + '] [inv=' + user.numinvitati + ']'
        trovato = true;
      }

      if (strnavidoppie.length > 1) {
        mystr += ' NAVI DUPLICATE! ' + strnavidoppie.join(',');
      }
      if (!mianave)
        noninnave++;
      else
        innave++;


      if (user.sospeso) {
        numsospesi++;
      }

      if (!mialistaingresso) {
        mystr += ' NO IN LISTA INGRESSO!';
        trovato = true;
        numnoinlista++;
      }

      if (trovato)
        mystr += tools.ACAPO;

      if (user.numinvitati === 0) {
        num0inv++;
      }
      if (user.numinvitati === 1) {
        num1inv++;
      }
      if (user.numinvitati >= 2) {
        num2inv++;
      }
    }
  }


  mystrstart = 'Registrati: ' + reg + tools.ACAPO;
  mystrstart += '0 Invitati: ' + num0inv + tools.ACAPO;
  mystrstart += '1 Invitato: ' + num1inv + tools.ACAPO;
  mystrstart += '2 o più Invitati: ' + num2inv + tools.ACAPO;
  mystrstart += 'Presente in Nave: ' + innave + tools.ACAPO;
  mystrstart += 'Non in Nave: ' + noninnave + tools.ACAPO;
  mystrstart += 'Non in Lista Imbarco: ' + numnoinlista + tools.ACAPO;
  mystrstart += 'Usciti (Nascosti): ' + numeliminati + tools.ACAPO;
  mystrstart += 'Sospesi: ' + numsospesi + tools.ACAPO;

  mystrstart += tools.ACAPO;

  mystr = mystrstart + mystr;

  return { num, mystr };
};

// UserSchema.statics.getNumUsersQualified = async function (idapp, numinvitati) {
//
//   arrrec = await this.getUsersQualified(idapp, numinvitati);
//
//   return arrrec.length
//
// };


UserSchema.statics.getEmailNotVerified = async function (idapp) {
  const User = this;

  const myfind = {
    idapp,
    $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
    verified_email: false
  };

  return await User.count(myfind);
};

UserSchema.statics.getUsersTelegramAttivo = async function (idapp) {
  const User = this;

  const myfind = {
    idapp,
    $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
    'profile.teleg_id': { $gt: 0 }
  };

  return await User.count(myfind);
};

UserSchema.statics.getUsersTelegramPending = async function (idapp) {
  const User = this;

  const myfind = {
    idapp,
    $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
    'profile.teleg_checkcode': { $gt: 0 }
  };

  return await User.count(myfind);
};

UserSchema.statics.getUsersZoom = async function (idapp) {
  const User = this;

  const myfind = {
    idapp,
    $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
    'profile.saw_zoom_presentation': true
  };

  return await User.count(myfind);
};

UserSchema.statics.getUsersResidenti = async function (idapp) {
  const User = this;

  const myfind = {
    idapp,
    $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
    'profile.socioresidente': { $exists: true, $eq: true }
  };

  return await User.find(myfind, { username: 1, name: 1, surname: 1 });
};

UserSchema.statics.getSaw_and_Accepted = async function (idapp) {
  const User = this;

  const myfind = {
    idapp,
    $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
    'profile.saw_and_accepted': shared_consts.ALL_SAW_AND_ACCEPTED
  };

  return await User.count(myfind);
};

UserSchema.statics.getUsersDreams = async function (idapp) {
  const User = this;

  const myfind = {
    idapp,
    $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
    'profile.my_dream': { $exists: true },
    "$expr": { "$gt": [{ "$strLenCP": "$profile.my_dream" }, 10] }
  };

  return await User.count(myfind);
};

UserSchema.statics.getLastUsers = async function (idapp) {
  const User = this;

  const lastn = await Settings.getValDbSettings(idapp, 'SHOW_LAST_N_USERS', 5);

  return await User.find(
    {
      idapp,
      $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }]
    },
    {
      username: 1,
      name: 1,
      surname: 1,
      date_reg: 1,
      index: 1,
      'profile.nationality': 1,
    }).sort({ date_reg: -1 }).limit(lastn).then((arr) => {
    //return JSON.stringify(arr)
    return arr
  });

};

UserSchema.statics.checkUser = async function (idapp, username) {
  const User = this;

  return await User.findOne({ idapp, username }, {
    verified_email: 1,
    'profile.teleg_id': 1,
    'profile.teleg_checkcode': 1,
  }).then((rec) => {
    return JSON.stringify(rec)
  });

};

UserSchema.statics.calculateStat = async function (idapp, username) {
  const User = this;

  return calcstat = {
    numinvitati: await ListaIngresso.getnumInvitati(idapp, username),
    numinvitati_attivi: await ListaIngresso.getnumInvitatiAttivi(idapp, username),
  };

};

UserSchema.statics.getDistinctNationalityQuery = function (idapp) {
  const query = [
    {
      $match: {
        idapp,
        $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
      }
    },
    {
      $group: { _id: "$profile.nationality", count: { $sum: 1 } }
    },
    {
      $sort: { count: -1 }
    }
  ];
  return query
};


UserSchema.statics.findAllDistinctNationality = async function (idapp) {
  const User = this;

  return User.aggregate(User.getDistinctNationalityQuery(idapp))
    .then(ris => {
      // console.table(ris);
      return JSON.stringify(ris);
    });
};

UserSchema.statics.getUsersRegDaily = function (idapp, nrec) {

  const query = [
    {
      $match: {
        idapp, date_reg: { $gte: tools.IncDateNow(-(1000 * 60 * 60 * 24 * nrec)) },
        $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }]
      }
    },
    {
      $group: {
        _id: { $dateToString: { format: "%Y-%m-%d", date: "$date_reg", timezone: 'Europe/Rome' } },
        count: { $sum: 1 }
      }
    },
    {
      $sort: { _id: 1 }
    }
  ];
  return query
};

UserSchema.statics.getUsersRegWeekly = function (idapp, nrec) {

  const query = [
    {
      $match: {
        idapp, date_reg: { $gte: tools.IncDateNow(-(1000 * 60 * 60 * 24 * nrec)) },
        $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }]
      }
    },
    {
      $group: {
        _id: { $dateToString: { format: "%Y-%U", date: "$date_reg", timezone: 'Europe/Rome' } },
        count: { $sum: 1 }
      }
    },
    {
      $sort: { _id: 1 }
    }
  ];
  return query
};

UserSchema.statics.getnumRegNDays = function (idapp, nrec) {


  const query = [
    {
      $match: {
        idapp,
        date_reg: { $lt: tools.IncDateNow(-(1000 * 60 * 60 * 24 * nrec)) },
        $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }]
      }
    },
    {
      $group: {
        _id: { $dateToString: { format: "%Y-%m-%d", date: "$date_reg", timezone: 'Europe/Rome' } },
        count: { $sum: 1 }
      }
    },
    {
      $sort: { _id: 1 }
    }
  ];
  return query
};

UserSchema.statics.calcnumRegUntilDay = async function (idapp) {
  const User = this;

  return await User.aggregate(User.getnumRegNDays(idapp, 30))
    .then((arr) => {
      return arr.reduce((sum, rec) => sum + rec.count, 0);
    });

};

UserSchema.statics.calcRegDaily = async function (idapp) {
  const User = this;

  return User.aggregate(User.getUsersRegDaily(idapp, 30))
    .then(ris => {
      // console.table(ris);
      return JSON.stringify(ris);
    });
};

UserSchema.statics.calcRegWeekly = async function (idapp) {
  const User = this;

  return User.aggregate(User.getUsersRegWeekly(idapp, 20 * 7))
    .then(ris => {
      // console.table(ris);
      return JSON.stringify(ris.slice(0, -1));
    });
};


if (tools.INITDB_FIRSTIME) {
  console.log('   createIndex User Index...');
  // UserSchema.index({ username: 'text', name: 'text', surname: 'text', email: 'text' });
  // UserSchema.index({ name: 'name' });
  // UserSchema.index({ name: 1 });
  // UserSchema.index({ surname: 1 });
}

async function addUtentiInLista(idapp, mode, arrusers) {

  let num = 0;
  for (const rec of arrusers) {
    let ok = false;
    let qualified = await User.isUserQualified7(idapp, rec.username);
    let numinvitatiattivi = await ListaIngresso.getnumInvitatiAttivi(idapp, rec.username);
    let numinvitati = await ListaIngresso.getnumInvitati(idapp, rec.username);

    if (rec.profile.special_req) {
      numinvitatiattivi = 2;
    }

    if (mode === 1) {
      // 9 punti qualificati
      ok = qualified && (numinvitatiattivi >= 2);
    } else if (mode === 2) {
      // 8 punti qualificati ( 1 Invitato)
      ok = qualified && (numinvitati === 2);
    } else if (mode === 3) {
      ok = qualified && (numinvitatiattivi === 1);
    } else if (mode === 4) {
      ok = qualified && (numinvitati === 1);
    } else if (mode === 5) {
      ok = qualified;
    }

    if (ok) {
      ris = await ListaIngresso.addUserInListaIngresso(idapp, rec.username, rec.aportador_solidario, rec.lang, false, true);
      if (!!ris)
        num++;
    }
  }
  return num;

}

UserSchema.statics.getUsernameByIndOrder = async function (idapp, ind_order) {

  const myrec = await User.getSmallRecByIndOrder(idapp, ind_order);
  return (!!myrec) ? myrec.username : '';

};

UserSchema.statics.getUsernameByIndex = async function (idapp, index) {

  const myrec = await User.findOne({
    idapp,
    index,
  }, { username: 1 });

  return (!!myrec) ? myrec.username : ''

};

UserSchema.statics.ricalcolaIndex = async function (idapp) {
  const User = this;

  const arrusers = await User.find({
    idapp,
    $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }]
  }).sort({ old_order: 1 });
  let index = 0;
  try {
    for (const user of arrusers) {
      let field = {
        index
      };

      index++;

      const ris = await User.findOneAndUpdate({ _id: user._id }, { $set: field }, { new: false });
    }
  } catch (e) {
    console.error(e.message);
  }


};

UserSchema.statics.changeInvitante = async function (idapp, username, invitante_username, ind_order_ingr) {
  const User = this;

  const rec_ind_order_prima = await ListaIngresso.findOne({ idapp, username });

  let modif_aportador = false;
  // cambia aportador_solidario solo se è la prima nave!

  // Oppure se ancora non sono in Lista!
  if (!rec_ind_order_prima) {
    modif_aportador = true;
  } else {
    if (rec_ind_order_prima.ind_order === ind_order_ingr) {
      modif_aportador = true;
    }
  }

  if (modif_aportador) {
    await User.findOneAndUpdate({ idapp, username }, { $set: { aportador_solidario: invitante_username } });
  }

  // **
  // ** Cambia invitante_username e ind_order di LISTAINGRESSO
  // **
  const rec_ingr = await ListaIngresso.findOne({ idapp, username: username });
  if (!!rec_ingr) {
    // await ListaIngresso.findByIdAndUpdate(rec_ingr._id, { $set: { invitante_username, ind_order: ind_order_ingr } });
    await ListaIngresso.findByIdAndUpdate(rec_ingr._id, { $set: { invitante_username } });
  }


};


UserSchema.statics.NessunaNavePresenteByUsername = async function (idapp, username) {
  const User = this;

  const rec = await User.findOne({ idapp, username }, { username: 1, ind_order: 1 });
  if (!!rec) {
    // Controlla se è qualificato!
    const qualified = await User.isUserQualified7(idapp, rec.username);
    if (qualified) {

      // Ha un'imbarco almeno?
      const arrimbarchi = await ListaIngresso.findOne({
        idapp, username: rec.username,
        $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }]
      });

      const arrnavi = await Nave.findOne({
        idapp, ind_order: rec.old_order,
      });


      if (!arrimbarchi && !arrnavi) {
        // NEANCHE 1 !
        const recout = await User.findOneAndUpdate({
          idapp,
          username
        }, { $set: { navinonpresenti: true } }, { new: false });

        return (!!recout);
      }
    }
  }

  return false;

};

UserSchema.statics.getInfoUser = async function (idapp, username) {
  return {
    username,
    is7req: await User.isUserQualified7(idapp, username),
    is9req: await User.isUserQualified9(idapp, username),
  }

}

UserSchema.statics.checkIfSbloccatiRequisiti = async function (idapp, allData, id) {
  const User = this;

  const telegrambot = require('../telegram/telegrambot');

  if (!allData.myuser)
    return false;

  if (await Nave.checkIfNaveExist(idapp, allData.myuser.username)) {
    // Se già sei dentro la Nave, allora sei OK
    return true;  //TOGLEREE
  }

  // Controlla se Sblocca i 7 requisiti
  const is7req = await User.isUserQualified7(idapp, allData.myuser.username);
  const is9req = await User.isUserQualified9(idapp, allData.myuser.username);

  const userlista = await ListaIngresso.getListaTessByUsername(idapp, allData.myuser.username);
  //if (userlista.length > 0) {  //TOGLIERE
  if (userlista.length === 0) {
    // Se non sono ancora dentro alla lista, allora controllo

    if (!!allData.precDataUser) {
      if ((!allData.precDataUser.is7req && is7req) && !await User.isUserAlreadyQualified(idapp, allData.myuser.username)) {

        await User.setUserQualified(idapp, allData.myuser.username);
        // ORA HAI I 7 REQUISITI !
        // const msgtext = telegrambot.getCiao(idapp, allData.myuser.username, allData.myuser.lang) + tools.gettranslate('HAI_I_7_REQUISITI', allData.myuser.lang);
        // telegrambot.sendMsgTelegram(idapp, allData.myuser.username, msgtext, true);  // Anche a STAFF

        // Aggiungilo alla ListaIngresso
        risingr = await ListaIngresso.addUserInListaIngresso(idapp, allData.myuser.username, allData.myuser.aportador_iniziale, allData.myuser.lang, true, false);
      }
    }
  }

  if (!!allData.precDataUser) {
    if ((!allData.precDataUser.is9req && is9req) && !await User.isUserAlreadyQualified_2Invitati(idapp, allData.myuser.username)) {
      await User.setUserQualified_2Invitati(idapp, allData.myuser.username);
      // ORA HAI I 9 REQUISITI !
      const msgtext = telegrambot.getCiao(idapp, allData.myuser.username, allData.myuser.lang) + tools.gettranslate('HAI_I_9_REQUISITI', allData.myuser.lang);
      telegrambot.sendMsgTelegram(idapp, allData.myuser.username, msgtext, false);  // Anche a STAFF
    }

  }

  // CHECK APORTADOR SOLIDARIO:
  if (!!allData.useraportador) {
    /*
        const is9reqAportador = await User.isUserQualified9(idapp, allData.myuser.aportador_solidario);

        if (!allData.precDataAportador.is9req && is9reqAportador) {
          // ORA HAI I 9 REQUISITI !
          const msgtext = telegrambot.getCiao(idapp, allData.myuser.aportador_solidario, allData.useraportador.lang) + tools.gettranslate('HAI_I_9_REQUISITI', allData.useraportador.lang);
          telegrambot.sendMsgTelegram(idapp, allData.myuser.aportador_solidario, msgtext, true);  // Anche a STAFF
        }
    */
  }

};


UserSchema.statics.mettiSognoePaypal = async function (idapp, modifica) {
  const User = this;

  let num = 0;

  arrusers = await User.find({
    'idapp': idapp,
    $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } },
      { subaccount: { $exists: false } }, { subaccount: { $exists: true, $eq: false } }]
  });

  for (const rec of arrusers) {

    if (rec.profile.saw_zoom_presentation) {
      aggiornato = false;
      my_dream_ok = !!rec.profile.my_dream;
      if (my_dream_ok)
        my_dream_ok = rec.profile.my_dream.length >= 8;

      if (!my_dream_ok) {
        if (modifica) {
          rec.profile.my_dream = '............';
          aggiornato = true;
        }
        num++;
      }
      revolut_ok = !!rec.profile.revolut;
      paypal_ok = !!rec.profile.email_paypal;

      if (paypal_ok)
        paypal_ok = rec.profile.email_paypal.length > 8;

      if ((!revolut_ok) && (!paypal_ok)) {
        if (modifica) {
          rec.profile.email_paypal = rec.email;
          aggiornato = true;
        }
        num++;
      }

      if (aggiornato && modifica) {

        let allData = {};
        allData.myuser = await User.getUserById(idapp, rec.id);
        if (!!allData.myuser)
          allData.precDataUser = await User.getInfoUser(idapp, allData.myuser.username);
        else
          allData.precDataUser = null;


        const risupd = await User.findByIdAndUpdate(rec._id, {
          'profile.email_paypal': rec.profile.email_paypal,
          'profile.my_dream': rec.profile.my_dream
        }, { new: false });

        if (risupd) {
          await User.checkIfSbloccatiRequisiti(idapp, allData, rec.id);
        }
      }
    }
  }

  return { num };

};

UserSchema.statics.flagUtentiNaviNonPresenti = async function (idapp) {
  const User = this;

  let num = 0;

  await User.updateMany({ idapp }, { $set: { navinonpresenti: false } });

  arrusers = await User.find({
    'idapp': idapp,
    $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } },
      { subaccount: { $exists: false } }, { subaccount: { $exists: true, $eq: false } }]
  });

  for (const rec of arrusers) {

    const nessunanave = await User.NessunaNavePresenteByUsername(idapp, rec.username);
    if (nessunanave)
      num++;
  }

  return { num };
};

UserSchema.statics.addNavePerUtentiNaviNonPresenti = async function (idapp) {
  const User = this;

  let num = 0;

  arrusers = await User.find({
    'idapp': idapp,
    navinonpresenti: true
  });

  for (const user of arrusers) {
    // Controlla se è qualificato!
    mydata = tools.AddDate(user.date_reg, 7);

    const newrecingr = await ListaIngresso.addUserInListaIngresso(idapp, user.username, user.aportador_solidario, user.lang, true, true, mydata);
    await tools.snooze(1000);

    num++;
  }

  return { num };
};

UserSchema.statics.convSubAccount = async function (idapp) {
  const User = this;


  // Solo i Cancellati !
  arrusers = await User.find({ 'idapp': idapp, deleted: true });
  let num = 0;
  for (const rec of arrusers) {
    // Cerca il suo Principale!
    const trovato = await User.findOne({
      idapp,
      'profile.teleg_id': rec.profile.teleg_id,
      $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }]
    });
    if (trovato) {
      num++;
      await User.findByIdAndUpdate(rec._id, { subaccount: true }, { new: false });
    }
  }

  return { num };
};


UserSchema.statics.getLastRec = async function (idapp) {
  const User = this;

  lastrec = await User.find({ idapp }).sort({ date_reg: -1 }).limit(1);
  if (!!lastrec) {
    return lastrec[0];
  } else {
    return null;
  }
};


UserSchema.statics.DbOp = async function (idapp, mydata) {
  const User = this;
  try {
    if (mydata.dbop === 'changeCellInt') {
      arrusers = await User.find({ 'idapp': idapp });
      let num = 0;
      for (const rec of arrusers) {
        //  DISATTIVATO: ORA NON MI SERVE PIU
        if (false) {
          let mycell = tools.removespaces(rec.profile.intcode_cell + rec.profile.cell);
          await User.findOneAndUpdate({ _id: rec._id }, { $set: { 'profile.cell': mycell } });
          num++;
        }
      }

      return { num };

      // return await User.updateMany({ idapp }, { $set: { 'profile.cell': { $concat: ["$profile.intcode_cell", "$profile.cell"] } } })
    } else if (mydata.dbop === 'changeEmailLowerCase') {
      arrusers = await User.find({ 'idapp': idapp });
      let num = 0;
      for (const rec of arrusers) {
        let myemail = rec.email.toLowerCase();
        if (myemail !== rec.email) {
          await User.findOneAndUpdate({ _id: rec._id }, { $set: { 'email': myemail } });
          num++;
        }
      }

      return { num };

      /*} else if (mydata.dbop === 'creaLista') {

        await ListaIngresso.deleteMany({ idapp, added: false });

        arrusers = await User.find({
          'idapp': idapp,
          $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }]
        }).sort({ date_added: 1 });
        let num = 0;

        num += await addUtentiInLista(idapp, 1, arrusers);
        num += await addUtentiInLista(idapp, 2, arrusers);
        num += await addUtentiInLista(idapp, 3, arrusers);
        num += await addUtentiInLista(idapp, 4, arrusers);
        num += await addUtentiInLista(idapp, 5, arrusers);
        // num += await addUtentiInLista(idapp, 3);
        // num += await addUtentiInLista(idapp, 4);

        return { num };
        */
    }
  } catch (e) {
    console.error(e.message);

  }

};


const User = mongoose.model('User', UserSchema);


class Hero {
  constructor(name, level) {
    this.name = name;
    this.level = level;
  }

  // Adding a method to the constructor
  greet() {
    return `${this.name} says hello.`;
  }
}


module.exports = { User, Hero };