@aarconada/urserver
Version:
Basic Server definitions to develope REST API with a node + express Server
823 lines (791 loc) • 74.3 kB
JavaScript
/**
* Created by ubuntu on 8/11/18.
*/
'use strict';
const server = require('./server')();
const _ = require('lodash');
const promise = require('bluebird');
const basicAuthentication = require('./authenticationmethods/basic');
const anonymousAuthentication = require('./authenticationmethods/anonymous');
const ldapAuthentication = require('./authenticationmethods/ldap');
const authenticationsTypes = {
Basic : 1,
Anonymous : 2,
Google : 4,
Facebook : 8,
LDAP : 16
};
module.exports.types = authenticationsTypes;
if(!_.isUndefined(server.configuration.authentication)) {
if(basicAuthentication.enabled) {
server.endpointmanager.addEndpoint({
name: 'Basic user signup',
description: 'This endpoint allows to ceate new basic users in the server',
route: '/basicuser/signup',
method: server.utils.method.POST,
callback: function (req, res, next, allowedResponses, transaction) {
server.debug('Trying to create a User with data:', req.body.type);
const currentRole = server.roles.getRoleById(req.body.type);
if (_.isUndefined(currentRole) || _.isNull(currentRole)) server.utils.throwError(allowedResponses.unknown_user_type);
if ((currentRole.authentication & authenticationsTypes.Basic) !== authenticationsTypes.Basic) server.utils.throwError(allowedResponses.unknown_user_type);
return basicAuthentication.signup(transaction, req.body.type, req.body.email, req.body.password)
.then(newUser => {
server.debug('Signup result', newUser !== null);
var currentRoleModelData = {
BasicUserId : newUser.id,
authenticationType : authenticationsTypes.Basic
};
if(!_.isUndefined(req.body.customUserData) && !_.isEmpty(req.body.customUserData)) {
var jsonCustomUserData = JSON.parse(req.body.customUserData);
for(var currentKey in jsonCustomUserData) {
if(jsonCustomUserData.hasOwnProperty(currentKey)) {
currentRoleModelData[currentKey] = jsonCustomUserData[currentKey];
}
}
}
return currentRole.model.create(
currentRoleModelData,
{transaction: transaction}
)
.then(newPersonInstance => {
return {};
}).catch(err => {
server.debug('Error on basic user signup', err);
server.utils.throwError(allowedResponses.authentication_unable_signup, err);
});
})
.catch(err => {
server.debug('Error on basic user signup', err);
server.utils.throwError(allowedResponses.authentication_unable_signup, err);
})
},
token : {required: false},
session : {required: false},
parameters : [
{
name: 'type',
dataType: server.utils.dataType.STRING,
parameterType: server.utils.parameterType.BODY,
required: true,
description: 'User type'
}, {
name: 'email',
dataType: server.utils.dataType.STRING,
parameterType: server.utils.parameterType.BODY,
required: true,
description: 'Valid email account of the user'
}, {
name: 'password',
dataType: server.utils.dataType.STRING,
parameterType: server.utils.parameterType.BODY,
required: true,
description: 'User account password'
}, {
name: 'customUserData',
dataType: server.utils.dataType.JSON,
parameterType: server.utils.parameterType.BODY,
required: false,
description: 'Custom user data (This fields must be part of the current role)'
}
],
responses: {
authentication_unable_signup: server.defaultResponses.authentication_unable_signup,
unknown_user_type: server.defaultResponses.unknown_user_type
},
transactional: true
});
server.endpointmanager.addEndpoint({
name : 'Basic user login',
description : 'This endpoint allows log into the system to a basic user',
route : '/basicuser/login',
method : server.utils.method.POST,
callback : function(req, res, next, allowedResponses, transaction) {
return basicAuthentication.login(transaction, req.body.email, req.body.password)
.then(loggedUser => {
if (!_.isUndefined(loggedUser) && !_.isNull(loggedUser) && loggedUser !== allowedResponses.authentication_invalid_credentials) {
return server.session.getSessionByIds(loggedUser.id, loggedUser.type, authenticationsTypes.Basic)
.then(existingSession => {
var bearerToken = '';
var refreshToken = '';
const loggedUserRole = server.roles.getRoleById(loggedUser.type);
if(_.isUndefined(loggedUserRole) || _.isNull(loggedUserRole)) server.utils.throwError(allowedResponses.authentication_invalid_credentials);
if (existingSession !== allowedResponses.unknown_session) {
bearerToken = existingSession.data.bearertoken;
refreshToken = existingSession.data.refreshtoken;
} else {
bearerToken = server.token.generateBearerToken({});
refreshToken = server.token.generateRefreshToken({});
}
const loggedUserInfo = {
bearertoken: bearerToken,
refreshtoken: refreshToken,
basicuser: {
id : loggedUser.id,
email : loggedUser.email,
lastlogin : loggedUser.lastlogin,
type : loggedUser.type,
}
};
const loggedUserFilters = {
userId: loggedUser.id
};
if(!_.isUndefined(loggedUserRole.schema) && !_.isNull(loggedUserRole.schema)) {
return loggedUser['get' + loggedUserRole.name]({transaction: transaction})
.then(relatedRoleData => {
server.debug('Related passenger founded?', relatedRoleData !== null);
if (_.isUndefined(relatedRoleData) || _.isNull(relatedRoleData)) {
loggedUserInfo[loggedUserRole.name] = null;
} else {
var sessionRoleData = {};
sessionRoleData.id = relatedRoleData.id;
loggedUserFilters[loggedUserRole.name + 'Id'] = relatedRoleData.id;
Object.keys(loggedUserRole.schema).forEach(currentFieldName => {
var currentField = loggedUserRole.schema[currentFieldName];
if (currentField.inSession) {
sessionRoleData[currentFieldName] = relatedRoleData[currentFieldName];
}
if(currentField.isFilter) {
loggedUserFilters[currentFieldName] = relatedRoleData[currentFieldName];
}
});
loggedUserInfo[loggedUserRole.name] = sessionRoleData;
}
server.session.createSession(loggedUser.id, bearerToken, loggedUser.type, authenticationsTypes.Basic, loggedUserInfo, loggedUserFilters);
return loggedUserInfo;
})
.catch(err => {
server.debug('Error on passenger obtaining', err);
server.utils.throwError(allowedResponses.authentication_invalid_credentials, err);
});
} else {
server.session.createSession(loggedUser.id, bearerToken, loggedUser.type, authenticationsTypes.Basic, loggedUserInfo, loggedUserFilters);
return loggedUserInfo;
}
})
.catch(err => {
server.debug(err);
server.utils.throwError(allowedResponses.unknown_session, err);
});
} else {
server.utils.throwError(allowedResponses.authentication_invalid_credentials);
}
})
.catch(err => {
server.debug('Error on basic user login', err);
server.utils.throwError(allowedResponses.authentication_invalid_credentials, err);
})
},
token : {required: false},
session : {required: false},
parameters : [
{
name: 'email',
dataType: server.utils.dataType.STRING,
parameterType: server.utils.parameterType.BODY,
required: true,
description: 'Valid email account of the user'
}, {
name: 'password',
dataType: server.utils.dataType.STRING,
parameterType: server.utils.parameterType.BODY,
required: true,
description: 'User account password '
}
],
responses : {
unknown_session : server.defaultResponses.unknown_session,
authentication_invalid_credentials : server.defaultResponses.authentication_invalid_credentials
},
success: {
bearertoken: 'asd',
refreshtoken: 'asd',
basicuser: {
id: 123,
email: 'asd',
lastlogin: 'yyyy-MM-ddThh:mm:ss:000Z',
type: 123
},
roleSpecificData: {
id: 123,
relatedRoleField1: 'VALUE OF THE ROLE SPECIFIC DATA 1'
}
},
transactional: true
});
}
if(anonymousAuthentication.enabled) {
server.endpointmanager.addEndpoint({
name: 'Anonymous user signup',
description: 'This endpoint allows to ceate new anonymous users in the server',
route: '/anonymous/signup',
method: server.utils.method.POST,
callback: function (req, res, next, allowedResponses, transaction) {
server.debug('Trying to create a User with data:', req.body.type);
const currentRole = server.roles.getRoleById(req.body.type);
if (_.isUndefined(currentRole) || _.isNull(currentRole)) server.utils.throwError(allowedResponses.unknown_user_type);
if ((currentRole.authentication & authenticationsTypes.Anonymous) !== authenticationsTypes.Anonymous) server.utils.throwError(allowedResponses.unknown_user_type);
return anonymousAuthentication.signup(transaction, req.body.type, req.body.code)
.then(newUser => {
server.debug('Signup result', newUser !== null);
var currentRoleModelData = {
AnonymousUserId : newUser.id,
authenticationType : authenticationsTypes.Anonymous
};
if(!_.isUndefined(req.body.customUserData) && !_.isEmpty(req.body.customUserData)) {
var jsonCustomUserData = JSON.parse(req.body.customUserData);
for(var currentKey in jsonCustomUserData) {
if(jsonCustomUserData.hasOwnProperty(currentKey)) {
currentRoleModelData[currentKey] = jsonCustomUserData[currentKey];
}
}
}
return currentRole.model.create(
currentRoleModelData,
{transaction: transaction}
)
.then(newPersonInstance => {
return {};
}).catch(err => {
server.debug('Error on basic user signup', err);
server.utils.throwError(allowedResponses.authentication_unable_signup, err);
});
})
.catch(err => {
server.debug('Error on basic user signup', err);
server.utils.throwError(allowedResponses.authentication_unable_signup, err);
})
},
token : {required: false},
session : {required: false},
parameters : [
{
name: 'type',
dataType: server.utils.dataType.STRING,
parameterType: server.utils.parameterType.BODY,
required: true,
description: 'User type'
}, {
name: 'code',
dataType: server.utils.dataType.STRING,
parameterType: server.utils.parameterType.BODY,
required: true,
description: 'Identificator code of the user'
}, {
name: 'customUserData',
dataType: server.utils.dataType.JSON,
parameterType: server.utils.parameterType.BODY,
required: false,
description: 'Custom user data (This fields must be part of the current role)'
}
],
responses: {
authentication_unable_signup: server.defaultResponses.authentication_unable_signup,
unknown_user_type: server.defaultResponses.unknown_user_type
},
transactional: true
});
server.endpointmanager.addEndpoint({
name : 'Anonymous user login',
description : 'This endpoint allows log into the system to a anonymous user',
route : '/anonymous/login',
method : server.utils.method.POST,
callback : function(req, res, next, allowedResponses, transaction) {
return anonymousAuthentication.login(transaction, req.body.code)
.then(loggedUser => {
if (!_.isUndefined(loggedUser) && !_.isNull(loggedUser) && loggedUser !== allowedResponses.authentication_invalid_credentials) {
return server.session.getSessionByIds(loggedUser.id, loggedUser.type, authenticationsTypes.Anonymous)
.then(existingSession => {
var bearerToken = '';
var refreshToken = '';
const loggedUserRole = server.roles.getRoleById(loggedUser.type);
if(_.isUndefined(loggedUserRole) || _.isNull(loggedUserRole)) server.utils.throwError(allowedResponses.authentication_invalid_credentials);
if (existingSession !== allowedResponses.unknown_session) {
bearerToken = existingSession.data.bearertoken;
refreshToken = existingSession.data.refreshtoken;
} else {
bearerToken = server.token.generateBearerToken({});
refreshToken = server.token.generateRefreshToken({});
}
const loggedUserInfo = {
bearertoken: bearerToken,
refreshtoken: refreshToken,
anonymoususer: {
id: loggedUser.id,
code: loggedUser.code,
lastlogin: loggedUser.lastlogin,
type: loggedUser.type,
}
};
/*if(server.configuration.inotify.enabled) {
if (!_.isUndefined(loggedUser["PushTokenId"]) && !_.isNull(loggedUser["PushTokenId"])) {
loggedUserInfo.pushTokenId = loggedUser.pushTokenId;
} else {
loggedUserInfo.pushTokenId = null;
}
}*/
const loggedUserFilters = {
userId: loggedUser.id
};
if(!_.isUndefined(loggedUserRole.schema) && !_.isNull(loggedUserRole.schema)) {
return loggedUser['get' + loggedUserRole.name]({transaction: transaction})
.then(relatedRoleData => {
server.debug('Related role data founded?', relatedRoleData !== null);
if (_.isUndefined(relatedRoleData) || _.isNull(relatedRoleData)) {
loggedUserInfo[loggedUserRole.name] = null;
} else {
var sessionRoleData = {};
sessionRoleData.id = relatedRoleData.id;
loggedUserFilters[loggedUserRole.name + 'Id'] = relatedRoleData.id;
Object.keys(loggedUserRole.schema).forEach(currentFieldName => {
var currentField = loggedUserRole.schema[currentFieldName];
if (currentField.inSession) {
sessionRoleData[currentFieldName] = relatedRoleData[currentFieldName];
}
if(currentField.isFilter) {
loggedUserFilters[currentFieldName] = relatedRoleData[currentFieldName];
}
});
loggedUserInfo[loggedUserRole.name] = sessionRoleData;
}
server.session.createSession(loggedUser.id, bearerToken, loggedUser.type, authenticationsTypes.Anonymous, loggedUserInfo, loggedUserFilters);
return loggedUserInfo;
})
.catch(err => {
server.debug('Error on passenger obtaining', err);
server.utils.throwError(allowedResponses.authentication_invalid_credentials, err);
});
} else {
server.session.createSession(loggedUser.id, bearerToken, loggedUser.type, authenticationsTypes.Anonymous, loggedUserInfo, loggedUserFilters);
return loggedUserInfo;
}
})
.catch(err => {
server.debug(err);
server.utils.throwError(allowedResponses.unknown_session, err);
});
} else {
server.utils.throwError(allowedResponses.authentication_invalid_credentials);
}
})
.catch(err => {
server.debug('Error on basic user login', err);
server.utils.throwError(allowedResponses.authentication_invalid_credentials, err);
})
},
token : {required: false},
session : {required: false},
parameters : [
{
name: 'code',
dataType: server.utils.dataType.STRING,
parameterType: server.utils.parameterType.BODY,
required: true,
description: 'Valid identificator code of the user'
}
],
responses : {
unknown_session : server.defaultResponses.unknown_session,
authentication_invalid_credentials : server.defaultResponses.authentication_invalid_credentials
},
success: {
bearertoken: 'asd',
refreshtoken: 'asd',
anonymoususer: {
id: 123,
code: 'asd',
lastlogin: 'yyyy-MM-ddThh:mm:ss:000Z',
type: 123
},
roleSpecificData: {
id: 123,
relatedRoleField1: 'VALUE OF THE ROLE SPECIFIC DATA 1'
}
},
transactional: true
});
}
if(ldapAuthentication.enabled) {
server.endpointmanager.addEndpoint({
name: 'LDAP user signup',
description: 'This endpoint allows to ceate new LDAP user in the server',
route: '/ldap/signup',
method: server.utils.method.POST,
callback: function (req, res, next, allowedResponses, transaction) {
server.debug('Trying to create a User with data:', req.body.type);
const currentRole = server.roles.getRoleById(req.body.type);
if (_.isUndefined(currentRole) || _.isNull(currentRole)) server.utils.throwError(allowedResponses.unknown_user_type);
if ((currentRole.authentication & authenticationsTypes.LDAP) !== authenticationsTypes.LDAP) server.utils.throwError(allowedResponses.unknown_user_type);
return ldapAuthentication.signup(transaction, req.body.type, req.body.username)
.then(newUser => {
server.debug('Signup result', newUser !== null);
var currentRoleModelData = {
LDAPUserId : newUser.id,
authenticationType : authenticationsTypes.LDAP
};
if(!_.isUndefined(req.body.customUserData) && !_.isEmpty(req.body.customUserData)) {
var jsonCustomUserData = JSON.parse(req.body.customUserData);
for(var currentKey in jsonCustomUserData) {
if(jsonCustomUserData.hasOwnProperty(currentKey)) {
currentRoleModelData[currentKey] = jsonCustomUserData[currentKey];
}
}
}
return currentRole.model.create(
currentRoleModelData,
{transaction: transaction}
)
.then(newPersonInstance => {
return {};
}).catch(err => {
server.debug('Error on LDAP user signup', err);
server.utils.throwError(allowedResponses.authentication_unable_signup, err);
});
})
.catch(err => {
server.debug('Error on LDAP user signup', err);
server.utils.throwError(allowedResponses.authentication_unable_signup, err);
})
},
token : {required: false},
session : {required: false},
parameters : [
{
name: 'type',
dataType: server.utils.dataType.STRING,
parameterType: server.utils.parameterType.BODY,
required: true,
description: 'User type'
}, {
name: 'username',
dataType: server.utils.dataType.STRING,
parameterType: server.utils.parameterType.BODY,
required: true,
description: 'UID of the user'
}, {
name: 'customUserData',
dataType: server.utils.dataType.JSON,
parameterType: server.utils.parameterType.BODY,
required: false,
description: 'Custom user data (This fields must be part of the current role)'
}
],
responses: {
authentication_unable_signup: server.defaultResponses.authentication_unable_signup,
unknown_user_type: server.defaultResponses.unknown_user_type
},
transactional: true
});
server.endpointmanager.addEndpoint({
name : 'LDAP user login',
description : 'This endpoint allows log into the system to a ldap user',
route : '/ldap/login',
method : server.utils.method.POST,
callback : function(req, res, next, allowedResponses, transaction) {
return ldapAuthentication.login(transaction, req.body.username, req.body.password)
.then(loggedUser => {
if (!_.isUndefined(loggedUser) && !_.isNull(loggedUser) && loggedUser !== allowedResponses.authentication_invalid_credentials) {
return server.session.getSessionByIds(loggedUser.id, loggedUser.type, authenticationsTypes.LDAP)
.then(existingSession => {
var bearerToken = '';
var refreshToken = '';
const loggedUserRole = server.roles.getRoleById(loggedUser.type);
if(_.isUndefined(loggedUserRole) || _.isNull(loggedUserRole)) server.utils.throwError(allowedResponses.authentication_invalid_credentials);
if (existingSession !== allowedResponses.unknown_session) {
bearerToken = existingSession.data.bearertoken;
refreshToken = existingSession.data.refreshtoken;
} else {
bearerToken = server.token.generateBearerToken({});
refreshToken = server.token.generateRefreshToken({});
}
const loggedUserInfo = {
bearertoken: bearerToken,
refreshtoken: refreshToken,
ldap: {
id : loggedUser.id,
cn : loggedUser.cn,
lastlogin : loggedUser.lastlogin,
type : loggedUser.type,
ldapAttributes : loggedUser.ldapAttributes
}
};
const loggedUserFilters = {
userId: loggedUser.id
};
if(!_.isUndefined(loggedUserRole.schema) && !_.isNull(loggedUserRole.schema)) {
return loggedUser['get' + loggedUserRole.name]({transaction: transaction})
.then(relatedRoleData => {
server.debug('Related role data founded?', relatedRoleData !== null);
if (_.isUndefined(relatedRoleData) || _.isNull(relatedRoleData)) {
loggedUserInfo[loggedUserRole.name] = null;
} else {
var sessionRoleData = {};
sessionRoleData.id = relatedRoleData.id;
loggedUserFilters[loggedUserRole.name + 'Id'] = relatedRoleData.id;
Object.keys(loggedUserRole.schema).forEach(currentFieldName => {
var currentField = loggedUserRole.schema[currentFieldName];
if (currentField.inSession) {
sessionRoleData[currentFieldName] = relatedRoleData[currentFieldName];
}
if(currentField.isFilter) {
loggedUserFilters[currentFieldName] = relatedRoleData[currentFieldName];
}
});
loggedUserInfo[loggedUserRole.name] = sessionRoleData;
}
server.session.createSession(loggedUser.id, bearerToken, loggedUser.type, authenticationsTypes.LDAP, loggedUserInfo, loggedUserFilters);
return loggedUserInfo;
})
.catch(err => {
server.debug('Error on passenger obtaining', err);
server.utils.throwError(allowedResponses.authentication_invalid_credentials, err);
});
} else {
server.session.createSession(loggedUser.id, bearerToken, loggedUser.type, authenticationsTypes.LDAP, loggedUserInfo, loggedUserFilters);
return loggedUserInfo;
}
})
.catch(err => {
server.debug(err);
server.utils.throwError(allowedResponses.unknown_session, err);
});
} else {
server.utils.throwError(allowedResponses.authentication_invalid_credentials);
}
})
.catch(err => {
server.debug('Error on ldap login', err);
server.utils.throwError(allowedResponses.authentication_invalid_credentials, err);
})
},
token : {required: false},
session : {required: false},
parameters : [
{
name: 'username',
dataType: server.utils.dataType.STRING,
parameterType: server.utils.parameterType.BODY,
required: true,
description: 'The username'
},
{
name: 'password',
dataType: server.utils.dataType.STRING,
parameterType: server.utils.parameterType.BODY,
required: true,
description: 'Password of the account'
}
],
responses : {
unknown_session : server.defaultResponses.unknown_session,
authentication_invalid_credentials : server.defaultResponses.authentication_invalid_credentials
},
success: {
bearertoken: 'asd',
refreshtoken: 'asd',
anonymoususer: {
id: 123,
code: 'asd',
lastlogin: 'yyyy-MM-ddThh:mm:ss:000Z',
type: 123
},
roleSpecificData: {
id: 123,
relatedRoleField1: 'VALUE OF THE ROLE SPECIFIC DATA 1'
}
},
transactional: true
});
server.endpointmanager.addEndpoint({
name : 'LDAP user login and signup',
description : 'This endpoint allows log into the system to a ldap user (This method auto signup the user if not exists in local database)',
route : '/ldap/loginwithsignup',
method : server.utils.method.POST,
callback : function(req, res, next, allowedResponses, transaction) {
return ldapAuthentication.loginWithSignup(transaction, req.body.username, req.body.password, req.body.type)
.then(loggedUser => {
if (!_.isUndefined(loggedUser) && !_.isNull(loggedUser) && loggedUser !== allowedResponses.authentication_invalid_credentials) {
return server.session.getSessionByIds(loggedUser.id, loggedUser.type, authenticationsTypes.LDAP)
.then(existingSession => {
var bearerToken = '';
var refreshToken = '';
const loggedUserRole = server.roles.getRoleById(loggedUser.type);
if(_.isUndefined(loggedUserRole) || _.isNull(loggedUserRole)) server.utils.throwError(allowedResponses.authentication_invalid_credentials);
if (existingSession !== allowedResponses.unknown_session) {
bearerToken = existingSession.data.bearertoken;
refreshToken = existingSession.data.refreshtoken;
} else {
bearerToken = server.token.generateBearerToken({});
refreshToken = server.token.generateRefreshToken({});
}
const loggedUserInfo = {
bearertoken: bearerToken,
refreshtoken: refreshToken,
ldap: {
id : loggedUser.id,
cn : loggedUser.cn,
lastlogin : loggedUser.lastlogin,
type : loggedUser.type,
ldapAttributes : loggedUser.ldapAttributes
}
};
const loggedUserFilters = {
userId: loggedUser.id
};
if(!_.isUndefined(loggedUserRole.schema) && !_.isNull(loggedUserRole.schema)) {
return loggedUser['get' + loggedUserRole.name]({transaction: transaction})
.then(relatedRoleData => {
server.debug('Related role data founded?', relatedRoleData !== null);
if (_.isUndefined(relatedRoleData) || _.isNull(relatedRoleData)) {
loggedUserInfo[loggedUserRole.name] = null;
} else {
var sessionRoleData = {};
sessionRoleData.id = relatedRoleData.id;
loggedUserFilters[loggedUserRole.name + 'Id'] = relatedRoleData.id;
Object.keys(loggedUserRole.schema).forEach(currentFieldName => {
var currentField = loggedUserRole.schema[currentFieldName];
if (currentField.inSession) {
sessionRoleData[currentFieldName] = relatedRoleData[currentFieldName];
}
if(currentField.isFilter) {
loggedUserFilters[currentFieldName] = relatedRoleData[currentFieldName];
}
});
loggedUserInfo[loggedUserRole.name] = sessionRoleData;
}
server.session.createSession(loggedUser.id, bearerToken, loggedUser.type, authenticationsTypes.LDAP, loggedUserInfo, loggedUserFilters);
return loggedUserInfo;
})
.catch(err => {
server.debug('Error on passenger obtaining', err);
server.utils.throwError(allowedResponses.authentication_invalid_credentials, err);
});
} else {
server.session.createSession(loggedUser.id, bearerToken, loggedUser.type, authenticationsTypes.LDAP, loggedUserInfo, loggedUserFilters);
return loggedUserInfo;
}
})
.catch(err => {
server.debug(err);
server.utils.throwError(allowedResponses.unknown_session, err);
});
} else {
server.utils.throwError(allowedResponses.authentication_invalid_credentials);
}
})
.catch(err => {
server.debug('Error on ldap login', err);
server.utils.throwError(allowedResponses.authentication_invalid_credentials, err);
})
},
token : {required: false},
session : {required: false},
parameters : [
{
name: 'type',
dataType: server.utils.dataType.STRING,
parameterType: server.utils.parameterType.BODY,
required: true,
description: 'User type'
},
{
name: 'username',
dataType: server.utils.dataType.STRING,
parameterType: server.utils.parameterType.BODY,
required: true,
description: 'The username'
},
{
name: 'password',
dataType: server.utils.dataType.STRING,
parameterType: server.utils.parameterType.BODY,
required: true,
description: 'Password of the account'
}
],
responses : {
unknown_session : server.defaultResponses.unknown_session,
authentication_invalid_credentials : server.defaultResponses.authentication_invalid_credentials
},
success: {
bearertoken: 'asd',
refreshtoken: 'asd',
anonymoususer: {
id: 123,
code: 'asd',
lastlogin: 'yyyy-MM-ddThh:mm:ss:000Z',
type: 123
},
roleSpecificData: {
id: 123,
relatedRoleField1: 'VALUE OF THE ROLE SPECIFIC DATA 1'
}
},
transactional: true
});
server.endpointmanager.addEndpoint({
name : 'LDAP user silent login',
description : 'This endpoint allows log into the system to a ldap user with the integrated authentication',
route : '/ldap/silentlogin',
method : server.utils.method.POST,
callback : function(req, res, next, allowedResponses, transaction) {
var receivedAuthUser = req.headers['x-iisnode-auth_user'];
server.debug('RECEIVED VALUE', receivedAuthUser);
const parts = receivedAuthUser.split('\\');
server.debug('parts', parts);
if(parts.length === 2) {
return ldapAuthentication.silentLogin(transaction, parts[1])
.then(loggedUser => {
if (!_.isUndefined(loggedUser) && !_.isNull(loggedUser) && loggedUser !== allowedResponses.authentication_invalid_credentials) {
return server.session.getSessionByIds(loggedUser.id, loggedUser.type, authenticationsTypes.LDAP)
.then(existingSession => {
var bearerToken = '';
var refreshToken = '';
const loggedUserRole = server.roles.getRoleById(loggedUser.type);
if (_.isUndefined(loggedUserRole) || _.isNull(loggedUserRole)) server.utils.throwError(allowedResponses.authentication_invalid_credentials);
if (existingSession !== allowedResponses.unknown_session) {
bearerToken = existingSession.data.bearertoken;
refreshToken = existingSession.data.refreshtoken;
} else {
bearerToken = server.token.generateBearerToken({});
refreshToken = server.token.generateRefreshToken({});
}
const loggedUserInfo = {
bearertoken: bearerToken,
refreshtoken: refreshToken,
ldap: {
id: loggedUser.id,
cn: loggedUser.cn,
lastlogin: loggedUser.lastlogin,
type: loggedUser.type,
ldapAttributes: loggedUser.ldapAttributes
}
};
const loggedUserFilters = {
userId: loggedUser.id
};
if (!_.isUndefined(loggedUserRole.schema) && !_.isNull(loggedUserRole.schema)) {
return loggedUser['get' + loggedUserRole.name]({transaction: transaction})
.then(relatedRoleData => {
server.debug('Related role data founded?', relatedRoleData !== null);
if (_.isUndefined(relatedRoleData) || _.isNull(relatedRoleData)) {
loggedUserInfo[loggedUserRole.name] = null;
} else {
var sessionRoleData = {};
sessionRoleData.id = relatedRoleData.id;
loggedUserFilters[loggedUserRole.name + 'Id'] = relatedRoleData.id;
Object.keys(loggedUserRole.schema).forEach(currentFieldName => {
var currentField = loggedUserRole.schema[currentFieldName];
if (currentField.inSession) {
sessionRoleData[currentFieldName] = relatedRoleData[currentFieldName];
}
if (currentField.isFilter) {
loggedUserFilters[currentFieldName] = relatedRoleData[currentFieldName];
}
});
loggedUserInfo[loggedUserRole.name] = sessionRoleData;
}
server.session.createSession(loggedUser.id, bearerToken, loggedUser.type, authenticationsTypes.LDAP, loggedUserInfo, loggedUserFilters);
return loggedUserInfo;
})
.catch(err => {
server.debug('Error