5908 lines
154 KiB
JavaScript
Executable File
5908 lines
154 KiB
JavaScript
Executable File
const bcrypt = require('bcryptjs');
|
|
const mongoose = require('mongoose').set('debug', false);
|
|
const validator = require('validator');
|
|
const jwt = require('jsonwebtoken');
|
|
const _ = require('lodash');
|
|
|
|
const printf = require('util').format;
|
|
const tools = require('../tools/general');
|
|
|
|
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 server_constants = require('../tools/server_constants');
|
|
|
|
const { Reaction } = require('../models/reaction');
|
|
|
|
const { MyGroup } = require('../models/mygroup');
|
|
const { Circuit } = require('../models/circuit');
|
|
|
|
const { Account } = require('../models/account');
|
|
const { Movement } = require('../models/movement');
|
|
|
|
const { ObjectID } = require('mongodb');
|
|
|
|
const i18n = require('i18n');
|
|
|
|
const shared_consts = require('../tools/shared_nodejs');
|
|
|
|
|
|
mongoose.Promise = global.Promise;
|
|
|
|
mongoose.level = 'F';
|
|
// Resolving error Unknown modifier: $pushAll
|
|
mongoose.plugin(schema => {
|
|
schema.options.usePushEach = true;
|
|
});
|
|
|
|
mongoose.set('debug', false);
|
|
|
|
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'
|
|
}*/
|
|
},
|
|
hash: {
|
|
type: String,
|
|
},
|
|
idapp: {
|
|
type: String,
|
|
required: true,
|
|
},
|
|
|
|
group: {
|
|
type: Number,
|
|
},
|
|
index: {
|
|
type: Number,
|
|
},
|
|
ind_order: {
|
|
type: Number,
|
|
},
|
|
old_order: {
|
|
type: Number,
|
|
},
|
|
username: {
|
|
type: String,
|
|
required: true,
|
|
trim: true,
|
|
minlength: 3,
|
|
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,
|
|
},
|
|
refreshToken: {
|
|
type: String,
|
|
default: '',
|
|
},
|
|
date_login: {
|
|
type: Date,
|
|
},
|
|
}],
|
|
perm: {
|
|
type: Number,
|
|
},
|
|
ipaddr: {
|
|
type: String,
|
|
},
|
|
banIp: {
|
|
type: Boolean,
|
|
},
|
|
date_reg: {
|
|
type: Date,
|
|
},
|
|
date_deleted: {
|
|
type: Date,
|
|
},
|
|
date_tokenforgot: {
|
|
type: Date,
|
|
},
|
|
tokenforgot: {
|
|
type: String,
|
|
},
|
|
tokenforgot_code: {
|
|
type: String,
|
|
},
|
|
retry_pwd: {
|
|
type: Number,
|
|
default: 0,
|
|
},
|
|
date_tokenreg: {
|
|
type: Date,
|
|
},
|
|
tokenreg: {
|
|
type: String,
|
|
},
|
|
lasttimeonline: {
|
|
type: Date,
|
|
},
|
|
useragent: {
|
|
type: String,
|
|
},
|
|
news_on: {
|
|
type: Boolean,
|
|
},
|
|
email_errata: {
|
|
type: Boolean,
|
|
},
|
|
lastid_newstosent: {
|
|
type: String
|
|
},
|
|
aportador_solidario: { // da cancellare
|
|
type: String,
|
|
},
|
|
verified_by_aportador: {
|
|
type: Boolean,
|
|
},
|
|
notask_verif: {
|
|
type: Boolean,
|
|
},
|
|
trust_modified: {
|
|
type: Date,
|
|
},
|
|
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,
|
|
},
|
|
blocked: {
|
|
type: Boolean,
|
|
},
|
|
username_who_block: {
|
|
type: String,
|
|
},
|
|
date_blocked: {
|
|
type: Date,
|
|
},
|
|
reported: {
|
|
type: Boolean,
|
|
},
|
|
username_who_report: {
|
|
type: String,
|
|
},
|
|
date_report: {
|
|
type: Date,
|
|
},
|
|
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,
|
|
},
|
|
firstname_telegram: {
|
|
type: String,
|
|
},
|
|
lastname_telegram: {
|
|
type: String,
|
|
},
|
|
website: {
|
|
type: String,
|
|
},
|
|
teleg_id: {
|
|
type: Number,
|
|
},
|
|
teleg_id_old: {
|
|
type: Number,
|
|
},
|
|
teleg_checkcode: {
|
|
type: Number,
|
|
},
|
|
manage_telegram: {
|
|
type: Boolean,
|
|
},
|
|
admin_telegram: {
|
|
type: Boolean,
|
|
},
|
|
resplist: {
|
|
type: Boolean,
|
|
},
|
|
workerslist: {
|
|
type: Boolean,
|
|
},
|
|
dateofbirth: {
|
|
type: Date,
|
|
},
|
|
born_city: {
|
|
type: String,
|
|
trim: true,
|
|
},
|
|
born_city_id: {
|
|
type: Number,
|
|
},
|
|
born_province: {
|
|
type: String,
|
|
trim: true,
|
|
},
|
|
born_country: {
|
|
type: String,
|
|
trim: true,
|
|
},
|
|
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,
|
|
},
|
|
biografia: {
|
|
type: String,
|
|
},
|
|
qualifica: {
|
|
type: String,
|
|
},
|
|
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 },
|
|
}],
|
|
friends: [
|
|
{
|
|
_id: false,
|
|
username: { type: String },
|
|
date: { type: Date },
|
|
}], // username
|
|
req_friends: [
|
|
{
|
|
_id: false,
|
|
username: { type: String },
|
|
date: { type: Date },
|
|
}], // username
|
|
handshake: [
|
|
{
|
|
_id: false,
|
|
username: { type: String },
|
|
date: { type: Date },
|
|
}], // username
|
|
mygroups: [
|
|
{
|
|
_id: false,
|
|
groupname: { type: String },
|
|
date: { type: Date },
|
|
}],
|
|
|
|
mycircuits: [
|
|
{
|
|
_id: false,
|
|
circuitname: { type: String },
|
|
date: { type: Date },
|
|
}],
|
|
last_circuitpath: {
|
|
type: String,
|
|
},
|
|
lastdate_reqRis: {
|
|
type: Date,
|
|
},
|
|
notifs: [
|
|
{
|
|
_id: false,
|
|
dir: { type: Number },
|
|
value: { type: Number },
|
|
},
|
|
],
|
|
notif_idCities: [
|
|
{
|
|
type: Number,
|
|
}],
|
|
notif_provinces: [
|
|
{
|
|
type: String,
|
|
}],
|
|
notif_regions: [
|
|
{
|
|
type: String,
|
|
}],
|
|
notif_sectors: [
|
|
{
|
|
type: Number,
|
|
}],
|
|
notif_sector_goods: [
|
|
{
|
|
type: Number,
|
|
}],
|
|
resid_prov_id: {
|
|
type: Number,
|
|
},
|
|
resid_province: {
|
|
type: String,
|
|
trim: true,
|
|
},
|
|
resid_card: {
|
|
type: String,
|
|
trim: true,
|
|
},
|
|
stepTutorial: {
|
|
type: Number,
|
|
},
|
|
noNameSurname: {
|
|
type: Boolean,
|
|
},
|
|
noCircuit: {
|
|
type: Boolean,
|
|
},
|
|
noCircIta: {
|
|
type: Boolean,
|
|
},
|
|
noFoto: {
|
|
type: Boolean,
|
|
},
|
|
seen: [
|
|
{
|
|
_id: false,
|
|
id: { type: String },
|
|
tab: { type: Number },
|
|
},
|
|
],
|
|
bookmark: [
|
|
{
|
|
_id: false,
|
|
id: { type: String },
|
|
tab: { type: Number },
|
|
},
|
|
],
|
|
favorite: [
|
|
{
|
|
_id: false,
|
|
id: { type: String },
|
|
tab: { type: Number },
|
|
},
|
|
],
|
|
attend: [
|
|
{
|
|
_id: false,
|
|
id: { type: String },
|
|
tab: { type: Number },
|
|
num: { type: Number },
|
|
},
|
|
],
|
|
version: { 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 prova = 'PROVAMSG@1A'
|
|
let attiva_scadenza = user.idapp ? tools.getEnableTokenExpiredByIdApp(user.idapp) : false;
|
|
|
|
let token = null;
|
|
|
|
let numsec = process.env.TOKEN_LIFE;
|
|
|
|
if (attiva_scadenza)
|
|
token = jwt.sign({ _id: prova, smart: user._id.toHexString(), access, un: user.username },
|
|
process.env.SIGNCODE, { expiresIn: numsec }).toString();
|
|
else
|
|
token = jwt.sign({ _id: prova, smart: user._id.toHexString(), access, un: user.username },
|
|
process.env.SIGNCODE).toString();
|
|
|
|
const refreshToken = jwt.sign({ _id: prova, smart: user._id.toHexString(), access, un: user.username },
|
|
process.env.SECRK, { expiresIn: process.env.REFRESH_TOKEN_LIFE }).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, refreshToken });
|
|
|
|
user.lasttimeonline = new Date();
|
|
|
|
return user.save().then(() => {
|
|
// console.log('Salvato refreshToken su DB', refreshToken);
|
|
// console.log("TOKEN CREATO IN LOGIN : " + token);
|
|
return { token, refreshToken };
|
|
}).catch(err => {
|
|
console.log('Error', err.message);
|
|
return { token: '', refreshToken: '' }
|
|
});
|
|
};
|
|
|
|
UserSchema.statics.setOnLine = function (idapp, username) {
|
|
const User = this;
|
|
|
|
try {
|
|
return User.findOneAndUpdate({ idapp, username }, { $set: { lasttimeonline: new Date() } });
|
|
} catch (e) {
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
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.canHavePower = function (perm) {
|
|
const User = this;
|
|
|
|
try {
|
|
let consentito = false;
|
|
if (User.isAdmin(perm) || User.isManager(perm) ||
|
|
User.isEditor(perm) || User.isFacilitatore(perm)) {
|
|
consentito = true;
|
|
}
|
|
|
|
return consentito;
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
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.isManagerById = async function (id) {
|
|
try {
|
|
const ris = await User.findOne({ _id: id }, { perm: 1 }).lean();
|
|
return ((ris.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.isFacilitatore = function (perm) {
|
|
try {
|
|
return ((perm & shared_consts.Permissions.Facilitatore) ===
|
|
shared_consts.Permissions.Facilitatore);
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
UserSchema.statics.findByToken = async function (token, typeaccess, con_auth) {
|
|
const User = this;
|
|
let decoded;
|
|
let code = server_constants.RIS_CODE_HTTP_INVALID_TOKEN;
|
|
let user = null;
|
|
|
|
try {
|
|
if (token) {
|
|
decoded = jwt.verify(token, process.env.SIGNCODE);
|
|
|
|
code = server_constants.RIS_CODE_OK;
|
|
}
|
|
|
|
} catch (e) {
|
|
|
|
if (e.expiredAt) {
|
|
|
|
code = server_constants.RIS_CODE_HTTP_FORBIDDEN_TOKEN_EXPIRED;
|
|
if (con_auth) {
|
|
return { user: null, code };
|
|
}
|
|
} else {
|
|
console.error('Err findByToken:', e);
|
|
}
|
|
}
|
|
|
|
if (code === server_constants.RIS_CODE_OK) {
|
|
user = await User.findOne({
|
|
'_id': decoded.smart,
|
|
'tokens.token': token,
|
|
'tokens.access': typeaccess,
|
|
});
|
|
|
|
if (user) {
|
|
let check_expiry_date = false
|
|
// Controlla se il sito ha attivo il controllo del Token Scaduto
|
|
if (tools.getEnableTokenExpiredByIdApp(user.idapp)) {
|
|
check_expiry_date = true
|
|
}
|
|
|
|
if (check_expiry_date && (decoded.exp < Date.now() / 1000)) {
|
|
console.log('Il token è scaduto, generazione del nuovo token...');
|
|
code = server_constants.RIS_CODE_HTTP_FORBIDDEN_TOKEN_EXPIRED;
|
|
} else {
|
|
// TOKEN ANCORA VALIDO
|
|
code = server_constants.RIS_CODE_OK;
|
|
}
|
|
}
|
|
}
|
|
|
|
return { user, code };
|
|
};
|
|
|
|
UserSchema.statics.findByTokenAnyAccess = function (token) {
|
|
const User = this;
|
|
let decoded;
|
|
|
|
try {
|
|
decoded = jwt.verify(token, process.env.SIGNCODE);
|
|
} catch (e) {
|
|
console.error('Err findByTokenAnyAccess:', e);
|
|
return Promise.resolve(null);
|
|
}
|
|
|
|
return User.findOne({
|
|
'_id': decoded.smart,
|
|
'tokens.token': token,
|
|
});
|
|
};
|
|
|
|
UserSchema.statics.findByCredentials = function (idapp, username, password, pwdcrypted) {
|
|
const User = this;
|
|
let pwd = '';
|
|
|
|
let regexp = new RegExp(`^${username}$`, 'i');
|
|
|
|
return User.findOne({
|
|
idapp,
|
|
username: { $regex: regexp },
|
|
$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;
|
|
|
|
if (pwdcrypted) {
|
|
if (pwd === user.password) {
|
|
return user;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
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, onlyifVerifiedByAportador) {
|
|
const User = this;
|
|
|
|
const myreg = ['^', username, '$'].join('');
|
|
let regexusername = new RegExp(myreg, 'i');
|
|
|
|
//++TODO: Set only the necessary fields to get in memory
|
|
|
|
return await User.findOne({
|
|
idapp: idapp,
|
|
username: { $regex: regexusername },
|
|
$or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
|
|
}).then(async (ris) => {
|
|
if ((!ris) && (alsoemail)) {
|
|
regexemail = new RegExp(['^', username.toLowerCase(), '$'].join(''), 'i');
|
|
|
|
return await User.findOne({
|
|
'idapp': idapp,
|
|
'email': { $regex: regexemail },
|
|
$or: [
|
|
{ deleted: { $exists: false } },
|
|
{ deleted: { $exists: true, $eq: false } }],
|
|
});
|
|
}
|
|
return ris;
|
|
}).then((rec) => {
|
|
if (rec && onlyifVerifiedByAportador) {
|
|
if (tools.getAskToVerifyReg(idapp)) {
|
|
if (!rec.verified_by_aportador)
|
|
return null;
|
|
|
|
}
|
|
}
|
|
|
|
return rec;
|
|
});
|
|
};
|
|
/**
|
|
* Find a user by their Telegram username.
|
|
*
|
|
* @param {string} idapp - The application ID
|
|
* @param {string} username - The Telegram username
|
|
* @param {boolean} alsoemail - Flag to indicate if email should also be considered
|
|
* @param {boolean} onlyifVerifiedByAportador - Flag to indicate if only verified users should be returned
|
|
* @return {Promise} A Promise that resolves to the found user or null
|
|
**/
|
|
|
|
UserSchema.statics.findByUsernameTelegram = async function (idapp, username, alsoemail, onlyifVerifiedByAportador) {
|
|
const User = this;
|
|
|
|
if (username && username[0] === '@') {
|
|
username = username.substring(1);
|
|
}
|
|
|
|
const myreg = ['^', username, '$'].join('');
|
|
let regexusername = new RegExp(myreg, 'i');
|
|
|
|
//++TODO: Set only the necessary fields to get in memory
|
|
|
|
return await User.findOne({
|
|
idapp: idapp,
|
|
'profile.username_telegram': { $regex: regexusername },
|
|
$or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
|
|
}).then(async (ris) => {
|
|
if ((!ris) && (alsoemail)) {
|
|
regexemail = new RegExp(['^', username.toLowerCase(), '$'].join(''), 'i');
|
|
|
|
return await User.findOne({
|
|
'idapp': idapp,
|
|
'email': { $regex: regexemail },
|
|
$or: [
|
|
{ deleted: { $exists: false } },
|
|
{ deleted: { $exists: true, $eq: false } }],
|
|
});
|
|
}
|
|
return ris;
|
|
}).then((rec) => {
|
|
if (rec && onlyifVerifiedByAportador) {
|
|
if (tools.getAskToVerifyReg(idapp)) {
|
|
if (!rec.verified_by_aportador)
|
|
return null;
|
|
|
|
}
|
|
}
|
|
|
|
return rec;
|
|
});
|
|
};
|
|
|
|
UserSchema.statics.getProjectUser = function () {
|
|
return {
|
|
idapp: 1,
|
|
lang: 1,
|
|
index: 1,
|
|
ind_order: 1,
|
|
username: 1,
|
|
aportador_solidario: 1,
|
|
name: 1,
|
|
surname: 1,
|
|
lasttimeonline: 1,
|
|
deleted: 1,
|
|
reported: 1,
|
|
date_report: 1,
|
|
username_who_report: 1,
|
|
sospeso: 1,
|
|
verified_email: 1,
|
|
verified_by_aportador: 1,
|
|
'profile.teleg_id': 1,
|
|
'profile.username_telegram': 1,
|
|
'profile.firstname_telegram': 1,
|
|
'profile.lastname_telegram': 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,
|
|
tokenreg: 1,
|
|
date_tokenreg: 1,
|
|
};
|
|
|
|
};
|
|
|
|
UserSchema.statics.getUserShortDataByUsername = async function (idapp, username) {
|
|
const User = this;
|
|
|
|
let regexp = new RegExp(`^${username}$`, 'i');
|
|
|
|
const myrec = await User.findOne({
|
|
'idapp': idapp,
|
|
username: { $regex: regexp },
|
|
$or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
|
|
},
|
|
this.getProjectUser(),
|
|
).lean();
|
|
|
|
if (myrec) {
|
|
myrec.qualified = await User.isUserQualified7(idapp, myrec.username);
|
|
myrec.numNaviEntrato = 0;
|
|
// myrec.numinvitati = await ListaIngresso.getnumInvitati(idapp, myrec.username);
|
|
// myrec.numinvitatiattivi = await ListaIngresso.getnumInvitatiAttivi(idapp, myrec.username);
|
|
}
|
|
|
|
return myrec;
|
|
};
|
|
|
|
UserSchema.statics.getUserShortDataByUsernameTelegram = async function (idapp, username_telegram) {
|
|
const User = this;
|
|
|
|
let regexp = new RegExp(`^${username_telegram}$`, 'i');
|
|
|
|
const myrec = await User.findOne({
|
|
'idapp': idapp,
|
|
'profile.username_telegram': { $regex: regexp },
|
|
$or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
|
|
},
|
|
this.getProjectUser(),
|
|
).lean();
|
|
|
|
if (myrec) {
|
|
myrec.qualified = await User.isUserQualified7(idapp, myrec.username);
|
|
myrec.numNaviEntrato = 0;
|
|
// 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 = [];
|
|
|
|
let myq = {
|
|
idapp,
|
|
aportador_solidario: username,
|
|
$or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
|
|
};
|
|
|
|
if (!includemyself) {
|
|
myq = { ...myq, username: { $ne: 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.setVerifiedByAportador = async function (
|
|
idapp, username, valuebool) {
|
|
const User = this;
|
|
|
|
if (username === undefined)
|
|
return false;
|
|
|
|
const myquery = {
|
|
'idapp': idapp,
|
|
'username': username,
|
|
};
|
|
|
|
const userver = await User.findOne(myquery, { verified_by_aportador: 1 }).lean();
|
|
|
|
let scrivi = true;
|
|
if (userver) {
|
|
scrivi = userver.verified_by_aportador !== valuebool;
|
|
}
|
|
if (scrivi) {
|
|
const myrec = await User.findOneAndUpdate(myquery,
|
|
{ $set: { 'verified_by_aportador': valuebool } }, { new: false });
|
|
|
|
return !!myrec;
|
|
} else {
|
|
return false;
|
|
}
|
|
|
|
};
|
|
|
|
UserSchema.statics.setnotask_verif = async function (
|
|
idapp, username, valuebool) {
|
|
const User = this;
|
|
|
|
if (username === undefined)
|
|
return false;
|
|
|
|
const myquery = {
|
|
'idapp': idapp,
|
|
'username': username,
|
|
};
|
|
|
|
const myrec = await User.findOneAndUpdate(myquery,
|
|
{ $set: { 'notask_verif': valuebool } }, { new: false });
|
|
|
|
return !!myrec;
|
|
};
|
|
|
|
UserSchema.statics.setaportador_solidario = async function (
|
|
idapp, username, usernameAportador) {
|
|
const User = this;
|
|
|
|
if (username === undefined)
|
|
return false;
|
|
|
|
const myquery = {
|
|
'idapp': idapp,
|
|
'username': username,
|
|
};
|
|
|
|
const myrec = await User.findOneAndUpdate(myquery,
|
|
{ $set: { 'aportador_solidario': usernameAportador } }, { new: false });
|
|
|
|
return !!myrec;
|
|
};
|
|
|
|
UserSchema.statics.setNewsletter = async function (
|
|
idapp, username, newsletter_on) {
|
|
const User = this;
|
|
|
|
if (username === undefined)
|
|
return false;
|
|
|
|
const myquery = {
|
|
'idapp': idapp,
|
|
'username': username,
|
|
};
|
|
|
|
const myrec = await User.findOneAndUpdate(myquery,
|
|
{ $set: { 'news_on': newsletter_on } }, { new: false });
|
|
|
|
return !!myrec;
|
|
};
|
|
|
|
UserSchema.statics.setEmailErrata = async function (
|
|
idapp, username, email_errata) {
|
|
const User = this;
|
|
|
|
if (username === undefined)
|
|
return false;
|
|
|
|
const myquery = {
|
|
'idapp': idapp,
|
|
'username': username,
|
|
};
|
|
|
|
const myrec = await User.findOneAndUpdate(myquery,
|
|
{ $set: { email_errata } }, { new: false });
|
|
|
|
return !!myrec;
|
|
};
|
|
|
|
UserSchema.statics.isEmailErrata = 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.email_errata : false);
|
|
}).catch((e) => {
|
|
return false;
|
|
});
|
|
};
|
|
UserSchema.statics.isNewsletterOn = 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.news_on : false);
|
|
}).catch((e) => {
|
|
console.error('isNewsletterOn', e);
|
|
return false;
|
|
});
|
|
};
|
|
|
|
|
|
|
|
UserSchema.statics.setVerifiedByAportadorToALL = async function () {
|
|
|
|
return await User.updateMany({}, { $set: { 'verified_by_aportador': true } },
|
|
{ new: false });
|
|
|
|
};
|
|
|
|
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 await User. countDocuments({
|
|
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 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.findByLinkTokenforgotCode = function (idapp, email, tokenforgot_code) {
|
|
const User = this;
|
|
|
|
return User.findOne({
|
|
email,
|
|
tokenforgot_code,
|
|
date_tokenforgot: { $gte: tools.IncDateNow(-1000 * 60 * 60 * 4) }, // 4 ore fa!
|
|
idapp,
|
|
});
|
|
};
|
|
|
|
UserSchema.statics.createNewRequestPwd = function (idapp, email, code) {
|
|
const User = this;
|
|
|
|
const sendemail = require('../sendemail');
|
|
|
|
console.log('createNewRequestPwd');
|
|
|
|
if (code && code.length === 6) {
|
|
return User.findByLinkTokenforgotCode(idapp, email, code)
|
|
.then((user) => {
|
|
if (user)
|
|
return { ris: true, link: tools.getlinkRelativeRequestNewPassword(idapp, email, user.tokenforgot) };
|
|
else
|
|
return { ris: false };
|
|
}).catch((e) => {
|
|
console.log(' Err createNewRequestPwd', e.message);
|
|
res.status(400).send();
|
|
});
|
|
} else {
|
|
return User.findByEmail(idapp, email).then(async (user) => {
|
|
if (!user) {
|
|
return { ris: false };
|
|
} else {
|
|
// Creo il tokenforgot
|
|
user.tokenforgot = jwt.sign({ _id: 'prova123##', smart: user._id.toHexString() }, process.env.SIGNCODE).
|
|
toString();
|
|
user.date_tokenforgot = new Date();
|
|
user.tokenforgot_code = 100000 + Math.round(Math.random() * 899999);
|
|
user.lasttimeonline = new Date();
|
|
return await user.save().then(async () => {
|
|
await sendemail.sendEmail_RequestNewPassword(user.lang, user, user.email, user.idapp, user.tokenforgot, user.tokenforgot_code);
|
|
|
|
return { ris: true };
|
|
});
|
|
}
|
|
|
|
});
|
|
}
|
|
};
|
|
|
|
UserSchema.statics.createNewRequestPwdByUsernameAndGetLink = async function (idapp, username) {
|
|
const User = this;
|
|
|
|
const user = await User.findOne({
|
|
idapp,
|
|
username,
|
|
$or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
|
|
});
|
|
|
|
if (user) {
|
|
const additionalData = {
|
|
code: user.username,
|
|
};
|
|
const prova = 'dasdas1231#11';
|
|
// Creo il tokenforgot
|
|
user.tokenforgot = jwt.sign({ _id: prova, smart: user._id.toHexString(), ...additionalData }, process.env.SIGNCODE).
|
|
toString();
|
|
user.date_tokenforgot = new Date();
|
|
user.tokenforgot_code = 100000 + Math.round(Math.random() * 899999);
|
|
user.lasttimeonline = new Date();
|
|
user.code_pwd_reset = 0;
|
|
|
|
return await user.save().then(() => {
|
|
return tools.getlinkRequestNewPassword(idapp, user.email, user.tokenforgot, user.tokenforgot_code);
|
|
});
|
|
}
|
|
|
|
return '';
|
|
|
|
};
|
|
|
|
UserSchema.statics.getifRegTokenIsValid = async function (idapp, tokenreg) {
|
|
const User = this;
|
|
|
|
let regexp = new RegExp(`^${tokenreg}$`, 'i');
|
|
|
|
const user = await User.findOne({
|
|
idapp,
|
|
tokenreg: { $regex: regexp }
|
|
});
|
|
if (user && user.date_tokenreg) {
|
|
return user.date_tokenreg > (new Date().getTime());
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
UserSchema.statics.createNewReqRegistrationGetLink = async function (idapp, username) {
|
|
const User = this;
|
|
|
|
const user = await User.findOne({
|
|
idapp,
|
|
username,
|
|
$or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
|
|
});
|
|
|
|
if (user) {
|
|
if (true) {
|
|
// Se è scaduto, ne crea uno nuovo
|
|
// Creo il tokenforgot
|
|
|
|
/*
|
|
if (!user.date_tokenreg || (!user.tokenreg) || (user.tokenreg && (user.date_tokenreg < new Date().getTime()))) {
|
|
|
|
let mycodestr = user._id.toHexString() + new Date().getTime().toString();
|
|
user.tokenreg = jwt.sign(mycodestr, process.env.SIGNCODE).
|
|
toString();
|
|
|
|
if (user.tokenreg) {
|
|
try {
|
|
user.tokenreg = user.tokenreg.replaceAll('.', '');
|
|
user.tokenreg = user.tokenreg.replaceAll('/', '');
|
|
user.tokenreg = user.tokenreg.slice(-8);
|
|
} catch (e) {
|
|
console.error('err', e);
|
|
}
|
|
}
|
|
}
|
|
|
|
user.date_tokenreg = tools.AddDate(new Date(), 1);
|
|
|
|
|
|
return await user.save().then(() => {
|
|
return user.tokenreg;
|
|
});
|
|
|
|
*/
|
|
|
|
}
|
|
}
|
|
|
|
return '';
|
|
|
|
};
|
|
|
|
UserSchema.statics.findByEmail = function (idapp, email, onlyifVerifiedByAportador) {
|
|
const User = this;
|
|
|
|
return User.findOne({
|
|
'idapp': idapp,
|
|
'email': email,
|
|
$or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
|
|
}).then((rec) => {
|
|
/* if (rec && onlyifVerifiedByAportador) {
|
|
if (tools.getAskToVerifyReg(idapp)) {
|
|
if (!rec.verified_by_aportador)
|
|
return null;
|
|
|
|
}
|
|
} */
|
|
|
|
return rec;
|
|
});
|
|
};
|
|
|
|
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.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 },
|
|
},
|
|
});
|
|
};
|
|
|
|
// TODO: Cancellare i token che non hanno refreshToken, ad esempio quando l'utente esce dal browser
|
|
// TODO: Cancellare i token con data_login meno di 2 giorni fa, per esempio se l'utente si è disconnesso dal browser ma è ancora online
|
|
|
|
UserSchema.statics.SvuotaTuttiGliAccessiOnlineConToken = async function (idapp) {
|
|
const User = this;
|
|
|
|
return await User.updateMany({ idapp },
|
|
{
|
|
$pull: {
|
|
tokens:
|
|
{
|
|
$or: [{ refreshToken: { $exists: false } },
|
|
{ refreshToken: { $exists: true, $eq: '' } }
|
|
]
|
|
},
|
|
}
|
|
});
|
|
|
|
};
|
|
|
|
|
|
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.getUsernameByEmail = async function (idapp, email) {
|
|
const User = this;
|
|
|
|
return await User.findOne({
|
|
idapp, email,
|
|
$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.getUserByUsername = function (idapp, username) {
|
|
const User = this;
|
|
|
|
return User.findOne({
|
|
idapp,
|
|
username,
|
|
$or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
|
|
});
|
|
};
|
|
|
|
UserSchema.statics.getUserByUsernameTelegram = function (idapp, username_telegram) {
|
|
const User = this;
|
|
|
|
if (username_telegram[0] === '@') {
|
|
username_telegram = username_telegram.substring(1);
|
|
}
|
|
|
|
return User.findOne({
|
|
idapp,
|
|
'profile.username_telegram': username_telegram,
|
|
$or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
|
|
});
|
|
};
|
|
|
|
UserSchema.statics.isMyFriend = async function (idapp, username, myusername) {
|
|
|
|
const myfriends = await User.getUsernameFriendsByUsername(idapp, myusername);
|
|
if (myfriends) {
|
|
return await myfriends.includes(username);
|
|
} else {
|
|
return false;
|
|
}
|
|
|
|
};
|
|
|
|
UserSchema.statics.isMyHandShake = async function (idapp, username, myusername) {
|
|
|
|
const myhandshake = await User.getUsernameHandShakeByUsername(idapp, myusername);
|
|
if (myhandshake) {
|
|
return await myhandshake.includes(username);
|
|
} else {
|
|
return false;
|
|
}
|
|
|
|
};
|
|
|
|
UserSchema.statics.getUserProfileByUsername = async function (
|
|
idapp, username, myusername, usaSuperPower, myperm = '') {
|
|
const User = this;
|
|
// If is my Friend, then can show all
|
|
|
|
const ismyfriend = await User.isMyFriend(idapp, username, myusername);
|
|
|
|
let perm = tools.Perm.PERM_NONE;
|
|
|
|
if (ismyfriend) {
|
|
perm = tools.Perm.PERM_FRIEND;
|
|
}
|
|
|
|
if (username === myusername) {
|
|
perm = tools.Perm.PERM_ALL;
|
|
} else {
|
|
if (await User.canHavePower(myperm) && usaSuperPower) {
|
|
perm = tools.Perm.PERM_ALL;
|
|
}
|
|
}
|
|
|
|
let whatToShow = {};
|
|
|
|
if (perm === tools.Perm.PERM_NONE) {
|
|
whatToShow = {
|
|
lang: 1,
|
|
index: 1,
|
|
username: 1,
|
|
aportador_solidario: 1,
|
|
name: 1,
|
|
surname: 1,
|
|
lasttimeonline: 1,
|
|
deleted: 1,
|
|
sospeso: 1,
|
|
reported: 1,
|
|
date_report: 1,
|
|
username_who_report: 1,
|
|
verified_email: 1,
|
|
verified_by_aportador: 1,
|
|
'profile.nationality': 1,
|
|
'profile.mygroups': 1,
|
|
'profile.mycircuits': 1,
|
|
'profile.qualifica': 1,
|
|
'profile.biografia': 1,
|
|
'profile.teleg_id': 1,
|
|
'profile.username_telegram': 1,
|
|
'profile.firstname_telegram': 1,
|
|
'profile.lastname_telegram': 1,
|
|
// 'profile.intcode_cell': 1,
|
|
// 'profile.cell': 1,
|
|
'profile.website': 1,
|
|
'profile.img': 1,
|
|
'profile.sex': 1,
|
|
'profile.dateofbirth': 1,
|
|
'profile.born_city_id': 1,
|
|
'profile.born_province': 1,
|
|
'profile.born_country': 1,
|
|
'profile.resid_province': 1,
|
|
'profile.resid_card': 1,
|
|
'profile.calc': 1,
|
|
'profile.handshake': 1,
|
|
'profile.friends': 1,
|
|
email: 1,
|
|
date_reg: 1,
|
|
'useraport.username': 1,
|
|
'useraport.profile.img': 1,
|
|
};
|
|
|
|
} else if (perm === tools.Perm.PERM_FRIEND) {
|
|
whatToShow = {
|
|
lang: 1,
|
|
index: 1,
|
|
username: 1,
|
|
aportador_solidario: 1,
|
|
name: 1,
|
|
surname: 1,
|
|
lasttimeonline: 1,
|
|
deleted: 1,
|
|
sospeso: 1,
|
|
reported: 1,
|
|
date_report: 1,
|
|
username_who_report: 1,
|
|
verified_email: 1,
|
|
verified_by_aportador: 1,
|
|
'profile.nationality': 1,
|
|
'profile.mygroups': 1,
|
|
'profile.mycircuits': 1,
|
|
'profile.qualifica': 1,
|
|
'profile.biografia': 1,
|
|
'profile.teleg_id': 1,
|
|
'profile.username_telegram': 1,
|
|
'profile.firstname_telegram': 1,
|
|
'profile.lastname_telegram': 1,
|
|
'profile.intcode_cell': 1,
|
|
'profile.cell': 1,
|
|
'profile.website': 1,
|
|
'profile.img': 1,
|
|
'profile.sex': 1,
|
|
'profile.dateofbirth': 1,
|
|
'profile.born_city_id': 1,
|
|
'profile.born_province': 1,
|
|
'profile.born_country': 1,
|
|
'profile.resid_province': 1,
|
|
'profile.resid_card': 1,
|
|
'profile.calc': 1,
|
|
'profile.handshake': 1,
|
|
'profile.friends': 1,
|
|
email: 1,
|
|
date_reg: 1,
|
|
'useraport.username': 1,
|
|
'useraport.profile.img': 1,
|
|
};
|
|
|
|
} else if (perm === tools.Perm.PERM_ALL) {
|
|
whatToShow = {
|
|
lang: 1,
|
|
index: 1,
|
|
username: 1,
|
|
aportador_solidario: 1,
|
|
name: 1,
|
|
surname: 1,
|
|
lasttimeonline: 1,
|
|
deleted: 1,
|
|
sospeso: 1,
|
|
reported: 1,
|
|
date_report: 1,
|
|
username_who_report: 1,
|
|
verified_email: 1,
|
|
verified_by_aportador: 1,
|
|
notask_verif: 1,
|
|
'profile.nationality': 1,
|
|
'profile.mygroups': 1,
|
|
'profile.mycircuits': 1,
|
|
'profile.qualifica': 1,
|
|
'profile.biografia': 1,
|
|
'profile.teleg_id': 1,
|
|
'profile.username_telegram': 1,
|
|
'profile.firstname_telegram': 1,
|
|
'profile.lastname_telegram': 1,
|
|
'profile.intcode_cell': 1,
|
|
'profile.cell': 1,
|
|
'profile.website': 1,
|
|
'profile.img': 1,
|
|
'profile.sex': 1,
|
|
'profile.dateofbirth': 1,
|
|
'profile.born_city_id': 1,
|
|
'profile.born_province': 1,
|
|
'profile.born_country': 1,
|
|
'profile.resid_province': 1,
|
|
'profile.resid_card': 1,
|
|
'profile.calc': 1,
|
|
'profile.handshake': 1,
|
|
'profile.friends': 1,
|
|
'mycities': 1,
|
|
'comune': 1,
|
|
email: 1,
|
|
date_reg: 1,
|
|
'useraport.username': 1,
|
|
'useraport.profile.img': 1,
|
|
};
|
|
}
|
|
|
|
let regexpusername = new RegExp(`^${username}$`, 'i');
|
|
|
|
const myfind = {
|
|
idapp, username: { $regex: regexpusername },
|
|
$or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
|
|
};
|
|
|
|
const query = [
|
|
{ $match: myfind },
|
|
{
|
|
$lookup: {
|
|
from: 'cities',
|
|
localField: 'profile.born_city_id',
|
|
foreignField: '_id',
|
|
as: 'mycities',
|
|
},
|
|
},
|
|
{
|
|
'$lookup': {
|
|
'from': 'users',
|
|
let: {
|
|
'idapp': '$idapp',
|
|
'user_name': '$aportador_solidario',
|
|
},
|
|
pipeline: [
|
|
{
|
|
'$match': {
|
|
'$expr': {
|
|
$and: [
|
|
{ $eq: ['$username', '$$user_name'] },
|
|
{ $eq: ['$idapp', '$$idapp'] },
|
|
],
|
|
},
|
|
},
|
|
},
|
|
],
|
|
as: 'useraport',
|
|
},
|
|
},
|
|
{
|
|
$unwind:
|
|
{
|
|
path: '$useraport',
|
|
preserveNullAndEmptyArrays: true,
|
|
},
|
|
},
|
|
|
|
{
|
|
'$replaceRoot': {
|
|
'newRoot': {
|
|
'$mergeObjects': [
|
|
{
|
|
'$arrayElemAt': [
|
|
'$mycities',
|
|
0,
|
|
],
|
|
},
|
|
'$$ROOT',
|
|
],
|
|
},
|
|
},
|
|
},
|
|
{ $project: whatToShow },
|
|
|
|
];
|
|
|
|
try {
|
|
const ris = await User.aggregate(query);
|
|
|
|
if (ris && ris.length > 0) {
|
|
|
|
ris[0].profile.calc = await User.calcOtherByUser(idapp, ris[0]._id);
|
|
return ris[0];
|
|
}
|
|
} catch (e) {
|
|
return null;
|
|
}
|
|
|
|
return null;
|
|
|
|
/*
|
|
return User.findOne({
|
|
}, whatToShow).then((rec) => {
|
|
return (rec._doc);
|
|
}).catch((e) => {
|
|
return null;
|
|
});
|
|
|
|
|
|
*/
|
|
|
|
};
|
|
|
|
UserSchema.statics.getArrUsernameFromFieldByUsername = async function (
|
|
idapp, username, field, subfield) {
|
|
|
|
const myobj = {};
|
|
myobj[field + '.' + subfield] = 1;
|
|
|
|
let arrrec = await User.findOne({
|
|
idapp, 'username': username,
|
|
$or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
|
|
}, myobj).then((ris) => ris ? ris._doc[field][subfield] : []);
|
|
|
|
if (arrrec && arrrec.length > 0) {
|
|
return arrrec.map(m => m.username);
|
|
}
|
|
return [];
|
|
|
|
};
|
|
|
|
UserSchema.statics.getUsernameReqFriendsByUsername = async function (
|
|
idapp, username) {
|
|
|
|
return await this.getArrUsernameFromFieldByUsername(idapp, username, 'profile',
|
|
'req_friends');
|
|
|
|
};
|
|
|
|
UserSchema.statics.getUsernameFriendsByUsername = async function (
|
|
idapp, username) {
|
|
|
|
return await this.getArrUsernameFromFieldByUsername(idapp, username, 'profile',
|
|
'friends');
|
|
|
|
};
|
|
|
|
UserSchema.statics.getUsernameHandShakeByUsername = async function (
|
|
idapp, username) {
|
|
|
|
return await this.getArrUsernameFromFieldByUsername(idapp, username, 'profile',
|
|
'handshake');
|
|
|
|
};
|
|
|
|
UserSchema.statics.getUsernameGroupsByUsername = async function (
|
|
idapp, username) {
|
|
|
|
return await this.getArrUsernameFromFieldByUsername(idapp, username, 'profile',
|
|
'mygroups');
|
|
|
|
};
|
|
UserSchema.statics.getUsernameCircuitsByUsername = async function (
|
|
idapp, username) {
|
|
|
|
return await this.getArrUsernameFromFieldByUsername(idapp, username, 'profile',
|
|
'mycircuits');
|
|
|
|
};
|
|
|
|
// Rimuovo l'Amicizia
|
|
UserSchema.statics.removeFriend = async function (
|
|
idapp, username, usernameDest) {
|
|
return await User.updateOne({ idapp, username },
|
|
{ $pull: { 'profile.friends': { username: { $in: [usernameDest] } } } });
|
|
};
|
|
|
|
// Rimuovo l'Amicizia
|
|
UserSchema.statics.removeHandShake = async function (
|
|
idapp, username, usernameDest) {
|
|
return await User.updateOne({ idapp, username },
|
|
{ $pull: { 'profile.handshake': { username: { $in: [usernameDest] } } } });
|
|
};
|
|
|
|
// Rimuovo il Gruppo
|
|
UserSchema.statics.removeFromMyGroups = async function (
|
|
idapp, username, groupnameDest) {
|
|
return await User.updateOne({ idapp, username },
|
|
{ $pull: { 'profile.mygroups': { groupname: { $in: [groupnameDest] } } } });
|
|
};
|
|
|
|
// Rimuovo il Circuito
|
|
UserSchema.statics.removeFromCircuits = async function (idapp, username, circuitname) {
|
|
|
|
// Elimina la richiesta (se esiste):
|
|
update = { $pull: { req_users: { username: { $in: [username] } } } };
|
|
await Circuit.updateOne({ idapp, name: circuitname }, update);
|
|
|
|
const ris = await User.updateOne({ idapp, username },
|
|
{ $pull: { 'profile.mycircuits': { circuitname: { $in: [circuitname] } } } });
|
|
|
|
|
|
const circuitId = await Circuit.getCircuitIdByName(idapp, circuitname);
|
|
let remove = false;
|
|
|
|
const circuit = await Circuit.findOne({ idapp, name: circuitname }).lean();
|
|
if (circuit) {
|
|
// Invio la notifica agli amministratori del circuito
|
|
const title = `L\'utente ${username} è uscito dal ${circuitname}`;
|
|
const msg = ``;
|
|
await tools.sendNotifToCircuitsAdmin(idapp, circuit, true, title, msg, '')
|
|
}
|
|
|
|
// Se il mio account non è stato utilizzato, allora lo cancello anche questo
|
|
const myaccount = await Account.getAccountByUsernameAndCircuitId(idapp, username, circuitId, false, false, '', '');
|
|
if (myaccount && myaccount.totTransato === 0) {
|
|
remove = true;
|
|
} else {
|
|
remove = true;
|
|
}
|
|
|
|
if (remove) {
|
|
await Account.removeAccount(myaccount._id);
|
|
}
|
|
|
|
return ris;
|
|
};
|
|
|
|
// Aggiungo il Circuito
|
|
UserSchema.statics.addCircuitToUser = async function (idapp, usernameOrig, circuitname, confido, groupname, contocom) {
|
|
|
|
let ris = null;
|
|
|
|
if (groupname) {
|
|
|
|
ris = await MyGroup.addCircuitFromGroup(idapp, groupname, circuitname);
|
|
|
|
// Elimina la richiesta:
|
|
update = { $pull: { req_groups: { groupname: { $in: [groupname] } } } };
|
|
await Circuit.updateOne({ idapp, name: circuitname }, update);
|
|
|
|
// Elimina eventualmente se era bloccato:
|
|
update = { $pull: { refused_groups: { groupname: { $in: [groupname] } } } };
|
|
await Circuit.updateOne({ idapp, name: circuitname }, update);
|
|
|
|
} else {
|
|
|
|
// prima di aggiungerlo controlla se esiste già !
|
|
|
|
let update = {
|
|
$addToSet: { // Utilizziamo $addToSet invece di $push per garantire che l'elemento venga aggiunto solo se non esiste già
|
|
'profile.mycircuits': {
|
|
$each: [{
|
|
circuitname,
|
|
date: new Date(),
|
|
}],
|
|
}
|
|
}
|
|
};
|
|
|
|
ris = await User.updateOne({ idapp, username: usernameOrig, 'profile.mycircuits': { $not: { $elemMatch: { circuitname } } } }, update);
|
|
|
|
if (confido) {
|
|
// Elimina la richiesta:
|
|
update = { $pull: { req_users: { username: { $in: [usernameOrig] } } } };
|
|
await Circuit.updateOne({ idapp, name: circuitname }, update);
|
|
}
|
|
|
|
// Elimina eventualmente se era bloccato:
|
|
update = { $pull: { refused_users: { username: { $in: [usernameOrig] } } } };
|
|
await Circuit.updateOne({ idapp, name: circuitname }, update);
|
|
|
|
}
|
|
|
|
await Account.createAccount(idapp, usernameOrig, circuitname, confido, groupname, contocom);
|
|
|
|
return ris;
|
|
};
|
|
|
|
// Rimuovo il Gruppo per Tutti gli Utenti
|
|
UserSchema.statics.removeAllUsersFromMyGroups = async function (idapp, groupnameDest) {
|
|
return await User.updateMany({ idapp },
|
|
{ $pull: { 'profile.mygroups': { groupname: { $in: [groupnameDest] } } } });
|
|
};
|
|
|
|
// Rimuovo il Circuito per Tutti gli Utenti
|
|
UserSchema.statics.removeAllUsersFromMyCircuits = async function (idapp, circuitname) {
|
|
return await User.updateMany({ idapp },
|
|
{ $pull: { 'profile.mycircuits': { circuitname: { $in: [circuitname] } } } });
|
|
};
|
|
|
|
// Rimuovo la Richiesta di Amicizia
|
|
UserSchema.statics.removeReqFriend = async function (
|
|
idapp, username, usernameDest) {
|
|
return await User.updateOne({ idapp, username: username },
|
|
{ $pull: { 'profile.req_friends': { username: { $in: [usernameDest] } } } });
|
|
};
|
|
|
|
|
|
|
|
// Aggiungo il Partecipa
|
|
UserSchema.statics.addAttend = async function (
|
|
req, idapp, username, id, tab, num) {
|
|
const ris = await User.updateOne({ idapp, username },
|
|
{ $push: { 'profile.attend': { id, tab, num } } });
|
|
|
|
const { SendNotif } = require('../models/sendnotif');
|
|
|
|
const globalTables = require('../tools/globalTables');
|
|
|
|
// Invia una Notifica al Destinatario
|
|
const recObjCreator = await globalTables.getUserCreatorByNumTabAndId(idapp, id, tab);
|
|
|
|
if (recObjCreator) {
|
|
await SendNotif.createNewNotifToSingleUser(req, null, { usernameDest: recObjCreator.username, recObjCreator, username_action: req.user.username }, false,
|
|
shared_consts.TypeNotifs.TYPEDIR_EVENTS,
|
|
shared_consts.TypeNotifs.ID_EVENTS_ATTEND);
|
|
|
|
}
|
|
|
|
return ris;
|
|
};
|
|
// Rimuovo il Bookmark
|
|
UserSchema.statics.removeBookmark = async function (
|
|
idapp, username, id, tab) {
|
|
return await User.updateOne({ idapp, username },
|
|
{ $pull: { 'profile.bookmark': { id: { $in: [id] }, tab } } });
|
|
};
|
|
|
|
// Aggiungo il Bookmark
|
|
UserSchema.statics.addBookmark = async function (
|
|
idapp, username, id, tab) {
|
|
return await User.updateOne({ idapp, username },
|
|
{ $push: { 'profile.bookmark': { id, tab } } });
|
|
};
|
|
// Rimuovo il Partecipa
|
|
UserSchema.statics.removeAttend = async function (
|
|
idapp, username, id, tab) {
|
|
return await User.updateOne({ idapp, username },
|
|
{ $pull: { 'profile.attend': { id: { $in: [id] }, tab } } });
|
|
};
|
|
|
|
// Aggiungo il Bookmark
|
|
UserSchema.statics.addSeen = async function (
|
|
idapp, username, id, tab) {
|
|
return await User.updateOne({ idapp, username },
|
|
{ $push: { 'profile.seen': { id, tab } } });
|
|
};
|
|
|
|
UserSchema.statics.setFriendsCmd = async function (req, idapp, usernameOrig, usernameDest, cmd, value, disablenotif) {
|
|
|
|
const { SendNotif } = require('../models/sendnotif');
|
|
|
|
const telegrambot = require('../telegram/telegrambot');
|
|
|
|
if (!req) {
|
|
req = tools.getReqByPar(idapp, usernameOrig);
|
|
}
|
|
|
|
let userDest = null;
|
|
if (usernameDest)
|
|
userDest = await User.getUserShortDataByUsername(idapp, usernameDest);
|
|
|
|
const username_action = req.user.username;
|
|
let username_worked = usernameDest;
|
|
|
|
let ris = null;
|
|
let lang = '';
|
|
let user = null;
|
|
if (usernameOrig) {
|
|
user = await User.getUserShortDataByUsername(idapp, usernameOrig);
|
|
}
|
|
lang = user ? user.lang : '';
|
|
let update = {};
|
|
try {
|
|
if (cmd === shared_consts.FRIENDSCMD.SETTRUST) {
|
|
|
|
let msgOrig = '';
|
|
let msgDest = '';
|
|
// Aggiorna true se lo accetti e false se non lo accetti
|
|
const ris = await User.updateOne({ idapp, username: usernameDest },
|
|
{ $set: { verified_by_aportador: value, trust_modified: new Date() } },
|
|
{ new: false });
|
|
|
|
if (value) {
|
|
// Aggiungi alle amicizie
|
|
// await this.setFriendsCmd(req, idapp, usernameOrig, usernameDest,
|
|
// shared_consts.FRIENDSCMD.SETFRIEND, value);
|
|
|
|
msgOrig = i18n.__({ phrase: '✅ Hai Abilitato l\'accesso alla App a %s !', locale: userDest.lang }, userDest.username);
|
|
msgDest = i18n.__({ phrase: '✅ Sei stato Abilitato correttamente da %s!', locale: lang }, usernameOrig);
|
|
msgAdmin = i18n.__({ phrase: '✅ %s è stato Abilitato correttamente (da %s)!', locale: userDest.lang }, userDest.username, usernameOrig);
|
|
} else {
|
|
msgOrig = i18n.__({ phrase: '🚫 Hai rifiutato l\'accesso alla App di RISO da parte di %s!', locale: userDest.lang }, userDest.username);
|
|
msgDest = i18n.__({ phrase: '🚫 Ti è stato rifiutato l\'accesso. Probabilmente l\'username con cui ti sei registrato non ti conosce. (%s) !<br>Contatta l\'Assistenza Tecnica.', locale: lang }, usernameOrig);
|
|
msgAdmin = i18n.__({ phrase: '🚫 %s ha rifiutato l\'accesso alla App a %s !', locale: userDest.lang }, usernameOrig, userDest.username);
|
|
|
|
}
|
|
|
|
await telegrambot.sendMsgTelegram(idapp, usernameOrig, msgOrig);
|
|
await telegrambot.sendMsgTelegram(idapp, userDest.username, msgDest);
|
|
|
|
// Invia questo msg anche all'Admin
|
|
await telegrambot.sendMsgTelegramToTheAdmin(idapp, msgAdmin, true);
|
|
|
|
// telegrambot.askConfirmationUser(user.idapp, shared_consts.CallFunz.REGISTRATION, user, '', '', '', '');
|
|
|
|
return ris;
|
|
|
|
} else if (cmd === shared_consts.FRIENDSCMD.SETFRIEND) {
|
|
// Aggiungo l'Amicizia a me
|
|
const foundIfAlreadyFriend = await User.findOne({
|
|
idapp,
|
|
username: usernameOrig,
|
|
'profile.friends': {
|
|
$elemMatch: { username: { $eq: usernameDest } },
|
|
},
|
|
}, { _id: 1 }).lean();
|
|
|
|
if (!foundIfAlreadyFriend) {
|
|
update = {
|
|
$push: {
|
|
'profile.friends': {
|
|
username: usernameDest,
|
|
date: new Date(),
|
|
},
|
|
},
|
|
};
|
|
ris = await User.updateOne({ idapp, username: usernameOrig }, update);
|
|
|
|
if (!disablenotif) {
|
|
// Send a notification to the DESTINATION FRIENDSHIP !
|
|
let req = tools.getReqByPar(idapp, usernameOrig);
|
|
await SendNotif.createNewNotifToSingleUser(req, null, { usernameDest }, true, shared_consts.TypeNotifs.TYPEDIR_FRIENDS,
|
|
shared_consts.TypeNotifs.ID_FRIENDS_ACCEPTED_MY_REQUEST);
|
|
|
|
// Send a notification to the SENDER FRIENDSHIP !
|
|
req = tools.getReqByPar(idapp, usernameDest);
|
|
await SendNotif.createNewNotifToSingleUser(req, null, { usernameDest: usernameOrig }, true, shared_consts.TypeNotifs.TYPEDIR_FRIENDS,
|
|
shared_consts.TypeNotifs.ID_FRIENDS_ACCEPTED);
|
|
|
|
}
|
|
|
|
update = { $pull: { 'profile.req_friends': { username: { $in: [usernameDest] } } } };
|
|
ris = await User.updateOne({ idapp, username: usernameOrig }, update);
|
|
|
|
if (ris) {
|
|
try {
|
|
if (!disablenotif) {
|
|
const userDest = await User.getRecLangAndIdByUsername(idapp, usernameDest);
|
|
const user = await User.getRecLangAndIdByUsername(idapp, usernameOrig);
|
|
const msgDest = i18n.__({ phrase: '✅ %s accepted your Friendship request !', locale: userDest.lang }, usernameDest);
|
|
const msgOrig = i18n.__({ phrase: '✅ You have accepted %s\' Friendship request!', locale: user.lang }, usernameOrig);
|
|
|
|
await telegrambot.sendMsgTelegram(idapp, usernameOrig, msgDest);
|
|
await telegrambot.sendMsgTelegram(idapp, usernameDest, msgOrig);
|
|
}
|
|
} catch (e) {
|
|
console.error('Notification : ', e);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// Controlla se lui aveva già la mia amicizia
|
|
const foundIfAlreadyFriend2 = await User.findOne({
|
|
idapp,
|
|
username: usernameDest,
|
|
'profile.friends': {
|
|
$elemMatch: { username: { $eq: usernameOrig } },
|
|
},
|
|
}, { _id: 1 }).lean();
|
|
|
|
if (!foundIfAlreadyFriend2) {
|
|
update = {
|
|
$push: {
|
|
'profile.friends': {
|
|
username: usernameOrig,
|
|
date: new Date(),
|
|
},
|
|
},
|
|
};
|
|
ris = await User.updateOne({ idapp, username: usernameDest }, update);
|
|
|
|
this.removeReqFriend(idapp, usernameDest, usernameOrig); // Rimuovo l'Amicizia da me
|
|
this.removeReqFriend(idapp, usernameOrig, usernameDest); // Rimuovo l'Amicizia da te
|
|
}
|
|
//if (ris) {
|
|
ris = await User.getInfoFriendByUsername(idapp, usernameDest);
|
|
//}
|
|
} else if (cmd === shared_consts.FRIENDSCMD.SETHANDSHAKE) {
|
|
// Aggiungo la Stretta di mano a lui
|
|
const foundIfAlreadyHandshake = await User.findOne({
|
|
idapp,
|
|
username: usernameDest,
|
|
'profile.handshake': {
|
|
$elemMatch: { username: { $eq: usernameOrig } },
|
|
},
|
|
}, { _id: 1 }).lean();
|
|
|
|
let rec = null;
|
|
|
|
if (!foundIfAlreadyHandshake) {
|
|
update = {
|
|
$push: {
|
|
'profile.handshake': {
|
|
username: usernameOrig,
|
|
date: new Date(),
|
|
},
|
|
},
|
|
};
|
|
|
|
const already_stretta = await User.isMyHandShake(idapp, usernameDest, usernameOrig);
|
|
const already_stretta_orig = await User.isMyHandShake(idapp, usernameOrig, usernameDest);
|
|
|
|
rec = await User.updateOne({ idapp, username: usernameDest }, update);
|
|
|
|
tools.sendNotificationByUsername(idapp, usernameDest, cmd, true, usernameOrig);
|
|
let req = tools.getReqByPar(idapp, usernameOrig);
|
|
|
|
if (rec) {
|
|
try {
|
|
if (!disablenotif) {
|
|
const userDest = await User.getRecLangAndIdByUsername(idapp, usernameDest);
|
|
const user = await User.getRecLangAndIdByUsername(idapp, usernameOrig);
|
|
|
|
let msgDest = i18n.__({ phrase: 'HANDSHAKE_SENT_FROM_YOU', locale: userDest.lang }, usernameDest);
|
|
if (already_stretta)
|
|
msgDest = i18n.__({ phrase: 'HANDSHAKE_CONFIRMED', locale: userDest.lang }, usernameDest);
|
|
|
|
let phrase = 'HANDSHAKE_SET';
|
|
if (already_stretta) {
|
|
phrase = 'HANDSHAKE_ACCEPTED';
|
|
}
|
|
|
|
const msgOrig = i18n.__({ phrase, locale: user.lang }, usernameOrig);
|
|
|
|
await telegrambot.sendMsgTelegram(idapp, usernameOrig, msgDest);
|
|
await telegrambot.sendMsgTelegram(idapp, usernameDest, msgOrig);
|
|
}
|
|
} catch (e) {
|
|
console.error('Notification : ', e);
|
|
}
|
|
}
|
|
|
|
// Send a notification to the DESTINATION HANDSHAKE !
|
|
// await SendNotif.createNewNotifToSingleUser(req, null, { usernameDest }, false, shared_consts.TypeNotifs.TYPEDIR_HANDSHAKE,
|
|
// shared_consts.TypeNotifs.ID_HANDSHAKE_ACCEPTED);
|
|
}
|
|
|
|
const userprofile = await User.getInfoFriendByUsername(idapp, usernameDest);
|
|
const myuser = await User.getInfoFriendByUsername(idapp, usernameOrig);
|
|
ris = { rec, userprofile, myuser };
|
|
} else if (cmd === shared_consts.FRIENDSCMD.REQFRIEND) {
|
|
// Aggiungo la richiesta di Amicizia a me
|
|
const foundIfAlreadyAskFriend = await User.findOne({
|
|
idapp,
|
|
username: usernameDest,
|
|
'profile.req_friends': {
|
|
$elemMatch: { username: { $eq: usernameOrig } },
|
|
},
|
|
}, { _id: 1 }).lean();
|
|
|
|
if (value) {
|
|
if (!foundIfAlreadyAskFriend) {
|
|
update = {
|
|
$push: {
|
|
'profile.req_friends': {
|
|
username: usernameOrig,
|
|
date: new Date(),
|
|
},
|
|
},
|
|
};
|
|
ris = await User.updateOne({ idapp, username: usernameDest }, update);
|
|
}
|
|
if (ris) {
|
|
// Invia una notifica alla persona
|
|
tools.sendNotificationByUsername(idapp, usernameDest, cmd, true, usernameOrig);
|
|
}
|
|
|
|
if (foundIfAlreadyAskFriend) {
|
|
ris = await User.getInfoFriendByUsername(idapp, usernameDest);
|
|
}
|
|
|
|
}
|
|
} else if (cmd === shared_consts.FRIENDSCMD.REMOVE_FROM_MYFRIENDS) {
|
|
|
|
// Rimuovi anche le eventuali richieste di Amicizia !
|
|
await this.removeReqFriend(idapp, usernameDest, usernameOrig); // Rimuovo la Richiesta di Amicizia da lui
|
|
await this.removeReqFriend(idapp, usernameOrig, usernameDest); // Rimuovo la Richiesta di Amicizia da me
|
|
|
|
await this.removeFriend(idapp, usernameDest, usernameOrig); // Rimuovo l'Amicizia da lui
|
|
ris = await this.removeFriend(idapp, usernameOrig, usernameDest); // Rimuovo l'Amicizia da me
|
|
|
|
} else if (cmd === shared_consts.FRIENDSCMD.REMOVE_FROM_MYHANDSHAKE) {
|
|
|
|
ris = await this.removeHandShake(idapp, usernameDest, usernameOrig); // Rimuovo l'Amicizia da lui
|
|
|
|
} else if (cmd === shared_consts.FRIENDSCMD.CANCEL_REQ_FRIEND) {
|
|
|
|
// CREATE NOTIFICATION IN TABLE SENDNOTIF
|
|
const req = tools.getReqByPar(idapp, usernameOrig);
|
|
await SendNotif.createNewNotifToSingleUser(req, null, { usernameDest }, true, shared_consts.TypeNotifs.TYPEDIR_FRIENDS,
|
|
shared_consts.TypeNotifs.ID_FRIENDS_REFUSED);
|
|
|
|
ris = true;
|
|
|
|
} else if (cmd === shared_consts.FRIENDSCMD.BLOCK_USER) {
|
|
|
|
await this.removeReqFriend(idapp, usernameDest, usernameOrig); // Rimuovo la Richiesta di Amicizia da lui
|
|
await this.removeReqFriend(idapp, usernameOrig, usernameDest); // Rimuovo la Richiesta di Amicizia da me
|
|
|
|
await this.removeFriend(idapp, usernameDest, usernameOrig); // Rimuovo l'Amicizia da lui
|
|
await this.removeFriend(idapp, usernameOrig, usernameDest); // Rimuovo l'Amicizia da me
|
|
|
|
// Blocco la persona
|
|
ris = await User.updateOne({ idapp, username: usernameDest }, {
|
|
$set: {
|
|
blocked: true,
|
|
sospeso: true,
|
|
username_who_block: usernameOrig,
|
|
date_blocked: new Date(),
|
|
},
|
|
});
|
|
} else if (cmd === shared_consts.FRIENDSCMD.REPORT_USER) {
|
|
|
|
username_worked = usernameDest;
|
|
|
|
// Segnalo la persona
|
|
ris = await User.updateOne({ idapp, username: username_worked }, {
|
|
$set: {
|
|
reported: true,
|
|
username_who_report: usernameOrig,
|
|
date_report: new Date(),
|
|
},
|
|
});
|
|
|
|
if (ris) {
|
|
// Send a notification to the DESTINATION!
|
|
// Sei stato segnalato da %s per comportamenti non idonei. Contatta %s per chiarimenti
|
|
await SendNotif.createNewNotifToSingleUser(req, null, { username_worked, usernameDest, username_action }, false,
|
|
shared_consts.TypeNotifs.TYPEDIR_FRIENDS,
|
|
shared_consts.TypeNotifs.ID_FRIENDS_REPORTED);
|
|
|
|
// Send a notification to the SENDER !
|
|
// Hai segnalato %s da %s per comportamenti non idonei.
|
|
await SendNotif.createNewNotifToSingleUser(req, null, { username_worked, usernameDest: username_action, username_action }, false,
|
|
shared_consts.TypeNotifs.TYPEDIR_FRIENDS,
|
|
shared_consts.TypeNotifs.ID_FRIENDS_REPORTED);
|
|
|
|
if (usernameOrig !== telegrambot.ADMIN_USER_SERVER) {
|
|
// Send a notification to the Admin
|
|
await SendNotif.createNewNotifToSingleUser(req, null,
|
|
{ username_worked, usernameDest: telegrambot.ADMIN_USER_SERVER, username_action, isAdmin: true }, false,
|
|
shared_consts.TypeNotifs.TYPEDIR_FRIENDS,
|
|
shared_consts.TypeNotifs.ID_FRIENDS_REPORTED);
|
|
}
|
|
|
|
}
|
|
} else if (cmd === shared_consts.FRIENDSCMD.UNBLOCK_USER) {
|
|
|
|
username_worked = usernameDest;
|
|
|
|
// Sblocco la persona
|
|
ris = await User.updateOne({ idapp, username: username_worked }, {
|
|
$set: {
|
|
reported: false,
|
|
},
|
|
});
|
|
|
|
if (ris) {
|
|
// Send a notification to the DESTINATION!
|
|
await SendNotif.createNewNotifToSingleUser(req, null, { username_worked, usernameDest, username_action }, false,
|
|
shared_consts.TypeNotifs.TYPEDIR_FRIENDS,
|
|
shared_consts.TypeNotifs.ID_FRIENDS_UNBLOCKED);
|
|
|
|
// Send a notification to the SENDER !
|
|
// Hai segnalato %s da %s per comportamenti non idonei.
|
|
await SendNotif.createNewNotifToSingleUser(req, null, { username_worked, usernameDest: username_action, username_action }, false,
|
|
shared_consts.TypeNotifs.TYPEDIR_FRIENDS,
|
|
shared_consts.TypeNotifs.ID_FRIENDS_UNBLOCKED);
|
|
|
|
if (usernameOrig !== telegrambot.ADMIN_USER_SERVER) {
|
|
// Send a notification to the Admin
|
|
await SendNotif.createNewNotifToSingleUser(req, null,
|
|
{ username_worked, usernameDest: telegrambot.ADMIN_USER_SERVER, username_action, isAdmin: true }, false,
|
|
shared_consts.TypeNotifs.TYPEDIR_FRIENDS,
|
|
shared_consts.TypeNotifs.ID_FRIENDS_UNBLOCKED);
|
|
}
|
|
|
|
}
|
|
}
|
|
} catch (e) {
|
|
console.error('Error: ', e);
|
|
}
|
|
|
|
return ris;
|
|
};
|
|
|
|
UserSchema.statics.sendCmd = async function (req, idapp, usernameOrig, usernameDest, cmd, value, disablenotif) {
|
|
|
|
const { SendNotif } = require('../models/sendnotif');
|
|
|
|
const telegrambot = require('../telegram/telegrambot');
|
|
|
|
const cl = telegrambot.getclTelegByidapp(idapp);
|
|
|
|
if (!req) {
|
|
req = tools.getReqByPar(idapp, usernameOrig);
|
|
}
|
|
|
|
const myuser = await User.getUserByUsername(idapp, usernameOrig);
|
|
const recuserDest = await User.getUserByUsername(idapp, usernameDest);
|
|
|
|
const langdest = recuserDest.lang;
|
|
const telegid = recuserDest.profile.teleg_id;
|
|
|
|
let userId = recuserDest._id;
|
|
let title = tools.getNomeAppByIdApp(idapp);
|
|
let keyb = null;
|
|
let descr = '';
|
|
|
|
let send_notif = false;
|
|
let send_msgTelegramBot = false;
|
|
let actions = [];
|
|
let popupOnApp = '';
|
|
|
|
let ris = null;
|
|
|
|
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';
|
|
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) {
|
|
// SEND PUSH NOTIFICATION
|
|
await tools.sendNotificationToUser(userId, title, descr, openUrl, '', tag, actions);
|
|
}
|
|
|
|
// Invia Msg
|
|
if (send_msgTelegramBot && msgtelegram) {
|
|
await telegrambot.local_sendMsgTelegramByIdTelegram(idapp, telegid, msgtelegram, undefined, undefined, true, keyb);
|
|
}
|
|
|
|
const userprofile = await User.getInfoFriendByUsername(idapp, usernameDest);
|
|
const myuser = await User.getInfoFriendByUsername(idapp, usernameOrig);
|
|
|
|
ris = { userprofile, myuser, popupOnApp, result: true };
|
|
|
|
} catch (e) {
|
|
popupOnApp = e;
|
|
ris = { popupOnApp };
|
|
console.error('Error sendCmd: ', e);
|
|
}
|
|
|
|
return ris;
|
|
};
|
|
|
|
UserSchema.statics.ifAlreadyInGroup = async function (idapp, usernameOrig, groupnameDest) {
|
|
|
|
// Controllo se è stato già inserito
|
|
return await User.findOne({
|
|
idapp,
|
|
username: usernameOrig,
|
|
'profile.mygroups': {
|
|
$elemMatch: { groupname: { $eq: groupnameDest } },
|
|
},
|
|
}).lean();
|
|
|
|
};
|
|
|
|
UserSchema.statics.ifAlreadyInCircuit = async function (idapp, usernameOrig, circuitname) {
|
|
|
|
// Controllo se è stato già inserito
|
|
return await User.findOne({
|
|
idapp,
|
|
username: usernameOrig,
|
|
'profile.mycircuits': {
|
|
$elemMatch: { circuitname: { $eq: circuitname } },
|
|
},
|
|
}).lean();
|
|
};
|
|
|
|
//** Get true if in 'profile.mycircuits' exist at least one circuit */
|
|
UserSchema.statics.ExistAtLeastOneCircuit = async function (idapp, username) {
|
|
|
|
// Controllo se è stato più inserito
|
|
return await User.countDocuments({
|
|
idapp,
|
|
username,
|
|
'profile.mycircuits': {
|
|
$ne: [],
|
|
},
|
|
});
|
|
};
|
|
|
|
UserSchema.statics.countUsersInGroup = async function (idapp, groupnameDest) {
|
|
|
|
// Controllo se è stato già inserito
|
|
return await User.countDocuments({
|
|
idapp,
|
|
'profile.mygroups': {
|
|
$elemMatch: { groupname: { $eq: groupnameDest } },
|
|
},
|
|
});
|
|
|
|
};
|
|
|
|
UserSchema.statics.countUsersInCircuit = async function (idapp, circuitname) {
|
|
|
|
// Controllo se è stato già inserito
|
|
return await User.countDocuments({
|
|
idapp,
|
|
'profile.mycircuits': {
|
|
$elemMatch: { circuitname: { $eq: circuitname } },
|
|
},
|
|
});
|
|
|
|
};
|
|
|
|
UserSchema.statics.setGroupsCmd = async function (idapp, usernameOrig, groupnameDest, cmd, value, username_action) {
|
|
|
|
let ris = null;
|
|
let update = {};
|
|
try {
|
|
if (cmd === shared_consts.GROUPSCMD.SETGROUP) {
|
|
const foundIfAlreadyGroup = await this.ifAlreadyInGroup(idapp, usernameOrig, groupnameDest);
|
|
|
|
if (!foundIfAlreadyGroup) {
|
|
update = {
|
|
$push: {
|
|
'profile.mygroups': {
|
|
groupname: groupnameDest,
|
|
date: new Date(),
|
|
},
|
|
},
|
|
};
|
|
ris = await User.updateOne({ idapp, username: usernameOrig }, update);
|
|
|
|
// Elimina la richiesta:
|
|
update = { $pull: { req_users: { username: { $in: [usernameOrig] } } } };
|
|
await MyGroup.updateOne({ idapp, groupname: groupnameDest }, update);
|
|
|
|
// Elimina eventualmente se era bloccato:
|
|
update = { $pull: { refused_users: { username: { $in: [usernameOrig] } } } };
|
|
await MyGroup.updateOne({ idapp, groupname: groupnameDest }, update);
|
|
} else {
|
|
ris = false;
|
|
}
|
|
if (ris) {
|
|
// Invia una notifica alla persona e agli Admin
|
|
tools.sendNotificationByGroupname(idapp, usernameOrig, groupnameDest, cmd, value, true, username_action);
|
|
ris = await MyGroup.getInfoGroupByGroupname(idapp, groupnameDest);
|
|
}
|
|
} else if (cmd === shared_consts.GROUPSCMD.REQGROUP) {
|
|
// Aggiungo la richiesta di Gruppo a me
|
|
const foundIfAlreadyAskGroup = await MyGroup.findOne({
|
|
idapp,
|
|
groupname: groupnameDest,
|
|
'req_users': {
|
|
$elemMatch: { username: { $eq: usernameOrig } },
|
|
},
|
|
});
|
|
|
|
if (value) {
|
|
if (!foundIfAlreadyAskGroup) {
|
|
update = {
|
|
$push: {
|
|
'req_users': {
|
|
username: usernameOrig,
|
|
date: new Date(),
|
|
},
|
|
},
|
|
};
|
|
ris = await MyGroup.updateOne({ idapp, groupname: groupnameDest },
|
|
update);
|
|
}
|
|
if (ris) {
|
|
// Invia una notifica alla persona
|
|
await tools.sendNotificationByGroupname(idapp, usernameOrig, groupnameDest, cmd, true, true, username_action);
|
|
}
|
|
} else {
|
|
if (foundIfAlreadyAskGroup) {
|
|
ris = await this.removeFromMyGroups(idapp, usernameOrig, groupnameDest); // Rimuovo il Gruppo da me
|
|
|
|
// Invia una notifica alla persona
|
|
await tools.sendNotificationByGroupname(idapp, usernameOrig, groupnameDest, cmd, false, true, username_action);
|
|
}
|
|
}
|
|
|
|
if (ris) {
|
|
ris = await MyGroup.getInfoGroupByGroupname(idapp, groupnameDest);
|
|
}
|
|
|
|
} else if (cmd === shared_consts.GROUPSCMD.REMOVE_FROM_MYGROUP) {
|
|
|
|
// Remove if is also an Admin
|
|
await MyGroup.removeAdminOfMyGroup(idapp, usernameOrig, groupnameDest);
|
|
|
|
ris = await User.removeFromMyGroups(idapp, usernameOrig, groupnameDest); // Rimuovo l'Amicizia da me
|
|
console.log('ris', ris);
|
|
|
|
// Invia una notifica alla persona
|
|
await tools.sendNotificationByGroupname(idapp, usernameOrig, groupnameDest, cmd, false, true, username_action);
|
|
|
|
} else if (cmd === shared_consts.GROUPSCMD.DELETE_GROUP) {
|
|
|
|
ris = await User.removeFromMyGroups(idapp, usernameOrig, groupnameDest); // Rimuovo l'Amicizia da me
|
|
|
|
if (ris) {
|
|
// Invia una notifica alla persona e agli Admin
|
|
await tools.sendNotificationByGroupname(idapp, usernameOrig, groupnameDest, cmd, false, true, username_action);
|
|
|
|
}
|
|
ris = await MyGroup.deleteGroup(idapp, usernameOrig, groupnameDest); // Rimuovo l'Amicizia da me
|
|
console.log('ris', ris);
|
|
|
|
} else if (cmd === shared_consts.GROUPSCMD.CANCEL_REQ_GROUP) {
|
|
|
|
ris = await MyGroup.removeReqGroup(idapp, usernameOrig, groupnameDest); // Rimuovo l'Amicizia da me
|
|
|
|
} else if (cmd === shared_consts.GROUPSCMD.REFUSE_REQ_GROUP) {
|
|
|
|
ris = await MyGroup.removeReqGroup(idapp, usernameOrig, groupnameDest); // Rimuovo l'Amicizia da me
|
|
|
|
ris = await MyGroup.refuseReqGroup(idapp, usernameOrig, groupnameDest); // Rimuovo l'Amicizia da me
|
|
|
|
} else if (cmd === shared_consts.GROUPSCMD.BLOCK_GROUP) {
|
|
|
|
await User.removeFromMyGroups(idapp, usernameOrig, groupnameDest); // Rimuovo l'Amicizia da me
|
|
|
|
// Blocco il Gruppo
|
|
ris = await MyGroup.updateOne({ idapp, groupname: groupnameDest }, {
|
|
$set: {
|
|
blocked: true,
|
|
username_who_block: usernameOrig,
|
|
date_blocked: new Date(),
|
|
},
|
|
});
|
|
//++Todo: Send Notification to Admin and Group's manager
|
|
tools.sendNotificationByGroupname(idapp, usernameOrig, groupnameDest, cmd, false, true, username_action);
|
|
|
|
} else if (cmd === shared_consts.GROUPSCMD.ADDADMIN_OFMYGROUP) {
|
|
ris = await MyGroup.addToAdminOfMyGroup(idapp, usernameOrig, groupnameDest); // Rimuovo la richiesta di entrare nel gruppo
|
|
|
|
// Invia una notifica alla persona
|
|
await tools.sendNotificationByGroupname(idapp, usernameOrig, groupnameDest, cmd, false, true, username_action);
|
|
|
|
} else if (cmd === shared_consts.GROUPSCMD.REMOVEADMIN_OFMYGROUP) {
|
|
ris = await MyGroup.removeAdminOfMyGroup(idapp, usernameOrig, groupnameDest); // Rimuovo la richiesta di entrare nel gruppo
|
|
|
|
// Invia una notifica alla persona
|
|
await tools.sendNotificationByGroupname(idapp, usernameOrig, groupnameDest, cmd, false, true, username_action);
|
|
|
|
}
|
|
} catch (e) {
|
|
console.error('Error: ', e);
|
|
}
|
|
|
|
return ris;
|
|
};
|
|
|
|
UserSchema.statics.updateMyData = async function (outres, idapp, username) {
|
|
|
|
try {
|
|
//++Todo: Ottimizzare ! Non occorre inviare tutti questi dati !!! Solo per il Circuito ?!
|
|
const userprofile = await User.getExtraInfoByUsername(idapp, username);
|
|
if (userprofile) {
|
|
outres.userprofile = userprofile;
|
|
}
|
|
outres.listcircuits = await Circuit.findAllIdApp(idapp);
|
|
outres.mygroups = await MyGroup.findAllGroups(idapp);
|
|
|
|
} catch (e) {
|
|
console.error('ERR', e);
|
|
}
|
|
|
|
return outres;
|
|
|
|
};
|
|
|
|
|
|
UserSchema.statics.setCircuitCmd = async function (idapp, usernameOrig, circuitname, cmd, value, username_action, extrarec) {
|
|
|
|
// console.log('setCircuitCmd', cmd);
|
|
|
|
const { SendNotif } = require('../models/sendnotif');
|
|
|
|
let ris = null;
|
|
let outres = {
|
|
result: false,
|
|
};
|
|
let update = {};
|
|
|
|
let groupname = extrarec && extrarec.groupname ? extrarec.groupname : '';
|
|
|
|
try {
|
|
if (cmd === shared_consts.CIRCUITCMD.CREATE) {
|
|
const mycirc = await Circuit.findOne({ idapp, name: circuitname });
|
|
if (mycirc) {
|
|
// Il Conto Comunitario prende il nome del circuito !
|
|
await Account.createAccount(idapp, '', circuitname, true, '', mycirc.path);
|
|
}
|
|
|
|
} else if (cmd === shared_consts.CIRCUITCMD.SET) {
|
|
if (groupname) {
|
|
const foundIfCircuitInGroup = await MyGroup.ifCircuitAlreadyInGroup(idapp, groupname, circuitname);
|
|
|
|
if (!foundIfCircuitInGroup) {
|
|
ris = await this.addCircuitToUser(idapp, usernameOrig, circuitname, true, groupname);
|
|
|
|
} else {
|
|
ris = false;
|
|
}
|
|
|
|
await Circuit.updateData(idapp, circuitname)
|
|
if (ris) {
|
|
// Invia una notifica alla persona e agli Admin
|
|
tools.sendNotificationByCircuit(idapp, usernameOrig, circuitname, cmd, value, true, username_action, extrarec);
|
|
outres.result = await Circuit.getInfoCircuitByName(idapp, circuitname);
|
|
}
|
|
} else {
|
|
const foundIfAlreadyCircuit = await this.ifAlreadyInCircuit(idapp, usernameOrig, circuitname);
|
|
|
|
if (!foundIfAlreadyCircuit) {
|
|
update = {
|
|
$push: {
|
|
'profile.mycircuits': {
|
|
circuitname,
|
|
date: new Date(),
|
|
},
|
|
},
|
|
};
|
|
ris = await User.updateOne({ idapp, username: usernameOrig }, update);
|
|
|
|
// Elimina eventualmente se era bloccato:
|
|
update = { $pull: { refused_users: { username: { $in: [usernameOrig] } } } };
|
|
await Circuit.updateOne({ idapp, name: circuitname }, update);
|
|
|
|
await Account.createAccount(idapp, usernameOrig, circuitname);
|
|
|
|
|
|
} else {
|
|
ris = false;
|
|
}
|
|
|
|
await Circuit.updateData(idapp, circuitname)
|
|
if (ris) {
|
|
// Invia una notifica alla persona e agli Admin
|
|
tools.sendNotificationByCircuit(idapp, usernameOrig, circuitname, cmd, value, true, username_action, extrarec);
|
|
outres.result = await Circuit.getInfoCircuitByName(idapp, circuitname);
|
|
}
|
|
}
|
|
|
|
} else if (cmd === shared_consts.CIRCUITCMD.SETFIDO) {
|
|
|
|
ris = await Circuit.setFido(idapp, usernameOrig, circuitname, groupname);
|
|
if (ris && ris.fidoConcesso && ris.changed) {
|
|
|
|
if (extrarec) {
|
|
extrarec.fidoConcesso = ris.fidoConcesso;
|
|
extrarec.qta_maxConcessa = ris.qta_maxConcessa;
|
|
}
|
|
|
|
// Elimina la richiesta:
|
|
update = { $pull: { req_users: { username: { $in: [usernameOrig] } } } };
|
|
await Circuit.updateOne({ idapp, name: circuitname }, update);
|
|
|
|
await Circuit.updateData(idapp, circuitname)
|
|
if (ris) {
|
|
// Invia una notifica alla persona e agli Admin
|
|
tools.sendNotificationByCircuit(idapp, usernameOrig, circuitname, cmd, value, true, username_action, extrarec);
|
|
outres.result = await Circuit.getInfoCircuitByName(idapp, circuitname);
|
|
}
|
|
} else {
|
|
// errore !?
|
|
}
|
|
|
|
} else if (cmd === shared_consts.CIRCUITCMD.REQ) {
|
|
|
|
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);
|
|
|
|
}
|
|
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 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 {
|
|
// Aggiungo la richiesta di Circuito a me
|
|
const foundIfAlreadyAskCircuit = await Circuit.findOne({
|
|
idapp,
|
|
name: circuitname,
|
|
'req_users': {
|
|
$elemMatch: { username: { $eq: usernameOrig } },
|
|
},
|
|
});
|
|
|
|
if (value) {
|
|
// 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
|
|
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) {
|
|
// Elimina la richiesta:
|
|
update = { $pull: { req_groups: { groupname: { $in: [groupname] } } } };
|
|
await Circuit.updateOne({ idapp, name: circuitname }, update);
|
|
|
|
outres.result = await MyGroup.removeCircuitFromGroup(idapp, groupname, circuitname); // Rimuovo l'Amicizia da me
|
|
} else {
|
|
|
|
// Remove if is also an Admin
|
|
await Circuit.removeAdminOfMyCircuit(idapp, usernameOrig, circuitname);
|
|
|
|
outres.result = await this.removeFromCircuits(idapp, usernameOrig, circuitname); // Rimuovo l'Amicizia da me
|
|
console.log('ris', ris);
|
|
|
|
await Circuit.updateData(idapp, circuitname);
|
|
}
|
|
|
|
// Invia una notifica alla persona
|
|
await tools.sendNotificationByCircuit(idapp, usernameOrig, circuitname, cmd, false, true, username_action, extrarec);
|
|
|
|
} else if (cmd === shared_consts.CIRCUITCMD.DELETE) {
|
|
|
|
ris = await this.removeFromCircuits(idapp, usernameOrig, circuitname); // Rimuovo l'Amicizia da me
|
|
|
|
if (ris) {
|
|
// Invia una notifica alla persona e agli Admin
|
|
await tools.sendNotificationByCircuit(idapp, usernameOrig, circuitname, cmd, false, true, username_action, extrarec);
|
|
|
|
}
|
|
outres.result = await Circuit.deleteCircuit(idapp, usernameOrig, circuitname); // Rimuovo l'Amicizia da me
|
|
|
|
} else if (cmd === shared_consts.CIRCUITCMD.CANCEL_REQ) {
|
|
|
|
if (groupname)
|
|
outres.result = await Circuit.removeReqGroupCircuit(idapp, groupname, circuitname); // Rimuovo l'Amicizia da me
|
|
else
|
|
outres.result = await Circuit.removeReqCircuit(idapp, usernameOrig, circuitname); // Rimuovo l'Amicizia da me
|
|
|
|
await Circuit.updateData(idapp, circuitname)
|
|
|
|
} else if (cmd === shared_consts.CIRCUITCMD.REFUSE_REQ) {
|
|
|
|
if (groupname) {
|
|
outres.result = await MyGroup.removeCircuitFromGroup(idapp, groupname, circuitname); // Rimuovo l'Amicizia da me
|
|
outres.result = await Circuit.removeReqGroupCircuit(idapp, groupname, circuitname); // Rimuovo l'Amicizia da me
|
|
outres.result = await Circuit.refuseReqGroupCircuit(idapp, groupname, circuitname); // Rimuovo l'Amicizia da me
|
|
} else {
|
|
outres.result = await this.removeFromCircuits(idapp, usernameOrig, circuitname); // Rimuovo l'Amicizia da me
|
|
outres.result = await Circuit.removeReqCircuit(idapp, usernameOrig, circuitname); // Rimuovo l'Amicizia da me
|
|
outres.result = await Circuit.refuseReqCircuit(idapp, usernameOrig, circuitname); // Rimuovo l'Amicizia 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.ADDADMIN) {
|
|
outres.result = await Circuit.addToAdminOfMyCircuit(idapp, usernameOrig, circuitname); // Rimuovo la richiesta di entrare nel gruppo
|
|
|
|
// Invia una notifica alla persona
|
|
await tools.sendNotificationByCircuit(idapp, usernameOrig, circuitname, cmd, false, true, username_action, extrarec);
|
|
|
|
} else if (cmd === shared_consts.CIRCUITCMD.REMOVEADMIN) {
|
|
outres.result = await Circuit.removeAdminOfMyCircuit(idapp, usernameOrig, circuitname); // Rimuovo la richiesta di entrare nel gruppo
|
|
|
|
// Invia una notifica alla persona
|
|
await tools.sendNotificationByCircuit(idapp, usernameOrig, circuitname, cmd, false, true, username_action, extrarec);
|
|
|
|
} else if (cmd === shared_consts.CIRCUITCMD.SENDCOINS_REQ) {
|
|
|
|
outres = await Circuit.sendCoins(true, idapp, usernameOrig, extrarec);
|
|
|
|
if (outres.cansend) {
|
|
// Invia una notifica di moneta alla persona
|
|
const out = await tools.sendNotificationByCircuit(idapp, usernameOrig, circuitname, cmd, false, true, username_action,
|
|
extrarec);
|
|
if (out)
|
|
outres.result = out.ris;
|
|
} else {
|
|
outres.cansend = false;
|
|
}
|
|
|
|
ris = true;
|
|
} else if ((cmd === shared_consts.CIRCUITCMD.SENDCOINS_ACCEPT) || (cmd === shared_consts.CIRCUITCMD.SENDCOINS_REFUSE)) {
|
|
// Before to accept, I see if it's already set !
|
|
|
|
outres = {
|
|
cansend: false,
|
|
errormsg: '',
|
|
};
|
|
|
|
let outcheck = outres;
|
|
|
|
let risStatus = '';
|
|
const status = await SendNotif.getStatus(extrarec.notifId);
|
|
if (status === shared_consts.CircuitsNotif.STATUS_ACCEPTED) {
|
|
risStatus = i18n.__('STATUS_SENT');
|
|
} else if (status === shared_consts.CircuitsNotif.STATUS_REFUSED) {
|
|
risStatus = i18n.__('STATUS_REFUSED');
|
|
}
|
|
// if (!await SendNotif.checkIfCoinsAlreadySent(extrarec.notifId)) {
|
|
if (!await Movement.checkIfCoinsAlreadySent(extrarec.notifId)) {
|
|
if (cmd === shared_consts.CIRCUITCMD.SENDCOINS_ACCEPT) {
|
|
outcheck = await Circuit.sendCoins(true, idapp, usernameOrig, extrarec);
|
|
} else {
|
|
outcheck.cansend = true;
|
|
outres.cansend = true;
|
|
}
|
|
|
|
if (cmd === shared_consts.CIRCUITCMD.SENDCOINS_ACCEPT && outcheck.cansend) {
|
|
if (!await Movement.checkIfCoinsAlreadySent(extrarec.notifId)) {
|
|
outres = await Circuit.sendCoins(false, idapp, usernameOrig, extrarec);
|
|
|
|
} else {
|
|
outcheck.cansend = false; //GIA INVIATO
|
|
}
|
|
}
|
|
|
|
if (outcheck.cansend) {
|
|
// Invia una notifica di moneta (accettata o rifiutata) alla persona
|
|
const out = await tools.sendNotificationByCircuit(idapp, usernameOrig, circuitname, cmd, false, true, username_action, extrarec);
|
|
|
|
if (outres && extrarec.groupname) {
|
|
// Setta agli altri admin,
|
|
}
|
|
}
|
|
|
|
outres.recnotif = await SendNotif.getRecNotif(extrarec.notifId);
|
|
outres.arrrecnotif = await SendNotif.findAllNotifByUsernameIdAndIdApp(username_action, extrarec.lastdr, idapp, shared_consts.LIMIT_NOTIF_FOR_USER);
|
|
|
|
} else {
|
|
outres.cansend = false;
|
|
|
|
outres.errormsg = i18n.__('CIRCUIT_COINS_ALREADY_PROCESSED', risStatus);
|
|
}
|
|
ris = true;
|
|
}
|
|
|
|
if (ris && username_action) {
|
|
outres = await this.updateMyData(outres, idapp, username_action);
|
|
}
|
|
|
|
if (circuitname)
|
|
outres.circuit = await Circuit.getInfoCircuitByName(idapp, circuitname);
|
|
|
|
return outres;
|
|
|
|
} catch (e) {
|
|
console.error('Error setCircuitCmd: ', e);
|
|
}
|
|
|
|
return ris;
|
|
};
|
|
|
|
function getWhatToShow(idapp, username) {
|
|
return {
|
|
username: 1,
|
|
aportador_solidario: 1,
|
|
name: 1,
|
|
surname: 1,
|
|
lasttimeonline: 1,
|
|
deleted: 1,
|
|
sospeso: 1,
|
|
reported: 1,
|
|
date_report: 1,
|
|
username_who_report: 1,
|
|
verified_email: 1,
|
|
verified_by_aportador: 1,
|
|
notask_verif: 1,
|
|
'profile.nationality': 1,
|
|
'profile.mygroups': 1,
|
|
'profile.mycircuits': 1,
|
|
'profile.qualifica': 1,
|
|
'profile.biografia': 1,
|
|
'profile.username_telegram': 1,
|
|
'profile.firstname_telegram': 1,
|
|
'profile.lastname_telegram': 1,
|
|
'profile.intcode_cell': 1,
|
|
'profile.cell': 1,
|
|
'profile.website': 1,
|
|
'profile.img': 1,
|
|
'profile.sex': 1,
|
|
'profile.dateofbirth': 1,
|
|
'profile.born_city_id': 1,
|
|
'profile.born_province': 1,
|
|
'profile.born_country': 1,
|
|
'profile.resid_province': 1,
|
|
'profile.resid_card': 1,
|
|
'profile.calc': 1,
|
|
email: 1,
|
|
date_reg: 1,
|
|
'profile.friends': 1,
|
|
'profile.handshake': 1,
|
|
};
|
|
|
|
}
|
|
|
|
function getWhatToShow_Unknown(idapp, username) {
|
|
return {
|
|
username: 1,
|
|
aportador_solidario: 1,
|
|
name: 1,
|
|
// deleted: 1,
|
|
// sospeso: 1,
|
|
verified_email: 1,
|
|
verified_by_aportador: 1,
|
|
'profile.username_telegram': 1,
|
|
'profile.img': 1,
|
|
'profile.sex': 1,
|
|
'profile.born_province': 1,
|
|
'profile.born_country': 1,
|
|
'profile.resid_province': 1,
|
|
'profile.resid_card': 1,
|
|
'profile.calc': 1,
|
|
date_reg: 1,
|
|
'profile.handshake': 1,
|
|
'profile.friends': 1,
|
|
'profile.favorite': 1,
|
|
'profile.bookmark': 1,
|
|
'profile.attend': 1,
|
|
'profile.seen': 1,
|
|
}
|
|
}
|
|
|
|
UserSchema.statics.getWhatToShow_IfFriends = async function (idapp, username) {
|
|
return {
|
|
username: 1,
|
|
aportador_solidario: 1,
|
|
name: 1,
|
|
// deleted: 1,
|
|
// sospeso: 1,
|
|
verified_email: 1,
|
|
'profile.username_telegram': 1,
|
|
verified_by_aportador: 1,
|
|
'profile.img': 1,
|
|
'profile.sex': 1,
|
|
'profile.born_province': 1,
|
|
'profile.born_country': 1,
|
|
'profile.resid_province': 1,
|
|
'profile.resid_card': 1,
|
|
'profile.calc': 1,
|
|
reported: 1,
|
|
date_report: 1,
|
|
username_who_report: 1,
|
|
date_reg: 1,
|
|
groups: 1,
|
|
'profile.handshake': 1,
|
|
'profile.friends': 1,
|
|
'profile.favorite': 1,
|
|
'profile.bookmark': 1,
|
|
'profile.attend': 1,
|
|
'profile.seen': 1,
|
|
};
|
|
|
|
};
|
|
|
|
UserSchema.statics.getInfoFriendByUsername = async function (idapp, username) {
|
|
|
|
const whatToShow = getWhatToShow(idapp, username);
|
|
|
|
return await User.findOne({
|
|
idapp,
|
|
username,
|
|
$or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
|
|
}, whatToShow).lean().then((rec) => !!rec ? rec : null);
|
|
|
|
};
|
|
|
|
UserSchema.statics.getInfoAskFriendByUsername = async function (
|
|
idapp, username) {
|
|
|
|
const whatToShow = getWhatToShow_Unknown(idapp, username);
|
|
|
|
return await User.findOne({
|
|
idapp,
|
|
username,
|
|
$or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
|
|
}, whatToShow).lean().then((rec) => !!rec ? rec : null);
|
|
|
|
};
|
|
|
|
UserSchema.statics.getAskedFriendsByUsername = async function (idapp, username) {
|
|
|
|
const whatToShow_Unknown = getWhatToShow_Unknown(idapp, username);
|
|
|
|
return await User.find({
|
|
idapp,
|
|
'profile.req_friends': {
|
|
$elemMatch: { username: { $eq: username } },
|
|
},
|
|
$or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
|
|
}, whatToShow_Unknown).then((rec) => {
|
|
|
|
//return rec.map(m => m.username);
|
|
});
|
|
|
|
};
|
|
|
|
|
|
UserSchema.statics.getUsersToVerify = async function (idapp, username) {
|
|
|
|
const whatToShow_Unknown = getWhatToShow(idapp, username);
|
|
let usersToVerify = await User.find({
|
|
idapp, aportador_solidario: username,
|
|
verified_by_aportador: { $exists: false },
|
|
$or: [
|
|
{ deleted: { $exists: false } },
|
|
{ deleted: { $exists: true, $eq: false } }],
|
|
}, whatToShow_Unknown).lean();
|
|
|
|
return usersToVerify;
|
|
};
|
|
|
|
UserSchema.statics.getFriendsByUsername = async function (idapp, username) {
|
|
|
|
if (!username) {
|
|
return {
|
|
listFriends: [],
|
|
listRequestFriends: [],
|
|
listTrusted: [],
|
|
listSentRequestFriends: [],
|
|
}
|
|
}
|
|
|
|
try {
|
|
const whatToShow = getWhatToShow(idapp, username);
|
|
const whatToShow_Unknown = getWhatToShow_Unknown(idapp, username);
|
|
const arrUsernameFriends = await User.getUsernameFriendsByUsername(idapp,
|
|
username);
|
|
const arrUsernameReqFriends = await User.getUsernameReqFriendsByUsername(
|
|
idapp, username);
|
|
const arrUsernameHandShake = await User.getUsernameHandShakeByUsername(idapp,
|
|
username);
|
|
|
|
let listFriends = await User.find({
|
|
idapp,
|
|
username: { $in: arrUsernameFriends },
|
|
$or: [
|
|
{ deleted: { $exists: false } },
|
|
{ deleted: { $exists: true, $eq: false } }],
|
|
}, whatToShow);
|
|
|
|
let listHandShake = await User.find({
|
|
idapp,
|
|
username: { $in: arrUsernameHandShake },
|
|
$or: [
|
|
{ deleted: { $exists: false } },
|
|
{ deleted: { $exists: true, $eq: false } }],
|
|
}, whatToShow);
|
|
|
|
let listRequestFriends = await User.find({
|
|
idapp,
|
|
username: { $in: arrUsernameReqFriends },
|
|
$or: [
|
|
{ deleted: { $exists: false } },
|
|
{ deleted: { $exists: true, $eq: false } }],
|
|
}, whatToShow_Unknown);
|
|
|
|
let listSentRequestFriends = await User.find({
|
|
idapp,
|
|
'profile.req_friends': {
|
|
$elemMatch: { username: { $eq: username } },
|
|
},
|
|
$or: [
|
|
{ deleted: { $exists: false } },
|
|
{ deleted: { $exists: true, $eq: false } }],
|
|
}, whatToShow_Unknown);
|
|
|
|
let listTrusted = await User.find({
|
|
idapp, aportador_solidario: username,
|
|
'profile.teleg_id': { $gt: 0 },
|
|
$or: [
|
|
{ deleted: { $exists: false } },
|
|
{ deleted: { $exists: true, $eq: false } }],
|
|
}, whatToShow);
|
|
|
|
return {
|
|
listFriends,
|
|
listHandShake,
|
|
listRequestFriends,
|
|
listTrusted,
|
|
listSentRequestFriends,
|
|
};
|
|
|
|
} catch (e) {
|
|
console.log('Error', e);
|
|
}
|
|
|
|
return {
|
|
listFriends: [],
|
|
listHandShake: [],
|
|
listRequestFriends: [],
|
|
listTrusted: [],
|
|
listSentRequestFriends: [],
|
|
|
|
};
|
|
};
|
|
|
|
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 } }],
|
|
}).lean().then(async (rec) => {
|
|
if (!rec) {
|
|
// Cerca se esiste in quello salvato in precedenza:
|
|
const recold = await User.findOne({
|
|
idapp,
|
|
'profile.teleg_id_old': teleg_id
|
|
}).lean();
|
|
if (recold && recold.profile.teleg_id_old === teleg_id) {
|
|
// Riaggiorna l'ID perché è ritornato sulla chat!
|
|
await User.SetTelegramIdSuccess(idapp, recold._id, recold.profile.teleg_id_old);
|
|
|
|
rec = await User.findOne({
|
|
idapp,
|
|
'profile.teleg_id': teleg_id,
|
|
$or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
|
|
}).lean();
|
|
}
|
|
|
|
}
|
|
return (!!rec) ? rec : null;
|
|
}).catch((e) => {
|
|
console.error('UserExistByIdTelegram', e);
|
|
});
|
|
};
|
|
|
|
|
|
UserSchema.statics.setPicProfile = async function (idapp, username, imgpic) {
|
|
const User = this;
|
|
|
|
const fields_to_update = {
|
|
'profile.img': imgpic,
|
|
};
|
|
|
|
return await User.findOneAndUpdate({
|
|
idapp, username,
|
|
}, { $set: fields_to_update }, { new: false }).lean().then((record) => {
|
|
return !!record;
|
|
});
|
|
|
|
};
|
|
|
|
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 }).lean().then((rec) => {
|
|
return (!!rec) ? rec.profile.teleg_id : null;
|
|
}).catch((e) => {
|
|
console.error('TelegIdByUsername', e);
|
|
});
|
|
};
|
|
|
|
UserSchema.statics.TelegIdById = async function (idapp, id) {
|
|
const User = this;
|
|
|
|
return await User.findOne({
|
|
idapp,
|
|
_id: id,
|
|
$or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
|
|
}, { 'profile.teleg_id': 1 }).lean().then((rec) => {
|
|
return (!!rec) ? rec.profile.teleg_id : null;
|
|
}).catch((e) => {
|
|
console.error('TelegIdByUsername', e);
|
|
});
|
|
};
|
|
UserSchema.statics.notAsk_VerifByUsername = async function (idapp, username) {
|
|
|
|
return await User.findOne({
|
|
idapp, username,
|
|
$or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
|
|
}, { 'notask_verif': 1 }).lean().then((rec) => {
|
|
return (!!rec && rec.notask_verif) ? true : false;
|
|
}).catch((e) => {
|
|
console.error('notAsk_VerifByUsername', e);
|
|
return false;
|
|
});
|
|
};
|
|
|
|
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 }).lean().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 }).lean().then((record) => {
|
|
|
|
if (record) {
|
|
return User.findOne({
|
|
idapp,
|
|
_id: id,
|
|
}).lean();
|
|
}
|
|
});
|
|
|
|
return null;
|
|
|
|
};
|
|
|
|
UserSchema.statics.getUsernameTelegram = async function (idapp, username) {
|
|
const User = this;
|
|
return await User.findOne({ idapp, username }, { 'profile.username_telegram': 1 }).lean().then((ris) => {
|
|
if (ris)
|
|
return ris.profile.username_telegram;
|
|
else
|
|
return '';
|
|
});
|
|
};
|
|
|
|
UserSchema.statics.setUsernameTelegram = async function (
|
|
idapp, id, username_telegram, firstname_telegram, lastname_telegram) {
|
|
const User = this;
|
|
|
|
const fields_to_update = {
|
|
'profile.username_telegram': username_telegram,
|
|
'profile.firstname_telegram': firstname_telegram,
|
|
'profile.lastname_telegram': lastname_telegram,
|
|
};
|
|
|
|
return await User.findOneAndUpdate({
|
|
idapp,
|
|
_id: id,
|
|
}, { $set: fields_to_update }, { new: false }).then((record) => {
|
|
return record;
|
|
});
|
|
|
|
};
|
|
|
|
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 (tools.sulServer()) {
|
|
if (true) {
|
|
|
|
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, reale = false) {
|
|
const User = this;
|
|
|
|
return await User.findOne({
|
|
idapp, username,
|
|
$or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
|
|
}, { username: 1, name: 1, surname: 1 }).then((rec) => {
|
|
let ris = rec.username;
|
|
if (!!rec) {
|
|
if (reale) {
|
|
if (!rec.name)
|
|
return '';
|
|
|
|
ris = `${rec.name} ${rec.surname}`;
|
|
} else {
|
|
if (rec.name) {
|
|
ris = `${rec.name} ${rec.surname}`;
|
|
}
|
|
}
|
|
}
|
|
return (!!rec) ? ris : '';
|
|
}).catch((e) => {
|
|
console.error('getNameSurnameByUsername', e);
|
|
});
|
|
};
|
|
|
|
UserSchema.statics.getIdByUsername = async function (idapp, username) {
|
|
const User = this;
|
|
|
|
let regexp = new RegExp(`^${username}$`, 'i');
|
|
|
|
return await User.findOne({
|
|
idapp,
|
|
username: { $regex: regexp },
|
|
$or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
|
|
}, { username: 1, _id: 1 }).then((rec) => {
|
|
return (!!rec) ? rec._id.toString() : '';
|
|
}).catch((e) => {
|
|
console.error('getIdByUsername', e);
|
|
});
|
|
};
|
|
|
|
UserSchema.statics.getRealUsernameByUsername = async function (idapp, username) {
|
|
const User = this;
|
|
|
|
let regexp = new RegExp(`^${username}$`, 'i');
|
|
|
|
return await User.findOne({
|
|
idapp,
|
|
username:
|
|
{ $regex: regexp },
|
|
$or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
|
|
}, { username: 1, _id: 1 }).then((rec) => {
|
|
return (!!rec) ? rec.username : '';
|
|
}).catch((e) => {
|
|
console.error('getRealUsernameByUsername', e);
|
|
});
|
|
};
|
|
|
|
UserSchema.statics.getRecLangAndIdByUsername = async function (idapp, username) {
|
|
const User = this;
|
|
|
|
return await User.findOne({
|
|
idapp, username,
|
|
$or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
|
|
}, { lang: 1, _id: 1 }).then((rec) => {
|
|
return (!!rec) ? rec : null;
|
|
}).catch((e) => {
|
|
console.error('getRecLangAndIdByUsername', 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.getusersManagers = async function (idapp) {
|
|
const User = this;
|
|
// Int32 mongodb 6.0
|
|
return await User.find({ idapp, 'profile.manage_telegram': true, perm: { $bitsAnySet: 0b010 } },
|
|
{ username: 1, 'profile.teleg_id': 1, perm: 1 }).then((arrrec) => {
|
|
return (!!arrrec) ? arrrec : null;
|
|
}).catch((e) => {
|
|
console.error('getusersManagers', e);
|
|
});
|
|
};
|
|
|
|
UserSchema.statics.getusersAdmin = async function (idapp) {
|
|
const User = this;
|
|
|
|
// Int32 mongodb 6.0
|
|
|
|
return await User.find({ idapp, 'profile.admin_telegram': true, perm: { $bitsAnySet: 0b001 } },
|
|
{ username: 1, 'profile.teleg_id': 1, perm: 1 }).then((arrrec) => {
|
|
return (!!arrrec) ? arrrec : null;
|
|
}).catch((e) => {
|
|
console.error('getusersAdmin', 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 } }).lean();
|
|
then((arrrec) => {
|
|
return (!!arrrec) ? arrrec : null;
|
|
}).
|
|
catch((e) => {
|
|
console.error('getUsersTelegALL', e);
|
|
});
|
|
} else {
|
|
return await User.find({ idapp, 'profile.teleg_id': { $gt: 0 } }).
|
|
lean().
|
|
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('isManagerByIdTeleg', e);
|
|
return false;
|
|
});
|
|
};
|
|
|
|
UserSchema.statics.isAdminByIdTeleg = async function (idapp, idtelegram) {
|
|
const User = this;
|
|
|
|
return await User.findOne({
|
|
idapp,
|
|
username: 'paoloar77',
|
|
'profile.admin_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,
|
|
lasttimeonline: 1,
|
|
verified_email: 1,
|
|
verified_by_aportador: 1,
|
|
made_gift: 1,
|
|
perm: 1,
|
|
email: 1,
|
|
date_reg: 1,
|
|
img: 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: 'ipaddr', type: tools.FieldType.string },
|
|
];
|
|
//{field: 'aportador_solidario', type: tools.FieldType.string}
|
|
};
|
|
|
|
UserSchema.statics.getFieldsForSearchUserFriend = function () {
|
|
return [
|
|
{ field: 'username', type: tools.FieldType.exact },
|
|
{ field: 'profile.username_telegram', type: tools.FieldType.string },
|
|
{ field: 'name', type: tools.FieldType.string },
|
|
{ field: 'surname', type: tools.FieldType.string },
|
|
];
|
|
};
|
|
|
|
UserSchema.statics.getFieldsForSearchUserFriend_AllWords = function () {
|
|
return [
|
|
{ field: 'username', type: tools.FieldType.string },
|
|
{ field: 'profile.username_telegram', type: tools.FieldType.string },
|
|
{ field: 'name', type: tools.FieldType.string },
|
|
{ field: 'surname', type: tools.FieldType.string },
|
|
|
|
];
|
|
};
|
|
|
|
UserSchema.statics.executeQueryTable = function (idapp, params) {
|
|
params.fieldsearch = this.getFieldsForSearch();
|
|
if (params.options) {
|
|
if (tools.isBitActive(params.options,
|
|
shared_consts.OPTIONS_SEARCH_USER_ONLY_FULL_WORDS)) {
|
|
params.fieldsearch = this.getFieldsForSearchUserFriend();
|
|
} else if (tools.isBitActive(params.options,
|
|
shared_consts.OPTIONS_SEARCH_USER_ALL_WORDS)) {
|
|
params.fieldsearch = this.getFieldsForSearchUserFriend_AllWords();
|
|
}
|
|
}
|
|
return tools.executeQueryTable(this, idapp, params);
|
|
};
|
|
|
|
UserSchema.statics.findAllIdApp = async function (idapp) {
|
|
const User = this;
|
|
|
|
const myfind = {
|
|
idapp,
|
|
$or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
|
|
};
|
|
|
|
return await User.find(myfind, (err, arrrec) => {
|
|
return arrrec;
|
|
});
|
|
};
|
|
|
|
UserSchema.statics.DuplicateAllRecords = async function (idapporig, idappdest) {
|
|
|
|
return await 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;
|
|
|
|
// 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.countDocuments(myfind);
|
|
};
|
|
|
|
UserSchema.statics.getUsersRegisteredToday = async function (idapp) {
|
|
const User = this;
|
|
|
|
let starttoday = new Date();
|
|
starttoday.setHours(0, 0, 0, 0);
|
|
|
|
const myfind = {
|
|
idapp,
|
|
$or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
|
|
date_reg: { $gt: starttoday },
|
|
};
|
|
|
|
return await User.countDocuments(myfind);
|
|
};
|
|
|
|
UserSchema.statics.getUsersOnLineToday = async function (idapp) {
|
|
const User = this;
|
|
|
|
let starttoday = new Date();
|
|
starttoday.setHours(0, 0, 0, 0);
|
|
|
|
const myfind = {
|
|
idapp,
|
|
$or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
|
|
lasttimeonline: { $gt: starttoday },
|
|
};
|
|
|
|
return await User.countDocuments(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.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.countDocuments(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.countDocuments(myfind);
|
|
};
|
|
|
|
UserSchema.statics.getUsersAutorizzati = async function (idapp) {
|
|
const User = this;
|
|
|
|
const myfind = {
|
|
idapp,
|
|
$or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
|
|
'profile.teleg_id': { $gt: 0 },
|
|
verified_by_aportador: true,
|
|
};
|
|
|
|
return await User.countDocuments(myfind);
|
|
};
|
|
|
|
UserSchema.statics.getUsersAutorizzare = async function (idapp) {
|
|
const User = this;
|
|
|
|
const myfind = {
|
|
idapp,
|
|
$or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
|
|
'profile.teleg_id': { $gt: 0 },
|
|
verified_by_aportador: { $exists: false },
|
|
};
|
|
|
|
return await User.countDocuments(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.countDocuments(myfind);
|
|
};
|
|
|
|
UserSchema.statics.getNumUsers = async function (idapp) {
|
|
const User = this;
|
|
|
|
const myfind = {
|
|
idapp,
|
|
$or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
|
|
};
|
|
|
|
return await User.countDocuments(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.countDocuments(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.countDocuments(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.countDocuments(myfind);
|
|
};
|
|
|
|
UserSchema.statics.getLastUsers = async function (idapp) {
|
|
const User = this;
|
|
|
|
const lastn = await Settings.getValDbSettings(idapp, 'SHOW_LAST_N_USERS', 20);
|
|
|
|
return await User.find(
|
|
{
|
|
idapp,
|
|
$or: [
|
|
{ deleted: { $exists: false } },
|
|
{ deleted: { $exists: true, $eq: false } }],
|
|
},
|
|
{
|
|
username: 1,
|
|
name: 1,
|
|
surname: 1,
|
|
lasttimeonline: 1,
|
|
verified_by_aportador: 1,
|
|
'profile.img': 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.getLastOnlineUsers = async function (idapp) {
|
|
const User = this;
|
|
|
|
const lastn = await Settings.getValDbSettings(idapp, 'SHOW_LAST_ONLINE_USERS', 20);
|
|
|
|
return await User.find(
|
|
{
|
|
idapp,
|
|
$or: [
|
|
{ deleted: { $exists: false } },
|
|
{ deleted: { $exists: true, $eq: false } }],
|
|
},
|
|
{
|
|
username: 1,
|
|
name: 1,
|
|
surname: 1,
|
|
lasttimeonline: 1,
|
|
date_reg: 1,
|
|
verified_by_aportador: 1,
|
|
'profile.img': 1,
|
|
index: 1,
|
|
}).sort({ lasttimeonline: -1 }).limit(lastn).then((arr) => {
|
|
//return JSON.stringify(arr)
|
|
return arr;
|
|
});
|
|
|
|
};
|
|
|
|
UserSchema.statics.getLastSharedLink = async function (idapp) {
|
|
const User = this;
|
|
|
|
const lastn = 10;
|
|
|
|
return await User.find(
|
|
{
|
|
idapp,
|
|
$or: [
|
|
{ deleted: { $exists: false } },
|
|
{ deleted: { $exists: true, $eq: false } }],
|
|
},
|
|
{
|
|
username: 1,
|
|
name: 1,
|
|
surname: 1,
|
|
lasttimeonline: 1,
|
|
verified_by_aportador: 1,
|
|
date_reg: 1,
|
|
'profile.img': 1,
|
|
index: 1,
|
|
}).sort({ date_tokenreg: -1 }).limit(lastn).then((arr) => {
|
|
return arr;
|
|
});
|
|
|
|
};
|
|
|
|
UserSchema.statics.getDiffusoriUsers = async function (idapp) {
|
|
const User = this;
|
|
|
|
const lastn = 10;
|
|
|
|
return await User.aggregate(User.getQueryUsersDiffusori(idapp)).then(ris => {
|
|
// console.table(ris);
|
|
return ris;
|
|
});
|
|
|
|
};
|
|
|
|
UserSchema.statics.getBestStretteDiManoUsers = async function (idapp) {
|
|
const User = this;
|
|
|
|
const lastn = 10;
|
|
|
|
return await User.aggregate(User.getQueryUsersStretteDiMano(idapp)).then(ris => {
|
|
// console.table(ris);
|
|
return ris;
|
|
});
|
|
|
|
};
|
|
|
|
UserSchema.statics.getReceiveRISUsers = async function (idapp) {
|
|
const User = this;
|
|
|
|
return await User.aggregate(User.getQueryReceiveRISUsers(idapp, 8)).then(ris => {
|
|
// console.table(ris);
|
|
return ris;
|
|
});
|
|
|
|
};
|
|
|
|
UserSchema.statics.checkUser = async function (idapp, username) {
|
|
const User = this;
|
|
|
|
return await User.findOne({ idapp, username }, {
|
|
verified_email: 1,
|
|
verified_by_aportador: 1,
|
|
notask_verif: 1,
|
|
'profile.teleg_id': 1,
|
|
'profile.teleg_checkcode': 1,
|
|
}).lean().then((rec) => {
|
|
return rec;
|
|
});
|
|
|
|
};
|
|
|
|
UserSchema.statics.calculateStat = async function (idapp, username) {
|
|
const User = this;
|
|
|
|
try {
|
|
const { MySkill } = require('../models/myskill');
|
|
const { MyGood } = require('../models/mygood');
|
|
const { MyBacheca } = require('../models/mybacheca');
|
|
const { MyGroup } = require('../models/mygroup');
|
|
const globalTables = require('../tools/globalTables');
|
|
|
|
const numUsersReg = await User.countDocuments(
|
|
{
|
|
idapp,
|
|
$or: [
|
|
{ deleted: { $exists: false } },
|
|
{ deleted: { $exists: true, $eq: false } }],
|
|
});
|
|
|
|
let numByTab = {};
|
|
|
|
for (let table of shared_consts.TABLES_VISU_STAT_IN_HOME) {
|
|
let mytable = globalTables.getTableByTableName(table);
|
|
if (mytable) {
|
|
numByTab[table] = await mytable.countDocuments({ idapp });
|
|
}
|
|
}
|
|
|
|
return { numByTab, numUsersReg };
|
|
} catch (e) {
|
|
console.error(e.message);
|
|
}
|
|
|
|
};
|
|
|
|
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 await User.aggregate(User.getDistinctNationalityQuery(idapp)).then(ris => {
|
|
// console.table(ris);
|
|
return 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.getUsersRegDailyAverage = 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 },
|
|
},
|
|
},
|
|
{
|
|
$group: {
|
|
_id: null,
|
|
total: { $sum: '$count' },
|
|
days: { $sum: 1 },
|
|
},
|
|
},
|
|
{
|
|
$project: {
|
|
_id: 0,
|
|
dailyAverage: { $divide: ['$total', '$days'] },
|
|
},
|
|
},
|
|
];
|
|
return query;
|
|
};
|
|
|
|
UserSchema.statics.getQueryUsersDiffusori = function (idapp) {
|
|
|
|
const query = [
|
|
{
|
|
$match: {
|
|
idapp,
|
|
$or: [
|
|
{
|
|
deleted: {
|
|
$exists: false,
|
|
},
|
|
},
|
|
{
|
|
deleted: {
|
|
$exists: true,
|
|
$eq: false,
|
|
},
|
|
},
|
|
],
|
|
},
|
|
},
|
|
{
|
|
$group: {
|
|
_id: "$aportador_solidario",
|
|
count: {
|
|
$sum: 1,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
$match: { "count": { $gte: 2 } }
|
|
},
|
|
{
|
|
$sort: {
|
|
count: -1,
|
|
},
|
|
},
|
|
{ $limit: 20 },
|
|
{
|
|
$lookup: {
|
|
from: "users",
|
|
let: {
|
|
username: "$_id",
|
|
idapp,
|
|
},
|
|
pipeline: [
|
|
{
|
|
$match: {
|
|
$expr: {
|
|
$and: [
|
|
{
|
|
$eq: [
|
|
"$$username",
|
|
"$username",
|
|
],
|
|
},
|
|
{
|
|
$eq: [
|
|
"$$idapp",
|
|
"$idapp",
|
|
],
|
|
},
|
|
],
|
|
},
|
|
},
|
|
},
|
|
],
|
|
as: "user",
|
|
},
|
|
},
|
|
{ $unwind: "$user" },
|
|
{
|
|
$replaceRoot: {
|
|
newRoot: {
|
|
$mergeObjects: ["$user", "$$ROOT"],
|
|
},
|
|
},
|
|
},
|
|
{
|
|
$project: {
|
|
_id: 0,
|
|
count: 1,
|
|
aportador_solidario: 1,
|
|
username: 1,
|
|
name: 1,
|
|
surname: 1,
|
|
lasttimeonline: 1,
|
|
date_reg: 1,
|
|
idapp: 1,
|
|
"profile.img": 1,
|
|
'profile.mycircuits': 1,
|
|
'profile.handshake': 1,
|
|
},
|
|
},
|
|
];
|
|
return query;
|
|
};
|
|
|
|
UserSchema.statics.getQueryUsersStretteDiMano = function (idapp) {
|
|
|
|
const query = [
|
|
{
|
|
$match: {
|
|
idapp: "13",
|
|
'profile.handshake': { $exists: true },
|
|
$or: [
|
|
{
|
|
deleted: {
|
|
$exists: false,
|
|
},
|
|
},
|
|
{
|
|
deleted: {
|
|
$exists: true,
|
|
$eq: false,
|
|
},
|
|
},
|
|
],
|
|
},
|
|
},
|
|
|
|
{
|
|
$group:
|
|
{
|
|
_id: "$username",
|
|
count:
|
|
{ $sum: { $size: "$profile.handshake" } }
|
|
}
|
|
},
|
|
{ $sort: { count: -1 } },
|
|
{ $limit: 20 },
|
|
{
|
|
$lookup: {
|
|
from: "users",
|
|
let: {
|
|
username: "$_id",
|
|
idapp,
|
|
},
|
|
pipeline: [
|
|
{
|
|
$match: {
|
|
$expr: {
|
|
$and: [
|
|
{
|
|
$eq: [
|
|
"$$username",
|
|
"$username",
|
|
],
|
|
},
|
|
{
|
|
$eq: [
|
|
"$$idapp",
|
|
"$idapp",
|
|
],
|
|
},
|
|
],
|
|
},
|
|
},
|
|
},
|
|
],
|
|
as: "user",
|
|
},
|
|
},
|
|
{ $unwind: "$user" },
|
|
{
|
|
$replaceRoot: {
|
|
newRoot: {
|
|
$mergeObjects: ["$user", "$$ROOT"],
|
|
},
|
|
},
|
|
},
|
|
{
|
|
$project: {
|
|
_id: 0,
|
|
count: 1,
|
|
aportador_solidario: 1,
|
|
username: 1,
|
|
name: 1,
|
|
surname: 1,
|
|
lasttimeonline: 1,
|
|
date_reg: 1,
|
|
idapp: 1,
|
|
"profile.img": 1,
|
|
'profile.handshake': 1,
|
|
'profile.mycircuits': 1,
|
|
},
|
|
},
|
|
];
|
|
return query;
|
|
};
|
|
|
|
UserSchema.statics.getQueryReceiveRISUsers = function (idapp, hours) {
|
|
|
|
const query = [
|
|
{
|
|
$match: {
|
|
idapp,
|
|
'profile.lastdate_reqRis': { $gte: tools.IncDateNow(-(1000 * 60 * 60 * hours)) },
|
|
$or: [
|
|
{ deleted: { $exists: false } },
|
|
{ deleted: { $exists: true, $eq: false } }],
|
|
},
|
|
},
|
|
{
|
|
$group:
|
|
{
|
|
_id: "$username",
|
|
count: {
|
|
$sum: 1,
|
|
},
|
|
}
|
|
},
|
|
{ $sort: { 'profile.lastdate_reqRis': -1 } },
|
|
{ $limit: 30 },
|
|
{
|
|
$lookup: {
|
|
from: "users",
|
|
let: {
|
|
username: "$_id",
|
|
idapp,
|
|
},
|
|
pipeline: [
|
|
{
|
|
$match: {
|
|
$expr: {
|
|
$and: [
|
|
{
|
|
$eq: [
|
|
"$$username",
|
|
"$username",
|
|
],
|
|
},
|
|
{
|
|
$eq: [
|
|
"$$idapp",
|
|
"$idapp",
|
|
],
|
|
},
|
|
],
|
|
},
|
|
},
|
|
},
|
|
],
|
|
as: "user",
|
|
},
|
|
},
|
|
{ $unwind: "$user" },
|
|
{
|
|
$replaceRoot: {
|
|
newRoot: {
|
|
$mergeObjects: ["$user", "$$ROOT"],
|
|
},
|
|
},
|
|
},
|
|
{
|
|
$project: {
|
|
_id: 0,
|
|
count: 1,
|
|
aportador_solidario: 1,
|
|
username: 1,
|
|
name: 1,
|
|
surname: 1,
|
|
lasttimeonline: 1,
|
|
'profile.lastdate_reqRis': 1,
|
|
'profile.mycircuits': 1,
|
|
date_reg: 1,
|
|
idapp: 1,
|
|
"profile.img": 1,
|
|
'profile.handshake': 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 },
|
|
},
|
|
},
|
|
{
|
|
$group: {
|
|
_id: null, // Raggruppa tutti i risultati
|
|
total: { $sum: '$count' }, // Calcola il numero totale di iscritti
|
|
days: { $sum: 1 }, // Calcola il numero totale di giorni
|
|
},
|
|
},
|
|
{
|
|
$project: {
|
|
_id: 0, // Escludi il campo _id dal risultato finale
|
|
dailyAverage: { $divide: ['$total', '$days'] }, // Calcola la media giornaliera
|
|
},
|
|
},
|
|
{
|
|
$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, 60)).then((arr) => {
|
|
return arr.reduce((sum, rec) => sum + rec.count, 0);
|
|
});
|
|
|
|
};
|
|
|
|
function calculate30DayAverage(data) {
|
|
const averages = [];
|
|
|
|
for (let i = 0; i < data.length; i++) {
|
|
const startDate = new Date(data[i]._id);
|
|
let sum = data[i].count;
|
|
let count = 1;
|
|
|
|
for (let j = i + 1; j < data.length; j++) {
|
|
const currentDate = new Date(data[j]._id);
|
|
const diffInTime = Math.abs(startDate.getTime() - currentDate.getTime());
|
|
const diffInDays = Math.ceil(diffInTime / (1000 * 60 * 60 * 24));
|
|
|
|
if (diffInDays <= 30) {
|
|
sum += data[j].count;
|
|
count++;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
averages.push({
|
|
_id: data[i]._id,
|
|
dailyAverage: sum / count
|
|
});
|
|
}
|
|
|
|
return averages;
|
|
}
|
|
|
|
UserSchema.statics.calcRegDaily = async function (idapp) {
|
|
const User = this;
|
|
|
|
return await User.aggregate(User.getUsersRegDaily(idapp, 120)).then(ris => {
|
|
// console.table(ris);
|
|
return ris;
|
|
});
|
|
};
|
|
|
|
|
|
|
|
UserSchema.statics.calcRegWeekly = async function (idapp) {
|
|
const User = this;
|
|
|
|
return await User.aggregate(User.getUsersRegDaily(idapp, 120)).then(ris => {
|
|
// console.table(ris);
|
|
return calculate30DayAverage(ris);
|
|
});
|
|
};
|
|
|
|
if (tools.INITDB_FIRSTIME) {
|
|
console.log(' createIndex User Index...');
|
|
|
|
UserSchema.index({ userId: 1 });
|
|
UserSchema.index({ idapp: 1 });
|
|
|
|
|
|
// UserSchema.index({ username: 'text', name: 'text', surname: 'text', email: 'text' });
|
|
// UserSchema.index({ name: 'name' });
|
|
// UserSchema.index({ name: 1 });
|
|
// UserSchema.index({ surname: 1 });
|
|
// ter
|
|
|
|
tools.INITDB_FIRSTIME = false;
|
|
}
|
|
|
|
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.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 = false;
|
|
// const is9req = await User.isUserQualified9(idapp, allData.myuser.username);
|
|
|
|
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.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).lean();
|
|
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 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);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
UserSchema.statics.getExtraInfoByUsername = async function (idapp, username) {
|
|
const User = this;
|
|
|
|
let myuser = await User.findOne({ idapp, username }).lean();
|
|
if (myuser) {
|
|
myuserextra = await User.addExtraInfo(idapp, myuser, null);
|
|
return myuser.profile;
|
|
}
|
|
|
|
return null;
|
|
|
|
};
|
|
UserSchema.statics.getProfilePerActivitiesByUsername = async function (idapp, username) {
|
|
const User = this;
|
|
|
|
try {
|
|
let myuser = await User.findOne({ idapp, username }).lean();
|
|
if (myuser) {
|
|
return {
|
|
mygroups: myuser.profile.mygroups,
|
|
mycircuits: myuser.profile.mycircuits
|
|
};
|
|
}
|
|
} catch (e) {
|
|
console.error('e', e);
|
|
}
|
|
|
|
return null;
|
|
|
|
};
|
|
|
|
UserSchema.statics.addExtraInfo = async function (idapp, recUser, recUserSave, version) {
|
|
|
|
try {
|
|
// tools.startTimeLog('addExtraInfo')
|
|
|
|
if (version) {
|
|
let versattualeuser = 0;
|
|
if (!recUser.profile.version) {
|
|
recUser.version = 0;
|
|
versattualeuser = 0;
|
|
} else {
|
|
versattualeuser = recUser.profile.version;
|
|
}
|
|
|
|
// versattualeuser = 0; // TOGLIERE!
|
|
|
|
if (versattualeuser < version) {
|
|
// Aggiornamento versione
|
|
recUser = await User.updateVersion(versattualeuser, recUser);
|
|
|
|
await User.findOneAndUpdate({ _id: recUser._id }, { $set: { 'profile.version': version } });
|
|
}
|
|
}
|
|
|
|
const listSentMyRequestFriends = await User.find({
|
|
idapp,
|
|
'profile.req_friends': {
|
|
$elemMatch: { username: { $eq: recUser.username } },
|
|
},
|
|
$or: [
|
|
{ deleted: { $exists: false } },
|
|
{ deleted: { $exists: true, $eq: false } }],
|
|
}, { username: 1 }).lean();
|
|
|
|
recUser.profile.asked_friends = listSentMyRequestFriends
|
|
? listSentMyRequestFriends
|
|
: [];
|
|
|
|
const listSentMyRequestGroups = await MyGroup.find({
|
|
idapp,
|
|
'req_users': {
|
|
$elemMatch: { username: { $eq: recUser.username } },
|
|
},
|
|
$or: [
|
|
{ deleted: { $exists: false } },
|
|
{ deleted: { $exists: true, $eq: false } }],
|
|
}, MyGroup.getWhatToShow_Unknown()).lean();
|
|
|
|
recUser.profile.asked_groups = listSentMyRequestGroups
|
|
? listSentMyRequestGroups
|
|
: [];
|
|
|
|
const listRefusedGroups = await MyGroup.find({
|
|
idapp,
|
|
'refused_users': {
|
|
$elemMatch: { username: { $eq: recUser.username } },
|
|
},
|
|
$or: [
|
|
{ deleted: { $exists: false } },
|
|
{ deleted: { $exists: true, $eq: false } }],
|
|
}, MyGroup.getWhatToShow_Unknown()).lean();
|
|
|
|
recUser.profile.refused_groups = listRefusedGroups
|
|
? listRefusedGroups
|
|
: [];
|
|
|
|
const listManageGroups = await MyGroup.find({
|
|
idapp,
|
|
'admins': {
|
|
$elemMatch: { username: { $eq: recUser.username } },
|
|
},
|
|
$or: [
|
|
{ deleted: { $exists: false } },
|
|
{ deleted: { $exists: true, $eq: false } }],
|
|
}).lean();
|
|
|
|
recUser.profile.reaction = await Reaction.find({ idapp, username: recUser.username }).lean();
|
|
|
|
recUser.profile.userstoverify = await User.getUsersToVerify(idapp, recUser.username);
|
|
|
|
recUser.profile.manage_mygroups = listManageGroups
|
|
? listManageGroups
|
|
: [];
|
|
|
|
// Circuit>
|
|
|
|
const circuitobj = await Circuit.getCircuitsByUsername(idapp, recUser.username, recUser);
|
|
|
|
const useraccounts = await Account.getUserAccounts(idapp, recUser.username);
|
|
|
|
for (const group of listManageGroups) {
|
|
const myaccounts = await Account.getGroupAccounts(idapp, group.groupname);
|
|
if (myaccounts && myaccounts.length > 0)
|
|
group.account = myaccounts[0];
|
|
else
|
|
group.account = null;
|
|
}
|
|
|
|
recUser.profile = { ...recUser.profile, ...circuitobj, useraccounts };
|
|
|
|
recUser.calcstat = await User.calculateStat(idapp, recUser.username);
|
|
|
|
recUser.profile.calc = await User.calcOtherByUser(idapp, recUser._id);
|
|
|
|
// tools.endTimeLog('addExtraInfo')
|
|
|
|
return recUser;
|
|
|
|
} catch (e) {
|
|
console.error('Err addExtraInfo', e);
|
|
}
|
|
|
|
return recUser;
|
|
};
|
|
|
|
addRecordReaction = async function (arr, fields, fieldtoset) {
|
|
let newrecord = {};
|
|
|
|
try {
|
|
|
|
if (tools.isArray(arr)) {
|
|
for (let myrec of arr) {
|
|
if (myrec.id) {
|
|
let myfields = { ...{ idrec: myrec.id }, ...fields };
|
|
newrecord = await Reaction.findOne(myfields)
|
|
|
|
if (!newrecord) {
|
|
newrecord = new Reaction(myfields);
|
|
// console.log('Nuovo Record: ', newrecord._doc);
|
|
}
|
|
|
|
newrecord[fieldtoset] = true;
|
|
|
|
await newrecord.save();
|
|
|
|
let newrecfound = await Reaction.findOne(myfields)
|
|
}
|
|
// if (newrecfound)
|
|
// console.log('trovato')
|
|
}
|
|
}
|
|
|
|
} catch (e) {
|
|
console.error(e.message);
|
|
}
|
|
|
|
};
|
|
|
|
|
|
UserSchema.statics.moverecordsFavorite = async function (tab) {
|
|
const { MySkill } = require('../models/myskill');
|
|
const { MyGood } = require('../models/mygood');
|
|
|
|
console.log('INIZIO - moverecordsFavorite tab', tab);
|
|
|
|
const arrusers = await User.find({ idapp: '13' }).lean();
|
|
|
|
let index = 0;
|
|
try {
|
|
|
|
|
|
let index = 0;
|
|
let totali = 0;
|
|
for (let user of arrusers) {
|
|
|
|
if (user.profile) {
|
|
let arrfav = user.profile.favorite;
|
|
let arrseen = user.profile.seen;
|
|
let arrbookmark = user.profile.bookmark;
|
|
let arrattend = user.profile.attend;
|
|
|
|
totali++;
|
|
|
|
if (arrfav || arrseen) {
|
|
console.log('utente n.', index, 'su', totali, user.username);
|
|
index++;
|
|
|
|
let fields = {
|
|
idapp: user.idapp,
|
|
userId: user._id,
|
|
username: user.username,
|
|
tab
|
|
};
|
|
|
|
await addRecordReaction(arrfav, fields, 'fav');
|
|
await addRecordReaction(arrseen, fields, 'seen');
|
|
await addRecordReaction(arrbookmark, fields, 'book:');
|
|
await addRecordReaction(arrattend, fields, 'attend');
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} catch (e) {
|
|
console.error(e.message);
|
|
}
|
|
|
|
console.log('fine moverecordsFavorite');
|
|
|
|
};
|
|
|
|
UserSchema.statics.removerecordsFavorite = async function () {
|
|
// Rimuovi i record del vecchio schema
|
|
const attivacanc = true;
|
|
|
|
if (attivacanc) {
|
|
const queryfind = { idapp: '13' };
|
|
await User.findOneAndUpdate(queryfind, {
|
|
$set:
|
|
{
|
|
'profile.favorite': [],
|
|
'profile.bookmark': [],
|
|
'profile.attend': [],
|
|
'profile.seen': []
|
|
},
|
|
});
|
|
|
|
}
|
|
};
|
|
|
|
UserSchema.statics.updateVersion = async function (userversion, recUser) {
|
|
|
|
const { MySkill } = require('../models/myskill');
|
|
const { MyGood } = require('../models/mygood');
|
|
const { City } = require('../models/city');
|
|
|
|
if (userversion < 604) {
|
|
if (!recUser.profile.notifs || recUser.profile.notifs.length === 0) {
|
|
recUser.profile.notifs = shared_consts.DEFAULT_NOTIFS_USER;
|
|
}
|
|
|
|
const recfavoriteNotif = recUser.profile.notifs.find((rec) => rec.dir === shared_consts.TypeNotifs.TYPEDIR_FAVORITE);
|
|
if (!recfavoriteNotif) {
|
|
recUser.profile.notifs.push({ dir: shared_consts.TypeNotifs.TYPEDIR_FAVORITE, value: shared_consts.TypeNotifs.ID_FAVORITE_ADDED })
|
|
}
|
|
|
|
const recAttendNotif = recUser.profile.notifs.find((rec) => rec.dir === shared_consts.TypeNotifs.TYPEDIR_EVENTS);
|
|
if (recAttendNotif) {
|
|
if (!tools.isBitActive(recAttendNotif.value, shared_consts.TypeNotifs.ID_EVENTS_ATTEND)) {
|
|
recAttendNotif.value = tools.SetBit(recAttendNotif.value, shared_consts.TypeNotifs.ID_EVENTS_ATTEND);
|
|
}
|
|
|
|
for (let i = 0; i < recUser.profile.notifs.length; i++) {
|
|
if (recUser.profile.notifs[i].dir === shared_consts.TypeNotifs.TYPEDIR_EVENTS)
|
|
recUser.profile.notifs[i].value = recAttendNotif.value;
|
|
}
|
|
|
|
}
|
|
|
|
// Imposta la provincia, se non l'ho messa, in base al bene o servizio che hai messo.
|
|
if (!recUser.profile.resid_province) {
|
|
let resid_province = '';
|
|
const firstrec = await MySkill.findOne({ userId: recUser._id }).lean();
|
|
if (firstrec && firstrec.idCity && firstrec.idCity.length > 0) {
|
|
resid_province = await City.getProvinceByIdCity(firstrec.idCity[0]);
|
|
} else {
|
|
const firstrec = await MyGood.findOne({ userId: recUser._id }).lean();
|
|
if (firstrec && firstrec.idCity && firstrec.idCity.length === 1) {
|
|
resid_province = await City.getProvinceByIdCity(firstrec.idCity[0]);
|
|
}
|
|
}
|
|
|
|
|
|
if (resid_province) {
|
|
await User.findOneAndUpdate({ _id: recUser._id }, { $set: { 'profile.resid_province': resid_province } });
|
|
}
|
|
}
|
|
|
|
let recmybach = recUser.profile.notifs.find((rec) => rec.dir === shared_consts.TypeNotifs.TYPEDIR_BACHECA);
|
|
if (!tools.isBitActive(recmybach.value, shared_consts.UsersNotif.NEW_ADV_YOUR_PROVINCE)) {
|
|
recmybach.value = tools.SetBit(recmybach.value, shared_consts.UsersNotif.NEW_ADV_YOUR_PROVINCE);
|
|
for (let i = 0; i < recUser.profile.notifs.length; i++) {
|
|
if (recUser.profile.notifs[i].dir === shared_consts.TypeNotifs.TYPEDIR_BACHECA)
|
|
recUser.profile.notifs[i].value = recmybach.value;
|
|
}
|
|
}
|
|
|
|
await User.findOneAndUpdate({ _id: recUser._id }, { $set: { 'profile.notifs': recUser.profile.notifs } });
|
|
}
|
|
|
|
if (userversion < 1016) {
|
|
|
|
}
|
|
|
|
return recUser;
|
|
};
|
|
|
|
UserSchema.statics.calcOtherByUser = async function (idapp, userId) {
|
|
|
|
const { MySkill } = require('../models/myskill');
|
|
const { MyGood } = require('../models/mygood');
|
|
const { MyHosp } = require('../models/myhosp');
|
|
|
|
let calc = {};
|
|
|
|
let numgoods = await MyGood.countDocuments({ idapp, userId });
|
|
let numskills = await MySkill.countDocuments({ idapp, userId });
|
|
let numhosps = await MyHosp.countDocuments({ idapp, userId });
|
|
|
|
calc.numGoodsAndServices = numgoods + numskills + numhosps;
|
|
|
|
return calc;
|
|
};
|
|
|
|
|
|
UserSchema.statics.tooManyReqPassword = async function (idapp, email, set) {
|
|
const User = this;
|
|
|
|
const maxnum = 30;
|
|
|
|
const user = await User.findByEmail(idapp, email);
|
|
if (user) {
|
|
if (!user.retry_pwd)
|
|
user.retry_pwd = 0
|
|
if (set && user.retry_pwd <= maxnum) {
|
|
user.retry_pwd++;
|
|
|
|
await User.findOneAndUpdate({ _id: user._id }, { $set: { retry_pwd: user.retry_pwd } });
|
|
}
|
|
return user.retry_pwd > maxnum;
|
|
}
|
|
|
|
};
|
|
|
|
UserSchema.statics.setLastCircuitOpened = async function (idapp, username, circuitpath) {
|
|
|
|
try {
|
|
return await User.findOneAndUpdate({ idapp, username }, { $set: { 'profile.last_circuitpath': circuitpath } });
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
|
|
};
|
|
|
|
UserSchema.statics.setReceiveRis = async function (idapp, username) {
|
|
const User = this;
|
|
|
|
return await User.findOneAndUpdate({
|
|
idapp, username,
|
|
},
|
|
{ $set: { 'profile.lastdate_reqRis': new Date() } }, { new: false }).lean().then((record) => {
|
|
return !!record;
|
|
});
|
|
|
|
};
|
|
|
|
UserSchema.statics.addNewSite = async function (idappPass, body) {
|
|
const User = this;
|
|
|
|
const Site = require('../models/site');
|
|
|
|
// Inserisci il nuovo Sito (se non esiste)
|
|
// Site.
|
|
// Inserisci il Nuovo Utente (se non esiste)
|
|
|
|
if (!body.code || body.code.toString() !== process.env.AUTH_NEW_SITES) {
|
|
return { code: server_constants.RIS_CODE_ERR_UNAUTHORIZED, idapp: -1 };
|
|
}
|
|
|
|
try {
|
|
// cerca un IdApp Libero
|
|
let idapp = await Site.generateNewSite_IdApp(idappPass, body, true);
|
|
|
|
|
|
if (idapp) {
|
|
let arrSite = await Site.find({ idapp }).lean();
|
|
let numutenti = 0;
|
|
if (idapp) {
|
|
numutenti = await User.countDocuments({ idapp });
|
|
};
|
|
|
|
if (arrSite && arrSite.length === 1 && numutenti < 2) {
|
|
const MyTelegramBot = require('../telegram/telegrambot');
|
|
|
|
// Nessun Sito Installato e Nessun Utente installato !
|
|
let myuser = new User();
|
|
myuser._id = new ObjectID();
|
|
myuser.idapp = idapp;
|
|
myuser.email = body.email;
|
|
myuser.username = body.username;
|
|
myuser.password = body.password;
|
|
myuser.name = body.username;
|
|
myuser.index = 1;
|
|
myuser.surname = '';
|
|
myuser.lang = 'it';
|
|
myuser.verified_email = true;
|
|
myuser.verified_by_aportador = true;
|
|
myuser.perm = '3';
|
|
myuser.profile.special_req = true;
|
|
myuser.profile.nationality = 'IT';
|
|
myuser.profile.manage_telegram = true;
|
|
myuser.profile.admin_telegram = true;
|
|
myuser.profile.teleg_id = MyTelegramBot.ADMIN_IDTELEGRAM_SERVER;
|
|
myuser.profile.username_telegram = MyTelegramBot.ADMIN_USERNAME_TELEGRAM;
|
|
myuser.lasttimeonline = new Date();
|
|
myuser.date_reg = new Date();
|
|
|
|
await myuser.save();
|
|
|
|
const { MyBot } = require('../models/bot');
|
|
|
|
// Genera il Menu del BOT:
|
|
await MyBot.generateBotMenuRecords(idapp);
|
|
|
|
return { code: server_constants.RIS_CODE_OK, idapp };
|
|
}
|
|
}
|
|
|
|
return { code: server_constants.RIS_CODE_ERR, idapp: -1 };
|
|
} catch (e) {
|
|
console.error('Error in addNewSite:', e.message);
|
|
}
|
|
|
|
};
|
|
|
|
UserSchema.statics.renameCircuitName = async function (idapp, oldcircuitname, newcircuitname) {
|
|
const User = this;
|
|
|
|
return await User.updateMany({ idapp, 'profile.mycircuits.circuitname': oldcircuitname }, { $set: { 'profile.mycircuits.$.circuitname': newcircuitname } });
|
|
};
|
|
|
|
UserSchema.statics.createNewSubRecord = async function (idapp, req) {
|
|
const User = this;
|
|
|
|
// console.log("GENERA TOKEN : ");
|
|
let userId = req.body.data.userId;
|
|
let fieldkey = req.body.data.field;
|
|
let data = req.body.data.data;
|
|
|
|
const filtro = { _id: userId };
|
|
|
|
let fieldsvalue = { ...data };
|
|
|
|
fieldsvalue.date_created = new Date();
|
|
fieldsvalue.date_updated = new Date();
|
|
|
|
var set = {
|
|
profile: {},
|
|
};
|
|
set.profile[fieldkey] = fieldsvalue;
|
|
|
|
const rec = await User.findOneAndUpdate(filtro, { $set: set }, { new: false });
|
|
|
|
return rec;
|
|
};
|
|
|
|
|
|
const User = mongoose.model('User', UserSchema);
|
|
|
|
User.createIndexes((err) => {
|
|
if (err) throw err;
|
|
});
|
|
|
|
class Hero {
|
|
constructor(name, level) {
|
|
this.name = name;
|
|
this.level = level;
|
|
}
|
|
|
|
// Adding a method to the constructor
|
|
greet() {
|
|
return `${this.name} says hello.`;
|
|
}
|
|
}
|
|
|
|
const FuncUsers = {
|
|
createRegistration_withTelegram(userdata) {
|
|
|
|
const telegrambot = require('../telegram/telegrambot');
|
|
|
|
try {
|
|
// Cerca se esiste già
|
|
const user = new User(userdata);
|
|
|
|
user.verified_email = false;
|
|
user.lasttimeonline = new Date();
|
|
user.date_reg = new Date();
|
|
|
|
return user.save().then(async () => {
|
|
return User.findByUsername(user.idapp, user.username, false).
|
|
then(async (usertrovato) => {
|
|
|
|
const numutenti = await User.getNumUsers(user.idapp);
|
|
|
|
let msg = '++ Nuovo Entrato: [' + numutenti + '] ' + user.username + ' ' + user.name + ' ' + user.surname;
|
|
|
|
await telegrambot.sendMsgTelegramToTheManagers(user.idapp, msg);
|
|
|
|
return telegrambot.askConfirmationUser(user.idapp, shared_consts.CallFunz.REGISTRATION, user, '', '', '', '');
|
|
});
|
|
}).catch((e) => {
|
|
console.error(e.message);
|
|
});
|
|
|
|
} catch (e) {
|
|
console.error(e.message);
|
|
}
|
|
|
|
}
|
|
};
|
|
|
|
|
|
module.exports = {
|
|
User, Hero, FuncUsers
|
|
};
|
|
|
|
|