4051 lines
104 KiB
JavaScript
Executable File
4051 lines
104 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 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 {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'
|
|
}*/
|
|
},
|
|
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: 6,
|
|
unique: false,
|
|
},
|
|
name: {
|
|
type: String,
|
|
trim: true,
|
|
},
|
|
surname: {
|
|
type: String,
|
|
trim: true,
|
|
},
|
|
password: {
|
|
type: String,
|
|
require: true,
|
|
minlength: 6,
|
|
},
|
|
lang: {
|
|
type: String,
|
|
require: true,
|
|
},
|
|
linkreg: {
|
|
type: String,
|
|
required: false,
|
|
},
|
|
verified_email: {
|
|
type: Boolean,
|
|
},
|
|
made_gift: {
|
|
type: Boolean,
|
|
},
|
|
tokens: [
|
|
{
|
|
access: {
|
|
type: String,
|
|
required: true,
|
|
},
|
|
browser: {
|
|
type: String,
|
|
required: true,
|
|
},
|
|
token: {
|
|
type: String,
|
|
required: true,
|
|
},
|
|
date_login: {
|
|
type: Date,
|
|
},
|
|
}],
|
|
perm: {
|
|
type: Number,
|
|
},
|
|
ipaddr: {
|
|
type: String,
|
|
},
|
|
date_reg: {
|
|
type: Date,
|
|
},
|
|
date_deleted: {
|
|
type: Date,
|
|
},
|
|
date_tokenforgot: {
|
|
type: Date,
|
|
},
|
|
tokenforgot: {
|
|
type: String,
|
|
},
|
|
date_tokenreg: {
|
|
type: Date,
|
|
},
|
|
tokenreg: {
|
|
type: String,
|
|
},
|
|
lasttimeonline: {
|
|
type: Date,
|
|
},
|
|
useragent: {
|
|
type: String,
|
|
},
|
|
news_on: {
|
|
type: Boolean,
|
|
},
|
|
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,
|
|
},
|
|
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
|
|
mygroups: [
|
|
{
|
|
_id: false,
|
|
groupname: {type: String},
|
|
date: {type: Date},
|
|
}], // username
|
|
|
|
mycircuits: [
|
|
{
|
|
_id: false,
|
|
circuitname: {type: String},
|
|
date: {type: Date},
|
|
}], // username
|
|
|
|
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,
|
|
}],
|
|
},
|
|
})
|
|
;
|
|
|
|
UserSchema.methods.toJSON = function() {
|
|
const user = this;
|
|
const userObject = user.toObject();
|
|
|
|
return _.pick(userObject, ['_id', ...shared_consts.fieldsUserToChange()]);
|
|
};
|
|
|
|
UserSchema.methods.generateAuthToken = function(req) {
|
|
// console.log("GENERA TOKEN : ");
|
|
const user = this;
|
|
|
|
const useragent = req.get('User-Agent');
|
|
// tools.mylog("GENERATE USER-AGENT = ", useragent);
|
|
|
|
const access = 'auth';
|
|
const browser = useragent;
|
|
const token = jwt.sign({_id: user._id.toHexString(), access},
|
|
process.env.SIGNCODE).toString();
|
|
const date_login = new Date();
|
|
|
|
// CANCELLA IL PRECEDENTE !
|
|
user.tokens = user.tokens.filter(function(tok) {
|
|
return (tok.access !== access) ||
|
|
((tok.access === access) && (tok.browser !== browser));
|
|
});
|
|
user.tokens.push({access, browser, token, date_login});
|
|
|
|
user.lasttimeonline = new Date();
|
|
|
|
return user.save().then(() => {
|
|
// console.log("TOKEN CREATO IN LOGIN : " + token);
|
|
return token;
|
|
}).catch(err => {
|
|
console.log('Error', err.message);
|
|
});
|
|
};
|
|
|
|
UserSchema.statics.setPermissionsById = function(id, perm) {
|
|
const user = this;
|
|
|
|
return user.findByIdAndUpdate(id, {$set: {perm}}).then((user) => {
|
|
if (user)
|
|
return res.send({code: server_constants.RIS_CODE_OK, msg: ''});
|
|
else
|
|
return res.send({code: server_constants.RIS_CODE_ERR, msg: ''});
|
|
});
|
|
|
|
};
|
|
|
|
UserSchema.statics.setZoomPresenza = async function(idapp, id, presenza) {
|
|
const User = this;
|
|
|
|
const telegrambot = require('../telegram/telegrambot');
|
|
|
|
let allData = {};
|
|
allData.myuser = await User.getUserById(idapp, id);
|
|
if (!!allData.myuser)
|
|
allData.precDataUser = await User.getInfoUser(idapp,
|
|
allData.myuser.username);
|
|
|
|
return await User.findByIdAndUpdate(id,
|
|
{$set: {'profile.saw_zoom_presentation': presenza}}).then((rec) => {
|
|
if (presenza) {
|
|
const messaggio = tools.get__('ZOOM_CONFERMATO');
|
|
telegrambot.sendMsgTelegram(rec.idapp, rec.username, messaggio);
|
|
telegrambot.sendMsgTelegramToTheManagersAndZoomeri(idapp,
|
|
`L\'utente ${rec.name} ${rec.surname} (${rec.username}) è stato confermato per aver visto lo Zoom di Benvenuto`);
|
|
} else {
|
|
telegrambot.sendMsgTelegramToTheManagersAndZoomeri(idapp,
|
|
`L\'utente ${rec.name} ${rec.surname} (${rec.username}) è stato annullata la sua richiesta per aver visto lo Zoom di Benvenuto! (Non ci risulta)`);
|
|
}
|
|
|
|
return User.findByIdAndUpdate(id,
|
|
{$set: {'profile.ask_zoom_partecipato': false}}).then((user) => {
|
|
|
|
User.checkIfSbloccatiRequisiti(idapp, allData, id);
|
|
});
|
|
});
|
|
|
|
};
|
|
|
|
UserSchema.statics.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.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 = function(token, typeaccess) {
|
|
const User = this;
|
|
let decoded;
|
|
|
|
try {
|
|
decoded = jwt.verify(token, process.env.SIGNCODE);
|
|
} catch (e) {
|
|
return Promise.resolve(null);
|
|
}
|
|
|
|
return User.findOne({
|
|
'_id': decoded._id,
|
|
'tokens.token': token,
|
|
'tokens.access': typeaccess,
|
|
});
|
|
};
|
|
|
|
UserSchema.statics.findByTokenAnyAccess = function(token) {
|
|
const User = this;
|
|
let decoded;
|
|
|
|
try {
|
|
decoded = jwt.verify(token, process.env.SIGNCODE);
|
|
} catch (e) {
|
|
return Promise.resolve(null);
|
|
}
|
|
|
|
return User.findOne({
|
|
'_id': decoded._id,
|
|
'tokens.token': token,
|
|
});
|
|
};
|
|
|
|
UserSchema.statics.findByCredentials = function(idapp, username, password, 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;
|
|
});
|
|
};
|
|
|
|
UserSchema.statics.getProjectUser = function() {
|
|
return {
|
|
idapp: 1,
|
|
lang: 1,
|
|
index: 1,
|
|
ind_order: 1,
|
|
username: 1,
|
|
aportador_solidario: 1,
|
|
name: 1,
|
|
surname: 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.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.count({
|
|
idapp,
|
|
$and: [
|
|
{
|
|
$or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
|
|
'profile.paymenttypes': { "$in": ['paypal'] },
|
|
},
|
|
{
|
|
$or: [
|
|
{ 'profile.email_paypal': { $exists: true } },
|
|
{ 'profile.revolut': { $exists: true } },
|
|
]
|
|
}
|
|
]
|
|
});
|
|
};
|
|
*/
|
|
|
|
UserSchema.statics.getUsersNationalityQuery = function(idapp) {
|
|
const query = [
|
|
{
|
|
$match: {
|
|
idapp,
|
|
$or: [
|
|
{deleted: {$exists: false}},
|
|
{deleted: {$exists: true, $eq: false}}],
|
|
},
|
|
},
|
|
{
|
|
$group: {_id: '$profile.nationality', count: {$sum: 1}},
|
|
},
|
|
{
|
|
$sort: {count: -1},
|
|
},
|
|
];
|
|
return query;
|
|
};
|
|
|
|
UserSchema.statics.getindOrderDuplicate = function(idapp) {
|
|
const User = this;
|
|
|
|
return User.aggregate(User.getUsersNationalityQuery(idapp)).then(ris => {
|
|
// console.table(ris);
|
|
return 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.createNewRequestPwd = function(idapp, email) {
|
|
const User = this;
|
|
|
|
const sendemail = require('../sendemail');
|
|
|
|
return User.findByEmail(idapp, email).then(async (user) => {
|
|
if (!user) {
|
|
return false;
|
|
} else {
|
|
// Creo il tokenforgot
|
|
user.tokenforgot = jwt.sign(user._id.toHexString(), process.env.SIGNCODE).
|
|
toString();
|
|
user.date_tokenforgot = new Date();
|
|
user.lasttimeonline = new Date();
|
|
return await user.save().then(async () => {
|
|
await sendemail.sendEmail_RequestNewPassword(user.lang, user, user.email, user.idapp, user.tokenforgot);
|
|
|
|
return 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) {
|
|
// Creo il tokenforgot
|
|
user.tokenforgot = jwt.sign(user._id.toHexString(), process.env.SIGNCODE).
|
|
toString();
|
|
user.date_tokenforgot = new Date();
|
|
user.lasttimeonline = new Date();
|
|
|
|
return await user.save().then(() => {
|
|
return tools.getlinkRequestNewPassword(idapp, user.email, user.tokenforgot);
|
|
});
|
|
}
|
|
|
|
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 (!user.date_tokenreg || (!user.tokenreg) || (user.tokenreg && (user.date_tokenreg < new Date().getTime()))) {
|
|
// Se è scaduto, ne crea uno nuovo
|
|
// Creo il tokenforgot
|
|
user.tokenreg = jwt.sign(user._id.toHexString(), process.env.SIGNCODE).
|
|
toString();
|
|
|
|
if (user.tokenreg){
|
|
try {
|
|
user.tokenreg = user.tokenreg.replaceAll('.', '');
|
|
user.tokenreg = user.tokenreg.replaceAll('/', '');
|
|
user.tokenreg = user.tokenreg.substring(1,8);
|
|
}catch (e) {
|
|
console.error('err', e);
|
|
}
|
|
}
|
|
|
|
user.date_tokenreg = tools.AddDate(new Date(), 2);
|
|
|
|
return await user.save().then(() => {
|
|
return user.tokenreg;
|
|
});
|
|
|
|
} else {
|
|
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},
|
|
},
|
|
});
|
|
};
|
|
|
|
UserSchema.statics.getEmailByUsername = async function(idapp, username) {
|
|
const User = this;
|
|
|
|
return await User.findOne({
|
|
idapp, username,
|
|
$or: [{deleted: {$exists: false}}, {deleted: {$exists: true, $eq: false}}],
|
|
}).then((arrrec) => {
|
|
return ((arrrec) ? arrrec.email : '');
|
|
}).catch((e) => {
|
|
console.error('getEmailByUsername', e);
|
|
});
|
|
};
|
|
|
|
UserSchema.statics.getUsernameById = async function(idapp, id) {
|
|
const User = this;
|
|
|
|
return await User.findOne({
|
|
idapp, _id: id,
|
|
$or: [{deleted: {$exists: false}}, {deleted: {$exists: true, $eq: false}}],
|
|
}, {username: 1}).then((myuser) => {
|
|
return ((myuser) ? myuser.username : '');
|
|
}).catch((e) => {
|
|
|
|
});
|
|
};
|
|
|
|
UserSchema.statics.getUserById = function(idapp, id) {
|
|
const User = this;
|
|
|
|
return User.findOne({
|
|
idapp, _id: id,
|
|
$or: [{deleted: {$exists: false}}, {deleted: {$exists: true, $eq: false}}],
|
|
});
|
|
};
|
|
|
|
UserSchema.statics.getUserByUsername = function(idapp, username) {
|
|
const User = this;
|
|
|
|
return User.findOne({
|
|
idapp,
|
|
username,
|
|
$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.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,
|
|
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,
|
|
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,
|
|
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,
|
|
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,
|
|
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,
|
|
'mycities': 1,
|
|
'comune': 1,
|
|
email: 1,
|
|
date_reg: 1,
|
|
'useraport.username': 1,
|
|
'useraport.profile.img': 1,
|
|
};
|
|
}
|
|
|
|
const myfind = {
|
|
idapp, username,
|
|
$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)
|
|
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.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 il Gruppo
|
|
UserSchema.statics.removeFromMyGroups = async function(
|
|
idapp, username, groupnameDest) {
|
|
return await User.updateOne({idapp, username},
|
|
{$pull: {'profile.mygroups': {groupname: {$in: [groupnameDest]}}}});
|
|
};
|
|
// Rimuovo il Gruppo
|
|
UserSchema.statics.removeFromCircuits = async function(idapp, username, circuitname) {
|
|
return await User.updateOne({idapp, username},
|
|
{$pull: {'profile.mycircuits': {circuitname: {$in: [circuitname]}}}});
|
|
|
|
};
|
|
|
|
// 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]}}}});
|
|
};
|
|
|
|
UserSchema.statics.setFriendsCmd = async function(req, idapp, usernameOrig, usernameDest, cmd, value) {
|
|
|
|
const {SendNotif} = require('../models/sendnotif');
|
|
|
|
const telegrambot = require('../telegram/telegrambot');
|
|
|
|
if (!req) {
|
|
req = tools.getReqByPar(idapp, usernameOrig);
|
|
}
|
|
|
|
const username_action = req.user.username;
|
|
let username_worked = usernameDest;
|
|
|
|
let ris = null;
|
|
let update = {};
|
|
try {
|
|
if (cmd === shared_consts.FRIENDSCMD.SETTRUST) {
|
|
|
|
// Aggiungi alle amicizie
|
|
await this.setFriendsCmd(req, idapp, usernameOrig, usernameDest,
|
|
shared_consts.FRIENDSCMD.SETFRIEND, value);
|
|
|
|
return await User.updateOne({idapp, username: usernameDest},
|
|
{$set: {verified_by_aportador: value, trust_modified: new Date()}},
|
|
{new: false});
|
|
|
|
} 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);
|
|
|
|
// 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);
|
|
|
|
// Send a notification to the SENDER FRIENDSHIP !
|
|
req = tools.getReqByPar(idapp, usernameOrig);
|
|
await SendNotif.createNewNotifToSingleUser(req, null, {usernameOrig}, true, shared_consts.TypeNotifs.TYPEDIR_FRIENDS,
|
|
shared_consts.TypeNotifs.ID_FRIENDS_ACCEPTED_MY_REQUEST);
|
|
|
|
update = {$pull: {'profile.req_friends': {username: {$in: [usernameDest]}}}};
|
|
ris = await User.updateOne({idapp, username: usernameOrig}, update);
|
|
|
|
if (ris) {
|
|
try {
|
|
const userDest = await User.getRecLangAndIdByUsername(idapp, usernameDest);
|
|
const user = await User.getRecLangAndIdByUsername(idapp, usernameOrig);
|
|
const msgOrig = i18n.__({phrase: '✅ %s accepted your Friendship request !', locale: user.lang}, usernameDest);
|
|
const msgDest = i18n.__({phrase: '✅ You have accepted %s\' Friendship request!', locale: userDest.lang}, usernameOrig);
|
|
|
|
await telegrambot.sendMsgTelegram(idapp, usernameDest, msgDest);
|
|
await telegrambot.sendMsgTelegram(idapp, usernameOrig, 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.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);
|
|
}
|
|
} else {
|
|
if (foundIfAlreadyAskFriend) {
|
|
ris = await this.removeReqFriend(idapp, usernameDest, usernameOrig); // Rimuovo l'Amicizia da me
|
|
}
|
|
}
|
|
|
|
// if (ris) {
|
|
ris = await User.getInfoAskFriendByUsername(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.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);
|
|
|
|
await this.removeReqFriend(idapp, usernameDest, usernameOrig); // Rimuovo la Richiesta di Amicizia da lui
|
|
ris = await this.removeFriend(idapp, usernameOrig, usernameDest); // Rimuovo l'Amicizia da me
|
|
|
|
} 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.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();
|
|
};
|
|
|
|
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.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 = {};
|
|
try {
|
|
if (cmd === shared_consts.CIRCUITCMD.SET) {
|
|
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 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);
|
|
|
|
|
|
} 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.REQ) {
|
|
// Aggiungo la richiesta di Gruppo a me
|
|
const foundIfAlreadyAskCircuit = await Circuit.findOne({
|
|
idapp,
|
|
name: circuitname,
|
|
'req_users': {
|
|
$elemMatch: {username: {$eq: usernameOrig}},
|
|
},
|
|
});
|
|
|
|
if (value) {
|
|
if (!foundIfAlreadyAskCircuit) {
|
|
update = {
|
|
$push: {
|
|
'req_users': {
|
|
username: usernameOrig,
|
|
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 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) {
|
|
|
|
// 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) {
|
|
|
|
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) {
|
|
|
|
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);
|
|
}
|
|
|
|
outres.recnotif = await SendNotif.getRecNotif(extrarec.notifId);
|
|
|
|
} else {
|
|
outres.cansend = false;
|
|
|
|
outres.errormsg = i18n.__('CIRCUIT_COINS_ALREADY_PROCESSED', risStatus);
|
|
}
|
|
ris = true;
|
|
}
|
|
|
|
if (ris && username_action) {
|
|
|
|
//++Todo: Ottimizzare ! Non occorre inviare tutti questi dati !!! Solo per il Circuito ?!
|
|
const userprofile = await User.getExtraInfoByUsername(idapp, username_action);
|
|
if (userprofile) {
|
|
outres.userprofile = userprofile;
|
|
}
|
|
outres.listcircuits = await Circuit.findAllIdApp(idapp);
|
|
}
|
|
|
|
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,
|
|
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,
|
|
email: 1,
|
|
date_reg: 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,
|
|
date_reg: 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,
|
|
reported: 1,
|
|
date_report: 1,
|
|
username_who_report: 1,
|
|
date_reg: 1,
|
|
groups: 1,
|
|
friends: 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.getFriendsByUsername = async function(idapp, username) {
|
|
|
|
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);
|
|
|
|
let listFriends = await User.find({
|
|
idapp,
|
|
username: {$in: arrUsernameFriends},
|
|
$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,
|
|
listRequestFriends,
|
|
listTrusted,
|
|
listSentRequestFriends,
|
|
};
|
|
|
|
} catch (e) {
|
|
console.log('Error', e);
|
|
}
|
|
|
|
return {
|
|
listFriends: [],
|
|
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((rec) => {
|
|
return (!!rec) ? rec : null;
|
|
}).catch((e) => {
|
|
console.error('UserExistByIdTelegram', e);
|
|
});
|
|
};
|
|
|
|
UserSchema.statics.UsersByIdTelegram = async function(idapp, teleg_id) {
|
|
const User = this;
|
|
|
|
return await User.find({
|
|
idapp, 'profile.teleg_id': teleg_id,
|
|
$or: [{deleted: {$exists: false}}, {deleted: {$exists: true, $eq: false}}],
|
|
}).lean().then((rec) => {
|
|
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()) {
|
|
|
|
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;
|
|
|
|
return await User.find({idapp, 'profile.manage_telegram': true},
|
|
{username: 1, 'profile.teleg_id': 1, perm: 1}).then((arrrec) => {
|
|
return (!!arrrec) ? arrrec : null;
|
|
}).catch((e) => {
|
|
console.error('getusersManagers', e);
|
|
});
|
|
};
|
|
|
|
UserSchema.statics.getusersRespList = async function(idapp) {
|
|
const User = this;
|
|
|
|
return await User.find({idapp, 'profile.resplist': true},
|
|
{_id: 1, username: 1, name: 1, surname: 1}).then((arrrec) => {
|
|
return (!!arrrec) ? arrrec : null;
|
|
}).catch((e) => {
|
|
console.error('getusersRespList', e);
|
|
});
|
|
};
|
|
|
|
UserSchema.statics.getusersWorkersList = async function(idapp) {
|
|
const User = this;
|
|
|
|
return await User.find({idapp, 'profile.workerslist': true},
|
|
{_id: 1, username: 1, name: 1, surname: 1}).then((arrrec) => {
|
|
return (!!arrrec) ? arrrec : null;
|
|
}).catch((e) => {
|
|
console.error('getusersWorkersList', e);
|
|
});
|
|
};
|
|
|
|
UserSchema.statics.getusersManagersAndZoomeri = async function(idapp) {
|
|
const User = this;
|
|
|
|
return await User.find(
|
|
{
|
|
idapp,
|
|
or: [
|
|
{'profile.manage_telegram': true},
|
|
{
|
|
perm:
|
|
{
|
|
$bit:
|
|
|
|
Number(shared_consts.Permissions.Zoomeri),
|
|
|
|
},
|
|
},
|
|
],
|
|
},
|
|
{'profile.teleg_id': 1}).then((arrrec) => {
|
|
return (!!arrrec) ? arrrec : null;
|
|
}).catch((e) => {
|
|
console.error('getusersManagers', e);
|
|
});
|
|
};
|
|
|
|
UserSchema.statics.getUsersTelegALL = async function(idapp, username) {
|
|
const User = this;
|
|
|
|
if (!!username) {
|
|
return await User.find({idapp, username, 'profile.teleg_id': {$gt: 0}}).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('getusersManagers', e);
|
|
return false;
|
|
});
|
|
};
|
|
|
|
UserSchema.statics.isAdminByIdTeleg = async function(idapp, idtelegram) {
|
|
const User = this;
|
|
|
|
return await User.findOne({
|
|
idapp,
|
|
username: 'paoloar77',
|
|
'profile.manage_telegram': true,
|
|
'profile.teleg_id': idtelegram,
|
|
}, {'profile.teleg_id': 1}).then((rec) => {
|
|
return (!!rec && rec.profile.teleg_id === idtelegram);
|
|
}).catch((e) => {
|
|
console.error('getusersManagers', e);
|
|
return false;
|
|
});
|
|
};
|
|
|
|
UserSchema.statics.getUsersList = function(idapp) {
|
|
const User = this;
|
|
|
|
return User.find({
|
|
'idapp': idapp,
|
|
$or: [{deleted: {$exists: false}}, {deleted: {$exists: true, $eq: false}}],
|
|
},
|
|
{
|
|
username: 1,
|
|
name: 1,
|
|
surname: 1,
|
|
verified_email: 1,
|
|
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}];
|
|
};
|
|
|
|
UserSchema.statics.getFieldsForSearchUserFriend_AllWords = function() {
|
|
return [{field: 'username', 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.count(myfind);
|
|
};
|
|
|
|
UserSchema.statics.getUsersOnLineToday = async function(idapp) {
|
|
const User = this;
|
|
|
|
let starttoday = new Date();
|
|
starttoday.setHours(6, 0, 0, 0);
|
|
|
|
const myfind = {
|
|
idapp,
|
|
$or: [{deleted: {$exists: false}}, {deleted: {$exists: true, $eq: false}}],
|
|
lasttimeonline: {$gt: starttoday},
|
|
};
|
|
|
|
return await User.count(myfind);
|
|
};
|
|
|
|
/*
|
|
UserSchema.statics.getUsersQualified = async function (idapp, numinvitati) {
|
|
const User = this;
|
|
|
|
const arrusers = await User.find({
|
|
idapp,
|
|
$and: [
|
|
{ $or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }] },
|
|
{
|
|
$or: [
|
|
{
|
|
'profile.special_req': true
|
|
},
|
|
{
|
|
verified_email: true,
|
|
'profile.teleg_id': { $gt: 0 },
|
|
'profile.paymenttypes': { "$in": ['paypal'] },
|
|
'profile.saw_and_accepted': shared_consts.ALL_SAW_AND_ACCEPTED,
|
|
'profile.saw_zoom_presentation': true,
|
|
'profile.my_dream': { $exists: true },
|
|
$and: [
|
|
{ "$expr": { "$gt": [{ "$strLenCP": "$profile.my_dream" }, 10] } },
|
|
{ "$expr": { "$gt": [{ "$strLenCP": "$profile.email_paypal" }, 6] } }
|
|
],
|
|
}]
|
|
}]
|
|
|
|
}, {
|
|
'username': 1,
|
|
});
|
|
|
|
|
|
if (numinvitati === 0)
|
|
return arrusers; // PRENDI TUTTI
|
|
|
|
let arrris = [];
|
|
|
|
for (const rec of arrusers) {
|
|
rec.numinvitatiattivi = await ListaIngresso.getnumInvitatiAttivi(idapp, rec.username);
|
|
if (rec.numinvitatiattivi >= numinvitati) {
|
|
arrris.push(rec);
|
|
}
|
|
}
|
|
|
|
return arrris
|
|
|
|
};
|
|
*/
|
|
|
|
// UserSchema.statics.getNumUsersQualified = async function (idapp, numinvitati) {
|
|
//
|
|
// arrrec = await this.getUsersQualified(idapp, numinvitati);
|
|
//
|
|
// return arrrec.length
|
|
//
|
|
// };
|
|
|
|
UserSchema.statics.getEmailNotVerified = async function(idapp) {
|
|
const User = this;
|
|
|
|
const myfind = {
|
|
idapp,
|
|
$or: [{deleted: {$exists: false}}, {deleted: {$exists: true, $eq: false}}],
|
|
verified_email: false,
|
|
};
|
|
|
|
return await User.count(myfind);
|
|
};
|
|
|
|
UserSchema.statics.getUsersTelegramAttivo = async function(idapp) {
|
|
const User = this;
|
|
|
|
const myfind = {
|
|
idapp,
|
|
$or: [{deleted: {$exists: false}}, {deleted: {$exists: true, $eq: false}}],
|
|
'profile.teleg_id': {$gt: 0},
|
|
};
|
|
|
|
return await User.count(myfind);
|
|
};
|
|
|
|
UserSchema.statics.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.count(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.count(myfind);
|
|
};
|
|
|
|
UserSchema.statics.getUsersTelegramPending = async function(idapp) {
|
|
const User = this;
|
|
|
|
const myfind = {
|
|
idapp,
|
|
$or: [{deleted: {$exists: false}}, {deleted: {$exists: true, $eq: false}}],
|
|
'profile.teleg_checkcode': {$gt: 0},
|
|
};
|
|
|
|
return await User.count(myfind);
|
|
};
|
|
|
|
UserSchema.statics.getNumUsers = async function(idapp) {
|
|
const User = this;
|
|
|
|
const myfind = {
|
|
idapp,
|
|
$or: [{deleted: {$exists: false}}, {deleted: {$exists: true, $eq: false}}],
|
|
};
|
|
|
|
return await User.count(myfind);
|
|
};
|
|
|
|
UserSchema.statics.getUsersZoom = async function(idapp) {
|
|
const User = this;
|
|
|
|
const myfind = {
|
|
idapp,
|
|
$or: [{deleted: {$exists: false}}, {deleted: {$exists: true, $eq: false}}],
|
|
'profile.saw_zoom_presentation': true,
|
|
};
|
|
|
|
return await User.count(myfind);
|
|
};
|
|
|
|
UserSchema.statics.getUsersResidenti = async function(idapp) {
|
|
const User = this;
|
|
|
|
const myfind = {
|
|
idapp,
|
|
$or: [{deleted: {$exists: false}}, {deleted: {$exists: true, $eq: false}}],
|
|
'profile.socioresidente': {$exists: true, $eq: true},
|
|
};
|
|
|
|
return await User.find(myfind, {username: 1, name: 1, surname: 1});
|
|
};
|
|
|
|
UserSchema.statics.getSaw_and_Accepted = async function(idapp) {
|
|
const User = this;
|
|
|
|
const myfind = {
|
|
idapp,
|
|
$or: [{deleted: {$exists: false}}, {deleted: {$exists: true, $eq: false}}],
|
|
'profile.saw_and_accepted': shared_consts.ALL_SAW_AND_ACCEPTED,
|
|
};
|
|
|
|
return await User.count(myfind);
|
|
};
|
|
|
|
UserSchema.statics.getUsersDreams = async function(idapp) {
|
|
const User = this;
|
|
|
|
const myfind = {
|
|
idapp,
|
|
$or: [{deleted: {$exists: false}}, {deleted: {$exists: true, $eq: false}}],
|
|
'profile.my_dream': {$exists: true},
|
|
'$expr': {'$gt': [{'$strLenCP': '$profile.my_dream'}, 10]},
|
|
};
|
|
|
|
return await User.count(myfind);
|
|
};
|
|
|
|
UserSchema.statics.getLastUsers = async function(idapp) {
|
|
const User = this;
|
|
|
|
const lastn = await Settings.getValDbSettings(idapp, 'SHOW_LAST_N_USERS', 5);
|
|
|
|
return await User.find(
|
|
{
|
|
idapp,
|
|
$or: [
|
|
{deleted: {$exists: false}},
|
|
{deleted: {$exists: true, $eq: false}}],
|
|
},
|
|
{
|
|
username: 1,
|
|
name: 1,
|
|
surname: 1,
|
|
date_reg: 1,
|
|
index: 1,
|
|
'profile.nationality': 1,
|
|
}).sort({date_reg: -1}).limit(lastn).then((arr) => {
|
|
//return JSON.stringify(arr)
|
|
return arr;
|
|
});
|
|
|
|
};
|
|
|
|
UserSchema.statics.checkUser = async function(idapp, username) {
|
|
const User = this;
|
|
|
|
return await User.findOne({idapp, username}, {
|
|
verified_email: 1,
|
|
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 numUsersReg = await User.countDocuments(
|
|
{
|
|
idapp,
|
|
$or: [
|
|
{deleted: {$exists: false}},
|
|
{deleted: {$exists: true, $eq: false}}],
|
|
});
|
|
|
|
let numByTab = {};
|
|
|
|
const globalTables = require('../tools/globalTables');
|
|
|
|
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.getUsersRegWeekly = function(idapp, nrec) {
|
|
|
|
const query = [
|
|
{
|
|
$match: {
|
|
idapp,
|
|
date_reg: {$gte: tools.IncDateNow(-(1000 * 60 * 60 * 24 * nrec))},
|
|
$or: [
|
|
{deleted: {$exists: false}},
|
|
{deleted: {$exists: true, $eq: false}}],
|
|
},
|
|
},
|
|
{
|
|
$group: {
|
|
_id: {
|
|
$dateToString: {
|
|
format: '%Y-%U',
|
|
date: '$date_reg',
|
|
timezone: 'Europe/Rome',
|
|
},
|
|
},
|
|
count: {$sum: 1},
|
|
},
|
|
},
|
|
{
|
|
$sort: {_id: 1},
|
|
},
|
|
];
|
|
return query;
|
|
};
|
|
|
|
UserSchema.statics.getnumRegNDays = function(idapp, nrec) {
|
|
|
|
const query = [
|
|
{
|
|
$match: {
|
|
idapp,
|
|
date_reg: {$lt: tools.IncDateNow(-(1000 * 60 * 60 * 24 * nrec))},
|
|
$or: [
|
|
{deleted: {$exists: false}},
|
|
{deleted: {$exists: true, $eq: false}}],
|
|
},
|
|
},
|
|
{
|
|
$group: {
|
|
_id: {
|
|
$dateToString: {
|
|
format: '%Y-%m-%d',
|
|
date: '$date_reg',
|
|
timezone: 'Europe/Rome',
|
|
},
|
|
},
|
|
count: {$sum: 1},
|
|
},
|
|
},
|
|
{
|
|
$sort: {_id: 1},
|
|
},
|
|
];
|
|
return query;
|
|
};
|
|
|
|
UserSchema.statics.calcnumRegUntilDay = async function(idapp) {
|
|
const User = this;
|
|
|
|
return await User.aggregate(User.getnumRegNDays(idapp, 30)).then((arr) => {
|
|
return arr.reduce((sum, rec) => sum + rec.count, 0);
|
|
});
|
|
|
|
};
|
|
|
|
UserSchema.statics.calcRegDaily = async function(idapp) {
|
|
const User = this;
|
|
|
|
return await User.aggregate(User.getUsersRegDaily(idapp, 60)).then(ris => {
|
|
// console.table(ris);
|
|
return ris;
|
|
});
|
|
};
|
|
|
|
UserSchema.statics.calcRegWeekly = async function(idapp) {
|
|
const User = this;
|
|
|
|
return await User.aggregate(User.getUsersRegWeekly(idapp, 20 * 7)).then(ris => {
|
|
// console.table(ris);
|
|
return ris.slice(0, -1);
|
|
});
|
|
};
|
|
|
|
if (tools.INITDB_FIRSTIME) {
|
|
console.log(' createIndex User Index...');
|
|
// UserSchema.index({ username: 'text', name: 'text', surname: 'text', email: 'text' });
|
|
// UserSchema.index({ name: 'name' });
|
|
// UserSchema.index({ name: 1 });
|
|
// UserSchema.index({ surname: 1 });
|
|
}
|
|
|
|
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});
|
|
if (myuser) {
|
|
myuserextra = await User.addExtraInfo(idapp, myuser);
|
|
}
|
|
|
|
return myuser._doc.profile;
|
|
|
|
};
|
|
UserSchema.statics.addExtraInfo = async function(idapp, recUser) {
|
|
|
|
try {
|
|
|
|
try {
|
|
if (recUser._doc.profile && recUser._doc.profile.notifs && recUser._doc.profile.notifs.length <= 0) {
|
|
recUser._doc.profile.notifs = shared_consts.DEFAULT_NOTIFS_USER;
|
|
await recUser.save();
|
|
}
|
|
} catch (e) {
|
|
console.error('Err addExtraInfo notifs ', e);
|
|
}
|
|
|
|
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._doc.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._doc.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._doc.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._doc.profile.manage_mygroups = listManageGroups
|
|
? listManageGroups
|
|
: [];
|
|
|
|
// Circuit>
|
|
|
|
const circuitobj = await Circuit.getCircuitsByUsername(idapp, recUser.username, recUser);
|
|
|
|
const useraccounts = await Account.getUserAccounts(idapp, recUser.username);
|
|
|
|
recUser._doc.profile = {...recUser._doc.profile, ...circuitobj, useraccounts};
|
|
|
|
recUser._doc.calcstat = await User.calculateStat(idapp, recUser.username);
|
|
|
|
return recUser._doc;
|
|
|
|
} catch (e) {
|
|
console.error('Err addExtraInfo', e);
|
|
}
|
|
|
|
return recUser;
|
|
};
|
|
|
|
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);
|
|
|
|
class Hero {
|
|
constructor(name, level) {
|
|
this.name = name;
|
|
this.level = level;
|
|
}
|
|
|
|
// Adding a method to the constructor
|
|
greet() {
|
|
return `${this.name} says hello.`;
|
|
}
|
|
}
|
|
|
|
module.exports = {User, Hero};
|
|
|
|
|