enhancer-data-bridge/controllers/userauth.js

A bridge between Enhancer Clould and user business datasource

// Mock user. 
// Copy from Bodhi/core/user object.

var mocker = require('../mock');
var path = require('path');
var os = require('os');
var customModuleBase = path.resolve(__dirname, '../repository/project/custom-module');
if (os.platform() === 'win32') {
    customModuleBase = customModuleBase.replace(/\\/g, '/') + '/';
} else {
    customModuleBase = customModuleBase + '/';
}
var requireNocache = require('require-nocache')(module);

var UserAuthController = {
    login: function(req, res, next) {
        var uid = req.params.uid;
        var pwd = req.params.pwd;
        var code = req.body.code;
        var context = req.body.context || '{}';
        try {
            context = JSON.parse(context);
        } catch (e) {
            res.send({
                success: false,
                message: '[Dev Error] Invalid Login context.'
            });
            return;
        }

        var loginSettings = req.body.loginSettings;
        try {
            loginSettings = JSON.parse(loginSettings);
        } catch (e) {
            res.send({
                success: false,
                message: '[Dev Error] Invalid login settings in workbench.'
            });
            return;
        }
        
        var dbConfig = req.body.database;
        try {
            dbConfig = JSON.parse(dbConfig);
        } catch (e) {
            res.send({
                success: false,
                message: '[Dev Error] Invalid database configurations in workbench.'
            });
            return
        }

        var serverVars = req.body.serverVars;
        try {
            serverVars = JSON.parse(decodeURIComponent(serverVars));
        } catch(e) {
            serverVars = {};
        }

        // Mock user
        var __enhancer_user = mocker.mockUser(uid, pwd);
        for (var key in context) {
            __enhancer_user.setVariable('LOGIN_CONTEXT_' + key, context[key]);
        }
        req.session.user = __enhancer_user;

        // Mock enhancer
        var __enhancer = global.Enhancer = mocker.mockEnhancer(dbConfig, serverVars, req, res);

        // Mock login process
        var before = function(enhancer, user, done) {done()};
        if (loginSettings.beforeAuthen && loginSettings.beforeAuthen.enabled) {
            try {
                var beforeFunc = eval( '(' + loginSettings.beforeAuthen.funcStr
                        .replace(/require\(\s*\'@custom\//g, 'requireNocache(\'' + customModuleBase)
                     + ')' );
                before = function(enhancer, user, done) {
                    try {
                        beforeFunc(enhancer, user, done);
                    } catch(err) {
                        err.message = err.message.replace(customModuleBase, '@custom/');
                        done(err);
                    }
                }
            } catch (e) {
                res.send({
                    success: false,
                    code: 'BEFORE_LOGIN_SYNTAX_ERR',
                    message: e.message.replace(customModuleBase, '@custom/')
                });
                return;
            }
        }
        var login;
        if (!loginSettings.authen) {
            res.end();
            return
        }
        if (loginSettings.authen.mode === 'userTable') {
            var map = loginSettings.authen.userTableMapping;
            var loginFields = (map.OTHER_LOGIN_FIELDS || '').replace(/\s/g, '').split(',')
                .filter(function(f) {
                    return !!f;
                });
            loginFields.push( map['USER_ID'] );
            var __fcnt = 0;
            var sql = 'SELECT '
                    + map['USER_ID'] + ' USER_ID, ' 
                    + map['USER_NAME'] + ' USER_NAME, '
                    + map['ROLES'] + ' ROLES, '
                    + 'u.* '
                    + 'FROM ' + map['tableName'] + ' u '
                    + 'WHERE ' + map['PASSWORD'] + ' = ? AND ('
                    + loginFields.map(function(f) {
                        __fcnt++;
                        return f + ' = ?';
                      }).join(' OR ')
                    + ')';

            console.log('Authentication mode is userTable.');
            console.log('Authentication sql is "' + sql + '"');
            login = function(Enhancer, user, callback) {
                var uid = user.getId();
                var pwd = user.getPassword();
                var params = [pwd];
                for (var i = 0; i < __fcnt; i++) {
                    params.push(uid);
                }
                var dbService = Enhancer.getDatabaseService();
                dbService.execute(sql, params, function(err, data) {
                    if (err) {
                        return callback(err)
                    }
                    if (!data || !data.rows) {
                        console.error('Unexpected data result when user login.' );
                        console.error('Validate SQL: ', sql);
                        console.error('user: ', uid, ' pwd: ', pwd);
                        console.error('data result: ', data);
                        return callback(null, false);
                    }
                    if (!data.rows.length) {
                        return callback(null, false);
                    }
                    var u = data.rows[0];
                    u.ROLES = u.ROLES instanceof Array ? u.ROLES[0] : u.ROLES;
                    u.USER_NAME = u.USER_NAME instanceof Array ? u.USER_NAME[0] : u.USER_NAME;
                    u.USER_ID = u.USER_ID instanceof Array ? u.USER_ID[0] : u.USER_ID;
                    // Set name and roles for this user.
                    user.setRoles(u.ROLES);
                    user.setId(u.USER_ID);
                    user.setName(u.USER_NAME);
                    // Set other fields as user data.
                    user.setVariables(u);

                    // add all
                    callback(null, true);
                });
            };
        } else {
            try {
                var loginFunc = eval( '('
                    + loginSettings.authen.customFuncStr
                        .replace(/require\(\s*\'@custom\//g, 'requireNocache(\'' + customModuleBase)
                    + ')' );

                login = function(enhancer, user, done) {
                    try {
                        loginFunc(enhancer, user, done);
                    } catch(err) {
                        err.message = err.message.replace(customModuleBase, '@custom/');
                        done(err);
                    }
                };
            } catch (e) {
                res.send({
                    success: false,
                    code: 'LOGIN_SYNTAX_ERR',
                    message: e.message.replace(customModuleBase, '@custom/')
                });
                return;
            }
        }

        var after = function(enhancer, user, done) {done()};
        if (loginSettings.afterAuthen && loginSettings.afterAuthen.enabled) {
            try {
                var afterFunc = eval( '('
                    + loginSettings.afterAuthen.funcStr
                        .replace(/require\(\s*\'@custom\//g, 'requireNocache(\'' + customModuleBase)
                    + ')' );
                after = function(enhancer, user, done) {
                    try {
                        afterFunc(enhancer, user, done);
                    } catch(err) {
                        err.message = err.message.replace(customModuleBase, '@custom/');
                        done(err);
                    }
                };
            } catch (e) {
                res.send({
                    success: false,
                    code: 'AFTER_LOGIN_SYNTAX_ERR',
                    message: e.message.replace(customModuleBase, '@custom/')
                });
                return;
            }
        };

        // call before, login, after
        before(__enhancer, __enhancer_user, function(err, isValid) {
            if (err) {
                console.error(err);
                res.send({
                    code: 'BEFORE_LOGIN_ERROR',
                    message: err.message
                });
                return;
            }
            if (isValid === false || typeof isValid === 'string') {
                res.send({
                    success: false,
                    code: isValid === false ? 'INVALID_USER_OR_PWD' : '',
                    message: typeof isValid === 'string' ? isValid : ''
                });
                return;
            }
            if (typeof isValid === 'object' && isValid.success === false) {
                res.send({
                    success: false,
                    code: isValid.code,
                    message: isValid.message
                });
                return;
            }
            login(__enhancer, __enhancer_user, function(err, isValid0) {
                if (err) {
                    console.error(err);
                    res.send({
                        code: 'LOGIN_ERROR',
                        message: err.message
                    });
                    return;
                }
                if (typeof isValid0 === 'object') {
                    if (!isValid0.success) {
                        isValid0.code = isValid0.code ? isValid0.code : 'INVALID_USER_OR_PWD';
                        res.send(isValid0);
                        return;
                    }
                } else if (isValid0 !== true) {
                    res.send({
                        success: false,
                        code: isValid0 === false ? 'INVALID_USER_OR_PWD' : '',
                        message: typeof isValid0 === 'string' ? isValid0 : ''
                    });
                    return;
                }

                after(__enhancer, __enhancer_user, function(err, isValid) {
                    if (err) {
                        console.error(err);
                        res.send({
                            code: 'AFTER_LOGIN_ERROR',
                            message: err.message
                        });
                        return;
                    }
                    if (isValid === false || typeof isValid === 'string') {
                        res.send({
                            success: false,
                            code: isValid === false ? 'INVALID_USER_OR_PWD' : '',
                            message: typeof isValid === 'string' ? isValid : ''
                        });
                        return;
                    }
                    if (typeof isValid === 'object' && isValid.success === false) {
                        res.send({
                            success: false,
                            code: isValid.code,
                            message: isValid.message
                        });
                        return;
                    }
                    var vars = __enhancer_user.getVariables();
                    vars['USER_NAME'] = __enhancer_user.getName();
                    vars['USER_ID'] = __enhancer_user.getId();
                    for (var i in vars) {
                        vars['1-' + i] = vars[i];
                    }
                    if (typeof isValid0 === 'object') {
                        isValid0.variables = vars;
                        res.send(isValid0);
                        return;
                    }
                    res.send({
                        success: true,
                        variables: vars
                    });
                });
            });
        });
    },
    logout: function(req, res, next) {
        res.jsonp({
            success: true,
            message: 'bye'
        });

        var loginSettings = req.query.loginSettings;
        try {
            loginSettings = JSON.parse(loginSettings);
        } catch (e) {
            console.error('[Dev Error] Invalid login settings in workbench');
            console.error(e);
            return;
        }
        
        if (!loginSettings.logout || !loginSettings.logout.enabled) {
            return;
        }
        var logoutFunc = loginSettings.logout.funcStr
                    .replace(/require\(\s*\'@custom\//g, 'requireNocache(\'' + customModuleBase)
        try {
            logoutFunc = eval( '(' + logoutFunc + ')');
        } catch (e) {
            console.error('[Dev Error] The logout function has syntax error.');
            console.error(e);
            console.error('Original Function Settings:', logoutFunc);
            return;
        }
        var dbConfig = req.query.database;
        try {
            dbConfig = JSON.parse(dbConfig);
        } catch (e) {
            console.error('[Dev Error] Invalid database configurations in workbench.');
            console.error(e);
            return;
        }
 
        var serverVars = req.query.serverVars;
        try {
            serverVars = JSON.parse(decodeURIComponent(serverVars));
        } catch(e) {
            serverVars = {};
        }

        var __enhancer = global.Enhancer = mocker.mockEnhancer(dbConfig, serverVars, req, res);
        var __enhancer_user = mocker.mockUser(serverVars['USER_ID'], '');
        __enhancer_user.setName(serverVars['USER_NAME']);
        __enhancer_user.setRoles(serverVars['ROLES']);

        logoutFunc(__enhancer, __enhancer_user);
    }
};

module.exports = UserAuthController;