opt-cc/api/routes/players.js

'use strict';

// modules
const express = require('express');

// HTTP status codes by name
const codes = require('./http-codes');

const routerHandling = require('../middleware/router-handling');

// Mongoose Model using mongoDB
const CampaignModel = require('../models/campaign');
const PlayerModel = require('../models/player');
const WarModel = require('../models/war');

// Util
const isSteamUUID = require('../tools/util').isSteamUUID;

const campaignPlayer = new express.Router();

// routes **********************
campaignPlayer.route('/ranking/:campaignId')
              .get((req, res, next) => {
                WarModel.find({campaign: req.params.campaignId}, '_id', (err, wars) => {
                  if (err) return next(err);
                  const warIds = wars.map((obj) => {
                    return obj._id;
                  });
                  PlayerModel.find({warId: {'$in': warIds}}, (err, items) => {
                    if (err) return next(err);
                    if (!items || items.length === 0) {
                      const err = new Error('No players for given campaignId');
                      err.status = codes.notfound;
                      return next(err);
                    }

                    const rankingItems = [];

                    // check only first player to have valid steamUUID - then decide if tracked by name or by ID
                    const usesUUID = isSteamUUID(items[0].steamUUID);

                    new Set(items.map(usesUUID ? (x) => x.steamUUID : (x) => x.name))
                      .forEach((player) => {
                        const playerInstances = items.filter(
                          usesUUID ? (p) => p.steamUUID === player : (p) => p.name === player);
                        const resItem = {
                          name: usesUUID ? playerInstances[playerInstances.length - 1].name : player,
                          kill: 0,
                          vehicle: 0,
                          death: 0,
                          friendlyFire: 0,
                          revive: 0,
                          respawn: 0,
                          flagTouch: 0,
                        };
                        for (let i = 0; i < playerInstances.length; i++) {
                          resItem.kill += playerInstances[i].kill;
                          resItem.death += playerInstances[i].death;
                          resItem.friendlyFire += playerInstances[i].friendlyFire;
                          resItem.vehicle += playerInstances[i].vehicle;
                          resItem.revive += playerInstances[i].revive;
                          resItem.respawn += playerInstances[i].respawn;
                          resItem.flagTouch += playerInstances[i].flagTouch;
                        }
                        resItem.fraction = playerInstances[playerInstances.length - 1].fraction;
                        rankingItems.push(resItem);
                      });

                    const getSortedField = (fieldName) => {
                      let num = 1;
                      rankingItems.sort((a, b) => b[fieldName] - a[fieldName]);
                      const res = JSON.parse(JSON.stringify(rankingItems));
                      for (const entity of res) {
                        entity.num = num++;
                      }
                      return res;
                    };

                    res.locals.items = {
                      kill: getSortedField('kill'),
                      death: getSortedField('death'),
                      friendlyFire: getSortedField('friendlyFire'),
                      vehicle: getSortedField('vehicle'),
                      revive: getSortedField('revive'),
                      respawn: getSortedField('respawn'),
                      flagTouch: getSortedField('flagTouch'),
                    };
                    next();
                  });
                });
              })

              .all(
                routerHandling.httpMethodNotAllowed
              );

campaignPlayer.route('/single/:campaignId/:playerId')
              .get((req, res, next) => {
                CampaignModel.findById(req.params.campaignId, (err, campaign) => {
                  if (err) return next(err);
                  WarModel.find({campaign: req.params.campaignId}, '_id', (err, wars) => {
                    if (err) return next(err);
                    const warIds = wars.map((obj) => {
                      return obj._id;
                    });

                    // find by player name until v1.6.12, afterwards by SteamUUID
                    const playerId = req.params.playerId;
                    const filter = {};
                    filter[isSteamUUID(playerId) ? 'steamUUID' : 'name'] = playerId;
                    filter['warId'] = {'$in': warIds};

                    PlayerModel.find(filter)
                               .populate('warId')
                               .exec((err, items) => {
                                 if (err) return next(err);
                                 if (!items || items.length === 0) {
                                   const err = new Error('Unknown player id');
                                   err.status = codes.notfound;
                                   return next(err);
                                 }
                                 res.locals.items = {
                                   name: items[items.length - 1].name,
                                   campaign: campaign,
                                   players: items,
                                 };
                                 next();
                               });
                  });
                });
              })

              .all(
                routerHandling.httpMethodNotAllowed
              );


campaignPlayer.use(routerHandling.emptyResponse);

module.exports = campaignPlayer;