660 lines
14 KiB
JavaScript
Executable File
660 lines
14 KiB
JavaScript
Executable File
const mongoose = require('mongoose').set('debug', false);
|
|
const Schema = mongoose.Schema;
|
|
|
|
const tools = require('../tools/general');
|
|
|
|
const shared_consts = require('../tools/shared_nodejs');
|
|
|
|
mongoose.Promise = global.Promise;
|
|
mongoose.level = 'F';
|
|
|
|
const { ObjectID } = require('mongodb');
|
|
|
|
// Resolving error Unknown modifier: $pushAll
|
|
mongoose.plugin(schema => {
|
|
schema.options.usePushEach = true;
|
|
});
|
|
|
|
const MyGroupSchema = new Schema({
|
|
_id: {
|
|
type: String,
|
|
default: function () {
|
|
return new ObjectID().toString();
|
|
},
|
|
},
|
|
idapp: {
|
|
type: String,
|
|
},
|
|
groupname: {
|
|
type: String,
|
|
},
|
|
title: {
|
|
type: String,
|
|
},
|
|
descr: {
|
|
type: String,
|
|
},
|
|
idCatGrp: {
|
|
type: Number,
|
|
},
|
|
userId: {
|
|
type: String,
|
|
},
|
|
photos: [
|
|
{
|
|
imagefile: {
|
|
type: String,
|
|
},
|
|
alt: {
|
|
type: String,
|
|
},
|
|
description: {
|
|
type: String,
|
|
},
|
|
}],
|
|
idCity: [
|
|
{
|
|
type: Number,
|
|
}],
|
|
website: {
|
|
type: String,
|
|
},
|
|
link_telegram: {
|
|
type: String,
|
|
},
|
|
note: {
|
|
type: String,
|
|
default: '',
|
|
},
|
|
//**ADDFIELD_MYGROUPS
|
|
visibility: [
|
|
{
|
|
type: Number,
|
|
},
|
|
],
|
|
pwd_cryp: {
|
|
type: String,
|
|
},
|
|
createdBy: {
|
|
type: String,
|
|
},
|
|
admins: [
|
|
{
|
|
username: { type: String },
|
|
perm: { type: Number },
|
|
date: { type: Date },
|
|
},
|
|
],
|
|
blocked: {
|
|
type: Boolean,
|
|
},
|
|
username_who_block: {
|
|
type: String,
|
|
},
|
|
date_created: {
|
|
type: Date,
|
|
},
|
|
date_updated: {
|
|
type: Date,
|
|
},
|
|
date_blocked: {
|
|
type: Date,
|
|
},
|
|
req_users: [
|
|
{
|
|
_id: false,
|
|
username: { type: String },
|
|
date: { type: Date },
|
|
}], // username
|
|
refused_users: [
|
|
{
|
|
_id: false,
|
|
username: { type: String },
|
|
date: { type: Date },
|
|
}], // username
|
|
deleted: {
|
|
type: Boolean,
|
|
default: false,
|
|
},
|
|
mycircuits: [
|
|
{
|
|
_id: false,
|
|
circuitname: { type: String },
|
|
date: { type: Date },
|
|
}],
|
|
lastdate_reqRisGroup: {
|
|
type: Date,
|
|
},
|
|
});
|
|
|
|
MyGroupSchema.statics.getFieldsForSearch = function () {
|
|
return [{ field: 'descr', type: tools.FieldType.string }];
|
|
};
|
|
|
|
MyGroupSchema.statics.executeQueryTable = function (idapp, params, user) {
|
|
params.fieldsearch = this.getFieldsForSearch();
|
|
|
|
const { User } = require('./user');
|
|
|
|
if (params.options) {
|
|
if (tools.isBitActive(params.options, shared_consts.OPTIONS_SEARCH_USER_ONLY_FULL_WORDS)) {
|
|
params.fieldsearch = User.getFieldsForSearchUserFriend();
|
|
} else if (tools.isBitActive(params.options, shared_consts.OPTIONS_SEARCH_USER_ALL_WORDS)) {
|
|
params.fieldsearch = User.getFieldsForSearchUserFriend_AllWords();
|
|
}
|
|
}
|
|
|
|
return tools.executeQueryTable(this, idapp, params, user);
|
|
};
|
|
|
|
MyGroupSchema.pre('save', async function (next) {
|
|
if (this.isNew) {
|
|
if (!this.date_created)
|
|
this.date_created = new Date();
|
|
}
|
|
|
|
next();
|
|
});
|
|
|
|
MyGroupSchema.statics.findAllIdApp = async function (idapp) {
|
|
const myfind = { idapp };
|
|
|
|
return await MyGroup.find(myfind);
|
|
};
|
|
|
|
MyGroupSchema.statics.findAllGroups = async function (idapp) {
|
|
|
|
const whatToShow = this.getWhatToShow(idapp, '');
|
|
|
|
return await MyGroup.find({
|
|
idapp,
|
|
$or: [
|
|
{ deleted: { $exists: false } },
|
|
{ deleted: { $exists: true, $eq: false } }],
|
|
}, whatToShow);
|
|
};
|
|
|
|
// Rimuovo la Richiesta del Gruppo
|
|
MyGroupSchema.statics.removeReqGroup = async function (idapp, username, groupnameDest) {
|
|
|
|
return await MyGroup.updateOne({ idapp, groupname: groupnameDest },
|
|
{ $pull: { req_users: { username: { $in: [username] } } } });
|
|
};
|
|
|
|
// Aggiungi agli utenti Rifiutati del Gruppo
|
|
MyGroupSchema.statics.refuseReqGroup = async function (idapp, username, groupnameDest) {
|
|
|
|
return await MyGroup.updateOne({ idapp, groupname: groupnameDest },
|
|
{
|
|
$push:
|
|
{
|
|
refused_users: {
|
|
username,
|
|
date: new Date(),
|
|
},
|
|
},
|
|
});
|
|
|
|
};
|
|
|
|
// Aggiungi agli Admin del Gruppo
|
|
MyGroupSchema.statics.addToAdminOfMyGroup = async function (idapp, username, groupnameDest) {
|
|
|
|
return await MyGroup.updateOne({ idapp, groupname: groupnameDest },
|
|
{
|
|
$push:
|
|
{
|
|
admins: {
|
|
username,
|
|
date: new Date(),
|
|
},
|
|
},
|
|
});
|
|
|
|
};
|
|
|
|
// Rimuovi dagli Admin del Gruppo
|
|
MyGroupSchema.statics.removeAdminOfMyGroup = async function (idapp, username, groupnameDest) {
|
|
|
|
return await MyGroup.updateOne({ idapp, groupname: groupnameDest },
|
|
{ $pull: { admins: { username: { $in: [username] } } } });
|
|
};
|
|
|
|
MyGroupSchema.statics.getListAdminsByGroupName = async function (idapp, groupname) {
|
|
|
|
let arr = await MyGroup.findOne({
|
|
idapp,
|
|
groupname,
|
|
$or: [
|
|
{ deleted: { $exists: false } },
|
|
{ deleted: { $exists: true, $eq: false } }],
|
|
}, { admins: 1 }).lean();
|
|
|
|
return arr && arr.admins ? arr.admins : [];
|
|
|
|
};
|
|
|
|
MyGroupSchema.statics.getWhatToShow = function (idapp, username) {
|
|
// FOR ME, PERMIT ALL
|
|
return {
|
|
groupname: 1,
|
|
title: 1,
|
|
descr: 1,
|
|
visibility: 1,
|
|
idCatGrp: 1,
|
|
userId: 1,
|
|
photos: 1,
|
|
idCity: 1,
|
|
website: 1,
|
|
//**ADDFIELD_MYGROUPS
|
|
link_telegram: 1,
|
|
note: 1,
|
|
admins: 1,
|
|
blocked: 1,
|
|
req_users: 1,
|
|
refused_users: 1,
|
|
createdBy: 1,
|
|
date_created: 1,
|
|
date_updated: 1,
|
|
mycircuits: 1,
|
|
lastdate_reqRisGroup: 1,
|
|
};
|
|
|
|
};
|
|
|
|
MyGroupSchema.statics.getWhatToShow_Unknown = function (idapp, username) {
|
|
return {
|
|
groupname: 1,
|
|
title: 1,
|
|
descr: 1,
|
|
photos: 1,
|
|
visibility: 1,
|
|
idCatGrp: 1,
|
|
idCity: 1,
|
|
note: 1,
|
|
date_created: 1,
|
|
date_updated: 1,
|
|
mycircuits: 1,
|
|
lastdate_reqRisGroup: 1,
|
|
};
|
|
};
|
|
|
|
MyGroupSchema.statics.getArrUsernameFromFieldByGroupname = async function (
|
|
idapp, groupname, field) {
|
|
|
|
const { User } = require('../models/user');
|
|
|
|
const myobj = {};
|
|
myobj[field + '.' + subfield] = 1;
|
|
|
|
let arrrec = await User.findOne({
|
|
idapp,
|
|
groupname,
|
|
$or: [{ deleted: { $exists: false } }, { deleted: { $exists: true, $eq: false } }],
|
|
}, myobj).then((ris) => ris ? ris._doc[field] : []);
|
|
|
|
if (arrrec.length > 0) {
|
|
return arrrec.map(m => m.username);
|
|
}
|
|
return [];
|
|
|
|
};
|
|
|
|
MyGroupSchema.statics.getInfoGroupByGroupname = async function (idapp, groupname) {
|
|
|
|
const whatToShow = this.getWhatToShow(idapp, groupname);
|
|
|
|
const myfind = {
|
|
idapp,
|
|
groupname,
|
|
};
|
|
|
|
const query = [
|
|
{ $match: myfind },
|
|
{
|
|
$lookup: {
|
|
from: 'circuits',
|
|
localField: 'mycircuits.circuitname',
|
|
foreignField: 'name',
|
|
as: 'mycircuits',
|
|
},
|
|
},
|
|
{
|
|
'$replaceRoot': {
|
|
'newRoot': {
|
|
'$mergeObjects': [
|
|
{
|
|
'$arrayElemAt': [
|
|
'$mycircuits',
|
|
0,
|
|
],
|
|
},
|
|
'$$ROOT',
|
|
],
|
|
},
|
|
},
|
|
},
|
|
{ $project: whatToShow },
|
|
|
|
];
|
|
|
|
|
|
try {
|
|
const ris = await MyGroup.aggregate(query);
|
|
|
|
if (ris && ris.length > 0)
|
|
return ris[0];
|
|
} catch (e) {
|
|
return null;
|
|
}
|
|
|
|
return null;
|
|
|
|
};
|
|
|
|
MyGroupSchema.statics.deleteGroup = async function (idapp, usernameOrig, groupname) {
|
|
console.log('Gruppo ' + groupname + ' rimosso da ' + usernameOrig);
|
|
return await MyGroup.findOneAndRemove({ idapp, groupname });
|
|
};
|
|
|
|
MyGroupSchema.statics.getGroupsByUsername = async function (idapp, username, req) {
|
|
|
|
try {
|
|
const { User } = require('../models/user');
|
|
|
|
const whatToShow = this.getWhatToShow(idapp, username);
|
|
const whatToShow_Unknown = this.getWhatToShow_Unknown(idapp, username);
|
|
const arrUsernameGroups = await User.getUsernameGroupsByUsername(idapp, username);
|
|
// const arrUsernameReqGroups = await MyGroup.getUsernameReqGroupsByGroupname(idapp, username);
|
|
|
|
let listUsersGroup = await User.find({
|
|
idapp,
|
|
username: { $in: arrUsernameGroups },
|
|
$or: [
|
|
{ deleted: { $exists: false } },
|
|
{ deleted: { $exists: true, $eq: false } }],
|
|
}, whatToShow);
|
|
|
|
let listgroups = await MyGroup.find({
|
|
idapp,
|
|
$or: [
|
|
{ deleted: { $exists: false } },
|
|
{ deleted: { $exists: true, $eq: false } }],
|
|
}, whatToShow_Unknown);
|
|
|
|
/*let listRequestUsersGroup = await User.find({
|
|
idapp,
|
|
username: {$in: arrUsernameReqGroups},
|
|
$or: [
|
|
{deleted: {$exists: false}},
|
|
{deleted: {$exists: true, $eq: false}}],
|
|
}, whatToShow_Unknown);
|
|
|
|
*/
|
|
|
|
let listSentRequestGroups = await MyGroup.find({
|
|
idapp,
|
|
'req_users': {
|
|
$elemMatch: { username: { $eq: username } },
|
|
},
|
|
$or: [
|
|
{ deleted: { $exists: false } },
|
|
{ deleted: { $exists: true, $eq: false } }],
|
|
}, whatToShow_Unknown);
|
|
|
|
let listRefusedGroups = await MyGroup.find({
|
|
idapp,
|
|
'refused_users': {
|
|
$elemMatch: { username: { $eq: username } },
|
|
},
|
|
$or: [
|
|
{ deleted: { $exists: false } },
|
|
{ deleted: { $exists: true, $eq: false } }],
|
|
}, whatToShow_Unknown);
|
|
|
|
return {
|
|
listUsersGroup,
|
|
listgroups,
|
|
listSentRequestGroups,
|
|
listRefusedGroups,
|
|
mygroups: req.user.profile.mygroups,
|
|
};
|
|
|
|
} catch (e) {
|
|
console.log('Error', e);
|
|
}
|
|
|
|
return {
|
|
listUsersGroup: [],
|
|
listRequestUsersGroup: [],
|
|
listTrusted: [],
|
|
listSentRequestGroups: [],
|
|
listRefusedGroups: [],
|
|
|
|
};
|
|
};
|
|
|
|
MyGroupSchema.statics.extractCitiesName = async function (idapp, id) {
|
|
|
|
try {
|
|
let aggr1 = [
|
|
{
|
|
$match: { idapp, _id: id },
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: 'cities',
|
|
localField: 'idCity',
|
|
foreignField: '_id',
|
|
as: 'mycities',
|
|
},
|
|
},
|
|
{
|
|
'$replaceRoot': {
|
|
'newRoot': {
|
|
'$mergeObjects': [
|
|
{
|
|
'$arrayElemAt': [
|
|
'$mycities',
|
|
0,
|
|
],
|
|
},
|
|
'$$ROOT',
|
|
],
|
|
},
|
|
},
|
|
},
|
|
{
|
|
$project: {
|
|
"mycities.comune": 1,
|
|
"mycities.prov": 1
|
|
},
|
|
},
|
|
];
|
|
|
|
ris = await this.aggregate(aggr1);
|
|
|
|
return ris;
|
|
} catch (e) {
|
|
console.error('e', e);
|
|
}
|
|
|
|
};
|
|
|
|
MyGroupSchema.statics.ifCircuitAlreadyInGroup = async function (idapp, groupname, circuitname) {
|
|
|
|
// Controllo se è stato già inserito il circuito sul gruppo
|
|
return await this.findOne({
|
|
idapp,
|
|
groupname,
|
|
'mycircuits': {
|
|
$elemMatch: { circuitname: { $eq: circuitname } },
|
|
},
|
|
}).lean();
|
|
};
|
|
|
|
// aggiungo il Circuito all'interno del Gruppo
|
|
MyGroupSchema.statics.addCircuitFromGroup = async function (idapp, groupname, circuitname) {
|
|
return await this.updateOne({ idapp, groupname },
|
|
{
|
|
$push: {
|
|
'mycircuits': {
|
|
circuitname,
|
|
date: new Date(),
|
|
}
|
|
}
|
|
});
|
|
|
|
};
|
|
|
|
// Rimuovo il Circuito all'interno del Gruppo
|
|
MyGroupSchema.statics.removeCircuitFromGroup = async function (idapp, groupname, circuitname) {
|
|
|
|
|
|
const ris = await this.updateOne({ idapp, groupname },
|
|
{ $pull: { 'mycircuits': { circuitname: { $in: [circuitname] } } } });
|
|
|
|
const circuitId = await Circuit.getCircuitIdByName(idapp, circuitname);
|
|
let remove = false;
|
|
|
|
// Se il mio account non è stato utilizzato, allora lo cancello anche questo
|
|
const myaccount = await Account.getAccountByUsernameAndCircuitId(idapp, username, circuitId, false, false, groupname, '');
|
|
if (myaccount && myaccount.totTransato === 0) {
|
|
remove = true;
|
|
} else {
|
|
remove = true;
|
|
}
|
|
|
|
if (remove) {
|
|
await Account.removeAccount(myaccount._id);
|
|
}
|
|
|
|
};
|
|
|
|
MyGroupSchema.statics.getQueryReceiveRISGroups = function (idapp, hours) {
|
|
|
|
const query = [
|
|
{
|
|
$match: {
|
|
idapp,
|
|
'lastdate_reqRisGroup': { $gte: tools.IncDateNow(-(1000 * 60 * 60 * hours)) },
|
|
$or: [
|
|
{ deleted: { $exists: false } },
|
|
{ deleted: { $exists: true, $eq: false } }],
|
|
},
|
|
},
|
|
{
|
|
$group:
|
|
{
|
|
_id: "$groupname",
|
|
count: {
|
|
$sum: 1,
|
|
},
|
|
}
|
|
},
|
|
{ $sort: { 'lastdate_reqRisGroup': -1 } },
|
|
{ $limit: 30 },
|
|
{
|
|
$lookup: {
|
|
from: "mygroups",
|
|
let: {
|
|
groupname: "$_id",
|
|
idapp,
|
|
},
|
|
pipeline: [
|
|
{
|
|
$match: {
|
|
$expr: {
|
|
$and: [
|
|
{
|
|
$eq: [
|
|
"$$groupname",
|
|
"$groupname",
|
|
],
|
|
},
|
|
{
|
|
$eq: [
|
|
"$$idapp",
|
|
"$idapp",
|
|
],
|
|
},
|
|
],
|
|
},
|
|
},
|
|
},
|
|
],
|
|
as: "mygroup",
|
|
},
|
|
},
|
|
{ $unwind: "$mygroup" },
|
|
{
|
|
$replaceRoot: {
|
|
newRoot: {
|
|
$mergeObjects: ["$mygroup", "$$ROOT"],
|
|
},
|
|
},
|
|
},
|
|
{
|
|
$project: {
|
|
_id: 0,
|
|
groupname: 1,
|
|
title: 1,
|
|
descr: 1,
|
|
visibility: 1,
|
|
idCatGrp: 1,
|
|
userId: 1,
|
|
photos: 1,
|
|
idCity: 1,
|
|
website: 1,
|
|
link_telegram: 1,
|
|
note: 1,
|
|
admins: 1,
|
|
blocked: 1,
|
|
req_users: 1,
|
|
createdBy: 1,
|
|
date_created: 1,
|
|
date_updated: 1,
|
|
lastdate_reqRisGroup: 1,
|
|
},
|
|
},
|
|
];
|
|
return query;
|
|
};
|
|
|
|
|
|
MyGroupSchema.statics.getReceiveRISGroups = async function (idapp) {
|
|
|
|
return await this.aggregate(this.getQueryReceiveRISGroups(idapp, 8)).then(ris => {
|
|
return ris;
|
|
});
|
|
|
|
};
|
|
|
|
|
|
MyGroupSchema.statics.renameCircuitName = async function (idapp, oldcircuitname, newcircuitname) {
|
|
|
|
return await this.updateMany({ idapp, 'mycircuits.circuitname': oldcircuitname }, { $set: { 'profile.mycircuits.$.circuitname': newcircuitname } });
|
|
};
|
|
|
|
|
|
MyGroupSchema.statics.setReceiveRisGroup = async function (idapp, groupname) {
|
|
|
|
return await this.findOneAndUpdate({
|
|
idapp, groupname,
|
|
},
|
|
{ $set: { 'lastdate_reqRisGroup': new Date() } }, { new: false }).lean().then((record) => {
|
|
return !!record;
|
|
});
|
|
|
|
};
|
|
|
|
|
|
|
|
const MyGroup = mongoose.model('MyGroup', MyGroupSchema);
|
|
|
|
MyGroup.createIndexes((err) => {
|
|
if (err) throw err;
|
|
});
|
|
|
|
module.exports = { MyGroup };
|