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');

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

const CircuitSchema = new Schema({
  Num: {
    type: Number,
    unique: true,
  },
  idapp: {
    type: String,
    required: true,
  },
  groupnameId: {
    type: String,
  },
  name: {
    type: String,
    unique: true,
  },
  path: {
    type: String,
    unique: true,
  },
  subname: {
    type: String,
  },
  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: 3,
  },
  abbrev: {
    type: String,
    maxlength: 3,
  },
  compara_valuta: {
    type: Number,
    default: 1,
  },
  compara_euro: {
    type: Number,
    default: 1,
  },
  valuta_per_euro: {
    type: Number,
    default: 1,
  },
  fido_scoperto_default: {
    type: Number,
  },
  data_costituz: {
    type: Date,
  },
  deperimento: {
    type: Boolean,
    default: true,
  },
  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},
    },
  ],
  img_logo: {
    type: String,
  },
  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,
  },
});

CircuitSchema.pre('save', async function(next) {
  if (this.isNew) {

    this.date_created = new Date();
  }

  next();
});


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

  const myfind = {idapp};

  return await Circuit.find(myfind, (err, arrrec) => {
    return arrrec;
  });
};

CircuitSchema.pre('save', async function(next) {
  if (this.isNew) {
    const myrec = await Circuit.findOne().limit(1).sort({Num: -1});
    if (!!myrec) {
      if (myrec._doc.Num === 0)
        this.Num = 1;
      else
        this.Num = myrec._doc.Num + 1;

    } else {
      this.Num = 1;
    }
  }

  next();
});

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

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

CircuitSchema.statics.getWhatToShow = function(idapp, username) {
  // FOR ME, PERMIT ALL
  return {
    Num: 1,
    circuitId: 1,
    groupnameId: 1,
    path: 1,
    name: 1,
    subname: 1,
    longdescr: 1,
    regulation: 1,
    systemUserId: 1,
    createdBy: 1,
    date_created: 1,
    date_updated: 1,
    nome_valuta: 1,
    symbol: 1,
    abbrev: 1,
    data_costituz: 1,
    img_logo: 1,
    admins: 1,
    req_users: 1,
    refused_users: 1,
  };

};

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

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


CircuitSchema.statics.getWhatToShow_Unknown = function(idapp, username) {
  return {
    Num: 1,
    circuitId: 1,
    groupnameId: 1,
    path: 1,
    name: 1,
    subname: 1,
    longdescr: 1,
    regulation: 1,
    systemUserId: 1,
    founderUserId: 1,
    nome_valuta: 1,
    symbol: 1,
    abbrev: 1,
    data_costituz: 1,
    img_logo: 1,
    admins: 1,
    createdBy: 1,
    date_created: 1,
    date_updated: 1,
    req_users: 1,
    refused_users: 1,
  };
};

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

  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);

    let listUserAccounts = await Account.getAccountsByUsername(idapp, username);

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

    let listcircuits = await Circuit.find({
      idapp,
      $or: [
        {deleted: {$exists: false}},
        {deleted: {$exists: true, $eq: false}}],
    }, whatToShow_Unknown).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).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).lean();

    return {
      listUserAccounts,
      listcircuits,
      asked_circuits,
      refused_circuits,
      manage_mycircuits,
      mycircuits: req.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.deleteCircuit = async function(idapp, usernameOrig, name) {
  console.log('Circuito ' + name + ' rimosso da ' + usernameOrig);
  return Circuit.findOneAndRemove({idapp, name});
};

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

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

// Aggiungi agli utenti Rifiutati del Circuito
CircuitSchema.statics.refuseReqCircuit = async function(idapp, username, name) {

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

};


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

module.exports = {Circuit};