node-rigorous/src/router/routes/PostMeDeleteByIdsRoute.js

Rigorous Framework

/* eslint class-methods-use-this: 0 */
const _ = require('lodash');

const RigorousError = require('../../facades/RigorousError');
const errorsMessages = require('../../etc/errorsMessages');

const RigorousRoute = require('./RigorousRoute');

const secure_user_input = require('../../helpers/secure_user_input');
const format_checker = require('../../helpers/format_checker');

class Route extends RigorousRoute {

    constructor(middlewares, modelService, authorizationUserId) {
        
        super(middlewares);

        this.modelService = modelService;
        this.authorizationUserId = authorizationUserId;
    }

    async secureInput(req) {

        const body = _.get(req, 'body');

        this.userIdAsking = req.authuser.user_id;

        const inputs = {
            ids: secure_user_input.escapeHtml(_.get(body, 'ids')),
        };

        return inputs;
    }

    async checkConformityInput(inputs) {

        const checker = {};

        const checkConformityIdInput = async (ids) => {
 
            const promises = [];

            for (let i = 0; i < ids.length; i += 1) { 
                const id = ids[i]; 
                promises.push(this.modelService.readIt({ _id: id }, { selectAttributesReturned: { [this.authorizationUserId]: 1 } })); 
            }

            const modelCheckers = await Promise.all(promises);

            modelCheckers.forEach((modelChecker) => {
                if (format_checker.isNil(modelChecker)) {
                    throw new RigorousError(errorsMessages.DataNotConformError);
                }
            });

            return modelCheckers;
        };

        checker.modelCheckers = await checkConformityIdInput(inputs.ids);

        checker.modelCheckers.forEach((modelChecker) => {
            if (format_checker.isNil(modelChecker)) {
                throw new RigorousError(errorsMessages.DataNotConformError);
            }
        });

        return checker;
    }

    async checkAuthorization(checker) {    

        checker.modelCheckers.forEach((modelChecker) => { 
            if (!modelChecker[this.authorizationUserId].equals(this.userIdAsking)) {
                throw new RigorousError(errorsMessages.DataNotConformError);
            } 
        });

    }

    async processData(inputs, checker) {
        
        const promises = [];
        
        for (let i = 0; i < inputs.ids.length; i += 1) { 

            const id = inputs.ids[i]; 
            promises.push(this.modelService.deleteIt({ _id: id })); 
        }

        await Promise.all(promises);

        return { 
            result: null, 
            notificationParam: inputs,
        };
    }

    async sendNotification(inputs, notificationParam) {
        // None
    }
}

module.exports = Route;