salix/back/models/account.js

/* eslint max-len: ["error", { "code": 150 }]*/
const md5 = require('md5');
const app = require('../../loopback/server/server.js');
const dataSources = require('../../print/config/print.json');
const LoopBackContext = require('loopback-context');
const {Email} = require('vn-print');

module.exports = Self => {
    require('../methods/account/login')(Self);
    require('../methods/account/logout')(Self);
    require('../methods/account/acl')(Self);
    require('../methods/account/change-password')(Self);
    require('../methods/account/set-password')(Self);
    require('../methods/account/recover-password')(Self);
    require('../methods/account/validate-token')(Self);
    require('../methods/account/privileges')(Self);

    // Validations

    Self.validatesFormatOf('email', {
        message: 'Invalid email',
        allowNull: true,
        allowBlank: true,
        with: /^[\w|.|-]+@[\w|-]+(\.[\w|-]+)*(,[\w|.|-]+@[\w|-]+(\.[\w|-]+)*)*$/
    });

    Self.validatesUniquenessOf('name', {
        message: `A client with that Web User name already exists`
    });

    Self.observe('before save', async function(ctx) {
        if (ctx.currentInstance && ctx.currentInstance.id && ctx.data && ctx.data.password)
            ctx.data.password = md5(ctx.data.password);
    });

    Self.observe('before save', async(ctx, instance) => {
        console.log(instance);
        const models = Self.app.models;
        const loopBackContext = LoopBackContext.getCurrentContext();
        const changes = ctx.data || ctx.instance;
        if (ctx.isNewInstance || !changes.email) return;

        const userId = ctx.currentInstance.id;
        const user = await models.Account.findById(userId);
        if (user.email == changes.email) return;

        const httpCtx = {req: loopBackContext.active};
        const httpRequest = httpCtx.req.http.req;
        const headers = httpRequest.headers;
        const origin = headers.origin;
        const $t = httpRequest.__;

        const title = $t('Verify email');
        const body = `
            <p>
            ${$t(`Click on the following link to verify this email. If you haven't requested this email, just ignore it`)}:
            </p>
            </b>
            <a href="${origin}/#!/account/${userId}/basic-data?emailVerified">
                ${title}
            </a>`;

        const url = app.get('rootUrl') || app.get('url');
        console.log(app.get('rootUrl'));
        console.log(app.get('url'));
        console.log(dataSources);
        const options = {
            type: 'email',
            to: 'alexm@verdnatura.es',
            from: dataSources.app.senderEmail,
            subject: title,
            template: body,
            redirect: `${origin}#/login/${instance.email}?emailConfirmed`,
            host: dataSources.smtp.host,
            port: dataSources.smtp.port,
            protocol: 'https',
            user: Self
        };

        const params = {
            recipient: 'alexm@verdnatura.es',
            url: `${origin}/#!/verified`
        };

        console.log(params);
        const sendEmail = new Email('email-verify', params);

        // ctx.instance.verify(options);
        sendEmail.send();
    });

    Self.remoteMethod('getCurrentUserData', {
        description: 'Gets the current user data',
        accepts: [
            {
                arg: 'ctx',
                type: 'Object',
                http: {source: 'context'}
            }
        ],
        returns: {
            type: 'Object',
            root: true
        },
        http: {
            verb: 'GET',
            path: '/getCurrentUserData'
        }
    });

    Self.getCurrentUserData = async function(ctx) {
        let userId = ctx.req.accessToken.userId;
        return await Self.findById(userId, {
            fields: ['id', 'name', 'nickname']
        });
    };

    /**
     * Checks if user has a role.
     *
     * @param {Integer} userId The user id
     * @param {String} name The role name
     * @param {Object} options Options
     * @return {Boolean} %true if user has the role, %false otherwise
     */
    Self.hasRole = async function(userId, name, options) {
        let roles = await Self.getRoles(userId, options);
        return roles.some(role => role == name);
    };

    /**
     * Get all user roles.
     *
     * @param {Integer} userId The user id
     * @param {Object} options Options
     * @return {Object} User role list
     */
    Self.getRoles = async(userId, options) => {
        let result = await Self.rawSql(
            `SELECT r.name
                FROM account.user u
                    JOIN account.roleRole rr ON rr.role = u.role
                    JOIN account.role r ON r.id = rr.inheritsFrom
                WHERE u.id = ?`, [userId], options);

        let roles = [];
        for (role of result)
            roles.push(role.name);

        return roles;
    };
};