opt-cc/server/routes/squads.js

'use strict';

// modules
const fs = require('fs');
const express = require('express');
const multer = require('multer');
const storage = multer.memoryStorage();
const upload = multer({storage: storage});

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

const apiAuthenticationMiddleware = require('../middleware/auth-middleware');
const checkHl = require('../middleware/permission-check').checkHl;

const routerHandling = require('../middleware/router-handling');
const idValidator = require('../middleware/validators').idValidator;
const resourceLocation = require('../middleware/resource-location').resourceLocation().concat('/squad/');

// Mongoose Model using mongoDB
const SquadModel = require('../models/squad');

// util
const genericGetById = require('./_generic').genericGetById;
const getFileBuffer = require('../tools/util').getFileBuffer;
const imageDimensionValidator = require('../middleware/validators').imageDimensionValidator;
const MAX_IMAGE_WIDTH = 150;
const MAX_IMAGE_HEIGHT = 150;

const squads = new express.Router();

// routes **********************
squads.route('/')
      .get((req, res, next) => {
        const filter = {};
        if (req.query.fractFilter) {
          filter.fraction = req.query.fractFilter.toUpperCase();
        }
        if (req.query.q) {
          filter.name = {$regex: req.query.q, $options: 'i'};
        }
        SquadModel.find(filter, {}, {sort: {fraction: 'asc', sortingNumber: 'asc'}}, (err, items) => {
          if (err) {
            err.status = codes.servererror;
            return next(err);
          }
          if (items) {
            res.locals.items = items;
          } else {
            res.locals.items = [];
          }
          res.locals.processed = true;
          next();
        });
      })

      .post(apiAuthenticationMiddleware, checkHl, upload.single('image'), (req, res, next) => {
        const squad = new SquadModel(req.body);
        // timestamp and default are set automatically by Mongoose Schema Validation
        if (req.file) {
          const imageFileBuffer = getFileBuffer(req.file);
          const err = imageDimensionValidator(imageFileBuffer, MAX_IMAGE_WIDTH, MAX_IMAGE_HEIGHT);
          if (err) {
            return next(err);
          }

          squad.save((err) => {
            if (err) {
              err.status = codes.wrongrequest;
              err.message += ' in fields: ' + Object.getOwnPropertyNames(err.errors);
              return next(err);
            }
            res.status(codes.created);
            res.locals.items = squad;
            fs.appendFile(resourceLocation.concat(squad._id).concat('.png'), imageFileBuffer, (err) => {
              next(err);
            });
          });
        } else {
          const err = new Error('no image file provided');
          err.status = codes.wrongmediasend;
          next(err);
        }
      })

      .all(
        routerHandling.httpMethodNotAllowed
      );

squads.route('/:id')
      .get(idValidator, (req, res, next) => {
        return genericGetById(req, res, next, SquadModel);
      })

      .patch(apiAuthenticationMiddleware, checkHl, upload.single('image'), (req, res, next) => {
        if (!req.body || (req.body._id && req.body._id !== req.params.id)) {
          // little bit different as in PUT. :id does not need to be in data, but if the _id and url id must match
          const err = new Error('id of PATCH resource and send JSON body are not equal ' + req.params.id + ' ' +
            req.body._id);
          err.status = codes.notfound;
          next(err);
          return; // prevent node to process this function further after next() has finished.
        }

        // increment version manually as we do not use .save(.)
        req.body.updatedAt = new Date();
        req.body.$inc = {__v: 1};

        if (req.file) {
          let imageFileBuffer = getFileBuffer(req.file);
          const err = imageDimensionValidator(imageFileBuffer, MAX_IMAGE_WIDTH, MAX_IMAGE_HEIGHT);
          if (err) {
            return next(err);
          }
          const file = resourceLocation.concat(req.params.id)
                                       .concat('.png');
          fs.unlink(file, (err) => {
            if (err) next(err);
            fs.appendFile(file, imageFileBuffer, (err) => {
              if (err) next(err);
            });
          });
        }

        // PATCH is easier with mongoose than PUT. You simply update by all data that comes from outside. no need to
        // reset attributes that are missing.
        SquadModel.findByIdAndUpdate(req.params.id, req.body, {new: true}, (err, item) => {
          if (err) {
            err.status = codes.wrongrequest;
          } else if (!item) {
            err = new Error('item not found');
            err.status = codes.notfound;
          } else {
            res.locals.items = item;
          }
          next(err);
        });
      })

      .delete(apiAuthenticationMiddleware, checkHl, (req, res, next) => {
        SquadModel.findByIdAndRemove(req.params.id, (err, item) => {
          if (err) {
            err.status = codes.wrongrequest;
          } else if (!item) {
            err = new Error('item not found');
            err.status = codes.notfound;
          }

          // delete graphic
          fs.unlink(resourceLocation.concat(req.params.id)
                                    .concat('.png'), (err) => {
            // we don't set res.locals.items  and thus it will send a 204 (no content) at the end. see last handler
            res.locals.processed = true;
            next(err);
          });
        });
      })

      .all(
        routerHandling.httpMethodNotAllowed
      );

// this middleware function can be used, if you like or remove it
// it looks for object(s) in res.locals.items and if they exist, they are send to the client as json
squads.use(routerHandling.emptyResponse);

module.exports = squads;