1669 lines
43 KiB
JavaScript
Executable File
1669 lines
43 KiB
JavaScript
Executable File
const mongoose = require('mongoose').set('debug', false);
|
|
const Schema = mongoose.Schema;
|
|
|
|
mongoose.Promise = global.Promise;
|
|
mongoose.level = 'F';
|
|
|
|
const tools = require('../tools/general');
|
|
|
|
const { ObjectID } = require('mongodb');
|
|
|
|
const { Movement } = require('../models/movement');
|
|
const { Account } = require('../models/account');
|
|
|
|
const { Province } = require('../models/province');
|
|
const shared_consts = require('../tools/shared_nodejs');
|
|
|
|
const i18n = require('i18n');
|
|
|
|
// Resolving error Unknown modifier: $pushAll
|
|
mongoose.plugin(schema => {
|
|
schema.options.usePushEach = true;
|
|
});
|
|
|
|
const CircuitSchema = new Schema({
|
|
_id: {
|
|
type: String,
|
|
default: function () {
|
|
return new ObjectID().toString();
|
|
},
|
|
},
|
|
idapp: {
|
|
type: String,
|
|
required: true,
|
|
},
|
|
groupnameId: {
|
|
type: String,
|
|
},
|
|
name: {
|
|
type: String,
|
|
unique: true,
|
|
},
|
|
path: {
|
|
type: String,
|
|
unique: true,
|
|
},
|
|
link_group: {
|
|
type: String,
|
|
},
|
|
subname: {
|
|
type: String,
|
|
},
|
|
idCity: [
|
|
{
|
|
type: Number,
|
|
}],
|
|
strProv:
|
|
{
|
|
type: String,
|
|
},
|
|
card: // Punti cardinali
|
|
{
|
|
type: String,
|
|
},
|
|
pub_to_share: {
|
|
type: Number, // PUB_TO_SHARE_ALL, PUB_TO_SHARE_ONLY_TABLE_FOLLOW
|
|
},
|
|
visibility: [
|
|
{
|
|
type: Number,
|
|
},
|
|
],
|
|
longdescr: {
|
|
type: String,
|
|
},
|
|
regulation: {
|
|
type: String,
|
|
},
|
|
systemUserDescr: {
|
|
type: String,
|
|
},
|
|
systemUserId: {
|
|
type: String,
|
|
},
|
|
totCircolante: {
|
|
type: Number,
|
|
},
|
|
totTransato: {
|
|
type: Number,
|
|
},
|
|
nome_valuta: {
|
|
type: String,
|
|
maxlength: 20,
|
|
},
|
|
symbol: {
|
|
type: String,
|
|
maxlength: 7,
|
|
},
|
|
color: {
|
|
type: String,
|
|
},
|
|
abbrev: {
|
|
type: String,
|
|
maxlength: 7,
|
|
},
|
|
compara_valuta: {
|
|
type: Number,
|
|
default: 1,
|
|
},
|
|
compara_euro: {
|
|
type: Number,
|
|
default: 1,
|
|
},
|
|
valuta_per_euro: {
|
|
type: Number,
|
|
default: 1,
|
|
},
|
|
fido_scoperto_default: {
|
|
type: Number,
|
|
},
|
|
qta_max_default: {
|
|
type: Number,
|
|
},
|
|
fido_scoperto_default_grp: {
|
|
type: Number,
|
|
},
|
|
qta_max_default_grp: {
|
|
type: Number,
|
|
},
|
|
data_costituz: {
|
|
type: Date,
|
|
},
|
|
deperimento: {
|
|
type: Boolean,
|
|
},
|
|
freq_deper: { // H, D, W, M, Y
|
|
type: String,
|
|
},
|
|
minuto_deper: {
|
|
type: Number,
|
|
},
|
|
ora_deper: {
|
|
type: Number,
|
|
},
|
|
giorno_deper: {
|
|
type: Number,
|
|
},
|
|
mese_deper: {
|
|
type: Number,
|
|
},
|
|
ultimo_deper: {
|
|
type: Date,
|
|
},
|
|
durata_deper: {
|
|
type: Number,
|
|
},
|
|
// -------------
|
|
createdBy: {
|
|
type: String,
|
|
},
|
|
date_created: {
|
|
type: Date,
|
|
},
|
|
date_updated: {
|
|
type: Date,
|
|
},
|
|
admins: [
|
|
{
|
|
username: { type: String },
|
|
date: { type: Date },
|
|
},
|
|
],
|
|
photos: [
|
|
{
|
|
imagefile: {
|
|
type: String,
|
|
},
|
|
alt: {
|
|
type: String,
|
|
},
|
|
description: {
|
|
type: String,
|
|
},
|
|
}],
|
|
req_users: [
|
|
{
|
|
_id: false,
|
|
username: { type: String },
|
|
date: { type: Date },
|
|
}], // username
|
|
refused_users: [
|
|
{
|
|
_id: false,
|
|
username: { type: String },
|
|
date: { type: Date },
|
|
}], // username
|
|
req_groups: [
|
|
{
|
|
_id: false,
|
|
groupname: { type: String },
|
|
date: { type: Date },
|
|
}], // username
|
|
refused_groups: [
|
|
{
|
|
_id: false,
|
|
groupname: { type: String },
|
|
date: { type: Date },
|
|
}], // username
|
|
deleted: {
|
|
type: Boolean,
|
|
default: false,
|
|
},
|
|
transactionsEnabled: {
|
|
type: Boolean,
|
|
},
|
|
numMembers: {
|
|
type: Number,
|
|
default: 0,
|
|
},
|
|
showAlways: {
|
|
type: Boolean,
|
|
default: false,
|
|
},
|
|
status: {
|
|
type: Number,
|
|
default: 0,
|
|
},
|
|
ignoreLimits: {
|
|
type: Boolean,
|
|
default: false,
|
|
},
|
|
});
|
|
|
|
CircuitSchema.pre('save', async function (next) {
|
|
if (this.isNew) {
|
|
this._id = new ObjectID().toString();
|
|
|
|
this.date_created = new Date();
|
|
}
|
|
|
|
next();
|
|
});
|
|
|
|
CircuitSchema.statics.findAllIdApp = async function (idapp) {
|
|
const Circuit = this;
|
|
|
|
const myfind = { idapp, deleted: false };
|
|
|
|
const whatToShow = this.getWhatToShow(idapp, '');
|
|
|
|
return await Circuit.find(myfind, whatToShow).sort({ status: -1, numMembers: -1, name: 1 });
|
|
};
|
|
|
|
CircuitSchema.statics.isCircuitAdmin = async function (idrec, username) {
|
|
const Circuit = this;
|
|
|
|
|
|
const mycirc = await Circuit.findOne({ _id: idrec }).lean();
|
|
if (mycirc) {
|
|
return mycirc.admins.some(admin => admin.username === username);
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
CircuitSchema.statics.getFieldsForSearch = function () {
|
|
return [
|
|
{ field: 'name', type: tools.FieldType.string },
|
|
{ field: 'subname', type: tools.FieldType.string },
|
|
{ field: 'path', type: tools.FieldType.string },
|
|
{ field: 'nome_valuta', type: tools.FieldType.string },
|
|
{ field: 'descr', type: tools.FieldType.string },
|
|
];
|
|
};
|
|
|
|
CircuitSchema.statics.executeQueryTable = function (idapp, params, user) {
|
|
params.fieldsearch = this.getFieldsForSearch();
|
|
return tools.executeQueryTable(this, idapp, params, user);
|
|
};
|
|
|
|
CircuitSchema.statics.getWhatToShow = function (idapp, username) {
|
|
// FOR ME, PERMIT ALL
|
|
return {
|
|
_id: 1,
|
|
groupnameId: 1,
|
|
path: 1,
|
|
name: 1,
|
|
subname: 1,
|
|
longdescr: 1,
|
|
regulation: 1,
|
|
numMembers: 1,
|
|
totCircolante: 1,
|
|
totTransato: 1,
|
|
systemUserId: 1,
|
|
createdBy: 1,
|
|
date_created: 1,
|
|
date_updated: 1,
|
|
nome_valuta: 1,
|
|
fido_scoperto_default: 1,
|
|
qta_max_default: 1,
|
|
fido_scoperto_default_grp: 1,
|
|
qta_max_default_grp: 1,
|
|
deperimento: 1,
|
|
showAlways: 1,
|
|
transactionsEnabled: 1,
|
|
status: 1,
|
|
valuta_per_euro: 1,
|
|
symbol: 1,
|
|
idCity: 1,
|
|
strProv: 1,
|
|
card: 1,
|
|
link_group: 1,
|
|
pub_to_share: 1,
|
|
visibility: 1,
|
|
color: 1,
|
|
abbrev: 1,
|
|
data_costituz: 1,
|
|
photos: 1,
|
|
admins: 1,
|
|
req_users: 1,
|
|
refused_users: 1,
|
|
req_groups: 1,
|
|
refused_groups: 1,
|
|
'mycities': 1,
|
|
};
|
|
|
|
};
|
|
|
|
// Aggiungi agli Admin del Circuito
|
|
CircuitSchema.statics.addToAdminOfMyCircuit = async function (idapp, username, name) {
|
|
|
|
return await Circuit.updateOne({ idapp, name },
|
|
{
|
|
$push:
|
|
{
|
|
admins: {
|
|
username,
|
|
date: new Date(),
|
|
},
|
|
},
|
|
});
|
|
|
|
};
|
|
|
|
// Rimuovi dagli Admin del Circuito
|
|
CircuitSchema.statics.removeAdminOfMyCircuit = async function (idapp, username, name) {
|
|
|
|
return await Circuit.updateOne({ idapp, name },
|
|
{ $pull: { admins: { username: { $in: [username] } } } });
|
|
};
|
|
|
|
CircuitSchema.statics.getWhatToShow_Unknown = function (idapp, username) {
|
|
return {
|
|
groupnameId: 1,
|
|
path: 1,
|
|
name: 1,
|
|
subname: 1,
|
|
longdescr: 1,
|
|
regulation: 1,
|
|
numMembers: 1,
|
|
showAlways: 1,
|
|
systemUserId: 1,
|
|
founderUserId: 1,
|
|
nome_valuta: 1,
|
|
totCircolante: 1,
|
|
totTransato: 1,
|
|
fido_scoperto_default: 1,
|
|
fido_scoperto_default_grp: 1,
|
|
qta_max_default_grp: 1,
|
|
qta_max_default: 1,
|
|
valuta_per_euro: 1,
|
|
symbol: 1,
|
|
color: 1,
|
|
idCity: 1,
|
|
strProv: 1,
|
|
card: 1,
|
|
link_group: 1,
|
|
pub_to_share: 1,
|
|
visibility: 1,
|
|
abbrev: 1,
|
|
data_costituz: 1,
|
|
photos: 1,
|
|
admins: 1,
|
|
createdBy: 1,
|
|
date_created: 1,
|
|
date_updated: 1,
|
|
req_users: 1,
|
|
refused_users: 1,
|
|
req_groups: 1,
|
|
refused_groups: 1,
|
|
transactionsEnabled: 1,
|
|
status: 1,
|
|
'mycities': 1,
|
|
};
|
|
};
|
|
|
|
CircuitSchema.statics.getCircuitsByUsername = async function (idapp, username, user) {
|
|
|
|
try {
|
|
const { User } = require('../models/user');
|
|
const { Account } = require('../models/account');
|
|
|
|
const whatToShow = this.getWhatToShow(idapp, username);
|
|
const whatToShow_Unknown = this.getWhatToShow_Unknown(idapp, username);
|
|
// const arrUsernameCircuits = await User.getUsernameCircuitsByUsername(idapp, username);
|
|
// const arrUsernameReqCircuits = await MyCircuit.getUsernameReqCircuitsByCircuitname(idapp, username);
|
|
|
|
const manage_mycircuits = await Circuit.find({
|
|
idapp,
|
|
'admins': {
|
|
$elemMatch: { username: { $eq: username } },
|
|
},
|
|
$or: [
|
|
{ deleted: { $exists: false } },
|
|
{ deleted: { $exists: true, $eq: false } }],
|
|
}).sort({ status: -1, numMembers: -1, name: 1 }).lean();
|
|
|
|
let listcircuits = await Circuit.find({
|
|
idapp,
|
|
$or: [
|
|
{ deleted: { $exists: false } },
|
|
{ deleted: { $exists: true, $eq: false } }],
|
|
}, whatToShow_Unknown).sort({ status: -1, numMembers: -1, name: 1 }).lean();
|
|
|
|
let asked_circuits = await Circuit.find({
|
|
idapp,
|
|
'req_users': {
|
|
$elemMatch: { username: { $eq: username } },
|
|
},
|
|
$or: [
|
|
{ deleted: { $exists: false } },
|
|
{ deleted: { $exists: true, $eq: false } }],
|
|
}, whatToShow_Unknown).sort({ status: -1 }).lean();
|
|
|
|
let refused_circuits = await Circuit.find({
|
|
idapp,
|
|
'refused_users': {
|
|
$elemMatch: { username: { $eq: username } },
|
|
},
|
|
$or: [
|
|
{ deleted: { $exists: false } },
|
|
{ deleted: { $exists: true, $eq: false } }],
|
|
}, whatToShow_Unknown).sort({ status: -1 }).lean();
|
|
|
|
return {
|
|
listcircuits,
|
|
asked_circuits,
|
|
refused_circuits,
|
|
manage_mycircuits,
|
|
mycircuits: user.profile.mycircuits,
|
|
};
|
|
|
|
} catch (e) {
|
|
console.log('Error getCircuitsByUsername', e);
|
|
}
|
|
|
|
return {
|
|
listUsersCircuit: [],
|
|
listRequestUsersCircuit: [],
|
|
listTrusted: [],
|
|
asked_circuits: [],
|
|
refused_circuits: [],
|
|
|
|
};
|
|
};
|
|
|
|
CircuitSchema.statics.getInfoCircuitByName = async function (idapp, name) {
|
|
|
|
const whatToShow = this.getWhatToShow(idapp, '');
|
|
|
|
const myfind = {
|
|
idapp,
|
|
name,
|
|
};
|
|
|
|
try {
|
|
return await Circuit.findOne(myfind, whatToShow).lean();
|
|
|
|
} catch (e) {
|
|
return null;
|
|
}
|
|
|
|
};
|
|
|
|
CircuitSchema.statics.getCircuitByName = async function (idapp, name) {
|
|
|
|
const myfind = {
|
|
idapp,
|
|
name,
|
|
};
|
|
|
|
try {
|
|
return await Circuit.findOne(myfind);
|
|
|
|
} catch (e) {
|
|
return null;
|
|
}
|
|
|
|
};
|
|
|
|
CircuitSchema.statics.getCircuitIdByName = async function (idapp, name) {
|
|
|
|
const myfind = {
|
|
idapp,
|
|
name,
|
|
};
|
|
|
|
try {
|
|
const circuit = await Circuit.findOne(myfind);
|
|
return (!!circuit ? circuit._id : 0);
|
|
|
|
} catch (e) {
|
|
return null;
|
|
}
|
|
|
|
};
|
|
|
|
CircuitSchema.statics.getCircuitByProvinceAndCard = async function (idapp, strProv, card) {
|
|
|
|
let myfind = {};
|
|
|
|
if (card) {
|
|
myfind = {
|
|
idapp,
|
|
strProv,
|
|
card
|
|
};
|
|
} else {
|
|
myfind = {
|
|
idapp,
|
|
strProv,
|
|
};
|
|
}
|
|
|
|
try {
|
|
return await Circuit.findOne(myfind);
|
|
|
|
} catch (e) {
|
|
return null;
|
|
}
|
|
|
|
};
|
|
|
|
CircuitSchema.statics.getCircuitById = async function (circuitId) {
|
|
|
|
const myfind = {
|
|
_id: circuitId,
|
|
};
|
|
|
|
try {
|
|
return await Circuit.findOne(myfind);
|
|
|
|
} catch (e) {
|
|
return null;
|
|
}
|
|
|
|
};
|
|
|
|
CircuitSchema.statics.deleteCircuit = async function (idapp, usernameOrig, name) {
|
|
console.log('Circuito ' + name + ' rimosso da ' + usernameOrig);
|
|
return await Circuit.findOneAndRemove({ idapp, name });
|
|
};
|
|
|
|
|
|
CircuitSchema.statics.getUsersSingleCircuit = async function (idapp, username, circuitname, circuitId) {
|
|
|
|
const { User } = require('../models/user');
|
|
|
|
try {
|
|
let aggr1 = [
|
|
{
|
|
$match: {
|
|
idapp: idapp,
|
|
'profile.mycircuits': {
|
|
$elemMatch: { circuitname: { $eq: circuitname } },
|
|
},
|
|
},
|
|
},
|
|
|
|
/*{
|
|
$lookup: {
|
|
from: 'circuits',
|
|
as: 'circuit',
|
|
let: {circuitname: circuitname, idapp: '$idapp'},
|
|
pipeline: [
|
|
{
|
|
$match:
|
|
{
|
|
$expr:
|
|
{
|
|
$and:
|
|
[
|
|
{$eq: ['$name', '$$circuitname']},
|
|
{$eq: ['$idapp', '$$idapp']},
|
|
|
|
],
|
|
},
|
|
},
|
|
},
|
|
],
|
|
},
|
|
|
|
},
|
|
{$unwind: '$circuit'},
|
|
*/
|
|
{
|
|
$project: {
|
|
username: 1,
|
|
verified_by_aportador: 1,
|
|
name: 1,
|
|
surname: 1,
|
|
profile: 1,
|
|
idapp: 1 /*, 'circuit.name': 1, 'circuit._id': 1*/
|
|
},
|
|
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: 'accounts',
|
|
as: 'account',
|
|
let: { username: '$username', idapp: '$idapp', circuitId: circuitId /*, circuitId: '$circuit._id' */ },
|
|
pipeline: [
|
|
{
|
|
$match:
|
|
{
|
|
$expr:
|
|
{
|
|
$and:
|
|
[
|
|
{ $eq: ['$$username', '$username'] },
|
|
{ $eq: ['$$idapp', '$idapp'] },
|
|
{ $eq: ['$$circuitId', '$circuitId'] },
|
|
],
|
|
},
|
|
},
|
|
},
|
|
],
|
|
},
|
|
},
|
|
{ $unwind: '$account' },
|
|
];
|
|
|
|
ris = await User.aggregate(aggr1);
|
|
|
|
return ris;
|
|
} catch (e) {
|
|
console.error('e', e);
|
|
}
|
|
|
|
};
|
|
|
|
CircuitSchema.statics.getCircolanteSingolaTransaz = function (accountorigTable, accountdestTable) {
|
|
|
|
let circolante = 0;
|
|
if (accountdestTable.saldo > 0)
|
|
circolante += accountdestTable.saldo;
|
|
if (accountorigTable.saldo > 0)
|
|
circolante += accountorigTable.saldo;
|
|
|
|
return circolante;
|
|
};
|
|
|
|
CircuitSchema.statics.sendCoins = async function (onlycheck, idapp, usernameOrig, extrarec) {
|
|
|
|
const { User } = require('../models/user');
|
|
|
|
let ris = {
|
|
result: false,
|
|
cansend: true,
|
|
errormsg: '',
|
|
rec: null,
|
|
useraccounts: [],
|
|
};
|
|
|
|
try {
|
|
let circuittable = null;
|
|
if (extrarec.circuitname)
|
|
circuittable = await Circuit.getCircuitByName(idapp, extrarec.circuitname);
|
|
if (extrarec.circuitId)
|
|
circuittable = await Circuit.getCircuitById(idapp, extrarec.circuitId);
|
|
|
|
if (circuittable) {
|
|
const myqty = Math.abs(extrarec.qty);
|
|
|
|
const esisteDest = await Account.isExistAccountByUsernameAndCircuitId(idapp, extrarec.dest, circuittable._id, extrarec.groupdest, extrarec.contoComDest);
|
|
|
|
|
|
if (!esisteDest) {
|
|
// Fallo entrare anche sul Circuito (oltre ad aver creato l'Account).
|
|
await User.addCircuitToUser(idapp, usernameOrig, extrarec.circuitname, false, extrarec.groupdest, extrarec.contoComDest);
|
|
}
|
|
if (extrarec.dest) {
|
|
const foundIfAlreadyCircuit = await User.ifAlreadyInCircuit(idapp, extrarec.dest, extrarec.circuitname);
|
|
if (!foundIfAlreadyCircuit) {
|
|
update = {
|
|
$push: {
|
|
'profile.mycircuits': {
|
|
circuitname: extrarec.circuitname,
|
|
date: new Date(),
|
|
},
|
|
},
|
|
};
|
|
const ris = await User.updateOne({ idapp, username: extrarec.dest }, update);
|
|
}
|
|
}
|
|
|
|
const accountdestTable = await Account.getAccountByUsernameAndCircuitId(idapp, extrarec.dest, circuittable._id, true, false, extrarec.groupdest, extrarec.contoComDest);
|
|
const accountorigTable = await Account.getAccountByUsernameAndCircuitId(idapp, usernameOrig, circuittable._id, true, true, extrarec.grouporig, extrarec.contoComOrig);
|
|
|
|
|
|
const circolantePrec = this.getCircolanteSingolaTransaz(accountorigTable, accountdestTable);
|
|
|
|
if (!circuittable.ignoreLimits) {
|
|
// Check if Sender has enough money
|
|
if (accountorigTable.saldo - myqty < -accountorigTable.fidoConcesso) {
|
|
ris.cansend = false;
|
|
ris.errormsg = i18n.__('CIRCUIT_AMOUNT_EXCEED_FIDO', usernameOrig);
|
|
}
|
|
|
|
if (accountdestTable.saldo + myqty > accountdestTable.qta_maxConcessa) {
|
|
ris.cansend = false;
|
|
ris.errormsg = i18n.__('CIRCUIT_AMOUNT_EXCEED_QTAMAX', extrarec.dest);
|
|
}
|
|
}
|
|
|
|
if (!onlycheck) {
|
|
// Add a Transaction !
|
|
if (ris.cansend) {
|
|
ris.rec = await Movement.addMov(idapp, accountorigTable, accountdestTable, myqty, extrarec.causal, extrarec.notifId, extrarec.idOrdersCart);
|
|
}
|
|
|
|
if (ris.cansend && ris.rec) {
|
|
|
|
const circolanteAtt = this.getCircolanteSingolaTransaz(accountorigTable, accountdestTable);
|
|
|
|
// Somma di tutte le transazioni
|
|
circuittable.totTransato += myqty;
|
|
// circuittable.totCircolante = circuittable.totCircolante + (circolanteAtt - circolantePrec);
|
|
circuittable.totCircolante = await Account.calcTotCircolante(idapp, circuittable._id);
|
|
// await circuittable.save();
|
|
paramstoupdate = {
|
|
totTransato: circuittable.totTransato,
|
|
totCircolante: circuittable.totCircolante,
|
|
};
|
|
await Circuit.updateOne({ _id: circuittable }, { $set: paramstoupdate });
|
|
|
|
extrarec.saldoOrig = tools.arrotondaA2Decimali(accountorigTable.saldo);
|
|
extrarec.saldoDest = tools.arrotondaA2Decimali(accountdestTable.saldo);
|
|
|
|
let orig = usernameOrig;
|
|
if (extrarec.grouporig) {
|
|
orig = extrarec.grouporig + ' (' + usernameOrig + ')'
|
|
}
|
|
if (extrarec.contoComOrig) {
|
|
orig = extrarec.contoComOrig + ' (' + usernameOrig + ')'
|
|
}
|
|
let dest = (extrarec.dest ? extrarec.dest : '') + (extrarec.groupdest ? extrarec.groupdest : '') + (extrarec.contoComDest ? extrarec.contoComDest : '');
|
|
|
|
ris.result = true;
|
|
let msg = '[<b>' + circuittable.name + '</b>]: Inviate Monete da ' + orig + ' a ' + dest + ' ' + myqty + ' ' + circuittable.symbol + ' [causale: ' + extrarec.causal +
|
|
`]\nSaldi:\n${orig}: ` + extrarec.saldoOrig + ' ' + circuittable.symbol + '] ' + `\n${dest}: ` + extrarec.saldoDest + ' ' + circuittable.symbol + ']';
|
|
console.log(msg);
|
|
|
|
ris.useraccounts = await Account.getUserAccounts(idapp, usernameOrig);
|
|
|
|
tools.writeTransactionLog(msg);
|
|
|
|
tools.sendMsgTelegramToAdmin(idapp, msg);
|
|
|
|
} else {
|
|
// console.log('NON Inviate Monete da', usernameOrig, extrarec.grouporig, extrarec.dest, extrarec.groupdest, myqty, extrarec.causal);
|
|
}
|
|
}
|
|
|
|
return ris;
|
|
|
|
}
|
|
} catch (e) {
|
|
console.error('Err sendCoins', e);
|
|
ris.result = false;
|
|
return ris;
|
|
}
|
|
|
|
};
|
|
|
|
// Rimuovo la Richiesta del Circuito
|
|
CircuitSchema.statics.removeReqCircuit = async function (idapp, username, name) {
|
|
|
|
return await Circuit.updateOne({ idapp, name },
|
|
{ $pull: { req_users: { username: { $in: [username] } } } });
|
|
};
|
|
|
|
// Rimuovo la Richiesta del Gruppo sul Circuito
|
|
CircuitSchema.statics.removeReqGroupCircuit = async function (idapp, groupname, name) {
|
|
|
|
return await Circuit.updateOne({ idapp, name },
|
|
{ $pull: { req_groups: { groupname: { $in: [groupname] } } } });
|
|
};
|
|
|
|
// Aggiungi agli utenti Rifiutati del Circuito
|
|
|
|
CircuitSchema.statics.refuseReqCircuit = async function (idapp, username, name) {
|
|
|
|
return await Circuit.updateOne({ idapp, name },
|
|
{
|
|
$push:
|
|
{
|
|
refused_users: {
|
|
username,
|
|
date: new Date(),
|
|
},
|
|
},
|
|
});
|
|
|
|
};
|
|
|
|
CircuitSchema.statics.refuseReqGroupCircuit = async function (idapp, groupname, name) {
|
|
|
|
return await Circuit.updateOne({ idapp, name },
|
|
{
|
|
$push:
|
|
{
|
|
refused_groups: {
|
|
groupname,
|
|
date: new Date(),
|
|
},
|
|
},
|
|
});
|
|
|
|
};
|
|
|
|
CircuitSchema.statics.updateData = async function (idapp, circuitname) {
|
|
|
|
try {
|
|
|
|
const { User } = require('./user');
|
|
|
|
let aggr1 = [
|
|
{
|
|
$match: {
|
|
idapp,
|
|
'profile.mycircuits': {
|
|
$elemMatch: { circuitname: { $eq: circuitname } },
|
|
},
|
|
},
|
|
},
|
|
{ $group: { _id: null, count: { $sum: 1 } } },
|
|
];
|
|
|
|
const ris = await User.aggregate(aggr1);
|
|
|
|
let numMembers = 0;
|
|
try {
|
|
numMembers = ris && tools.isArray(ris) ? ris[0].count : 0;
|
|
} catch (e) {
|
|
|
|
};
|
|
|
|
|
|
let paramstoupdate = {
|
|
numMembers: numMembers,
|
|
};
|
|
const risult = await this.updateOne({ idapp, name: circuitname }, { $set: paramstoupdate });
|
|
|
|
console.log('risult', risult);
|
|
|
|
} catch (e) {
|
|
console.error('Err', e);
|
|
}
|
|
|
|
};
|
|
|
|
CircuitSchema.statics.setDeperimentoOff = async function () {
|
|
|
|
return await Circuit.updateMany({}, { $set: { 'deperimento': false } },
|
|
{ new: false });
|
|
|
|
};
|
|
|
|
CircuitSchema.statics.getNameByCircuitId = async function (circuitId) {
|
|
|
|
let circuit = await Circuit.findOne({ _id: circuitId });
|
|
if (circuit)
|
|
return circuit.name;
|
|
|
|
return '';
|
|
|
|
};
|
|
|
|
CircuitSchema.statics.getCircuitByCircuitId = async function (circuitId) {
|
|
|
|
return await Circuit.findOne({ _id: circuitId });
|
|
|
|
};
|
|
|
|
CircuitSchema.statics.getListAdminsByCircuitPath = async function (idapp, circuitPath) {
|
|
|
|
let arr = await Circuit.findOne({
|
|
idapp,
|
|
path: circuitPath,
|
|
$or: [
|
|
{ deleted: { $exists: false } },
|
|
{ deleted: { $exists: true, $eq: false } }],
|
|
}, { admins: 1 }).lean();
|
|
|
|
return arr && arr.admins ? arr.admins : [];
|
|
|
|
};
|
|
|
|
|
|
// Imposta a tutti i Conti Collettivi, i seguenti minimi e massimi
|
|
CircuitSchema.statics.setstrProvByIdCityCircuits = async function (idapp) {
|
|
const { City } = require('../models/city');
|
|
|
|
const arrcircuits = await Circuit.find({ idapp }).lean();
|
|
try {
|
|
for (const rec of arrcircuits) {
|
|
let recstrProv = await City.findOne({ _id: rec.idCity[0] });
|
|
if (recstrProv) {
|
|
let objProv = {}
|
|
objProv['strProv'] = recstrProv.prov;
|
|
await Circuit.updateOne({ _id: rec._id }, { $set: objProv });
|
|
}
|
|
}
|
|
} catch (e) {
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
CircuitSchema.statics.AbilitaTuttiCircuiti = async function (idapp) {
|
|
|
|
const ris = await Circuit.updateMany({ idapp },
|
|
{
|
|
$set:
|
|
{
|
|
transactionsEnabled: true
|
|
}
|
|
});
|
|
|
|
return ris;
|
|
};
|
|
|
|
CircuitSchema.statics.AzzeraRegolamentiTuttiCircuiti = async function (idapp) {
|
|
|
|
const ris = await Circuit.updateMany({ idapp },
|
|
{
|
|
$set:
|
|
{
|
|
regulation: '',
|
|
}
|
|
});
|
|
|
|
return ris;
|
|
};
|
|
|
|
// Imposta a tutti i Conti Personali, i seguenti minimi e massimi
|
|
CircuitSchema.statics.SetDefMinMaxPersonali = async function (idapp, valmin, valmax, circuitId) {
|
|
|
|
if (circuitId) {
|
|
const ris = await Circuit.updateOne({ _id: circuitId },
|
|
{
|
|
$set:
|
|
{
|
|
fido_scoperto_default: valmin,
|
|
qta_max_default: valmax,
|
|
}
|
|
});
|
|
} else {
|
|
|
|
const ris = await Circuit.updateMany({ idapp },
|
|
{
|
|
$set:
|
|
{
|
|
fido_scoperto_default: valmin,
|
|
qta_max_default: valmax,
|
|
}
|
|
});
|
|
}
|
|
|
|
};
|
|
|
|
// Imposta a tutti i Conti Collettivi, i seguenti minimi e massimi
|
|
CircuitSchema.statics.getCircuitMyProvince = async function (idapp, username) {
|
|
const { User } = require('../models/user');
|
|
|
|
const myuser = await User.getUserByUsername(idapp, username);
|
|
|
|
try {
|
|
const circuit = await this.getCircuitByProvinceAndCard(idapp, myuser.profile.resid_province, myuser.profile.resid_card);
|
|
|
|
if (circuit) {
|
|
if (await User.ifAlreadyInCircuit(idapp, username, circuit.name)) {
|
|
return circuit.name;
|
|
}
|
|
}
|
|
|
|
return '[nessun Circuito]';
|
|
|
|
} catch (e) {
|
|
console.error('Error', e);
|
|
}
|
|
};
|
|
|
|
// Imposta a tutti i Conti Collettivi, i seguenti minimi e massimi
|
|
CircuitSchema.statics.createCircuitIfNotExist = async function (req, idapp, province, card) {
|
|
const { User } = require('../models/user');
|
|
|
|
const useradmin = tools.USER_ADMIN_CIRCUITS;
|
|
|
|
let myrec = null;
|
|
try {
|
|
const circuit = await this.getCircuitByProvinceAndCard(idapp, province, card);
|
|
|
|
const nomeprovincia = await Province.getStrProvinceByProv(province);
|
|
|
|
if (!circuit && nomeprovincia) {
|
|
const circ = new Circuit({
|
|
idapp,
|
|
name: 'Circuito RIS ' + nomeprovincia,
|
|
path: 'ris' + tools.convertSpaces_ToUScore(nomeprovincia.toLowerCase()),
|
|
strProv: province,
|
|
card,
|
|
photos: [],
|
|
color: '#ff5500',
|
|
deperimento: false,
|
|
showAlways: false,
|
|
transactionsEnabled: true, // Abilita cmq il circuito dall'inizio
|
|
status: shared_consts.CIRCUIT_STATUS.FASE1_CREAZIONE_GRUPPO,
|
|
symbol: 'RIS',
|
|
fido_scoperto_default: 100,
|
|
qta_max_default: 200,
|
|
fido_scoperto_default_grp: shared_consts.CIRCUIT_PARAMS.SCOPERTO_MIN_GRP,
|
|
qta_max_default_grp: shared_consts.CIRCUIT_PARAMS.SCOPERTO_MAX_GRP,
|
|
valuta_per_euro: 1,
|
|
totTransato: 0,
|
|
totCircolante: 0,
|
|
date_created: new Date(),
|
|
admins: [{ username: useradmin }],
|
|
});
|
|
|
|
myrec = await circ.save();
|
|
|
|
if (myrec) {
|
|
|
|
// nuovo Circuito:
|
|
await User.setCircuitCmd(idapp, useradmin, myrec.name,
|
|
shared_consts.CIRCUITCMD.CREATE, true, useradmin, myrec).then((ris) => {
|
|
|
|
});
|
|
|
|
// aggiungi il creatore al Circuito stesso
|
|
await User.setCircuitCmd(idapp, useradmin, myrec.name,
|
|
shared_consts.CIRCUITCMD.SET, true, useradmin, myrec).then((ris) => {
|
|
|
|
});
|
|
|
|
}
|
|
|
|
msg = 'Nuovo Circuito Creato in Automatico: ' + myrec.name + ' (da ' + req.user.username + ')';
|
|
tools.sendMsgTelegramToAdmin(idapp, msg);
|
|
}
|
|
} catch (e) {
|
|
console.error('Error', e);
|
|
}
|
|
|
|
return myrec;
|
|
|
|
};
|
|
|
|
CircuitSchema.statics.getListAdmins = async function (idapp, circuitname) {
|
|
|
|
let arr = await Circuit.findOne({
|
|
idapp,
|
|
name: circuitname,
|
|
$or: [
|
|
{ deleted: { $exists: false } },
|
|
{ deleted: { $exists: true, $eq: false } }],
|
|
}, { admins: 1 }).lean();
|
|
|
|
let mystr = '';
|
|
|
|
if (arr) {
|
|
for (const admin of arr.admins) {
|
|
mystr += await tools.getAhref(admin.username, await tools.getLinkUserTelegram(idapp, admin.username)) + ', ';
|
|
}
|
|
}
|
|
|
|
return { str: mystr, num: arr ? arr.admins.length : 0 };
|
|
|
|
};
|
|
|
|
CircuitSchema.statics.isAdminCircuit = async function (idapp, circuitname, username) {
|
|
|
|
let arr = await Circuit.findOne({
|
|
idapp,
|
|
name: circuitname,
|
|
$or: [
|
|
{ deleted: { $exists: false } },
|
|
{ deleted: { $exists: true, $eq: false } }],
|
|
}, { admins: 1 }).lean();
|
|
|
|
if (arr) {
|
|
for (const admin of arr.admins) {
|
|
if (admin.username === username)
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
|
|
};
|
|
|
|
CircuitSchema.statics.getListCircuitsByUsername = async function (idapp, username, groupname) {
|
|
|
|
let mystr = '';
|
|
const { User } = require('../models/user');
|
|
const myuser = await User.getUserByUsername(idapp, username);
|
|
|
|
const useraccounts = await Account.getUserAccounts(idapp, username);
|
|
const groupsaccounts = await Account.getGroupAccounts(idapp, groupname);
|
|
|
|
|
|
|
|
for (let account of useraccounts) {
|
|
if (myuser.profile.mycircuits.find((rec) => (rec.circuitname === account.circuit.name))) {
|
|
if (account.groupname === '') {
|
|
mystr += '\n👉🏻 ' + account.circuit.name + '\n';
|
|
mystr += ' [Saldo: ' + account.saldo + ' RIS, ';
|
|
mystr += ' Fiducia: ' + account.fidoConcesso + ' RIS, ';
|
|
mystr += ' Transato: ' + account.totTransato + ' RIS]';
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
for (let account of groupsaccounts) {
|
|
if (myuser.profile.mycircuits.find((rec) => (rec.circuitname === account.circuit.name))) {
|
|
mystr += '\n GRUPPO: 👉🏻 <b>' + account.groupname + '</b> in ' + account.circuit.name + '\n';
|
|
mystr += ' [Saldo: ' + account.saldo + ' RIS, ';
|
|
mystr += ' Fiducia: ' + account.fidoConcesso + ' RIS, ';
|
|
mystr += ' Transato: ' + account.totTransato + ' RIS]';
|
|
}
|
|
}
|
|
|
|
if (!mystr) {
|
|
mystr = '[Nessun Circuito]';
|
|
}
|
|
|
|
return mystr;
|
|
|
|
};
|
|
|
|
CircuitSchema.statics.SetDefMinMaxCollettivi = async function (idapp, valmin, valmax, circuitId) {
|
|
|
|
if (circuitId) {
|
|
const ris = await Circuit.updateOne({ _id: circuitId },
|
|
{
|
|
$set:
|
|
{
|
|
fido_scoperto_default_grp: valmin,
|
|
qta_max_default_grp: valmax,
|
|
}
|
|
});
|
|
} else {
|
|
const ris = await Circuit.updateMany({ idapp },
|
|
{
|
|
$set:
|
|
{
|
|
fido_scoperto_default_grp: valmin,
|
|
qta_max_default_grp: valmax,
|
|
}
|
|
});
|
|
}
|
|
|
|
};
|
|
|
|
|
|
CircuitSchema.statics.setFido = async function (idapp, username, circuitName, groupname) {
|
|
|
|
try {
|
|
mycircuit = await Circuit.findOne({ idapp, name: circuitName }).lean();
|
|
if (mycircuit) {
|
|
const circuitId = mycircuit._id;
|
|
let account = null;
|
|
let fido = 0;
|
|
let qtamax = 0;
|
|
let variato = false;
|
|
let variato2 = false;
|
|
|
|
if (mycircuit.showAlways) {
|
|
|
|
const { User } = require('../models/user');
|
|
|
|
const myuser = await User.getUserByUsername(idapp, username);
|
|
|
|
// Se è il circuito Nazionale, allora prende i valori dal proprio Circuito Locale:
|
|
const accountsuser = await Account.getUserAccounts(idapp, username);
|
|
if (accountsuser) {
|
|
// Se lo trovo della mia provincia, prendo quello
|
|
account = accountsuser.find((account) => account.circuit.strProv === myuser.profile.resid_province && ((account.circuit.card === myuser.profile.resid_card) || !myuser.profile.resid_card))
|
|
if (!account && accountsuser.length > 0) {
|
|
// Se non lo trovo, prendo il primo in cui sono entrato !
|
|
account = accountsuser[0];
|
|
}
|
|
if (account && account.circuit) {
|
|
if (groupname) {
|
|
qtamax = account.circuit.qta_max_default_grp * shared_consts.CIRCUIT_CFG.MULT_FIDO_GROUP;
|
|
fido = account.circuit.fido_scoperto_default_grp * shared_consts.CIRCUIT_CFG.MULT_FIDO_GROUP;
|
|
} else {
|
|
qtamax = account.circuit.qta_max_default * shared_consts.CIRCUIT_CFG.MULT_FIDO_USER;
|
|
fido = account.circuit.fido_scoperto_default * shared_consts.CIRCUIT_CFG.MULT_FIDO_USER;
|
|
}
|
|
}
|
|
} else {
|
|
// Se non ho Circuiti locali, non applico il Fido !
|
|
return null;
|
|
}
|
|
|
|
} else {
|
|
account = await Account.getAccountByUsernameAndCircuitId(idapp, username, circuitId, true, true, groupname, '');
|
|
if (groupname)
|
|
fido = mycircuit.fido_scoperto_default_grp;
|
|
else
|
|
fido = mycircuit.fido_scoperto_default;
|
|
}
|
|
|
|
if (account) {
|
|
if (qtamax > 0) {
|
|
variato = await Account.updateQtaMax(idapp, username, groupname, circuitId, qtamax);
|
|
}
|
|
|
|
const ris = await Account.updateFido(idapp, username, groupname, circuitId, fido);
|
|
if (ris) {
|
|
return { qta_maxConcessa: qtamax, fidoConcesso: fido, changed: variato || (ris && ris.nModified > 0) };
|
|
}
|
|
}
|
|
}
|
|
} catch (e) {
|
|
console.error('Err:', e);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
CircuitSchema.statics.CheckTransazioniCircuiti = async function (correggi) {
|
|
const { User } = require('../models/user');
|
|
const { MyGroup } = require('../models/mygroup');
|
|
const { SendNotif } = require('../models/sendnotif');
|
|
|
|
const idapp = tools.RISO;
|
|
|
|
try {
|
|
console.log('--------- INIZIO CONTROLLO CheckTransazioniCircuiti -----------');
|
|
|
|
if (correggi)
|
|
console.log('CORREZIONE !');
|
|
else
|
|
console.log('SOLO VERIFICA');
|
|
|
|
|
|
if (correggi) {
|
|
// Trova tutti i documenti che contengono circuitname a null nell'array mycircuits
|
|
const usersWithNullCircuit = await User.find({ idapp, "profile.mycircuits.circuitname": null });
|
|
|
|
// Itera su ciascun documento
|
|
for (const user of usersWithNullCircuit) {
|
|
// Rimuove i campi null dall'array mycircuits
|
|
user.profile.mycircuits = user.profile.mycircuits.filter(circuit => circuit.circuitname !== null);
|
|
|
|
// Salva le modifiche al documento
|
|
await User.findOneAndUpdate({ _id: user._id }, { $set: { 'profile.mycircuits': user.profile.mycircuits } });
|
|
|
|
}
|
|
}
|
|
|
|
|
|
let usersWithDuplicateCircuits = await User.aggregate([
|
|
{
|
|
$unwind: "$profile.mycircuits"
|
|
},
|
|
{
|
|
$group: {
|
|
_id: {
|
|
userId: "$_id",
|
|
username: "$username",
|
|
circuitname: "$profile.mycircuits.circuitname"
|
|
},
|
|
count: { $sum: 1 }
|
|
}
|
|
},
|
|
{
|
|
$match: {
|
|
count: { $gt: 1 }
|
|
}
|
|
},
|
|
{
|
|
$group: {
|
|
_id: "$_id.userId",
|
|
username: { $first: "$_id.username" },
|
|
duplicatedCircuits: {
|
|
$push: "$_id.circuitname"
|
|
}
|
|
}
|
|
}
|
|
]);
|
|
|
|
if (usersWithDuplicateCircuits.length > 0) {
|
|
console.log("Utenti con circuitname duplicati:");
|
|
usersWithDuplicateCircuits.forEach(user => {
|
|
console.log("Username:", user.username);
|
|
console.log("Circuiti duplicati:", user.duplicatedCircuits);
|
|
});
|
|
|
|
if (correggi) {
|
|
// CORREGGI DUPLICATI NEI CIRCUITI
|
|
for (const user of usersWithDuplicateCircuits) {
|
|
// Troviamo l'utente dal suo _id e aggiorniamo il suo documento
|
|
const arraycirc = await User.findOne({ _id: user._id }).lean();
|
|
|
|
let risdel = await User.updateOne(
|
|
{ _id: user._id },
|
|
{ $pull: { "profile.mycircuits": { circuitname: { $in: user.duplicatedCircuits } } } }
|
|
);
|
|
|
|
let risadd = await User.updateOne(
|
|
{ _id: user._id },
|
|
{ $push: { "profile.mycircuits": { $each: user.duplicatedCircuits.map(circuitname => ({ circuitname, date: arraycirc.profile.mycircuits.find((rec) => rec.circuitname === circuitname).date })) } } }
|
|
);
|
|
console.log('DEL', risdel, 'risadd', risadd);
|
|
}
|
|
}
|
|
|
|
console.log("*** FINE DUPLICATI *** ");
|
|
} else {
|
|
console.log("Nessun utente ha circuitname duplicati.");
|
|
}
|
|
|
|
let numtransazionitot = 0;
|
|
|
|
const arrcircuits = await Circuit.find({ idapp }).lean();
|
|
for (const circuit of arrcircuits) {
|
|
let strusersnotinaCircuit = '';
|
|
let strusersnotExist = '';
|
|
numtransazionitot = 0;
|
|
|
|
let qta = 0;
|
|
|
|
let mystr = ''
|
|
|
|
// 1. Calcola la somma di tutti i Saldi
|
|
|
|
// prendo la lista di tutti gli account del circuito
|
|
|
|
let circuitId = circuit._id;
|
|
|
|
const accounts = await Account.find({ idapp, circuitId }).lean();
|
|
|
|
// CONTROLLA DUPLICATI !
|
|
|
|
const usernameCounts = accounts.reduce((acc, curr) => {
|
|
if (curr.username !== '') {
|
|
acc[curr.username] = (acc[curr.username] || 0) + 1;
|
|
}
|
|
return acc;
|
|
}, {});
|
|
|
|
const duplicatedUsernames = Object.keys(usernameCounts).filter(username => usernameCounts[username] > 1);
|
|
|
|
if (duplicatedUsernames.length > 0) {
|
|
mystr += ' Esistono username duplicati (escludendo quelli vuoti):' + duplicatedUsernames;
|
|
}
|
|
|
|
let saldotot = 0;
|
|
|
|
let ris = await User.find({
|
|
"profile.mycircuits": { $elemMatch: { circuitname: circuit.name } }
|
|
}, "username").lean()
|
|
|
|
let arrusers_byprofile = ris ? ris.map(user => user.username) : [];
|
|
|
|
let risgroups = await MyGroup.find({
|
|
"mycircuits": { $elemMatch: { circuitname: circuit.name } }
|
|
}, "groupname").lean()
|
|
|
|
let arrgroups_byprofile = risgroups ? risgroups.map(group => group.groupname) : [];
|
|
|
|
let arrusers_byaccounts = [];
|
|
let ind = 0
|
|
let stracc = '';
|
|
|
|
for (const account of accounts) {
|
|
let aggiorna = false;
|
|
|
|
if (account.username && !arrusers_byaccounts.includes(account.username)) {
|
|
arrusers_byaccounts.push(account.username);
|
|
} else if (account.groupname && !arrusers_byaccounts.includes(account.groupname)) {
|
|
arrusers_byaccounts.push(account.groupname);
|
|
} else if (account.contocom && !arrusers_byaccounts.includes(account.contocom)) {
|
|
arrusers_byaccounts.push(account.contocom);
|
|
}
|
|
|
|
// per ogni Account ricalcolo il numero di transazioni avvenute in Entrata/uscita
|
|
let result = await Movement.aggregate([
|
|
{
|
|
$match: {
|
|
$or: [
|
|
{ accountFromId: account._id },
|
|
{ accountToId: account._id },
|
|
]
|
|
}
|
|
},
|
|
{
|
|
$group: {
|
|
_id: null,
|
|
numtransactions: { $sum: 1 },
|
|
totTransato: { $sum: { $abs: "$amount" } },
|
|
saldo: {
|
|
$sum: {
|
|
$cond: [
|
|
{ $eq: ["$accountToId", account._id] },
|
|
"$amount",
|
|
{
|
|
$cond: [
|
|
{ $eq: ["$accountFromId", account._id] },
|
|
{ $multiply: ["$amount", -1] },
|
|
0
|
|
]
|
|
}
|
|
]
|
|
}
|
|
}
|
|
}
|
|
}
|
|
]);
|
|
|
|
let numtransactions = result && result.length > 0 ? result[0].numtransactions : 0;
|
|
let totTransato = result && result.length > 0 ? result[0].totTransato : 0;
|
|
let saldo = result && result.length > 0 ? result[0].saldo : 0;
|
|
|
|
// TRANSAZIONI PENDENTI:
|
|
let saldo_pend = 0;
|
|
let pendingtransactionsMittente = await SendNotif.getSumPendingTransactionsMittente(account.idapp, account.username, circuit.name, account.groupname);
|
|
if (pendingtransactionsMittente.length > 0) {
|
|
let saldopendingMitt = pendingtransactionsMittente.reduce((sum, rec) => sum + rec.extrarec.qty, 0);
|
|
// transatopending = pendingtransactionsMittente.reduce((sum, rec) => sum + Math.abs(rec.extrarec.qty), 0);
|
|
|
|
saldo_pend = saldo - saldopendingMitt;
|
|
} else {
|
|
saldo_pend = saldo;
|
|
}
|
|
|
|
let strtemp = '';
|
|
|
|
if (numtransactions > 0) {
|
|
if (correggi)
|
|
await Account.findOneAndUpdate({ _id: account._id }, { $set: { numtransactions } })
|
|
}
|
|
if (saldo !== account.saldo) {
|
|
aggiorna = true;
|
|
strtemp += ' SALDO DIFFERENTE ! => ' + '\nPRIMA: ' + account.saldo + '\nDOPO: ' + saldo;
|
|
if (correggi)
|
|
await Account.findOneAndUpdate({ _id: account._id }, { $set: { saldo } })
|
|
}
|
|
if (account.saldo_pend === undefined) {
|
|
await Account.findOneAndUpdate({ _id: account._id }, { $set: { saldo_pend: 0 } })
|
|
}
|
|
if (saldo_pend !== account.saldo_pend) {
|
|
aggiorna = true;
|
|
strtemp += ' SALDO_PENDENTE DIFF. ! => ' + '\nPRIMA: ' + account.saldo_pend + '\nDOPO: ' + saldo_pend;
|
|
if (correggi)
|
|
await Account.findOneAndUpdate({ _id: account._id }, { $set: { saldo_pend } })
|
|
}
|
|
if (!account.totTransato || (totTransato !== account.totTransato)) {
|
|
if (totTransato > account.totTransato || account.totTransato === undefined)
|
|
if (correggi)
|
|
await Account.findOneAndUpdate({ _id: account._id }, { $set: { totTransato } })
|
|
}
|
|
|
|
saldotot += account.saldo;
|
|
|
|
// if (account.totTransato === NaN || account.totTransato === undefined)
|
|
// stracc += ' TOTTRANSATO => ' + account.totTransato;
|
|
|
|
if (account.totTransato)
|
|
qta += account.totTransato;
|
|
if (account.numtransactions)
|
|
numtransazionitot += account.numtransactions;
|
|
|
|
if (aggiorna && strtemp) {
|
|
stracc += '\n ** Account ' + account.username + '\n' + strtemp;
|
|
}
|
|
|
|
// await account.calcPending();
|
|
ind++;
|
|
}
|
|
|
|
let numaccounts = accounts.length;
|
|
let esistecontocom = accounts.find((rec) => (rec.hasOwnProperty('contocom') && rec.contocom !== ''));
|
|
|
|
let numacc_profile = arrusers_byprofile.length + arrgroups_byprofile.length;
|
|
if (esistecontocom && esistecontocom.contocom === circuit.path) {
|
|
numacc_profile++;
|
|
}
|
|
|
|
if (numacc_profile !== numaccounts) {
|
|
mystr += ' IL NUMERO DI UTENTI NON COINCIDONO ! \n';
|
|
mystr += 'Utenti Profilo = ' + numacc_profile + '\n';
|
|
mystr += 'Utenti Accounts = ' + arrusers_byaccounts.length + '\n';
|
|
|
|
}
|
|
|
|
saldotot = saldotot.toFixed(2);
|
|
|
|
// mystr += ' numaccounts=' + numaccounts;
|
|
if (strusersnotinaCircuit)
|
|
mystr += ' Utenti non presenti nel Circuito ! => ' + strusersnotinaCircuit;
|
|
if (strusersnotExist)
|
|
mystr += ' Utenti non più esistenti ! => ' + strusersnotExist;
|
|
|
|
|
|
// Verifica se saldotot è uguale a ZERO
|
|
if (saldotot != 0) {
|
|
mystr += '*** ATTENZIONE! ' + circuit.name + ' ha come somma un saldo di ' + saldotot + ' invece che ZERO';
|
|
} else {
|
|
if (numtransazionitot)
|
|
mystr += ' qta=' + qta + ' numtransazionitot ' + numtransazionitot;
|
|
}
|
|
|
|
if (mystr || stracc) {
|
|
console.log('************************* ' + circuit.name + ':');
|
|
console.log(mystr);
|
|
if (stracc)
|
|
console.log(stracc);
|
|
}
|
|
|
|
|
|
}
|
|
|
|
console.log('--------- FINE CONTROLLO CheckTransazioniCircuiti -----------', 'Transazioni = ', numtransazionitot)
|
|
|
|
} catch (e) {
|
|
console.error('Err', e);
|
|
}
|
|
|
|
};
|
|
|
|
CircuitSchema.statics.replaceAllCircuitNames = async function (idapp) {
|
|
const Circuit = this;
|
|
|
|
const { City } = require('../models/city');
|
|
const { Province } = require('../models/province');
|
|
|
|
const { MyGroup } = require('../models/mygroup');
|
|
const { User } = require('../models/user');
|
|
|
|
const myfind = { idapp };
|
|
|
|
let circuits = [];
|
|
try {
|
|
circuits = await Circuit.find(myfind);
|
|
|
|
let quanti = 0;
|
|
|
|
for (const circuit of circuits) {
|
|
if (!circuit || !circuit._id) {
|
|
console.error('Error: circuit is null or has no _id property');
|
|
continue;
|
|
}
|
|
const circuitId = circuit._id;
|
|
|
|
let provincia = '';
|
|
if (circuit.idCity && circuit.idCity.length > 0) {
|
|
provincia = await City.getProvinceByIdCity(circuit.idCity[0]);
|
|
}
|
|
if (!provincia)
|
|
provincia = circuit.strProv;
|
|
if (provincia) {
|
|
provincia = await Province.getStrProvinceByProv(provincia);
|
|
}
|
|
|
|
if (!provincia) {
|
|
console.log('PROVINCIA NON ESISTENTE !', circuit.name);
|
|
}
|
|
|
|
let path = '';
|
|
|
|
if (!circuit.showAlways) {
|
|
let newname = 'Circuito RIS ' + provincia;
|
|
|
|
// Se newname contiene 'ROMA', allora non aggiorna
|
|
|
|
if (circuit.name == 'RIS Roma Sud Est ' || circuit.name === 'Circuito RIS Roma Sud Est') {
|
|
newname = 'Circuito RIS Roma Sud Est';
|
|
} else if (circuit.name == 'Circuito RIS Roma Sud e Litora') {
|
|
newname = 'Circuito RIS Roma Sud e Litora';
|
|
} else if (circuit.name.trim() === 'RISO Roma Nord' || circuit.name.trim() === 'Circuito RISO Roma Nord') {
|
|
newname = 'Circuito RIS Roma Nord';
|
|
} else if (circuit.name == 'Circuito RIS Benevento' || circuit.name == 'Circuito RIS Campania') {
|
|
newname = 'Circuito RIS Campania';
|
|
path = 'riscampania';
|
|
} else if (circuit.name == 'Circuito RIS Milano Est') {
|
|
newname = 'Circuito RIS Milano Est';
|
|
} else if (circuit.name == 'Circuito RIS Repubblica di San Marino') {
|
|
newname = 'Circuito RIS Repubblica di San Marino';
|
|
}
|
|
|
|
if (((newname !== circuit.name) && (newname.indexOf('ROMA') === -1)) || path) {
|
|
|
|
console.log(`Sostituisci ${circuit.name} con ${newname}`);
|
|
|
|
quanti++;
|
|
|
|
if (path) {
|
|
// Update path
|
|
await Circuit.findOneAndUpdate({ _id: circuitId }, { $set: { path } })
|
|
.catch(e => console.error('Err ', e));
|
|
}
|
|
|
|
await Circuit.findOneAndUpdate({ _id: circuitId }, { $set: { name: newname } })
|
|
.catch(e => console.error('Err ', e));
|
|
|
|
// Rename profile.mycircuits.circuitname in User
|
|
await User.renameCircuitName(idapp, circuit.name, newname)
|
|
.catch(e => console.error('Err ', e));
|
|
|
|
await MyGroup.renameCircuitName(idapp, circuit.name, newname)
|
|
.catch(e => console.error('Err ', e));
|
|
|
|
}
|
|
}
|
|
}
|
|
console.log('Circuiti aggiornati: ' + quanti);
|
|
|
|
} catch (e) {
|
|
console.error('Err ', e);
|
|
return;
|
|
}
|
|
|
|
};
|
|
CircuitSchema.statics.addMovementByOrdersCart = async function (ordersCart, usernameDest, groupDest) {
|
|
|
|
const { User } = require('../models/user');
|
|
|
|
const idapp = ordersCart.idapp;
|
|
|
|
let extrarec = {
|
|
causal: 'Pagato Ordine n.' + ordersCart.numorder,
|
|
circuitname: 'Euro',
|
|
idOrdersCart: ordersCart._id,
|
|
qty: ordersCart.totalPrice,
|
|
dest: usernameDest,
|
|
groupdest: groupDest,
|
|
contoComDest: '',
|
|
};
|
|
|
|
const usernameOrig = await User.getUsernameById(idapp, ordersCart.userId);
|
|
|
|
return this.sendCoins(false, idapp, usernameOrig, extrarec);
|
|
|
|
};
|
|
|
|
const Circuit = mongoose.model('Circuit', CircuitSchema);
|
|
|
|
Circuit.createIndexes((err) => {
|
|
if (err) throw err;
|
|
});
|
|
|
|
module.exports = { Circuit };
|