@aarconada/urserver/role.js

Basic Server definitions to develope REST API with a node + express Server

/**
 * Created by ubuntu on 8/11/18.
 */
'use strict';
const server            = require('./server')();
const _                 = require('lodash');
const definedRoles      = [];
const definedRolesById  = {};

module.exports.define      = function(options) {
    if(!_.isUndefined(options) &&
        !_.isUndefined(options.id) &&
        !_.isUndefined(options.name) &&
        !_.isUndefined(options.authentication &&
        !_.isUndefined(options.schema))
    ){
        definedRoles[options.name] = options;
        definedRolesById[options.id] = options;
        options.schema.authenticationType = {type: server.sequelize.api.INTEGER, allowNull: false, inSession: true};
        options.model = server.sequelize.define(
            {
                modelname: options.name,
                schema: options.schema,
                POST: {
                    single: {
                        enabled: true
                    },
                    all: {
                        enabled: false
                    }
                },
                PUT: {
                    single: {
                        enabled: true
                    }
                    ,
                    all: {
                        enabled: false
                    }
                },
                DELETE: {
                    single: {
                        enabled: true
                    }
                    ,
                    all: {
                        enabled: false
                    }
                },
                GET: {
                    single: {
                        enabled: true
                    }
                    ,
                    all: {
                        enabled: true
                    }
                }
            }
        );

        server.sequelize[options.name].addHook('beforeUpdate', 'UpdateSessionInfo', (updatedEntity, options) => {
            const currentRole = server.roles.getRoleByName(updatedEntity._modelOptions.name.singular);
            var userId = null;
            switch (updatedEntity.authenticationType) {
                case server.authentication.types.Anonymous:
                    userId = updatedEntity.AnonymousUserId;
                    break;
                case server.authentication.types.Basic:
                    userId = updatedEntity.BasicUserId;
                    break;
                case server.authentication.types.Facebook:
                    userId = updatedEntity.FacebookUserId;
                    break;
                case server.authentication.types.Google:
                    userId = updatedEntity.GoogleUserId;
                    break;
                case server.authentication.types.LDAP:
                    userId = updatedEntity.LDAPUserId;
                    break;
                default:
                    throw server.defaultResponses.unknown_session;
            }

            return server.session.getSessionByIds(userId, currentRole.id, updatedEntity.authenticationType)
                .then(currentUserSession => {
                    server.debug(currentUserSession);
                    if (!_.isUndefined(currentUserSession) && !_.isNull(currentUserSession) && currentUserSession !== server.defaultResponses.unknown_session) {
                        server.debug(currentUserSession);
                        var sessionRoleData = {};
                        sessionRoleData.id = updatedEntity.id;
                        var sessionFilters = currentUserSession.filters;
                        Object.keys(currentRole.schema).forEach(currentFieldName => {
                            var currentField = currentRole.schema[currentFieldName];
                            if (currentField.inSession) {
                                sessionRoleData[currentFieldName] = updatedEntity[currentFieldName];
                            }
                            if (currentField.isFilter) {
                                sessionFilters[currentFieldName] = updatedEntity[currentFieldName];
                            }
                        });
                        currentUserSession.data[currentRole.name] = sessionRoleData;
                        server.session.updateSessionData(currentUserSession.bearerToken, currentUserSession.data, sessionFilters);
                    }
                });
        });

        server.authentication.modelBelongsToAuthenticationMethods(options.model);
/*
        if ((options.authentication & server.authentication.types.Basic) === server.authentication.types.Basic) {
            options.model.belongsTo(server.sequelize.BasicUser, {foreignKey: 'BasicUserId'});
            server.sequelize.BasicUser.hasOne(options.model, {foreignKey: 'BasicUserId'});
        }

        if ((options.authentication & server.authentication.types.Anonymous) === server.authentication.types.Anonymous) {
            options.model.belongsTo(server.sequelize.AnonymousUser, {foreignKey: 'AnonymousUserId'});
            server.sequelize.AnonymousUser.hasOne(options.model, {foreignKey: 'AnonymousUserId'});
        }
*/
    }
};

module.exports.getRoleById = function(roleId) {
    return definedRolesById[roleId];
};
module.exports.getRoleByName = function(roleName) {
    return definedRoles[roleName];
};
module.exports.definedRoles = definedRoles;