Source: models/ranks.js


/**
 * Class represents ranks (basedata) and offers methods for ranks handling
 * @class
 */
class ranks {

  /**
   * @constructor
   */
  constructor() {
    // always initialize all instance properties
  }

  /**
   * Returns all ranks from core database
   * @param {function} callback rows with ranks
   */
  getListOfRanks(callback) {
    console.log('Reading Ranks');
    let query = "SELECT * FROM `basedata_ranks`";
    global.coreDb.all(query, [], (err, rows) => {
      if (err) {
        this._logger.error('MODELS-RANKS | Error loading ranks from core data: ' + err.message);
        return callback(null);
      } else {
        return callback(rows);
      }
    });
  }

  /**
   * Returns rows with ranks for basedata id
   * @param {integer} basedataId basedata id of user ranks should be returned for
   * @param {object} callback rows or null
   */
  getListOfRanksForBaseData(basedataId, callback) {
    console.log('reading referenced Ranks for basedata record with id ' + basedataId);
    let query = "SELECT  xt_basedata_ranks.*, " +
      "basedata_ranks.title AS ranktitle, " +
      "basedata_ranks.avatar AS rankavatar, " +
      "basedata_ranks.id AS rankid " +
      "FROM xt_basedata_ranks " +
      "INNER JOIN basedata_ranks ON xt_basedata_ranks.rankid = basedata_ranks.id " +
      "WHERE xt_basedata_ranks.basedataid = ? "
    "ORDER BY xt_basedata_ranks.datevocation ASC";

    global.coreDb.all(query, [
      basedataId
    ], (err, rows) => {
      if (err) {
        this._logger.error(`MODELS-RANKS | Error loading ranks for basedata with id ${basedataId} from core data: ${err.message}`);
        return callback(null);
      } else {
        return callback(rows);
      }
    });
  }

  /**
   * Adds a rank to a basedata in core database
   * @param {integer} basedataId basedata id of user the rank should be added to
   * @param {integer} rankid id of rank
   * @param {date} datevocation date of vocation of rank
   * @param {string} locationvocation location of vocation 
   * @param {integer} setByBasedataId which basedata id has made this change
   * @param {function} callback success (true or false)
   */
  assignRankToBasedata(basedataId, rankid, datevocation, locationvocation, setByBasedataId, callback) {
    let query = "INSERT INTO `xt_basedata_ranks` (basedataid, rankid, datevocation, locationvocation, setByBasedataId) VALUES ( ?, ?, ?, ?, ?)";

    global.coreDb.run(query,
      [
        basedataId,
        rankid,
        datevocation,
        locationvocation,
        setByBasedataId
      ],
      function (err) {
        if (err) {
          console.log('ERROR adding rank to basedata id in core database: ' + err.message);
          callback(false);
        } else {
          callback(true);
        }
      });
  }

  /**
   * Deletes a referenced rank for a basedata entry in core database
   * @param {integer} xtRankId id of rank in xt_basedata_ranks table in core database
   * @param {function} callback success (true or false)
   */
  removeRankForBasedata(xtRankId, callback) {
    let query = "DELETE FROM xt_basedata_ranks WHERE id = ?";
    global.coreDb.run(query,
      [
        xtRankId
      ],
      function (err) {
        if (err) {
          console.log('ERROR removing rank for basedata in core database: ' + err.message);
          callback(false);
        } else {
          callback(true);
        }
      });
  }

}

// export the class
module.exports = ranks;