freeplanet_serverside/src/server/models/circuit.js

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 { Movement } = require('../models/movement');
const { Account } = require('../models/account');

const i18n = require('i18n');

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

const CircuitSchema = new Schema({
  _id: {
    type: String,
    default: function () {
      return new ObjectID().toString();
    },
  },
  idapp: {
    type: String,
    required: true,
  },
  groupnameId: {
    type: String,
  },
  name: {
    type: String,
    unique: true,
  },
  path: {
    type: String,
    unique: true,
  },
  subname: {
    type: String,
  },
  idCity: [
    {
      type: Number,
    }],
  pub_to_share: {
    type: Number,  // PUB_TO_SHARE_ALL, PUB_TO_SHARE_ONLY_TABLE_FOLLOW
  },
  visibility: [
    {
      type: Number,
    },
  ],
  longdescr: {
    type: String,
  },
  regulation: {
    type: String,
  },
  systemUserDescr: {
    type: String,
  },
  systemUserId: {
    type: String,
  },
  totCircolante: {
    type: Number,
  },
  totTransato: {
    type: Number,
  },
  nome_valuta: {
    type: String,
    maxlength: 20,
  },
  symbol: {
    type: String,
    maxlength: 7,
  },
  color: {
    type: String,
  },
  abbrev: {
    type: String,
    maxlength: 7,
  },
  compara_valuta: {
    type: Number,
    default: 1,
  },
  compara_euro: {
    type: Number,
    default: 1,
  },
  valuta_per_euro: {
    type: Number,
    default: 1,
  },
  fido_scoperto_default: {
    type: Number,
  },
  qta_max_default: {
    type: Number,
  },
  fido_scoperto_default_grp: {
    type: Number,
  },
  qta_max_default_grp: {
    type: Number,
  },
  data_costituz: {
    type: Date,
  },
  deperimento: {
    type: Boolean,
  },
  freq_deper: {   // H, D, W, M, Y
    type: String,
  },
  minuto_deper: {
    type: Number,
  },
  ora_deper: {
    type: Number,
  },
  giorno_deper: {
    type: Number,
  },
  mese_deper: {
    type: Number,
  },
  ultimo_deper: {
    type: Date,
  },
  durata_deper: {
    type: Number,
  },
  // -------------
  createdBy: {
    type: String,
  },
  date_created: {
    type: Date,
  },
  date_updated: {
    type: Date,
  },
  admins: [
    {
      username: { type: String },
      date: { type: Date },
    },
  ],
  photos: [
    {
      imagefile: {
        type: String,
      },
      alt: {
        type: String,
      },
      description: {
        type: String,
      },
    }],
  req_users: [
    {
      _id: false,
      username: { type: String },
      date: { type: Date },
    }],  // username
  refused_users: [
    {
      _id: false,
      username: { type: String },
      date: { type: Date },
    }],  // username
  req_groups: [
    {
      _id: false,
      groupname: { type: String },
      date: { type: Date },
    }],  // username
  refused_groups: [
    {
      _id: false,
      groupname: { type: String },
      date: { type: Date },
    }],  // username
  deleted: {
    type: Boolean,
    default: false,
  },
  transactionsEnabled: {
    type: Boolean,
  },
  numMembers: {
    type: Number,
    default: 0,
  },
  status: {
    type: Number,
    default: 0,
  },
});

CircuitSchema.pre('save', async function (next) {
  if (this.isNew) {
    this._id = new ObjectID().toString();

    this.date_created = new Date();
  }

  next();
});

CircuitSchema.statics.findAllIdApp = async function (idapp) {
  const Circuit = this;

  const myfind = { idapp, deleted: false };

  const whatToShow = this.getWhatToShow(idapp, '');

  return await Circuit.find(myfind, whatToShow).sort({status: -1, numMembers: -1, name: 1});
};

CircuitSchema.statics.getFieldsForSearch = function () {
  return [
    { field: 'name', type: tools.FieldType.string },
    { field: 'subname', type: tools.FieldType.string },
    { field: 'path', type: tools.FieldType.string },
    { field: 'nome_valuta', type: tools.FieldType.string },
    { field: 'descr', type: tools.FieldType.string },
  ];
};

CircuitSchema.statics.executeQueryTable = function (idapp, params, user) {
  params.fieldsearch = this.getFieldsForSearch();
  return tools.executeQueryTable(this, idapp, params, user);
};

CircuitSchema.statics.getWhatToShow = function (idapp, username) {
  // FOR ME, PERMIT ALL
  return {
    _id: 1,
    groupnameId: 1,
    path: 1,
    name: 1,
    subname: 1,
    longdescr: 1,
    regulation: 1,
    numMembers: 1,
    totCircolante: 1,
    totTransato: 1,
    systemUserId: 1,
    createdBy: 1,
    date_created: 1,
    date_updated: 1,
    nome_valuta: 1,
    fido_scoperto_default: 1,
    qta_max_default: 1,
    fido_scoperto_default_grp: 1,
    qta_max_default_grp: 1,
    deperimento: 1,
    transactionsEnabled: 1,
    status: 1,
    valuta_per_euro: 1,
    symbol: 1,
    idCity: 1,
    pub_to_share: 1,
    visibility: 1,
    color: 1,
    abbrev: 1,
    data_costituz: 1,
    photos: 1,
    admins: 1,
    req_users: 1,
    refused_users: 1,
    req_groups: 1,
    refused_groups: 1,
    'mycities': 1,
  };

};

// Aggiungi agli Admin del Circuito
CircuitSchema.statics.addToAdminOfMyCircuit = async function (idapp, username, name) {

  return await Circuit.updateOne({ idapp, name },
    {
      $push:
      {
        admins: {
          username,
          date: new Date(),
        },
      },
    });

};

// Rimuovi dagli Admin del Circuito
CircuitSchema.statics.removeAdminOfMyCircuit = async function (idapp, username, name) {

  return await Circuit.updateOne({ idapp, name },
    { $pull: { admins: { username: { $in: [username] } } } });
};

CircuitSchema.statics.getWhatToShow_Unknown = function (idapp, username) {
  return {
    groupnameId: 1,
    path: 1,
    name: 1,
    subname: 1,
    longdescr: 1,
    regulation: 1,
    numMembers: 1,
    systemUserId: 1,
    founderUserId: 1,
    nome_valuta: 1,
    totCircolante: 1,
    totTransato: 1,
    fido_scoperto_default: 1,
    fido_scoperto_default_grp: 1,
    qta_max_default_grp: 1,
    qta_max_default: 1,
    valuta_per_euro: 1,
    symbol: 1,
    color: 1,
    idCity: 1,
    pub_to_share: 1,
    visibility: 1,
    abbrev: 1,
    data_costituz: 1,
    photos: 1,
    admins: 1,
    createdBy: 1,
    date_created: 1,
    date_updated: 1,
    req_users: 1,
    refused_users: 1,
    req_groups: 1,
    refused_groups: 1,
    transactionsEnabled: 1,
    status: 1,
    'mycities': 1,
  };
};

CircuitSchema.statics.getCircuitsByUsername = async function (idapp, username, user) {

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

    const whatToShow = this.getWhatToShow(idapp, username);
    const whatToShow_Unknown = this.getWhatToShow_Unknown(idapp, username);
    // const arrUsernameCircuits = await User.getUsernameCircuitsByUsername(idapp, username);
    // const arrUsernameReqCircuits = await MyCircuit.getUsernameReqCircuitsByCircuitname(idapp, username);

    const manage_mycircuits = await Circuit.find({
      idapp,
      'admins': {
        $elemMatch: { username: { $eq: username } },
      },
      $or: [
        { deleted: { $exists: false } },
        { deleted: { $exists: true, $eq: false } }],
    }).sort({status: -1, numMembers: -1, name: 1}).lean();

    let listcircuits = await Circuit.find({
      idapp,
      $or: [
        { deleted: { $exists: false } },
        { deleted: { $exists: true, $eq: false } }],
    }, whatToShow_Unknown).sort({status: -1, numMembers: -1, name: 1}).lean();

    let asked_circuits = await Circuit.find({
      idapp,
      'req_users': {
        $elemMatch: { username: { $eq: username } },
      },
      $or: [
        { deleted: { $exists: false } },
        { deleted: { $exists: true, $eq: false } }],
    }, whatToShow_Unknown).sort({status: -1}).lean();

    let refused_circuits = await Circuit.find({
      idapp,
      'refused_users': {
        $elemMatch: { username: { $eq: username } },
      },
      $or: [
        { deleted: { $exists: false } },
        { deleted: { $exists: true, $eq: false } }],
    }, whatToShow_Unknown).sort({status: -1}).lean();

    return {
      listcircuits,
      asked_circuits,
      refused_circuits,
      manage_mycircuits,
      mycircuits: user.profile.mycircuits,
    };

  } catch (e) {
    console.log('Error getCircuitsByUsername', e);
  }

  return {
    listUsersCircuit: [],
    listRequestUsersCircuit: [],
    listTrusted: [],
    asked_circuits: [],
    refused_circuits: [],

  };
};

CircuitSchema.statics.getInfoCircuitByName = async function (idapp, name) {

  const whatToShow = this.getWhatToShow(idapp, '');

  const myfind = {
    idapp,
    name,
  };

  try {
    return await Circuit.findOne(myfind, whatToShow).lean();

  } catch (e) {
    return null;
  }

};

CircuitSchema.statics.getCircuitByName = async function (idapp, name) {

  const myfind = {
    idapp,
    name,
  };

  try {
    return await Circuit.findOne(myfind);

  } catch (e) {
    return null;
  }

};

CircuitSchema.statics.getCircuitById = async function (circuitId) {

  const myfind = {
    _id: circuitId,
  };

  try {
    return await Circuit.findOne(myfind);

  } catch (e) {
    return null;
  }

};

CircuitSchema.statics.deleteCircuit = async function (idapp, usernameOrig, name) {
  console.log('Circuito ' + name + ' rimosso da ' + usernameOrig);
  return await Circuit.findOneAndRemove({ idapp, name });
};

CircuitSchema.statics.getUserCircuits = async function (idapp, username) {

  try {
    let aggr1 = [
      {
        $match: {
          idapp, username,
          $or: [
            { deleted: { $exists: false } },
            { deleted: { $exists: true, $eq: false } }],
        },
      },
      {
        $lookup: {
          from: 'circuits',
          localField: 'circuitId',
          foreignField: '_id',
          as: 'circuit',
        },
      },
      {
        '$replaceRoot': {
          'newRoot': {
            '$mergeObjects': [
              {
                '$arrayElemAt': [
                  '$circuit',
                  0,
                ],
              },
              '$$ROOT',
            ],
          },
        },
      },
      /*
    {
      $project: {
        "circuit.name": 1,
      },
    },

       */
    ];

    ris = await this.aggregate(aggr1);

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

};

CircuitSchema.statics.getUsersSingleCircuit = async function (idapp, username, circuitname, circuitId) {

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

  try {
    let aggr1 = [
      {
        $match: {
          idapp: idapp,
          'profile.mycircuits': {
            $elemMatch: { circuitname: { $eq: circuitname } },
          },
        },
      },

      /*{
        $lookup: {
          from: 'circuits',
          as: 'circuit',
          let: {circuitname: circuitname, idapp: '$idapp'},
          pipeline: [
            {
              $match:
                  {
                    $expr:
                        {
                          $and:
                              [
                                {$eq: ['$name', '$$circuitname']},
                                {$eq: ['$idapp', '$$idapp']},

                              ],
                        },
                  },
            },
          ],
        },

      },
      {$unwind: '$circuit'},
       */
      {
        $project: {
          username: 1,
          name: 1,
          surname: 1,
          profile: 1, 
          idapp: 1 /*, 'circuit.name': 1, 'circuit._id': 1*/
        },

      },
      {
        $lookup: {
          from: 'accounts',
          as: 'account',
          let: { username: '$username', idapp: '$idapp', circuitId: circuitId /*, circuitId: '$circuit._id' */ },
          pipeline: [
            {
              $match:
              {
                $expr:
                {
                  $and:
                    [
                      { $eq: ['$$username', '$username'] },
                      { $eq: ['$$idapp', '$idapp'] },
                      { $eq: ['$$circuitId', '$circuitId'] },
                    ],
                },
              },
            },
          ],
        },
      },
      { $unwind: '$account' },
    ];

    ris = await User.aggregate(aggr1);

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

};

CircuitSchema.statics.getCircolanteSingolaTransaz = function (accountorigTable, accountdestTable) {

  let circolante = 0;
  if (accountdestTable.saldo > 0)
    circolante += accountdestTable.saldo;
  if (accountorigTable.saldo > 0)
    circolante += accountorigTable.saldo;

  return circolante;
};

CircuitSchema.statics.sendCoins = async function (onlycheck, idapp, usernameOrig, extrarec) {

  let ris = {
    result: false,
    cansend: true,
    errormsg: '',
    rec: null,
    useraccounts: [],
  };

  try {
    let circuittable = null;
    if (extrarec.circuitname)
      circuittable = await Circuit.getCircuitByName(idapp, extrarec.circuitname);
    if (extrarec.circuitId)
      circuittable = await Circuit.getCircuitById(idapp, extrarec.circuitId);

    if (circuittable) {
      const myqty = Math.abs(extrarec.qty);

      const accountdestTable = await Account.getAccountByUsernameAndCircuitId(idapp, extrarec.dest, circuittable._id, true, extrarec.groupdest, extrarec.contoComDest);
      const accountorigTable = await Account.getAccountByUsernameAndCircuitId(idapp, usernameOrig, circuittable._id, true, extrarec.grouporig, extrarec.contoComOrig);

      const circolantePrec = this.getCircolanteSingolaTransaz(accountorigTable, accountdestTable);

      // Check if Sender has enough money
      if (accountorigTable.saldo - myqty < -accountorigTable.fidoConcesso) {
        ris.cansend = false;
        ris.errormsg = i18n.__('CIRCUIT_AMOUNT_EXCEED_FIDO', usernameOrig);
      }

      if (accountdestTable.saldo + myqty > accountorigTable.qta_maxConcessa) {
        ris.cansend = false;
        ris.errormsg = i18n.__('CIRCUIT_AMOUNT_EXCEED_QTAMAX', extrarec.dest);
      }

      if (!onlycheck) {
        // Add a Transaction !
        if (ris.cansend) {
          ris.rec = await Movement.addMov(idapp, accountorigTable, accountdestTable, myqty, extrarec.causal, extrarec.notifId);
        }

        if (ris.cansend && ris.rec) {

          const circolanteAtt = this.getCircolanteSingolaTransaz(accountorigTable, accountdestTable);

          // Somma di tutte le transazioni
          circuittable.totTransato += myqty;
          // circuittable.totCircolante = circuittable.totCircolante + (circolanteAtt - circolantePrec);
          circuittable.totCircolante = await Account.calcTotCircolante(idapp, circuittable._id);
          // await circuittable.save();
          paramstoupdate = {
            totTransato: circuittable.totTransato,
            totCircolante: circuittable.totCircolante,
          };
          await Circuit.updateOne({ _id: circuittable }, { $set: paramstoupdate });

          extrarec.saldoOrig = accountorigTable.saldo;
          extrarec.saldoDest = accountdestTable.saldo;

          let orig = usernameOrig + (extrarec.grouporig ? extrarec.grouporig : '') + (extrarec.contoComOrig ? extrarec.contoComOrig : '');
          let dest = (extrarec.dest ? extrarec.dest : '')  + (extrarec.groupDest ? extrarec.groupDest : '')  + (extrarec.contoComDest ? extrarec.contoComDest : '');

          ris.result = true;
          let msg = 'Inviate Monete da ' + orig + ' a ' + dest + ' ' + myqty + ' ' + circuittable.symbol + ' [causale: ' + extrarec.causal + `] [Saldo ${orig}: ` + extrarec.saldoOrig + ' ' + circuittable.symbol + '] ' + ` [Saldo ${dest}: ` + extrarec.saldoDest + ' ' + circuittable.symbol + ']';
          console.log(msg);

          ris.useraccounts = await Account.getUserAccounts(idapp, usernameOrig);

          tools.writeTransactionLog(msg);

          tools.sendMsgTelegramToAdmin(idapp, msg);

        } else {
          // console.log('NON Inviate Monete da', usernameOrig, extrarec.grouporig, extrarec.dest, extrarec.groupdest, myqty, extrarec.causal);
        }
      }

      return ris;

    }
  } catch (e) {
    console.error('Err sendCoins', e);
    ris.result = false;
    return ris;
  }

};

// Rimuovo la Richiesta del Circuito
CircuitSchema.statics.removeReqCircuit = async function (idapp, username, name) {

  return await Circuit.updateOne({ idapp, name },
    { $pull: { req_users: { username: { $in: [username] } } } });
};

// Rimuovo la Richiesta del Gruppo sul Circuito
CircuitSchema.statics.removeReqGroupCircuit = async function (idapp, groupname, name) {

  return await Circuit.updateOne({ idapp, name },
    { $pull: { req_groups: { groupname: { $in: [groupname] } } } });
};

// Aggiungi agli utenti Rifiutati del Circuito

CircuitSchema.statics.refuseReqCircuit = async function (idapp, username, name) {

  return await Circuit.updateOne({ idapp, name },
    {
      $push:
      {
        refused_users: {
          username,
          date: new Date(),
        },
      },
    });

};

CircuitSchema.statics.refuseReqGroupCircuit = async function (idapp, groupname, name) {

  return await Circuit.updateOne({ idapp, name },
    {
      $push:
      {
        refused_groups: {
          groupname,
          date: new Date(),
        },
      },
    });

};

CircuitSchema.statics.updateData = async function (idapp, circuitname) {

  try {

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

    let aggr1 = [
      {
        $match: {
          idapp,
          'profile.mycircuits': {
            $elemMatch: { circuitname: { $eq: circuitname } },
          },
        },
      },
      { $group: { _id: null, count: { $sum: 1 } } },
    ];

    const ris = await User.aggregate(aggr1);

    let numMembers = ris ? ris[0].count : 0;

    let paramstoupdate = {
      numMembers: numMembers,
    };
    const risult = await this.updateOne({ idapp, name: circuitname }, { $set: paramstoupdate });

    console.log('risult', risult);

  } catch (e) {
    console.error('Err', e);
  }

};

CircuitSchema.statics.setDeperimentoOff = async function () {

  return await Circuit.updateMany({}, { $set: { 'deperimento': false } },
    { new: false });

};

CircuitSchema.statics.getNameByCircuitId = async function (circuitId) {

  let circuit = await Circuit.findOne({ _id: circuitId });
  if (circuit)
    return circuit.name;

  return '';

};

CircuitSchema.statics.getCircuitByCircuitId = async function (circuitId) {

  return await Circuit.findOne({ _id: circuitId });

};

CircuitSchema.statics.getListAdminsByCircuitPath = async function (idapp, circuitPath) {

  let arr = await Circuit.findOne({
    idapp,
    path: circuitPath,
    $or: [
      { deleted: { $exists: false } },
      { deleted: { $exists: true, $eq: false } }],
  }, { admins: 1 }).lean();

  return arr && arr.admins ? arr.admins : [];

};


// Imposta a tutti i Conti Collettivi, i seguenti minimi e massimi
CircuitSchema.statics.SetDefMinMaxCollettivi = async function (idapp, valmin, valmax) {

  ris = await Circuit.updateMany({ idapp, contocom: { "$nin": [null, ""] } },
    {
      $set:
      {
        fido_scoperto_default: valmin,
        qta_max_default: valmax,
      }
    });

};

// Imposta a tutti i Conti Personali, i seguenti minimi e massimi
CircuitSchema.statics.SetDefMinMaxPersonali = async function (idapp, valmin, valmax) {

  ris = await Circuit.updateMany({ idapp },
    {
      $set:
      {
        fido_scoperto_default: valmin,
        qta_max_default: valmax,
      }
    });

};

// Imposta a tutti i Conti Collettivi, i seguenti minimi e massimi
CircuitSchema.statics.SetDefMinMaxCollettivi = async function (idapp, valmin, valmax) {

  ris = await Circuit.updateMany({ idapp },
    {
      $set:
      {
        fido_scoperto_default_grp: valmin,
        qta_max_default_grp: valmax,
      }
    });

};

const Circuit = mongoose.model('Circuit', CircuitSchema);

module.exports = { Circuit };