freeplanet_serverside/src/server/models/sendnotif.js

const mongoose = require('mongoose').set('debug', false);
const Schema = mongoose.Schema;

mongoose.Promise = global.Promise;
mongoose.level = 'F';

const i18n = require('i18n');

const {ObjectID} = require('mongodb');

const shared_consts = require('../tools/shared_nodejs');

const globalTables = require('../tools/globalTables');

const tools = require('../tools/general');

// Resolving error Unknown modifier: $pushAll
mongoose.plugin(schema => {
  schema.options.usePushEach = true;
});

const sendNotifSchema = new Schema({
  idapp: {
    type: String,
  },
  typedir: {
    type: Number,
    default: 0,
  },
  typeid: {
    type: Number,
    default: 0,
  },
  sender: {  // mittente
    type: String,
    default: '',
  },
  dest: {
    type: String,
    default: '',
  },
  title: {
    type: String,
  },
  descr: {
    type: String,
  },
  openUrl: {
    type: String,
  },
  datenotif: {
    type: Date,
  },
  status: {
    type: Number,
    default: 0,
  },
  read: {
    type: Boolean,
    default: false,
  },
  tablerec: {
    type: String,
  },
  idrec: {
    type: String,
  },
  deleted: {
    type: Boolean,
    default: false,
  },

});

sendNotifSchema.statics.setNotifAsRead = function(idapp, username, idnotif) {
  const SendNotif = this;

  try {

    if (idnotif) {
      return SendNotif.findOneAndUpdate({
        $and: [
          {idapp},
          {dest: username},
          {'_id': idnotif},
        ],
        $or: [
          {deleted: {$exists: false}},
          {deleted: {$exists: true, $eq: false}}],

      }, {$set: {read: true}}, {new: false}).then((ret) => {
        return !!ret;
      }).catch((err) => {
        console.error('err', err);
      });
    }
  } catch (e) {
    return false;
  }
};

sendNotifSchema.statics.findAllNotifByUsernameIdAndIdApp = function(username, lastdataread, idapp) {
  const SendNotif = this;

  return SendNotif.find({
    $and: [
      {idapp},
      {'dest': username},
      {'datenotif': {$gt: new Date(lastdataread)}},
    ],
  }).lean().sort({datenotif: -1}).then(async (arrnotif) => {
    // console.log('arrnotif', arrnotif.length);

    return this.compileOtherFields(arrnotif);

  }).catch((err) => {
    console.error('err', err);
  });

};

sendNotifSchema.statics.getDescrAndLinkByRecNotif = function(recnotif) {

  const numchars = 80;
  let newdescr = '';
  let mydescr = '';
  let myidrec = '';
  let userorig = recnotif.sender;

  try {
    if (recnotif.myrectableorig) {
      myidrec = recnotif.myrectableorig._id;
      mydescr = recnotif.myrectableorig.descr ? tools.firstchars(recnotif.myrectableorig.descr, numchars) : '';
    }

    if (recnotif.typedir === shared_consts.TypeNotifs.TYPEDIR_BACHECA) {
      if (recnotif.typeid === shared_consts.TypeNotifs.ID_BACHECA_NEW_GOOD) {
        newdescr = i18n.__('<strong>%s</strong> new Good: %s', userorig, mydescr);
        recnotif.openUrl = '/mygood/' + myidrec;
      } else if (recnotif.typeid === shared_consts.TypeNotifs.ID_BACHECA_NEW_SERVICE) {
        newdescr = i18n.__('<strong>%s</strong> new Service: %s', userorig, mydescr);
        recnotif.openUrl = '/myservice/' + myidrec;
      }
    } else if (recnotif.typedir === shared_consts.TypeNotifs.TYPEDIR_FRIENDS) {
      recnotif.openUrl = '/my/' + userorig;
      if (recnotif.typeid === shared_consts.TypeNotifs.ID_FRIENDS_NEW_REC) {
        newdescr = i18n.__('<strong>%s</strong> asked you for Friendship', userorig, mydescr);
      } else if ((recnotif.typeid === shared_consts.TypeNotifs.ID_FRIENDS_ACCEPTED) ||
          (recnotif.typeid === shared_consts.TypeNotifs.ID_FRIENDS_ACCEPTED_MY_REQUEST)) {
        newdescr = i18n.__('<strong>%s</strong> accepted your Friendship', userorig, mydescr);
      } else if (recnotif.typeid === shared_consts.TypeNotifs.ID_FRIENDS_REFUSED) {
        newdescr = i18n.__('<strong>%s</strong> refused your Friendship', userorig, mydescr);
      }
    } else if (recnotif.typedir === shared_consts.TypeNotifs.TYPEDIR_GROUPS) {
      recnotif.openUrl = '/grp/' + recnotif.paramsObj.groupNameDest;
      if (recnotif.typeid === shared_consts.TypeNotifs.ID_GROUP_NEW_REC) {
        newdescr = i18n.__('GROUP_CREATED', userorig, recnotif.paramsObj.groupNameDest);
      } else if (recnotif.typeid === shared_consts.TypeNotifs.ID_GROUP_ACCEPTED) {
        newdescr = i18n.__('GROUPS_ACCEPTED', userorig, recnotif.paramsObj.groupNameDest);
      }
    }

    if (!recnotif.descr) {
      recnotif.descr = newdescr;
    }

    return recnotif;
  } catch (e) {
    console.error(e);
    return null;
  }

};

sendNotifSchema.statics.compileOtherFields = async function(arrnotif) {

  const {User} = require('../models/user');

  try {
    // Fill in the image profile of the semyinders !
    for (const notif of arrnotif) {
      let myimgprofile = await User.findOne({idapp: notif.idapp, username: notif.sender}, {'profile.img': 1}).lean();
      if (myimgprofile && myimgprofile.profile.img)
        notif.myimgsender = 'upload/profile/' + notif.sender + '/' + myimgprofile.profile.img;
    }

    return arrnotif;

  } catch (e) {
    console.error(e);
    return arrnotif;
  }

};

sendNotifSchema.statics.findLastNotifsByUserIdAndIdApp = function(username, idapp, limit) {
  const SendNotif = this;

  return SendNotif.aggregate([
    {
      $match: {
        idapp,
        dest: username,
      },
    },
    {$limit: limit},
    {
      $sort: {datenotif: -1},
    },
  ]).then(async (arrnotif) => {
    return this.compileOtherFields(arrnotif);

  }).catch((err) => {
    console.error(err);
  });

};

sendNotifSchema.statics.saveAndSendNotif = function(myrecnotif, req, res, user) {

  let idapp = req.body.idapp;
  const check = tools.checkUserOk(myrecnotif.sender, user ? myrecnotif.sender : req.user.username, res);
  if (check.exit) return check.ret;

  myrecnotif._id = new ObjectID();
  if (!myrecnotif.openUrl) {
    // If not exist, then I set openUrl and description
    myrecnotif = this.getDescrAndLinkByRecNotif(myrecnotif);
  }

  return myrecnotif.save().then((writeresult) => {
    let idobj = writeresult._id;

    myrecnotif._id = idobj;

    return SendNotif.findById(idobj).lean().then(async (recnotif) => {
      return await globalTables.sendNotif(myrecnotif.typedir, myrecnotif.typeid, res, idapp, user ? user : req.user, recnotif).
          then((ris) => {
            return recnotif;
          });
    });
  }).catch((e) => {
    console.log(e.message);
    return null;
  });
};

sendNotifSchema.statics.saveNotif = async function(myrecnotif) {

  const SendNotif = this;

  let newstatus = 0;
  let typeidsearch = 0;
  // Controllare se devo modificare un Notif già esistente !
  if (myrecnotif.typedir === shared_consts.TypeNotifs.TYPEDIR_FRIENDS) {
    typeidsearch = shared_consts.TypeNotifs.ID_FRIENDS_NEW_REC;
    if (myrecnotif.typeid === shared_consts.TypeNotifs.ID_FRIENDS_ACCEPTED) {
      newstatus = shared_consts.StatusNotifs.STATUS_FRIENDS_ACCEPTED;
    } else if (myrecnotif.typeid === shared_consts.TypeNotifs.ID_FRIENDS_REFUSED) {
      newstatus = shared_consts.StatusNotifs.STATUS_FRIENDS_REFUSED;
    }
  } else if (myrecnotif.typedir === shared_consts.TypeNotifs.TYPEDIR_GROUPS) {
    typeidsearch = shared_consts.TypeNotifs.ID_GROUP_NEW_REC;
    if (myrecnotif.typeid === shared_consts.TypeNotifs.ID_GROUP_ACCEPTED) {
      newstatus = shared_consts.StatusNotifs.STATUS_GROUPS_ACCEPTED;
    } else if (myrecnotif.typeid === shared_consts.TypeNotifs.ID_GROUP_REFUSED) {
      newstatus = shared_consts.StatusNotifs.STATUS_GROUPS_REFUSED;
    }
  }

  if (newstatus) {
    const fields_to_update = {
      status: newstatus,
      read: true,
    };

    const query = {
      idapp: myrecnotif.idapp,
      typedir: myrecnotif.typedir,
      typeid: typeidsearch,
      dest: myrecnotif.sender,
      deleted: false,
      status: 0,
    };

    // Cerca il record e se lo trova lo aggiorna
    const myrec = await SendNotif.findOneAndUpdate(query, {$set: fields_to_update}, {
      new: false,
      returnNewDocument: true,
    });

    if (myrec) {
      return myrec._doc;
    }
  }

  myrecnotif._id = new ObjectID();
  if (!myrecnotif.openUrl) {
    // If not exist, then I set openUrl and description
    myrecnotif = this.getDescrAndLinkByRecNotif(myrecnotif);
  }

  return myrecnotif.save().then((writeresult) => {
    let idobj = writeresult._id;

    myrecnotif._id = idobj;

    return SendNotif.findById(idobj).lean().then(async (recnotif) => {
      return recnotif;
    });
  }).catch((e) => {
    console.log(e.message);
    return null;
  });

};

sendNotifSchema.statics.getDefaultRec = function(req) {

  return {
    idapp: req.body.idapp,
    typedir: '',
    typeid: '',
    sender: req.user ? req.user.username : '',
    dest: '',
    descr: '',
    openUrl: '',
    datenotif: new Date(),
    status: 0,
    read: false,
    tablerec: '',
    idrec: 0,
  };

};

sendNotifSchema.statics.createNewNotification = async function(req, res, paramsObj, table, rec, typedir, typeid) {
  const SendNotif = this;

  try {
    let myrecnotif = new SendNotif(this.getDefaultRec(req));

    myrecnotif.tablerec = table;
    if (rec && table) {
      myrecnotif.idrec = rec._id;
    }

    myrecnotif.typedir = typedir;
    myrecnotif.typeid = typeid;

    await SendNotif.sendToTheDestinations(myrecnotif, req, res, paramsObj);

    return true;
  } catch (e) {
    console.error('createNewNotification', e);
    return false;
  }
};

sendNotifSchema.statics.createNewNotifToSingleUser = async function(req, res, paramsObj, onlysave, typedir, typeid) {
  const SendNotif = this;

  try {
    let myrecnotif = new SendNotif(this.getDefaultRec(req));

    myrecnotif.typedir = typedir;
    myrecnotif.typeid = typeid;

    await SendNotif.sendToSingleUserDest(myrecnotif, req, res, paramsObj, onlysave);

    return true;
  } catch (e) {
    console.error('createNewNotification', e);
    return false;
  }
};

sendNotifSchema.statics.sendToTheDestinations = async function(myrecnotif, req, res, paramsObj) {
  const SendNotif = this;

  const {User} = require('../models/user');

  const {City} = require('../models/city');
  const {Province} = require('../models/province');

  myrecnotif.paramsObj = paramsObj;

  try {

    // Send only to the destination to reach:
    const userlist = await User.find({
      idapp: myrecnotif.idapp,
      $or: [
        {deleted: {$exists: false}},
        {deleted: {$exists: true, $eq: false}}],
    }, {
      name: 1,
      surname: 1,
      lang: 1,
      username: 1,
      'profile.notifs': 1,
      'profile.notif_idCities': 1,
      'profile.notif_provinces': 1,
      'profile.notif_regions': 1,
      'profile.notif_sectors': 1,
      'profile.notif_sector_goods': 1,
    }).lean();

    let arrprovinces = [];
    let arrregions = [];
    let idSector = 0;

    const mytable = globalTables.getTableByTableName(myrecnotif.tablerec);

    if (shared_consts.TABLES_ADV_NOTIFICATION.includes(myrecnotif.tablerec) ||
        shared_consts.TABLES_EVENTS_NOTIFICATION.includes(myrecnotif.tablerec)) {

      const myrectableorig = await mytable.findOne({_id: myrecnotif.idrec}).lean();
      if (myrectableorig) {
        for (const city of myrectableorig.idCity) {
          arrprovinces.push(await City.getProvinceByIdCity(city));
          arrregions.push(await City.getRegionByIdCity(city));
        }

        if (myrecnotif.tablerec === shared_consts.TABLES_MYGOODS) {
          idSector = myrectableorig.idSectorGood;
        } else {
          idSector = myrectableorig.idSector;
        }

      }
      myrecnotif.myrectableorig = myrectableorig;
    }

    myrecnotif = this.getDescrAndLinkByRecNotif(myrecnotif);

    for (const user of userlist) {

      if (user.profile.notifs) {
        const usernotifprofile = user.profile.notifs.find((notif) => notif.dir === myrecnotif.typedir);

        let send = false;

        if (shared_consts.TABLES_ADV_NOTIFICATION.includes(myrecnotif.tablerec) ||
            shared_consts.TABLES_EVENTS_NOTIFICATION.includes(myrecnotif.tablerec)) {
          // Estrai la Città, la Provincia e la regione.

          if (usernotifprofile && tools.isBitActive(usernotifprofile.value, shared_consts.UsersNotif.NEW_ADV_PROVINCE) &&
              user.profile.notif_provinces && user.profile.notif_provinces.some(r => arrprovinces.indexOf(r) >= 0)) {
            send = true;
          }

          if (usernotifprofile && tools.isBitActive(usernotifprofile.value, shared_consts.UsersNotif.NEW_ADV_REGION) &&
              user.profile.notif_regions && user.profile.notif_regions.some(r => arrregions.indexOf(r) >= 0)) {
            send = true;
          }

          if (idSector && usernotifprofile && tools.isBitActive(usernotifprofile.value, shared_consts.UsersNotif.NEW_ADV_SECTOR)) {
            // Controlla se è del settore selezionato
            if (myrecnotif.tablerec === shared_consts.TABLES_MYGOODS) {
              if (user.profile.notif_sector_goods) {
                send = send && (user.profile.notif_sector_goods.includes(idSector));
              }
            } else if (user.profile.notif_sectors) {
              send = send && (user.profile.notif_sectors.includes(idSector));
            }
          }

        }

        if (shared_consts.TABLES_GROUPS_NOTIFICATION.includes(myrecnotif.tablerec)) {
          if (tools.isBitActive(usernotifprofile.value, shared_consts.GroupsNotifs.STATUS_GROUPS_NEW)) {
            send = true;
          }
        }

          if (send) {
          myrecnotif.dest = user.username;
          await SendNotif.saveAndSendNotif(myrecnotif, req, res, user);
        }
      }
    }
  } catch (e) {
    console.error('sendToTheDestinations', e);
    return false;
  }

};

sendNotifSchema.statics.sendToSingleUserDest = async function(myrecnotif, req, res, paramsObj, onlysave) {
  const SendNotif = this;

  try {

    myrecnotif.paramsObj = paramsObj;
    myrecnotif.dest = paramsObj.usernameDest ? paramsObj.usernameDest : '';
    myrecnotif = this.getDescrAndLinkByRecNotif(myrecnotif);

    if (onlysave) {
      await SendNotif.saveNotif(myrecnotif);
    } else {
      await SendNotif.saveAndSendNotif(myrecnotif, req, res, user);
    }

  } catch (e) {
    console.error('sendToSingleUserDest', e);
    return false;
  }

};

const SendNotif = mongoose.model('SendNotif', sendNotifSchema);

module.exports = {SendNotif: SendNotif};