3f7eda05cf
- Ora pertanto viene inviata la richiesta agli admin solo dopo che l'utente viene abilitato al Circuito provinciale.
792 lines
20 KiB
JavaScript
Executable File
792 lines
20 KiB
JavaScript
Executable File
/*
|
|
Account is a User's single Circuit
|
|
*/
|
|
|
|
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 shared_consts = require('../tools/shared_nodejs');
|
|
|
|
// Resolving error Unknown modifier: $pushAll
|
|
mongoose.plugin((schema) => {
|
|
schema.options.usePushEach = true;
|
|
});
|
|
|
|
const AccountSchema = new Schema({
|
|
_id: {
|
|
type: String,
|
|
default: function () {
|
|
return new ObjectId().toString();
|
|
},
|
|
},
|
|
idapp: {
|
|
type: String,
|
|
},
|
|
numtransactions: {
|
|
type: Number,
|
|
},
|
|
username: {
|
|
type: String,
|
|
},
|
|
groupname: {
|
|
// For the Groups
|
|
type: String,
|
|
},
|
|
contocom: {
|
|
// For the Conto Comunitario dei Circuiti
|
|
type: String,
|
|
},
|
|
circuitId: {
|
|
// ----- REF TO Circuit
|
|
type: String,
|
|
},
|
|
name: {
|
|
type: String,
|
|
},
|
|
deperibile: {
|
|
type: Boolean,
|
|
},
|
|
fidoConcesso: {
|
|
type: Number,
|
|
},
|
|
qta_maxConcessa: {
|
|
type: Number,
|
|
},
|
|
importo_iniziale: {
|
|
type: Number,
|
|
default: 0,
|
|
},
|
|
saldo: {
|
|
type: Number,
|
|
default: 0,
|
|
},
|
|
totTransato: {
|
|
type: Number,
|
|
default: 0,
|
|
},
|
|
saldo_pend: {
|
|
type: Number,
|
|
default: 0,
|
|
},
|
|
totTransato_pend: {
|
|
type: Number,
|
|
default: 0,
|
|
},
|
|
regulation_ok: {
|
|
type: Boolean,
|
|
},
|
|
deleted: {
|
|
type: Boolean,
|
|
default: false,
|
|
},
|
|
date_created: {
|
|
type: Date,
|
|
default: Date.now,
|
|
},
|
|
date_updated: {
|
|
type: Date,
|
|
},
|
|
});
|
|
|
|
AccountSchema.statics.findAllIdApp = async function (idapp) {
|
|
const Account = this;
|
|
|
|
const myfind = { idapp, deleted: false };
|
|
|
|
return await Account.find(myfind).lean();
|
|
};
|
|
|
|
AccountSchema.pre('save', async function (next) {
|
|
if (this.isNew) {
|
|
this._id = new ObjectId().toString();
|
|
}
|
|
|
|
next();
|
|
});
|
|
|
|
AccountSchema.statics.getFieldsForSearch = function () {
|
|
return [
|
|
{ field: 'name', type: tools.FieldType.string },
|
|
{ field: 'username', type: tools.FieldType.string },
|
|
{ field: 'groupname', type: tools.FieldType.string },
|
|
{ field: 'contocom', type: tools.FieldType.string },
|
|
];
|
|
};
|
|
|
|
AccountSchema.statics.executeQueryTable = function (idapp, params) {
|
|
params.fieldsearch = this.getFieldsForSearch();
|
|
return tools.executeQueryTable(this, idapp, params);
|
|
};
|
|
|
|
AccountSchema.statics.getAccountsByUsername = async function (idapp, username) {
|
|
const Account = this;
|
|
|
|
if (username === undefined) return false;
|
|
|
|
const myquery = {
|
|
idapp: idapp,
|
|
username: username,
|
|
};
|
|
|
|
return await Account.find(myquery).lean();
|
|
};
|
|
|
|
AccountSchema.statics.calcTotCircolante = async function (idapp, circuitId) {
|
|
const Account = this;
|
|
|
|
try {
|
|
let aggr1 = [
|
|
{
|
|
$match: { idapp, circuitId, saldo: { $gt: 0 } },
|
|
},
|
|
{ $group: { _id: null, count: { $sum: '$saldo' } } },
|
|
];
|
|
|
|
const ris = await Account.aggregate(aggr1);
|
|
|
|
return ris ? ris[0].count : 0;
|
|
} catch (e) {
|
|
console.error('err', e);
|
|
}
|
|
};
|
|
AccountSchema.methods.calcPending = async function (mittente) {
|
|
try {
|
|
const account = this;
|
|
|
|
const { SendNotif } = require('../models/sendnotif');
|
|
const { Circuit } = require('../models/circuit');
|
|
|
|
// *** Calc Pending Transactions ***
|
|
|
|
const circuit = await Circuit.getCircuitById(account.circuitId);
|
|
if (circuit) {
|
|
let prec_saldo_pend = account.saldo_pend;
|
|
let prec_totTransato_pend = account.totTransato_pend;
|
|
let transatopending = 0;
|
|
|
|
if (mittente) {
|
|
let pendingtransactionsMittente = await SendNotif.getSumPendingTransactionsMittente(
|
|
account.idapp,
|
|
account.username,
|
|
circuit.name,
|
|
account.groupname
|
|
);
|
|
let saldopendingMitt = pendingtransactionsMittente.reduce((sum, rec) => sum + rec.extrarec.qty, 0);
|
|
transatopending = pendingtransactionsMittente.reduce((sum, rec) => sum + Math.abs(rec.extrarec.qty), 0);
|
|
|
|
account.saldo_pend = account.saldo - saldopendingMitt;
|
|
} else {
|
|
// let pendingtransactionsDest = await SendNotif.getSumPendingTransactionsMittente(account.idapp, account.username, circuit.name, account.groupname);
|
|
|
|
// let saldopendingDest = pendingtransactionsDest.reduce((sum, rec) => sum + rec.extrarec.qty, 0);
|
|
// transatopending = pendingtransactionsDest.reduce((sum, rec) => sum + Math.abs(rec.extrarec.qty), 0);
|
|
|
|
// account.saldo_pend = account.saldo + saldopendingDest;
|
|
account.saldo_pend = account.saldo;
|
|
}
|
|
account.totTransato_pend = account.totTransato + transatopending;
|
|
|
|
if (prec_saldo_pend !== account.saldo_pend || prec_totTransato_pend !== account.totTransato_pend) {
|
|
const myaccountupdate = {
|
|
saldo_pend: account.saldo_pend,
|
|
totTransato_pend: account.totTransato_pend,
|
|
};
|
|
|
|
// Update Record
|
|
return await Account.findByIdAndUpdate(account.id, {
|
|
$set: myaccountupdate,
|
|
})
|
|
.then((ris) => {
|
|
console.log('calcPending', ris);
|
|
})
|
|
.catch((err) => {
|
|
console.error('calcPending', err);
|
|
});
|
|
}
|
|
}
|
|
|
|
// -----
|
|
} catch (e) {
|
|
console.error(e);
|
|
}
|
|
};
|
|
|
|
AccountSchema.statics.addtoSaldo = async function (myaccount, amount, mitt) {
|
|
const Account = this;
|
|
|
|
try {
|
|
let myaccountupdate = {};
|
|
|
|
if (myaccount) {
|
|
myaccount.saldo = myaccount.saldo + amount;
|
|
if (!myaccount.totTransato) {
|
|
myaccount.totTransato = 0;
|
|
}
|
|
myaccount.totTransato += Math.abs(amount);
|
|
|
|
if (!myaccount.numtransactions) myaccount.numtransactions = 0;
|
|
myaccount.numtransactions++;
|
|
|
|
myaccount.date_updated = new Date();
|
|
|
|
myaccountupdate.saldo = myaccount.saldo;
|
|
myaccountupdate.totTransato = myaccount.totTransato;
|
|
myaccountupdate.numtransactions = myaccount.numtransactions;
|
|
myaccountupdate.date_updated = myaccount.date_updated;
|
|
|
|
const ris = await Account.updateOne(
|
|
{ _id: myaccount.id },
|
|
{
|
|
$set: myaccountupdate,
|
|
}
|
|
);
|
|
|
|
// Calcola Saldo Pendente !
|
|
await myaccount.calcPending(true);
|
|
|
|
const recupdated = await Account.findOne({ _id: myaccount.id });
|
|
|
|
return recupdated;
|
|
}
|
|
} catch (e) {
|
|
console.error('error', e);
|
|
}
|
|
|
|
return null;
|
|
};
|
|
|
|
AccountSchema.pre('save', async function (next) {
|
|
if (this.isNew) {
|
|
if (!this.date_created) this.date_created = new Date();
|
|
}
|
|
|
|
next();
|
|
});
|
|
|
|
AccountSchema.statics.getAccountByUsernameAndCircuitId = async function (
|
|
idapp,
|
|
username,
|
|
circuitId,
|
|
createifnotexist,
|
|
confido,
|
|
groupname = '',
|
|
contocom = ''
|
|
) {
|
|
const Account = this;
|
|
|
|
try {
|
|
const { Circuit } = require('../models/circuit');
|
|
|
|
// if (username === undefined)
|
|
// return false;
|
|
|
|
let myquery = {
|
|
idapp,
|
|
circuitId,
|
|
};
|
|
|
|
if (groupname) {
|
|
myquery.groupname = groupname;
|
|
} else if (contocom) {
|
|
myquery.contocom = contocom;
|
|
} else {
|
|
myquery.username = username;
|
|
}
|
|
|
|
let mycircuit = await Circuit.getCircuitById(circuitId);
|
|
|
|
if (mycircuit) {
|
|
let myaccount = await Account.findOne(myquery);
|
|
|
|
if (!myaccount && createifnotexist) {
|
|
myaccount = new Account({
|
|
_id: new ObjectId().toString(),
|
|
idapp,
|
|
username: !groupname && !contocom ? username : '',
|
|
groupname,
|
|
contocom,
|
|
circuitId: mycircuit._id,
|
|
deperibile: false,
|
|
importo_iniziale: 0,
|
|
saldo: 0,
|
|
saldo_pend: 0,
|
|
fidoConcesso: 0,
|
|
qta_maxConcessa: 0,
|
|
totTransato: 0,
|
|
numtransactions: 0,
|
|
totTransato_pend: 0,
|
|
});
|
|
|
|
if (contocom) {
|
|
myaccount.fidoConcesso =
|
|
mycircuit.fido_scoperto_default_contocom || shared_consts.CIRCUIT_PARAMS.SCOPERTO_MIN_CONTO_COMUNITARIO;
|
|
myaccount.qta_maxConcessa =
|
|
mycircuit.qta_max_default_contocom || shared_consts.CIRCUIT_PARAMS.SCOPERTO_MAX_CONTO_COMUNITARIO;
|
|
} else {
|
|
if (!mycircuit.fido_scoperto_default_grp)
|
|
mycircuit.fido_scoperto_default_grp = shared_consts.CIRCUIT_PARAMS.SCOPERTO_MIN_GRP;
|
|
if (!mycircuit.qta_max_default_grp)
|
|
mycircuit.qta_max_default_grp = shared_consts.CIRCUIT_PARAMS.SCOPERTO_MAX_GRP;
|
|
|
|
if (groupname) {
|
|
myaccount.fidoConcesso = mycircuit.fido_scoperto_default_grp;
|
|
myaccount.qta_maxConcessa = mycircuit.qta_max_default_grp;
|
|
} else {
|
|
myaccount.fidoConcesso = mycircuit.fido_scoperto_default;
|
|
myaccount.qta_maxConcessa = mycircuit.qta_max_default;
|
|
}
|
|
}
|
|
|
|
if (!confido) {
|
|
myaccount.fidoConcesso = 0;
|
|
}
|
|
|
|
let acc = await myaccount.save();
|
|
|
|
if (mycircuit.creditodiPartenza && mycircuit.creditodiPartenza > 0) {
|
|
acc = await Account.addtoSaldo(acc, mycircuit.creditodiPartenza, false);
|
|
}
|
|
|
|
return acc;
|
|
}
|
|
|
|
return myaccount;
|
|
}
|
|
return null;
|
|
} catch (e) {
|
|
console.error('error', e);
|
|
}
|
|
};
|
|
|
|
AccountSchema.statics.isExistAccountByUsernameAndCircuitId = async function (
|
|
idapp,
|
|
username,
|
|
circuitId,
|
|
groupname = '',
|
|
contocom = ''
|
|
) {
|
|
const Account = this;
|
|
|
|
try {
|
|
const { Circuit } = require('../models/circuit');
|
|
|
|
if (username === undefined) return false;
|
|
|
|
let myquery = {
|
|
idapp,
|
|
circuitId,
|
|
};
|
|
|
|
if (groupname) {
|
|
myquery.groupname = groupname;
|
|
} else if (contocom) {
|
|
myquery.contocom = contocom;
|
|
} else {
|
|
myquery.username = username;
|
|
}
|
|
|
|
let mycircuit = await Circuit.getCircuitById(circuitId);
|
|
|
|
if (mycircuit) {
|
|
let myaccount = await Account.findOne(myquery);
|
|
return !!myaccount;
|
|
}
|
|
|
|
return false;
|
|
} catch (e) {
|
|
console.error('error', e);
|
|
}
|
|
};
|
|
|
|
AccountSchema.statics.createAccount = async function (
|
|
idapp,
|
|
username,
|
|
circuitName,
|
|
confido,
|
|
groupname = '',
|
|
contocom = ''
|
|
) {
|
|
const { Circuit } = require('../models/circuit');
|
|
|
|
try {
|
|
mycircuit = await Circuit.findOne({ name: circuitName }, { _id: 1 });
|
|
if (mycircuit) {
|
|
return await Account.getAccountByUsernameAndCircuitId(
|
|
idapp,
|
|
username,
|
|
mycircuit._id,
|
|
true,
|
|
confido,
|
|
groupname,
|
|
contocom
|
|
);
|
|
} else {
|
|
return null;
|
|
}
|
|
} catch (e) {
|
|
console.error('error', e);
|
|
return null;
|
|
}
|
|
};
|
|
|
|
AccountSchema.statics.getUserAccounts = async function (idapp, username) {
|
|
const { SendNotif } = require('../models/sendnotif');
|
|
|
|
try {
|
|
let aggr1 = [
|
|
{
|
|
$match: { idapp, username },
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: 'circuits',
|
|
localField: 'circuitId',
|
|
foreignField: '_id',
|
|
as: 'circuit',
|
|
},
|
|
},
|
|
{ $unwind: '$circuit' },
|
|
{
|
|
$lookup: {
|
|
from: 'sendnotifs',
|
|
as: 'notifspending',
|
|
let: {
|
|
circuitname: '$circuit.name',
|
|
username: '$username',
|
|
idapp: '$idapp',
|
|
typedir: shared_consts.TypeNotifs.TYPEDIR_CIRCUITS,
|
|
typeid: shared_consts.TypeNotifs.ID_CIRCUIT_SENDCOINSREQ,
|
|
},
|
|
pipeline: [
|
|
{
|
|
$match: {
|
|
$expr: {
|
|
$and: [
|
|
{ $eq: ['$idapp', '$$idapp'] },
|
|
{ $eq: ['$typedir', '$$typedir'] },
|
|
{ $eq: ['$typeid', '$$typeid'] },
|
|
{ $eq: ['$status', 0] },
|
|
{ $eq: ['$sender', '$$username'] },
|
|
{ $eq: ['$extrarec.circuitname', '$$circuitname'] },
|
|
],
|
|
},
|
|
},
|
|
},
|
|
{
|
|
$group: { _id: '$extrarec.notifIdToUpdate', result: { $first: '$$ROOT' } },
|
|
},
|
|
],
|
|
},
|
|
},
|
|
];
|
|
|
|
const ris = await this.aggregate(aggr1);
|
|
|
|
// console.log('1 - INIZIA getUserAccounts ')
|
|
// console.log(aggr1);
|
|
|
|
/* if (ris) {
|
|
for (const account of ris) {
|
|
try {
|
|
//++OTTIMIZZARE QUESTA PARTE ! (CON UNA QUERY...)
|
|
// console.log(' 1B - PENDIND... ')
|
|
|
|
let pendingtransactions = await SendNotif.getSumPendingTransactions(idapp, username, account.circuit.name);
|
|
let saldopending = pendingtransactions.reduce((sum, rec) => sum + rec.extrarec.qty, 0);
|
|
if (saldopending !== 0) {
|
|
account.saldo -= saldopending;
|
|
account.totTransato = account.totTransato || 0;
|
|
}
|
|
|
|
|
|
} catch (e) {
|
|
console.error('getUserAccounts 1) ', e);
|
|
}
|
|
|
|
}
|
|
} */
|
|
|
|
return ris;
|
|
} catch (e) {
|
|
console.error('getUserAccounts', e);
|
|
}
|
|
};
|
|
|
|
AccountSchema.statics.getGroupAccounts = async function (idapp, groupname) {
|
|
if (!groupname) {
|
|
return [];
|
|
}
|
|
try {
|
|
let aggr1 = [
|
|
{
|
|
$match: { idapp, groupname },
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: 'circuits',
|
|
localField: 'circuitId',
|
|
foreignField: '_id',
|
|
as: 'circuit',
|
|
},
|
|
},
|
|
{ $unwind: '$circuit' },
|
|
{
|
|
$lookup: {
|
|
from: 'sendnotifs',
|
|
as: 'notifspending',
|
|
let: {
|
|
circuitname: '$circuit.name',
|
|
groupname: '$groupname',
|
|
idapp: '$idapp',
|
|
typedir: shared_consts.TypeNotifs.TYPEDIR_CIRCUITS,
|
|
typeid: shared_consts.TypeNotifs.ID_CIRCUIT_SENDCOINSREQ,
|
|
},
|
|
pipeline: [
|
|
{
|
|
$match: {
|
|
$expr: {
|
|
$and: [
|
|
{ $eq: ['$typedir', '$$typedir'] },
|
|
{ $eq: ['$typeid', '$$typeid'] },
|
|
{ $eq: ['$status', 0] },
|
|
{ $eq: ['$sendergroup', '$$groupname'] },
|
|
{ $eq: ['$idapp', '$$idapp'] },
|
|
{ $eq: ['$extrarec.circuitname', '$$circuitname'] },
|
|
],
|
|
},
|
|
},
|
|
},
|
|
{
|
|
$group: { _id: '$extrarec.notifIdToUpdate', result: { $first: '$$ROOT' } },
|
|
},
|
|
],
|
|
},
|
|
},
|
|
];
|
|
|
|
const ris = await this.aggregate(aggr1);
|
|
|
|
return ris;
|
|
} catch (e) {
|
|
console.error('e', e);
|
|
}
|
|
};
|
|
|
|
// Imposta a tutti i Conti Collettivi, i seguenti minimi e massimi
|
|
AccountSchema.statics.SetMinMaxCollettivi = async function (idapp, valmin, valmax) {
|
|
const Account = this;
|
|
|
|
const ris = await Account.updateMany(
|
|
{ idapp, groupname: { $nin: [null, ''] } },
|
|
{
|
|
$set: {
|
|
fidoConcesso: valmin,
|
|
qta_maxConcessa: valmax,
|
|
},
|
|
}
|
|
);
|
|
};
|
|
|
|
// Imposta a tutti i Conti Comunitari, i seguenti minimi e massimi
|
|
AccountSchema.statics.SetMinMaxComunitari = async function (idapp, valmin, valmax) {
|
|
const Account = this;
|
|
|
|
const ris = await Account.updateMany(
|
|
{ idapp, contocom: { $nin: [null, ''] } },
|
|
{
|
|
$set: {
|
|
fidoConcesso: valmin,
|
|
qta_maxConcessa: valmax,
|
|
},
|
|
}
|
|
);
|
|
};
|
|
|
|
// Imposta a tutti i Conti Personali, i seguenti minimi e massimi
|
|
AccountSchema.statics.SetMinMaxPersonali = async function (idapp, fidoConcesso, qta_maxConcessa, circuitId) {
|
|
const Account = this;
|
|
|
|
if (circuitId) {
|
|
const ris = await Account.updateMany(
|
|
{ idapp, circuitId, fidoConcesso: { $gt: 0 }, username: { $nin: [null, ''] } },
|
|
{
|
|
$set: {
|
|
fidoConcesso,
|
|
qta_maxConcessa,
|
|
},
|
|
}
|
|
);
|
|
|
|
const circuit = await Circuit.findOne({ _id: circuitId });
|
|
|
|
if (!circuit.circuitoIndipendente) {
|
|
// Se aggiorno questi dati, e non è un Circuito Indipendente, allora devo aggiornare anche gli account del RIS Nazionale
|
|
await Account.updateAccountCircuitoItaliaByLimiti(idapp, circuitId, fidoConcesso, qta_maxConcessa);
|
|
}
|
|
} else {
|
|
const ris = await Account.updateMany(
|
|
{ idapp, fidoConcesso: { $gt: 0 }, username: { $nin: [null, ''] } },
|
|
{
|
|
$set: {
|
|
fidoConcesso,
|
|
qta_maxConcessa,
|
|
},
|
|
}
|
|
);
|
|
}
|
|
};
|
|
|
|
AccountSchema.statics.updateFido = async function (idapp, username, groupname, circuitId, fido) {
|
|
let paramstoupdate = {
|
|
fidoConcesso: fido,
|
|
};
|
|
let risult = null;
|
|
if (groupname) risult = await Account.updateOne({ idapp, circuitId, groupname }, { $set: paramstoupdate });
|
|
else risult = await Account.updateOne({ idapp, username, circuitId }, { $set: paramstoupdate });
|
|
|
|
return risult;
|
|
};
|
|
|
|
AccountSchema.statics.updateQtaMax = async function (idapp, username, groupname, circuitId, qtamax) {
|
|
let paramstoupdate = {
|
|
qta_maxConcessa: qtamax,
|
|
};
|
|
let risult = null;
|
|
if (groupname) risult = await Account.updateOne({ idapp, circuitId, groupname }, { $set: paramstoupdate });
|
|
else risult = await Account.updateOne({ idapp, username, circuitId }, { $set: paramstoupdate });
|
|
|
|
return risult && risult.modifiedCount > 0;
|
|
};
|
|
|
|
AccountSchema.statics.getAccountsCircuitiExtraProvinciali = async function (idapp) {
|
|
const { Circuit } = require('../models/circuit');
|
|
|
|
const circuits = await Circuit.getCircuitiExtraProvinciali(idapp);
|
|
|
|
if (circuits.length > 0) {
|
|
const circuitIds = circuits.map((circuit) => circuit._id);
|
|
return Account.find({ idapp, circuitId: { $in: circuitIds } });
|
|
}
|
|
};
|
|
|
|
AccountSchema.statics.getAccountsCircuitoItalia = async function (idapp) {
|
|
const { Circuit } = require('../models/circuit');
|
|
|
|
const circuit = await Circuit.getCircuitoItalia(idapp);
|
|
|
|
if (circuit) {
|
|
return Account.find({ idapp, circuitId: circuit._id });
|
|
}
|
|
};
|
|
|
|
AccountSchema.statics.updateAccountCircuitoItaliaByLimiti = async function (
|
|
idapp,
|
|
circuitId,
|
|
fidoConcesso,
|
|
qta_maxConcessa
|
|
) {
|
|
const { Circuit } = require('../models/circuit');
|
|
|
|
try {
|
|
const accounts = await this.getAccountsCircuitoItalia(idapp);
|
|
|
|
for (const account of accounts) {
|
|
const circuitId = account.circuitId;
|
|
const circuit = await Circuit.findOne({ _id: circuitId });
|
|
if (circuit) {
|
|
let fido = 0;
|
|
let qtamax = 0;
|
|
|
|
if (account.groupname) {
|
|
fido = circuit.fido_scoperto_default_grp * shared_consts.CIRCUIT_CFG.MULT_FIDO_GROUP;
|
|
qtamax = circuit.qta_max_default_grp * shared_consts.CIRCUIT_CFG.MULT_FIDO_GROUP;
|
|
} else {
|
|
fido = circuit.fido_scoperto_default * shared_consts.CIRCUIT_CFG.MULT_FIDO_USER;
|
|
qtamax = circuit.qta_max_default * shared_consts.CIRCUIT_CFG.MULT_FIDO_USER;
|
|
}
|
|
|
|
let paramstoupdate = {
|
|
fidoConcesso: fido,
|
|
qta_maxConcessa: qtamax,
|
|
};
|
|
|
|
risult = await Account.updateOne({ _id: account.id }, { $set: paramstoupdate });
|
|
}
|
|
}
|
|
return risult;
|
|
} catch (e) {
|
|
console.error('updateAccountCircuitoItaliaByLimiti', e);
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
AccountSchema.statics.canEditAccountAdmins = async function (username, id) {
|
|
const account = await Account.findOne({ _id: id }).lean();
|
|
|
|
const { Circuit } = require('../models/circuit');
|
|
|
|
if (account) {
|
|
const circuit = await Circuit.findOne({ _id: account.circuitId }).lean();
|
|
if (circuit) {
|
|
return circuit.admins.findIndex((admin) => admin.username === username) >= 0;
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
|
|
AccountSchema.statics.addToPeopleOfMyAccount = async function (idapp, username, circuitId, person_username, perm) {
|
|
return await Account.updateOne(
|
|
{ idapp, username, circuitId },
|
|
{
|
|
$push: {
|
|
people: {
|
|
username: person_username,
|
|
perm,
|
|
date: new Date(),
|
|
},
|
|
},
|
|
}
|
|
);
|
|
};
|
|
|
|
// Rimuovi dagli Admin del Account
|
|
AccountSchema.statics.removeAdminOfAccount = async function (idapp, username, circuitId, person_username, perm) {
|
|
const { Circuit } = require('../models/circuit');
|
|
|
|
return await Circuit.updateOne(
|
|
{ idapp, username, circuitId },
|
|
{ $pull: { people: { username: { $in: [person_username] } } } }
|
|
);
|
|
};
|
|
|
|
// Rimuovi l'account
|
|
AccountSchema.statics.removeAccount = async function (accountId) {
|
|
return await Account.deleteOne({ _id: accountId });
|
|
};
|
|
|
|
AccountSchema.statics.updateSaldoAndTransato_AllAccounts = async function (idapp) {
|
|
const recaccounts = await Account.find({ idapp });
|
|
|
|
for (const account of recaccounts) {
|
|
await account.calcPending();
|
|
}
|
|
};
|
|
|
|
const Account = mongoose.model('Account', AccountSchema);
|
|
|
|
Account.createIndexes()
|
|
.then(() => {})
|
|
.catch((err) => {
|
|
throw err;
|
|
});
|
|
|
|
module.exports = { Account };
|