freeplanet_serverside/src/server/models/movement.js

const mongoose = require('mongoose').set('debug', process.env.DEBUG);
const Schema = mongoose.Schema;

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

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

const {ObjectID} = require('mongodb');
const {Account} = require('../models/account');

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

const MovementSchema = new Schema({
  _id: {
    type: Number,
  },
  idapp: {
    type: String,
  },
  transactionDate: {
    type: Date,
  },
  accountFromId: {
    type: Number,
  },
  accountToId: {
    type: Number,
  },
  causal_table: {
    type: String,
  },
  causal_IdRec: {
    type: String,
  },
  amount: {
    type: Number,
  },
  causal: {
    type: String,
  },
  residual: {
    type: Number,
  },
  expiringDate: {
    type: Date,
  },
});

MovementSchema.statics.findAllIdApp = async function(idapp) {
  const MyMovement = this;

  const myfind = {idapp};

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

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

    } else {
      this._id = 1;
    }
  }

  next();
});

MovementSchema.statics.getFieldsForSearch = function() {
  return [
    {field: 'nome_conto', type: tools.FieldType.string},
  ];

};

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

MovementSchema.statics.addMov = async function(idapp, accountFromId, accountToId, amount, causal) {

  try {
    let mymov = Movement(
        {
          idapp,
          transactionDate: new Date(),
          accountFromId: accountFromId._id,
          accountToId: accountToId._id,
          amount,
          causal,
          residual: 0,
          // expiringDate:
        },
    );

    // Update saldo dell'Account
    Account.addtoSaldo(accountToId, amount);

    Account.addtoSaldo(accountFromId, -amount);

    return await mymov.save();
  } catch (e) {
    console.error('Error in addMov', e.message);
  }
};

MovementSchema.statics.getQueryMovsByCircuitId = async function(idapp, username, circuitId) {

  try {
    if (!circuitId) {
      return [];
    }
    const myaccount = await Account.getAccountByUsernameAndCircuitId(idapp, username, {circuitId}, false);

    if (myaccount) {

      let aggr1 = [
        {
          $match: {
            idapp,
            $or: [
              {accountFromId: myaccount._id},
              {accountToId: myaccount._id}],
          },
        },
        {
          $lookup: {
            from: 'accounts',
            localField: 'accountFromId',
            foreignField: '_id',
            as: 'accfrom',
          },
        },
        {$unwind: '$accfrom'},
        {
          $lookup: {
            from: 'users',
            let: {username: '$accfrom.username', idapp: '$accfrom.idapp'},
            pipeline: [
              {
                $match:
                    {
                      $expr:
                          {
                            $and:
                                [
                                  {$eq: ['$$username', '$username']},
                                  {$eq: ['$$idapp', '$idapp']},
                                ],
                          },
                    },
              },
            ],
            as: 'userfrom',
          },
        },
        {$unwind: '$userfrom'},
        {
          $lookup: {
            from: 'accounts',
            localField: 'accountToId',
            foreignField: '_id',
            as: 'accto',
          },
        },
        {$unwind: '$accto'},
        {
          "$lookup": {
            "from": "circuits",
            "localField": "accfrom.circuitId",
            "foreignField": "_id",
            "as": "circuitfrom"
          }
        },
        {
          "$unwind": "$circuitfrom"
        },
        {
          "$lookup": {
            "from": "circuits",
            "localField": "accto.circuitId",
            "foreignField": "_id",
            "as": "circuitto"
          }
        },
        {
          "$unwind": "$circuitto"
        },
        {
          $lookup: {
            from: 'users',
            let: {username: '$accto.username', idapp: '$accto.idapp'},
            pipeline: [
              {
                $match:
                    {
                      $expr:
                          {
                            $and:
                                [
                                  {$eq: ['$$username', '$username']},
                                  {$eq: ['$$idapp', '$idapp']},
                                ],
                          },
                    },
              },
            ],
            as: 'userto',
          },
        },
        {$unwind: '$userto'},
        {
          $project:
              {
                transactionDate: 1,
                amount: 1,
                causal: 1,
                'circuitfrom.symbol': 1,
                'circuitto.symbol': 1,
                'userfrom.username': 1,
                'userfrom.profile.img': 1,
                'userto.username': 1,
                'userto.profile.img': 1,
              },
        },

      ];

      return aggr1;
    }

  } catch (e) {
    return [];
  }

  return [];
};

MovementSchema.statics.getMovsByCircuitId = async function(idapp, username, circuitId) {
  const MyMovement = this;

  const myquery = await MyMovement.getQueryMovsByCircuitId(idapp, username, circuitId);

  if (myquery && myquery.length > 0) {
    ris = await MyMovement.aggregate(myquery);

    return ris;
  }

  return [];
};

const Movement = mongoose.model('Movement', MovementSchema);

module.exports = {Movement};