definma-api/src/routes/material.ts

import express from 'express';
import _ from 'lodash';

import MaterialValidate from './validate/material';
import MaterialModel from '../models/material'
import SampleModel from '../models/sample';
import MaterialGroupsModel from '../models/material_groups';
import MaterialSuppliersModel from '../models/material_suppliers';
import IdValidate from './validate/id';
import res400 from './validate/res400';
import mongoose from 'mongoose';
import globals from '../globals';



const router = express.Router();

router.get('/materials', (req, res, next) => {
  if (!req.auth(res, ['read', 'write', 'maintain', 'dev', 'admin'], 'all')) return;

  MaterialModel.find({status:globals.status.validated}).populate('group_id').populate('supplier_id').lean().exec((err, data) => {
    if (err) return next(err);
    console.log(data);
    data.forEach((material: any) => {  // map group and supplier
      material.group = material.group_id.name;
      material.supplier = material.supplier_id.name;
    });
    res.json(_.compact(data.map(e => MaterialValidate.output(e))));  // validate all and filter null values from validation errors
  });
});

router.get('/materials/:state(new|deleted)', (req, res, next) => {
  if (!req.auth(res, ['maintain', 'admin'], 'basic')) return;

  MaterialModel.find({status: globals.status[req.params.state]}).populate('group_id').populate('supplier_id').lean().exec((err, data) => {
    if (err) return next(err);
    data.forEach((material: any) => {  // map group and supplier
      material.group = material.group_id.name;
      material.supplier = material.supplier_id.name;
    });
    res.json(_.compact(data.map(e => MaterialValidate.output(e))));  // validate all and filter null values from validation errors
  });
});

router.get('/material/' + IdValidate.parameter(), (req, res, next) => {
  if (!req.auth(res, ['read', 'write', 'maintain', 'dev', 'admin'], 'all')) return;

  MaterialModel.findById(req.params.id).populate('group_id').populate('supplier_id').lean().exec((err, data: any) => {
    if (err) return next(err);

    if (!data) {
      return res.status(404).json({status: 'Not found'});
    }

    data.group = data.group_id.name;
    data.supplier = data.supplier_id.name;
    if (data.status === globals.status.deleted && !req.auth(res, ['maintain', 'admin'], 'all')) return;  // deleted materials only available for maintain/admin
    res.json(MaterialValidate.output(data));
  });
});

router.put('/material/' + IdValidate.parameter(), (req, res, next) => {
  if (!req.auth(res, ['write', 'maintain', 'dev', 'admin'], 'basic')) return;

  const {error, value: material} = MaterialValidate.input(req.body, 'change');
  if (error) return res400(error, res);

  MaterialModel.findById(req.params.id).lean().exec(async (err, materialData: any) => {
    if (!materialData) {
      return res.status(404).json({status: 'Not found'});
    }
    if (materialData.status === globals.status.deleted) {
      return res.status(403).json({status: 'Forbidden'});
    }
    if (material.hasOwnProperty('name') && material.name !== materialData.name) {
      if (!await nameCheck(material, res, next)) return;
    }

    // check for changes
    if (!_.isEqual(_.pick(IdValidate.stringify(materialData), _.keys(material)), material)) {
      material.status = globals.status.new;  // set status to new
    }

    await MaterialModel.findByIdAndUpdate(req.params.id, material, {new: true}).lean().exec((err, data) => {
      if (err) return next(err);
      res.json(MaterialValidate.output(data));
    });
  });
});

router.delete('/material/' + IdValidate.parameter(), (req, res, next) => {
  if (!req.auth(res, ['write', 'maintain', 'dev', 'admin'], 'basic')) return;

  // check if there are still samples referencing this material
  SampleModel.find({'material_id': new mongoose.Types.ObjectId(req.params.id)}).lean().exec((err, data) => {
    if (err) return next(err);
    if (data.length) {
      return res.status(400).json({status: 'Material still in use'});
    }
    MaterialModel.findByIdAndUpdate(req.params.id, {status:globals.status.deleted}).lean().exec((err, data) => {
      if (err) return next(err);
      if (data) {
        res.json({status: 'OK'});
      }
      else {
        res.status(404).json({status: 'Not found'});
      }
    });
  });
});

router.put('/material/restore/' + IdValidate.parameter(), (req, res, next) => {
  if (!req.auth(res, ['maintain', 'admin'], 'basic')) return;

  MaterialModel.findByIdAndUpdate(req.params.id, {status: globals.status.new}).lean().exec((err, data) => {
    if (err) return next(err);

    if (!data) {
      return res.status(404).json({status: 'Not found'});
    }
    res.json({status: 'OK'});
  });
});

router.post('/material/new', async (req, res, next) => {  // TODO: check supplier and group, also for PUT and DELETE
  if (!req.auth(res, ['write', 'maintain', 'dev', 'admin'], 'basic')) return;

  const {error, value: material} = MaterialValidate.input(req.body, 'new');
  if (error) return res400(error, res);

  if (!await nameCheck(material, res, next)) return;

  material.status = globals.status.new;  // set status to new
  await new MaterialModel(material).save((err, data) => {
    if (err) return next(err);
    res.json(MaterialValidate.output(data.toObject()));
  });
});

router.get('/material/groups', (req, res, next) => {
  if (!req.auth(res, ['read', 'write', 'maintain', 'dev', 'admin'], 'all')) return;

  MaterialGroupsModel.find().lean().exec((err, data: any) => {
    if (err) return next(err);

    res.json(_.compact(data.map(e => MaterialValidate.outputGroups(e.name))));  // validate all and filter null values from validation errors
  });
});

router.get('/material/suppliers', (req, res, next) => {
  if (!req.auth(res, ['read', 'write', 'maintain', 'dev', 'admin'], 'all')) return;

  MaterialSuppliersModel.find().lean().exec((err, data: any) => {
    if (err) return next(err);

    res.json(_.compact(data.map(e => MaterialValidate.outputSuppliers(e.name))));  // validate all and filter null values from validation errors
  });
});


module.exports = router;


async function nameCheck (material, res, next) {  // check if name was already taken
  const materialData = await MaterialModel.findOne({name: material.name}).lean().exec().catch(err => next(err)) as any;
  if (materialData instanceof Error) return false;
  if (materialData) {  // could not find material_id
    res.status(400).json({status: 'Material name already taken'});
    return false;
  }
  return true;
}