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,
  },
  typeid: {
    type: Number,
  },
  sender: {  // mittente
    type: String,
  },
  dest: {
    type: String,
  },
  descr: {
    type: String,
  },
  openUrl: {
    type: String,
  },
  datenotif: {
    type: Date,
  },
  status: {
    type: Number,
  },
  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((arrnotif) => {
    // console.log('arrnotif', arrnotif.length);
    return arrnotif;
  }).catch((err) => {
    console.error('err', err);
  });

};

sendNotifSchema.statics.getDescrAndLinkByRecNotif = function(recnotif) {

  if (recnotif.typedir === shared_consts.TypeNotifs.TYPEDIR_BACHECA) {
    if (recnotif.typeid === shared_consts.TypeNotifs.ID_BACHECA_NEW_GOOD) {
      recnotif.descr = i18n.__('Good: %s');
      recnotif.openUrl = '/goods';
    } else if (recnotif.typeid === shared_consts.TypeNotifs.ID_BACHECA_NEW_SERVICE) {
      recnotif.descr = i18n.__('Service: %s');
      recnotif.openUrl = '/services';
    }
  } else if (recnotif.typedir === shared_consts.TypeNotifs.TYPEDIR_FRIENDS) {
    recnotif.openUrl = '/friends';
  }

  return recnotif;
};

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

  return SendNotif.aggregate([
    {
      $match: {
        idapp,
        dest: username,
      },
    },
    {$limit: limit},
    {
      $sort: {datenotif: -1},
    },
  ]).then((arrnotif) => {
    // Remove duplicate
    // Exclude my chat
    const myarr = arrnotif.filter((ris) => ris._id !== username);
    // console.table(myarr);
    return myarr;

  }).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();
  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.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,
  };

};

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

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

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

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

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

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

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

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

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

  // 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 myrec = await mytable.findOne({_id: myrecnotif.idrec}).lean();
    if (myrec) {
      for (const city of myrec.idCity) {
        arrprovinces.push(await City.getProvinceByIdCity(city));
        arrregions.push(await City.getRegionByIdCity(city));
      }

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

    }
  }

  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 (send) {
        myrecnotif.dest = user.username;
        await SendNotif.saveAndSendNotif(myrecnotif, req, res, user);
      }
    }
  }

};

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

module.exports = {SendNotif: SendNotif};