1220 lines
31 KiB
JavaScript
Executable File
1220 lines
31 KiB
JavaScript
Executable File
const mongoose = require('mongoose');
|
|
const _ = require('lodash');
|
|
|
|
const tools = require('../tools/general');
|
|
|
|
const { ListaIngresso } = require('./listaingresso');
|
|
const { Settings } = require('./settings');
|
|
const { User } = require('./user');
|
|
|
|
const { ObjectID } = require('mongodb');
|
|
|
|
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', process.env.DEBUG);
|
|
|
|
|
|
const NaveSchema = new mongoose.Schema({
|
|
idapp: {
|
|
type: String,
|
|
required: true,
|
|
},
|
|
riga: {
|
|
type: Number,
|
|
},
|
|
col: {
|
|
type: Number,
|
|
},
|
|
indprimario: {
|
|
type: Number,
|
|
},
|
|
ind_order: {
|
|
type: Number,
|
|
},
|
|
parent_id: {
|
|
type: mongoose.Schema.Types.ObjectId,
|
|
},
|
|
date_start: {
|
|
type: Date
|
|
},
|
|
date_gift_chat_open: {
|
|
type: Date
|
|
},
|
|
link_chat: {
|
|
type: String,
|
|
},
|
|
sent_msg_howto_make_gift: {
|
|
type: Boolean,
|
|
default: false,
|
|
},
|
|
made_gift: {
|
|
type: Boolean,
|
|
default: false,
|
|
},
|
|
date_made_gift: {
|
|
type: Date,
|
|
},
|
|
received_gift: {
|
|
type: Boolean,
|
|
default: false,
|
|
},
|
|
date_received_gift: {
|
|
type: Date,
|
|
},
|
|
created: {
|
|
type: Date,
|
|
},
|
|
num_tess: { // numero di tessitura
|
|
type: Number,
|
|
default: 1
|
|
},
|
|
provvisoria: {
|
|
type: Boolean
|
|
},
|
|
note: {
|
|
type: String
|
|
},
|
|
note_interne: {
|
|
type: String
|
|
}
|
|
});
|
|
|
|
NaveSchema.statics.getTotInLista = async function (idapp) {
|
|
const Nave = this;
|
|
|
|
const myfind = { idapp };
|
|
|
|
return await Nave.count(myfind);
|
|
};
|
|
|
|
NaveSchema.statics.findByIndOrder = function (idapp, ind_order) {
|
|
const Nave = this;
|
|
|
|
try {
|
|
return Nave.findOne({
|
|
'idapp': idapp,
|
|
'ind_order': ind_order,
|
|
});
|
|
} catch (e) {
|
|
|
|
}
|
|
};
|
|
|
|
NaveSchema.statics.findById = function (idapp, id) {
|
|
const Nave = this;
|
|
|
|
const myquery = getQueryProj({ idapp, '_id': ObjectID(id) });
|
|
|
|
return Nave.aggregate(myquery);
|
|
|
|
};
|
|
|
|
NaveSchema.statics.findByIndPrimario = function (idapp, indprimario) {
|
|
const Nave = this;
|
|
|
|
try {
|
|
return Nave.findOne({
|
|
idapp,
|
|
indprimario,
|
|
});
|
|
} catch (e) {
|
|
|
|
}
|
|
};
|
|
|
|
|
|
NaveSchema.statics.getFieldsForSearch = function () {
|
|
return [{ field: 'ind_order', type: tools.FieldType.number },
|
|
{ field: 'col', type: tools.FieldType.number }]
|
|
};
|
|
|
|
NaveSchema.statics.executeQueryTable = function (idapp, params) {
|
|
params.fieldsearch = this.getFieldsForSearch();
|
|
return tools.executeQueryTable(this, idapp, params);
|
|
};
|
|
|
|
NaveSchema.statics.findAllIdApp = function (idapp) {
|
|
const Nave = this;
|
|
|
|
const myfind = { idapp };
|
|
|
|
return Nave.find(myfind, (err, arrrec) => {
|
|
return arrrec
|
|
});
|
|
};
|
|
|
|
NaveSchema.statics.findByRigaCol = function (idapp, riga, col, nullifnotexist) {
|
|
const Nave = this;
|
|
|
|
myrigacol = {
|
|
idapp,
|
|
riga,
|
|
col,
|
|
nullifnotexist
|
|
};
|
|
|
|
return Nave.findGeneric(myrigacol);
|
|
|
|
};
|
|
|
|
NaveSchema.statics.findDonatoreByNave = function (idapp, nave) {
|
|
try {
|
|
|
|
const arrrigacol = nave.split(".");
|
|
if (arrrigacol.length <= 0)
|
|
return;
|
|
|
|
let riganave = parseInt(arrrigacol[0]);
|
|
let colnave = parseInt(arrrigacol[1]);
|
|
|
|
let rigadonatore = riganave + 3;
|
|
if (rigadonatore < 1)
|
|
rigadonatore = 1;
|
|
|
|
coldonatoreIni = calcval(riganave, colnave, 8) + (1);
|
|
coldonatoreFine = calcval(riganave, colnave, 8) + (8);
|
|
|
|
const miaquery = {
|
|
idapp,
|
|
riga: rigadonatore,
|
|
$and: [{ col: { $gte: { coldonatoreIni } } }, { col: { $lte: { coldonatoreFine } } }]
|
|
};
|
|
|
|
return Nave.findOne(miaquery);
|
|
} catch (e) {
|
|
|
|
}
|
|
};
|
|
|
|
function getIndColonneByNave(navemediatore) {
|
|
let riga = navemediatore.riga;
|
|
let col = navemediatore.col;
|
|
|
|
let col_ini = calcval(riga, col, 8) + 1;
|
|
let col_fine = col_ini + 7;
|
|
|
|
return { riga: riga + 3, col_ini, col_fine }
|
|
}
|
|
|
|
NaveSchema.statics.getusersByNave = function (idapp, navemediatore) {
|
|
|
|
if ((!navemediatore.riga) || (!navemediatore.col))
|
|
return [];
|
|
|
|
const obj = getIndColonneByNave(navemediatore);
|
|
|
|
const miacol_ini = obj.col_ini;
|
|
const miacol_fine = obj.col_fine;
|
|
|
|
const miaquery = {
|
|
idapp,
|
|
riga: obj.riga,
|
|
$and: [
|
|
{ col: { $gte: miacol_ini } },
|
|
{ col: { $lte: miacol_fine } }
|
|
],
|
|
};
|
|
|
|
return Nave.find(miaquery);
|
|
|
|
};
|
|
|
|
|
|
NaveSchema.statics.findRecByRigaColParent = async function (idapp, riga, col, numparentUp) {
|
|
const Nave = this;
|
|
|
|
const { User } = require('./user');
|
|
|
|
const myrigacol = {
|
|
idapp,
|
|
riga,
|
|
col
|
|
};
|
|
|
|
if (numparentUp === 0) {
|
|
return await Nave.findGeneric(myrigacol);
|
|
}
|
|
|
|
let parentup = 0;
|
|
let myrec = null;
|
|
let lastrec = null;
|
|
|
|
while (parentup < numparentUp) {
|
|
|
|
myrec = await Nave.findGeneric(myrigacol);
|
|
if (!!myrec) {
|
|
if (myrec.parent_id === "0") {
|
|
break;
|
|
}
|
|
|
|
recfind = await Nave.findById(idapp, myrec.parent_id);
|
|
if (!!recfind) {
|
|
if (recfind.length > 0) {
|
|
recfind = recfind[0];
|
|
lastrec = recfind;
|
|
myrigacol.riga = lastrec.riga;
|
|
myrigacol.col = lastrec.col;
|
|
} else {
|
|
//lastrec = await User.findByIndOrder(idapp, 0);
|
|
lastrec = await Nave.findGeneric({ idapp, riga: 0, col: 0 });
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
parentup++;
|
|
}
|
|
|
|
if (!lastrec) {
|
|
// return await User.findByIndOrder(idapp, 0);
|
|
return await Nave.findGeneric({ idapp, riga: 0, col: 0 });
|
|
}
|
|
|
|
return lastrec;
|
|
|
|
};
|
|
|
|
function getlimiti(mypos) {
|
|
|
|
if (mypos.col < 0) {
|
|
mypos.col = 0;
|
|
}
|
|
|
|
if (mypos.riga < 0) {
|
|
mypos.riga = 0;
|
|
mypos.col = 0;
|
|
}
|
|
|
|
return mypos;
|
|
}
|
|
|
|
function getRigaColGenerica(idapp, riga, col, numup) {
|
|
mypos = {
|
|
idapp,
|
|
riga,
|
|
col,
|
|
numup
|
|
};
|
|
|
|
if (idapp === tools.AYNI) {
|
|
tools.getRigaColByPosUp(mypos);
|
|
ris = getlimiti(mypos);
|
|
}
|
|
|
|
return ris;
|
|
}
|
|
|
|
function getRigaColSognatoreByFuoco(idapp, riga, col) {
|
|
return getRigaColGenerica(idapp, riga, col, 6);
|
|
}
|
|
|
|
function getRigaColMediatoreByFuoco(idapp, riga, col) {
|
|
return getRigaColGenerica(idapp, riga, col, 3);
|
|
}
|
|
|
|
NaveSchema.statics.findGeneric = function (myrigacol) {
|
|
|
|
const { ListaIngresso } = require('./listaingresso');
|
|
|
|
const myquery = getQueryProj({ idapp: myrigacol.idapp, riga: myrigacol.riga, col: myrigacol.col });
|
|
|
|
return Nave.aggregate(myquery)
|
|
.then(async (rec) => {
|
|
if (!rec || rec.length === 0) {
|
|
if (myrigacol.nullifnotexist)
|
|
return null;
|
|
|
|
const ris = await ListaIngresso.findByIndOrder(myrigacol.idapp, 0);
|
|
const arr = [];
|
|
arr.push(ris);
|
|
return arr;
|
|
}
|
|
else {
|
|
return rec;
|
|
}
|
|
}
|
|
).then(async (rec) => {
|
|
|
|
const { User } = require('./user');
|
|
|
|
if (!!rec) {
|
|
if (rec.length > 0) {
|
|
// console.log('rec', rec);
|
|
// console.table('myrigacol', myrigacol);
|
|
if (!!rec[0]) {
|
|
const newrec = await User.getSmallRecByIndOrder(myrigacol.idapp, rec[0].ind_order);
|
|
if (!!newrec) {
|
|
let myarr = {};
|
|
if (rec[0]._doc === undefined)
|
|
myarr = { ...newrec._doc, ...rec[0] };
|
|
else
|
|
myarr = { ...newrec._doc, ...rec[0]._doc };
|
|
return myarr;
|
|
} else {
|
|
let myarr = null;
|
|
if (!!newrec) {
|
|
if (rec[0]._doc === undefined)
|
|
myarr = { ...newrec._doc, ...rec[0] };
|
|
else
|
|
myarr = { ...newrec._doc, ...rec[0]._doc };
|
|
}
|
|
return myarr;
|
|
}
|
|
} else {
|
|
const ris = await ListaIngresso.findByIndOrder(myrigacol.idapp, 0);
|
|
if (!!ris)
|
|
return ris[0]
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}).catch((e) => {
|
|
console.error(e);
|
|
});
|
|
|
|
}
|
|
;
|
|
|
|
|
|
NaveSchema.statics.findSognatoriByFuoco = async function (idapp, riga, col, offset) {
|
|
const Nave = this;
|
|
|
|
// const myrigacol = getRigaColSognatoreByFuoco(idapp, riga, col);
|
|
|
|
// return Nave.findGeneric(myrigacol);
|
|
|
|
return [await Nave.findRecByRigaColParent(idapp, riga, col, 6 - offset),
|
|
await Nave.findRecByRigaColParent(idapp, riga, col, 5 - offset),
|
|
await Nave.findRecByRigaColParent(idapp, riga, col, 4 - offset)
|
|
]
|
|
|
|
};
|
|
|
|
|
|
NaveSchema.statics.findMediatoreByFuoco = async function (idapp, riga, col, offset) {
|
|
const Nave = this;
|
|
|
|
// const myrigacol = getRigaColMediatoreByFuoco(idapp, riga, col);
|
|
// return Nave.findGeneric(myrigacol);
|
|
return await Nave.findRecByRigaColParent(idapp, riga, col, 3 - offset);
|
|
|
|
};
|
|
|
|
function getQueryProj(myfilter) {
|
|
|
|
myobjField = {
|
|
_id: 1,
|
|
idapp: 1,
|
|
lang: 1,
|
|
ind_order: 1,
|
|
name: 1,
|
|
surname: 1,
|
|
username: 1,
|
|
'profile.paymenttypes': 1,
|
|
'profile.email_paypal': 1,
|
|
date_start: 1,
|
|
date_gift_chat_open: 1,
|
|
made_gift: 1,
|
|
link_chat: 1,
|
|
sent_msg_howto_make_gift: 1,
|
|
date_made_gift: 1,
|
|
provvisoria: 1,
|
|
note: 1,
|
|
note_interne: 1,
|
|
received_gift: 1,
|
|
date_received_gift: 1,
|
|
num_tess: 1,
|
|
indprimario: 1,
|
|
parent_id: 1,
|
|
riga: 1,
|
|
col: 1,
|
|
created: 1,
|
|
};
|
|
|
|
const query = [
|
|
{ $match: myfilter },
|
|
{
|
|
$lookup: {
|
|
from: "users",
|
|
localField: "ind_order",
|
|
foreignField: "ind_order", // field in the user collection
|
|
as: "user"
|
|
}
|
|
},
|
|
{
|
|
$replaceRoot: { newRoot: { $mergeObjects: [{ $arrayElemAt: ["$user", 0] }, "$$ROOT"] } }
|
|
// $replaceRoot: { newRoot: { $mergeObjects: [{ $arrayElemAt: ["$user", 0] },] } }
|
|
},
|
|
{ $project: myobjField }
|
|
];
|
|
|
|
return query;
|
|
}
|
|
|
|
|
|
NaveSchema.statics.setRiga = function (idapp, riga) {
|
|
return Settings.setKeyNum(idapp, 'riga', riga);
|
|
};
|
|
|
|
NaveSchema.statics.getRiga = function (idapp) {
|
|
return Settings.getKeyNum(idapp, 'riga', 1);
|
|
};
|
|
|
|
NaveSchema.statics.setCol = function (idapp, col) {
|
|
return Settings.setKeyNum(idapp, 'col', col);
|
|
};
|
|
|
|
NaveSchema.statics.getCol = function (idapp) {
|
|
return Settings.getKeyNum(idapp, 'col', 1);
|
|
};
|
|
|
|
function getmaxcol(riga) {
|
|
|
|
return Math.pow(2, riga - 1);
|
|
}
|
|
|
|
function getPrimoFuocoByIndCol(col) {
|
|
// let ris = Math.ceil(col - (col % 8)) + 1;
|
|
let ris = ((Math.ceil(col / 8) - 1) * 8) + 1;
|
|
if (ris <= 0)
|
|
ris = 1;
|
|
return ris
|
|
}
|
|
|
|
async function getusertextbyrec(myrec, symbol, lettera, riga, col, ind) {
|
|
let visu_test = false;
|
|
if (!!myrec)
|
|
visu_test = await Settings.getValDbSettings(myrec.idapp, 'VISU_TEST');
|
|
|
|
if (!visu_test) {
|
|
if (myrec)
|
|
return lettera + ind + ' - ' + symbol + ' ' + myrec.name + ' ' + tools.getFirst2Car(myrec.surname) + ' (' + myrec.username + ')';
|
|
else
|
|
return lettera + ind + ' - ' + symbol;
|
|
|
|
} else {
|
|
if (myrec)
|
|
return lettera + ind + ' - ' + symbol + '[' + riga + ',' + col + ']' + ' ' + myrec.name + ' ' + myrec.surname + '';
|
|
else
|
|
return lettera + ind + ' - ' + symbol;
|
|
}
|
|
}
|
|
|
|
function checkifNullThenEmpty(rec, riga, col) {
|
|
if (rec === null) {
|
|
return {
|
|
name: '',
|
|
surname: '',
|
|
username: '',
|
|
riga,
|
|
col,
|
|
}
|
|
} else {
|
|
return rec;
|
|
}
|
|
}
|
|
|
|
NaveSchema.statics.getPlaccaGenerica = async function (idapp, riga, col, offset, solorecord) {
|
|
const Nave = this;
|
|
|
|
try {
|
|
let recsognatori = await Nave.findSognatoriByFuoco(idapp, riga, col, offset);
|
|
let recmediatore = await Nave.findMediatoreByFuoco(idapp, riga, col, offset);
|
|
|
|
let primofuoco = getPrimoFuocoByIndCol(col);
|
|
|
|
mystr = tools.ACAPO;
|
|
|
|
mystr += 'GIFTING CHAT (' + riga + '.' + col + ') ' + tools.ACAPO + tools.ACAPO;
|
|
|
|
if (offset === tools.Placca.SONOFUOCO) {
|
|
mystr += tools.Placca.SOGNATORE + tools.Placca.STR_SOGNATORE + ': ' + await getusertextbyrec(recsognatori[0], '', '', riga, col, '') + tools.ACAPO + tools.ACAPO;
|
|
mystr += tools.Placca.MEDIATORE + tools.Placca.STR_MEDIATORE + ': ' + await getusertextbyrec(recmediatore, '', '', riga, col, '') + tools.ACAPO + tools.ACAPO;
|
|
}
|
|
|
|
if (offset === tools.Placca.SONOACQUA) {
|
|
mystr += tools.Placca.SOGNATORE + tools.Placca.STR_SOGNATORE + ': ' + await getusertextbyrec(recmediatore, '', '', riga, col, '') + tools.ACAPO + tools.ACAPO;
|
|
}
|
|
|
|
let symb = {
|
|
car: 'D',
|
|
icona: '🔥'
|
|
};
|
|
|
|
if (offset === tools.Placca.SONOFUOCO) {
|
|
mystr += tools.Placca.STR_DONATORI + ':' + tools.ACAPO;
|
|
} else if (offset === tools.Placca.SONOACQUA) {
|
|
mystr += tools.Placca.STR_MEDIATORI + ':' + tools.ACAPO;
|
|
symb = {
|
|
car: 'A',
|
|
icona: '💦'
|
|
};
|
|
}
|
|
|
|
// mystr += '🔥🌏💦💨🔥🌏💦💨' + tools.ACAPO;
|
|
|
|
let arrdonatori = [];
|
|
// let numcol = Math.pow(2, indriga - 1);
|
|
primofuoco = getPrimoFuocoByIndCol(col * Math.pow(2, offset));
|
|
|
|
let ind = 1;
|
|
for (let indcol = primofuoco; indcol < primofuoco + 8; indcol++) {
|
|
let indr = riga + offset;
|
|
let indc = indcol + (offset * indr);
|
|
|
|
indr = riga + offset;
|
|
// indc = calcval(riga, col, 8) + (indcol - primofuoco + 1);
|
|
if (offset === 0)
|
|
indc = indcol;
|
|
else
|
|
indc = indcol;
|
|
// miacol = calcval(riga, col, 8) + (indfuoco);
|
|
|
|
|
|
let recfuoco = await Nave.findByRigaCol(idapp, indr, indc, true);
|
|
recfuoco = checkifNullThenEmpty(recfuoco, indr, indc);
|
|
arrdonatori.push({ index: ind, ...recfuoco });
|
|
mystr += await getusertextbyrec(recfuoco, symb.icona, symb.car, indr, indc, ind) + tools.ACAPO;
|
|
ind++;
|
|
}
|
|
|
|
if (solorecord) {
|
|
res = {
|
|
recsognatori,
|
|
recmediatore,
|
|
arrdonatori
|
|
};
|
|
|
|
return res;
|
|
} else {
|
|
return mystr;
|
|
}
|
|
|
|
} catch (e) {
|
|
console.error(e);
|
|
}
|
|
|
|
};
|
|
|
|
NaveSchema.statics.getPlaccaPerDonatore = async function (idapp, riga, col, solorecord, rec) {
|
|
const Nave = this;
|
|
|
|
if (solorecord) {
|
|
|
|
rec.donatore = await Nave.getPlaccaGenerica(idapp, riga, col, tools.Placca.SONOFUOCO, solorecord);
|
|
newcol = Math.ceil(col / (Math.pow(2, 3)));
|
|
rec.donatore.arrterra = await Nave.getArrTerra(idapp, riga - 3, newcol);
|
|
rec.donatore.arraria = await Nave.getArrAria(idapp, riga - 3, newcol);
|
|
|
|
return rec;
|
|
} else {
|
|
return await Nave.getPlaccaGenerica(idapp, riga, col, tools.Placca.SONOFUOCO, solorecord);
|
|
}
|
|
|
|
|
|
};
|
|
|
|
NaveSchema.statics.getPlaccaPerMediatore = async function (idapp, riga, col, solorecord, rec) {
|
|
const Nave = this;
|
|
rec.mediatore = await Nave.getPlaccaGenerica(idapp, riga, col, tools.Placca.SONOACQUA, solorecord);
|
|
|
|
rec.mediatore.arrterra = await Nave.getArrTerra(idapp, riga, col);
|
|
rec.mediatore.arraria = await Nave.getArrAria(idapp, riga, col);
|
|
|
|
return rec;
|
|
};
|
|
|
|
NaveSchema.statics.getArrTerra = async function (idapp, riga, col) {
|
|
const Nave = this;
|
|
|
|
let arrterra = [];
|
|
for (let indterra = 1; indterra <= 2; indterra++) {
|
|
miacol = calcval(riga, col, 2) + (indterra);
|
|
miariga = riga + 1;
|
|
let rec = await Nave.findByRigaCol(idapp, miariga, miacol, true);
|
|
rec = checkifNullThenEmpty(rec, miariga, miacol);
|
|
arrterra.push(rec);
|
|
}
|
|
|
|
return arrterra;
|
|
};
|
|
|
|
NaveSchema.statics.getArrAria = async function (idapp, riga, col) {
|
|
const Nave = this;
|
|
|
|
let arraria = [];
|
|
for (let indaria = 1; indaria <= 4; indaria++) {
|
|
miacol = calcval(riga, col, 4) + (indaria);
|
|
miariga = riga + 2;
|
|
let rec = await Nave.findByRigaCol(idapp, miariga, miacol, true);
|
|
rec = checkifNullThenEmpty(rec, miariga, miacol);
|
|
arraria.push(rec);
|
|
}
|
|
|
|
return arraria;
|
|
|
|
};
|
|
|
|
function calcval(riga, col, quanti) {
|
|
return (quanti * (col - 1));
|
|
}
|
|
|
|
NaveSchema.statics.getNavePos = async function (idapp, riga, col, solorecord) {
|
|
const Nave = this;
|
|
|
|
if (riga <= 0)
|
|
riga = 1;
|
|
if (col <= 0)
|
|
col = 1;
|
|
|
|
|
|
try {
|
|
let recsognatori = [await Nave.findRecByRigaColParent(idapp, riga, col, 3),
|
|
await Nave.findRecByRigaColParent(idapp, riga, col, 2),
|
|
await Nave.findRecByRigaColParent(idapp, riga, col, 1)];
|
|
|
|
let recmediatore = await Nave.findByRigaCol(idapp, riga, col, true);
|
|
|
|
|
|
mystr = '🌈SOGNATORE: ';
|
|
for (let indsogn = 0; indsogn < recsognatori.length; indsogn++) {
|
|
mystr += 'A' + (3 - indsogn) + await getusertextbyrec(recsognatori[indsogn], '', '', riga, col, '') + tools.ACAPO;
|
|
}
|
|
|
|
mystr += tools.ACAPO + '🌀 MEDIATORE:' + await getusertextbyrec(recmediatore, '', '', riga, col, '') + tools.ACAPO + tools.ACAPO;
|
|
|
|
for (let indterra = 1; indterra <= 2; indterra++) {
|
|
miacol = calcval(riga, col, 2) + (indterra);
|
|
miariga = riga + 1;
|
|
let recterra = await Nave.findByRigaCol(idapp, miariga, miacol, true);
|
|
mystr += await getusertextbyrec(recterra, '', 'B', miariga, miacol, indterra) + tools.ACAPO;
|
|
}
|
|
|
|
mystr += tools.ACAPO;
|
|
|
|
for (let indaria = 1; indaria <= 4; indaria++) {
|
|
miacol = calcval(riga, col, 4) + (indaria);
|
|
miariga = riga + 2;
|
|
let recaria = await Nave.findByRigaCol(idapp, miariga, miacol, true);
|
|
mystr += await getusertextbyrec(recaria, '', 'C', miariga, miacol, indaria) + tools.ACAPO;
|
|
}
|
|
|
|
mystr += tools.ACAPO;
|
|
|
|
let primofuoco = null;
|
|
|
|
mystr += '🎁 DONATORI:' + tools.ACAPO;
|
|
let donitotali = 0;
|
|
let donifatti = 0;
|
|
|
|
for (let indfuoco = 1; indfuoco <= 8; indfuoco++) {
|
|
miacol = calcval(riga, col, 8) + (indfuoco);
|
|
miariga = riga + 3;
|
|
// miariga = riga + 2;
|
|
let recfuoco = await Nave.findByRigaCol(idapp, miariga, miacol, true);
|
|
if (indfuoco === 1)
|
|
primofuoco = recfuoco;
|
|
|
|
let symbol = '';
|
|
if (recfuoco.made_gift) {
|
|
symbol = '🎁';
|
|
donifatti++;
|
|
}
|
|
if (!!recfuoco && recmediatore) {
|
|
if (recfuoco.ind_order === recmediatore.ind_order && recfuoco.num_tess === 2) {
|
|
mystr += await getusertextbyrec(recfuoco, '', 'TESS', miariga, miacol, '') + tools.ACAPO;
|
|
} else {
|
|
mystr += await getusertextbyrec(recfuoco, symbol, 'D', miariga, miacol, indfuoco) + tools.ACAPO;
|
|
donitotali++;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (donitotali > 0 && donifatti >= donitotali) {
|
|
mystr += tools.ACAPO + '💫💫💫💫💫💫💫💫💫💫💫💫💫💫💫💫💫💫' + tools.ACAPO +
|
|
'✨✨✨ NAVE COMPLETATA (Doni Effettuati) ! ✨✨✨' + tools.ACAPO +
|
|
'💫💫💫💫💫💫💫💫💫💫💫💫💫💫💫💫💫💫' + tools.ACAPO;
|
|
}
|
|
|
|
let data = "";
|
|
let mystrtemp = '';
|
|
if (primofuoco) {
|
|
data = '💬 Giorno di Apertura GIFT CHAT: ' + tools.getstrDateLong(primofuoco.date_gift_chat_open) + tools.ACAPO;
|
|
data += "🎁 Giorno in cui Inviare il DONO : " + tools.getstrDateLong(primofuoco.date_start) + tools.ACAPO;
|
|
if (!!recmediatore.note)
|
|
data += "Note: " + recmediatore.note + tools.ACAPO;
|
|
data += tools.ACAPO;
|
|
|
|
data += 'Il Mediatore sarà contattato 1 giorno prima dal Tutor' + tools.ACAPO;
|
|
|
|
if (primofuoco.provvisoria)
|
|
mystrtemp = 'TEMPORANEA ';
|
|
} else
|
|
data = "";
|
|
|
|
|
|
mystr = tools.ACAPO + 'NAVE ' + '[' + riga + '.' + col + '] ' + mystrtemp + tools.ACAPO + data + tools.ACAPO + mystr;
|
|
|
|
return mystr;
|
|
} catch (e) {
|
|
console.error(e);
|
|
return '';
|
|
}
|
|
|
|
};
|
|
|
|
async function Fuochi8Completati(idapp, params) {
|
|
// Inviare un msg al Mediatore che può aprire la Chat con gli 8 fuochi
|
|
const telegrambot = require('../telegram/telegrambot');
|
|
|
|
let text = '\nCompletata NAVE [riga=' + params.riga + ',col=' + params.col + ', ind_order=' + params.ind_order + ']';
|
|
console.log(text);
|
|
tools.writeNaveLog(text);
|
|
|
|
const { User } = require('./user');
|
|
|
|
const rec = await User.findByIndOrder(idapp, params.ind_order);
|
|
|
|
text = await Nave.getNaveByUser(idapp, params.ind_order, rec.lang, true);
|
|
|
|
// Inviare un msg a questi 8 Fuochi, che la loro placca è Pronta !
|
|
|
|
if (tools.isAbilitaNave(idapp)) {
|
|
// .............
|
|
}
|
|
|
|
if (false) {
|
|
await telegrambot.sendMsgTelegram(idapp, rec.username, text, true);
|
|
} else {
|
|
await telegrambot.sendMsgTelegramToTheAdmin(idapp, text);
|
|
}
|
|
|
|
// Inviare la placca a Managers
|
|
// await telegrambot.sendMsgTelegramToTheManagers(idapp, txt);
|
|
}
|
|
|
|
NaveSchema.statics.getArrPosizioniByIndOrder = async function (idapp, ind_order) {
|
|
const Nave = this;
|
|
|
|
arrposizioni = await Nave.find({ 'idapp': idapp, ind_order }).sort({ riga: 1, col: 1 });
|
|
|
|
return arrposizioni;
|
|
};
|
|
|
|
NaveSchema.statics.getPrimaNaveByRiga = async function (idapp, riga) {
|
|
const Nave = this;
|
|
|
|
nave = await Nave.findOne({ 'idapp': idapp, riga: (riga + 3), col: 1 });
|
|
|
|
return nave;
|
|
};
|
|
|
|
NaveSchema.statics.showListaOrd = async function (idapp) {
|
|
const Nave = this;
|
|
|
|
const myquery = getQueryProj({ idapp });
|
|
|
|
arrrec = await Nave.aggregate(myquery).sort({ riga: 1, col: 1 });
|
|
|
|
let mystr = '';
|
|
let conta = 1;
|
|
for (const rec of arrrec) {
|
|
mystr += '[' + conta + '] [' + rec.riga + '.' + rec.col + '] ' + rec.ind_order + ' ' + rec.name + ' ' + rec.surname + ' (' + tools.getstrDateShort(rec.date_start) + ')\n';
|
|
conta++;
|
|
}
|
|
|
|
|
|
return mystr;
|
|
};
|
|
|
|
NaveSchema.statics.getLastRigaCol = async function (idapp) {
|
|
return Nave.findOne({ idapp }).sort({ _id: -1 });
|
|
};
|
|
|
|
async function addRecordNaveByParams(params, siRitesse) {
|
|
const { ListaIngresso } = require('./listaingresso');
|
|
|
|
if (!siRitesse) {
|
|
// Check if Exist:
|
|
const giapresente = await Nave.findOne({
|
|
idapp: params.idapp,
|
|
ind_order: params.ind_order,
|
|
num_tess: params.num_tess
|
|
});
|
|
if (!!giapresente) {
|
|
let fields_to_update = { added: true };
|
|
await ListaIngresso.findOneAndUpdate({ _id: params.id.toString() }, { $set: fields_to_update }, { new: false });
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
let myNave = new Nave({
|
|
idapp: params.idapp,
|
|
indprimario: params.indprimario,
|
|
ind_order: params.ind_order,
|
|
riga: params.riga,
|
|
col: params.col,
|
|
date_start: params.date_start,
|
|
date_gift_chat_open: params.date_gift_chat_open,
|
|
num_tess: params.num_tess,
|
|
provvisoria: params.provvisoria,
|
|
});
|
|
myNave.created = new Date();
|
|
|
|
console.log('[' + params.riga + ',' + params.col + ']');
|
|
|
|
const recfindparent = await Nave.findByRigaCol(idapp, params.rigaparent, params.colparent, false);
|
|
if (!!recfindparent) {
|
|
myNave.parent_id = recfindparent._id;
|
|
} else {
|
|
myNave.parent_id = "0";
|
|
}
|
|
|
|
console.log('addRecordNaveByParams (' + myNave.parent_id + ')');
|
|
|
|
return await myNave.save()
|
|
.then(async (result) => {
|
|
|
|
if (!!result) {
|
|
|
|
let fields_to_update = { added: true };
|
|
await ListaIngresso.findOneAndUpdate({ _id: params.id.toString() }, { $set: fields_to_update }, { new: false });
|
|
|
|
params.conta++;
|
|
|
|
// Check if the Ship has Completed
|
|
if (idapp === tools.AYNI) {
|
|
if ((params.col % 8) === 0) {
|
|
// Completed 8 people
|
|
if (!params.primavolta) {
|
|
await Fuochi8Completati(idapp, params);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Next
|
|
if (params.col === params.maxcol) {
|
|
params.riga++;
|
|
params.rigaparent = params.riga - 1;
|
|
params.col = 1;
|
|
params.maxcol = getmaxcol(params.riga);
|
|
} else {
|
|
params.col++;
|
|
}
|
|
|
|
if (params.riga === 2)
|
|
params.colparent = 1;
|
|
else
|
|
params.colparent = Math.ceil(params.col / 2);
|
|
|
|
await Nave.setRiga(idapp, params.riga);
|
|
await Nave.setCol(idapp, params.col);
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
|
|
}).catch((e) => {
|
|
console.error(e);
|
|
});
|
|
}
|
|
|
|
NaveSchema.statics.checkifDeveRitessersi = async function (recuser) {
|
|
const Nave = this;
|
|
|
|
let deveritessersi = true;
|
|
|
|
arrrec = await Nave.find({ idapp: recuser.idapp, ind_order: recuser.ind_order });
|
|
|
|
if (!!arrrec) {
|
|
if (arrrec.length > 2) {
|
|
// deveritessersi = await User.deveRitessersi(recuser.idapp, recuser.ind_order)
|
|
deveritessersi = false;
|
|
}
|
|
}
|
|
|
|
return { deveritessersi, num_tess: arrrec.length };
|
|
|
|
};
|
|
|
|
|
|
NaveSchema.statics.addUserFromListaIngresso_IntoNave = async function (init, idapp, params, addednowreal) {
|
|
const Nave = this;
|
|
|
|
const { User } = require('./user');
|
|
|
|
if (init) {
|
|
params.idapp = idapp;
|
|
params.conta = 0;
|
|
}
|
|
|
|
params.primavolta = (params.riga === 1) && (params.col === 1);
|
|
params.riga = await Nave.getRiga(idapp);
|
|
params.col = await Nave.getCol(idapp);
|
|
params.maxcol = getmaxcol(params.riga);
|
|
params.colparent = Math.ceil(params.col / 2);
|
|
params.rigaparent = params.riga - 1;
|
|
|
|
myriga = params.riga;
|
|
mycol = params.col;
|
|
|
|
const inserito = await addRecordNaveByParams(params, false);
|
|
if (inserito) {
|
|
if (idapp === tools.AYNI) {
|
|
if (((params.col) % 8) === 0) {
|
|
// Trova se la persona di 3 livelli sopra, si deve ritessere
|
|
let recmediatore = await Nave.findMediatoreByFuoco(idapp, myriga, mycol, 0);
|
|
if (!!recmediatore) {
|
|
const ris = await Nave.checkifDeveRitessersi(recmediatore);
|
|
if (ris.num_tess >= 2) {
|
|
console.log('E\' arrivato alla TERZA RITESSITURA, PERTANTO LO METTIAMO IN CODA... [riga=', params.riga, 'col', params.col, '] indorder=' + recmediatore.ind_order);
|
|
// E' arrivato alla TERZA RITESSITURA, PERTANTO LO METTIAMO IN CODA...
|
|
|
|
//++Todo: TESSITURA????
|
|
|
|
//const risultato = await ListaIngresso.addUserInListaIngresso(idapp, recmediatore.ind_order, rec.lang, false, ris.num_tess);
|
|
|
|
} else {
|
|
console.log('Si deve ritessere: [riga=', params.riga, 'col', params.col, ']');
|
|
if (ris.deveritessersi) {
|
|
params.indprimario = recmediatore.indprimario;
|
|
params.ind_order = recmediatore.ind_order;
|
|
params.id = recmediatore._id;
|
|
params.num_tess = ris.num_tess;
|
|
|
|
await addRecordNaveByParams(params, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if ((params.riga === 4 + 3) && (params.col === (8 * 2) + 3)) {
|
|
// Si ritesse il Fondo AYNI nella Nave 3.3
|
|
const userFondo = await User.findByIndOrder(idapp, 0);
|
|
params.indprimario = userFondo.indprimario;
|
|
params.ind_order = userFondo.ind_order;
|
|
params.id = userFondo._id;
|
|
params.num_tess = userFondo.num_tess;
|
|
|
|
await addRecordNaveByParams(params, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Se ho completato 8 persone, allora
|
|
if (addednowreal) {
|
|
|
|
}
|
|
|
|
};
|
|
|
|
NaveSchema.statics.generaNave = async function (idapp, mydata) {
|
|
const Nave = this;
|
|
|
|
const { User } = require('./user');
|
|
const { ListaIngresso } = require('./listaingresso');
|
|
|
|
let params = {
|
|
idapp,
|
|
riga: await Nave.getRiga(idapp),
|
|
col: await Nave.getCol(idapp),
|
|
date_start: mydata.date_start,
|
|
date_gift_chat_open: tools.AddDate(mydata.date_start, -7),
|
|
numpersone: mydata.numpersone,
|
|
};
|
|
|
|
params.primavolta = (params.riga === 1) && (params.col === 1);
|
|
// params.primavolta = false;
|
|
|
|
const recfindFondo = await Nave.findByRigaCol(params.idapp, 0, 0, true);
|
|
if (!recfindFondo) {
|
|
let myNave = new Nave({ idapp, indprimario: 0, ind_order: 0, riga: 0, col: 0 });
|
|
myNave.created = new Date();
|
|
myNave.parent_id = ObjectID("5e592aecbfd0b75f3021d9c9");
|
|
myNave.date_start = params.date_start;
|
|
await myNave.save();
|
|
|
|
const userFondo = await User.findByIndOrder(idapp, 0);
|
|
if (!userFondo || userFondo === undefined) {
|
|
await telegrambot.sendMsgTelegramToTheAdmin(idapp, 'Devi creare l\'utente FONDO , con ind_order = 0 ! ');
|
|
}
|
|
}
|
|
|
|
const arrlistaingresso = await ListaIngresso.getProssimiInLista(idapp, true);
|
|
|
|
let index = 0;
|
|
for (const reclista of arrlistaingresso) {
|
|
|
|
params.indprimario = reclista.indprimario;
|
|
params.ind_order = reclista.ind_order;
|
|
params.id = reclista._id;
|
|
params.num_tess = reclista.num_tess;
|
|
params.provvisoria = mydata.provvisoria;
|
|
|
|
await Nave.addUserFromListaIngresso_IntoNave(index === 0, idapp, params, false);
|
|
index++;
|
|
|
|
if (index >= params.numpersone)
|
|
break;
|
|
}
|
|
|
|
return params.conta;
|
|
|
|
};
|
|
|
|
async function addUserToNave(idapp, rec) {
|
|
|
|
let params = {};
|
|
|
|
params.indprimario = rec.indprimario;
|
|
params.ind_order = rec.ind_order;
|
|
params.id = rec._id;
|
|
params.num_tess = rec.num_tess;
|
|
params.provvisoria = false;
|
|
|
|
return await Nave.addUserFromListaIngresso_IntoNave(true, idapp, params, true);
|
|
|
|
}
|
|
|
|
NaveSchema.statics.checkIfDevoAggiungereInNave = async function (idapp) {
|
|
|
|
const { ListaIngresso } = require('./listaingresso');
|
|
|
|
// Ottieni la lista Ordinata in base al numero d'invitati
|
|
arrlista = await ListaIngresso.getProssimiInLista(idapp, false);
|
|
|
|
for (const rec of arrlista) {
|
|
if (rec.numinvitatiattivi >= 2) {
|
|
await addUserToNave(idapp, rec);
|
|
}
|
|
}
|
|
|
|
};
|
|
|
|
NaveSchema.statics.pulisciNonPresenzeInNave = async function (idapp) {
|
|
const Nave = this;
|
|
|
|
let numrec = 0;
|
|
|
|
const { ListaIngresso } = require('./listaingresso');
|
|
|
|
const myquery = getQueryProj({
|
|
idapp,
|
|
ind_order: { $gt: 0 },
|
|
added: true,
|
|
deleted: false,
|
|
});
|
|
|
|
arrrec = await ListaIngresso.aggregate(myquery)
|
|
.then(async (arrlista) => {
|
|
for (const rec of arrlista) {
|
|
const trovato = await Nave.findByIndOrder(idapp, rec.ind_order);
|
|
if (!trovato) {
|
|
let fields_to_update = { added: false };
|
|
await ListaIngresso.findOneAndUpdate({ _id: rec._id }, { $set: fields_to_update }, { new: false });
|
|
numrec++;
|
|
}
|
|
}
|
|
|
|
});
|
|
|
|
return numrec;
|
|
|
|
};
|
|
|
|
NaveSchema.statics.getNaveByUser = async function (idapp, ind_order, lang, fuoco) {
|
|
const Nave = this;
|
|
|
|
let mystr = '';
|
|
let rec = {};
|
|
const arrposiz = await Nave.getArrPosizioniByIndOrder(idapp, ind_order);
|
|
if (!!arrposiz) {
|
|
for (const pos of arrposiz) {
|
|
let mypos = {
|
|
riga: pos.riga,
|
|
col: pos.col,
|
|
numup: 3,
|
|
};
|
|
tools.getRigaColByPosUp(mypos);
|
|
|
|
mystr += await Nave.getNavePos(idapp, mypos.riga, mypos.col, false);
|
|
// mystr += await Nave.getPlaccaPerDonatore(idapp, pos.riga, pos.col, false, rec);
|
|
// mystr += await Nave.getPlaccaPerMediatore(idapp, pos.riga, pos.col, false, rec);
|
|
}
|
|
}
|
|
|
|
return mystr;
|
|
};
|
|
|
|
NaveSchema.statics.getNaveByRigaCol = async function (idapp, riganave, colnave) {
|
|
const Nave = this;
|
|
|
|
const rigaprec = riganave;
|
|
|
|
rec = {};
|
|
rec = await Nave.getPlaccaPerMediatore(idapp, riganave, colnave, true, rec);
|
|
|
|
if (riganave < 4) {
|
|
riganave = 4;
|
|
colnave = 1;
|
|
}
|
|
rec = await Nave.getPlaccaPerDonatore(idapp, riganave, colnave, true, rec);
|
|
|
|
return rec;
|
|
};
|
|
|
|
NaveSchema.statics.getDonatoridelSognatore = async function (idapp, riganave, colnave) {
|
|
const Nave = this;
|
|
|
|
coldonatoreIni = calcval(riganave, colnave, 8) + (1);
|
|
coldonatoreFine = calcval(riganave, colnave, 8) + (64);
|
|
|
|
const myquery = getQueryProj({
|
|
idapp,
|
|
riga: riganave + 6,
|
|
col: { $gte: coldonatoreIni, $lte: coldonatoreFine }
|
|
});
|
|
|
|
const arrnaviout = [];
|
|
|
|
const arrnavi = await Nave.aggregate(myquery);
|
|
|
|
for (const nave of arrnavi) {
|
|
// Se è il mediatore, allora non includerlo nei Donatori!
|
|
mypos = {
|
|
riga: nave.riga,
|
|
col: nave.col,
|
|
numup: 3,
|
|
};
|
|
|
|
tools.getRigaColByPosUp(mypos);
|
|
|
|
const navemediatore = await Nave.findByRigaCol(idapp, mypos.riga, mypos.col, true);
|
|
if (!!navemediatore) {
|
|
if (navemediatore.ind_order !== nave.ind_order) {
|
|
arrnaviout.push(nave);
|
|
}
|
|
} else {
|
|
arrnaviout.push(nave);
|
|
}
|
|
}
|
|
|
|
return arrnaviout;
|
|
|
|
};
|
|
|
|
const Nave = mongoose.model('Nave', NaveSchema);
|
|
|
|
module.exports = { Nave };
|
|
|
|
|