opt-cc/api/routes/decorations.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('/decoration/');

// Mongoose Model using mongoDB
const DecorationModel = require('../models/decoration');
const AwardingsModel = require('../models/awarding');

// util
const genericGetById = require('./_generic').genericGetById;

const decoration = new express.Router();

// routes **********************
decoration.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'};
            }
            DecorationModel.find(filter, {}, {
              sort: {
                fraction: 'asc',
                isMedal: 'asc',
                sortingNumber: 'asc',
                name: 'asc',
              },
            }, (err, items) => {
              if (err) {
                err.status = codes.servererror;
                return next(err);
              }
              if (items && items.length > 0) {
                res.locals.items = items;
              } else {
                res.locals.items = [];
              }
              res.locals.processed = true;
              next();
            });
          })

          .post(apiAuthenticationMiddleware, checkHl, upload.single('image'), (req, res, next) => {
            const decoration = new DecorationModel(req.body);
            // timestamp and default are set automatically by Mongoose Schema Validation
            decoration.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 = decoration;
              fs.appendFile(resourceLocation + decoration._id + '.png',
                new Buffer(req.file.buffer),
                (err) => {
                  if (err) next(err);
                });
              next();
            });
          })

          .all(
            routerHandling.httpMethodNotAllowed
          );

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

          .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.
            }

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

            if (req.file) {
              const file = resourceLocation + req.params.id + '.png';
              fs.unlink(file, (err) => {
                if (err) next(err);
                fs.appendFile(file, new Buffer(req.file.buffer), (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.
            DecorationModel.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) => {
            const id = req.params.id;
            DecorationModel.findByIdAndRemove(id, (err, item) => {
              if (err) {
                err.status = codes.wrongrequest;
              } else if (!item) {
                err = new Error('item not found');
                err.status = codes.notfound;
              }

              // deleted all awardings linked to this decoration
              AwardingsModel.find({decorationId: id}).remove().exec();

              // delete graphic
              fs.unlink(resourceLocation.concat(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
decoration.use(routerHandling.emptyResponse);


module.exports = decoration;