550 lines
16 KiB
JavaScript
550 lines
16 KiB
JavaScript
const Authentication = require('../modules/authentication');
|
|
const Mongoose = require('mongoose');
|
|
const Reset = require('./reset');
|
|
|
|
const UserSchema = new Mongoose.Schema({
|
|
username: { type: String, required: true, unique: true },
|
|
password: { type: String },
|
|
name: { first: { type: String, required: true }, last: { type: String, required: true } },
|
|
email: { type: String, required: true, unique: true },
|
|
can: [{ type: String, enum: ['add','edit','delete','manage','super','update','view'], default: ['view'] }],
|
|
forceReset: { type: Boolean, default: true },
|
|
updated_at: { type: Date, default: Date.now }
|
|
});
|
|
|
|
UserSchema.pre('findOneAndUpdate', function (next) {
|
|
var self = this;
|
|
|
|
this.update({}, { $set: { updated_at: Date.now() } });
|
|
|
|
if (this._update.$set.settings && this._update.$set.settings.length) {
|
|
|
|
}
|
|
|
|
if (this._update.$set.password && this._update.$set.confirmPassword && (this._update.$set.password == this._update.$set.confirmPassword)) {
|
|
delete this._update.$set.confirmPassword;
|
|
|
|
if (this._update.$set.currentPassword) {
|
|
confirmPassword(this._conditions.userName, this._update.$set.currentPassword, (err, valid) => {
|
|
if (err || !valid) {
|
|
err = new Error({ success: false, message: 'There was an error validating the current password.', err: (err || null) });
|
|
next(err);
|
|
}
|
|
|
|
if (valid) {
|
|
delete this._update.$set.currentPassword;
|
|
hashPassword(this._update.$set.password, (err, hashedPassword) => {
|
|
self.update({}, { $set: { password: hashedPassword } });
|
|
self.update({}, { $set: { forceReset: false } });
|
|
next();
|
|
});
|
|
}
|
|
});
|
|
} else {
|
|
hashPassword(this._update.$set.password, (err, hashedPassword) => {
|
|
self.update({}, { $set: { password: hashedPassword } });
|
|
self.update({}, { $set: { forceReset: false } });
|
|
next();
|
|
});
|
|
}
|
|
} else if (this._update.$set.password && this._update.$set.confirmPassword && (this._update.$set.password != this._update.$set.confirmPassword)) {
|
|
let err = new Error({ success: false, message: 'There was an error saving the updated password.'});
|
|
next(err);
|
|
} else if (!this._update.$set.password && !this._update.$set.confirmPassword) {
|
|
next();
|
|
}
|
|
});
|
|
|
|
UserSchema.post('save', function (err, res, next) {
|
|
if (err.name === 'MongoError' && err.code === 11000) {
|
|
next(new Error('There was a duplicate key error'));
|
|
} else if (err) {
|
|
next(err);
|
|
} else {
|
|
next();
|
|
}
|
|
});
|
|
|
|
const UserModel = Mongoose.model('users', UserSchema);
|
|
|
|
var logger = require('../modules/logger');
|
|
|
|
function hashPassword (password, callback) {
|
|
callback = callback || false;
|
|
|
|
Authentication.hashPassword(password, (err, password) => {
|
|
if (err !== null) {
|
|
err = new Error({ success: false, message: 'There was an error hashing the updated password.', err: err });
|
|
logger.error('[updateUser:hashPassword] ', err);
|
|
|
|
if (callback) {
|
|
callback(err, null);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (password) {
|
|
var result = password.toString('hex');
|
|
|
|
if (callback) {
|
|
callback(null, result);
|
|
} else {
|
|
return result;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
function confirmPassword (username, passwordToValidate, callback) {
|
|
callback = callback || false;
|
|
|
|
UserModel.findById({ userName: username }, (err, user) => {
|
|
if (err !== null) {
|
|
err = new Error({ success: false, message: 'There was an error locating the user.', err: (err || null) });
|
|
logger.error('[updateUser:confirmPassword] ', err);
|
|
|
|
if (callback) {
|
|
callback(err, null);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (user) {
|
|
Authentication.verifyPassword(passwordToValidate, Buffer.from(storedUser.password, 'hex'), (err, valid) => {
|
|
if (err !== null || !valid) {
|
|
err = new Error({ success: false, message: (!err && !valid ? 'The current password was incorrect.' : 'There was an error attempting to validate the password.'), err: (err || null) });
|
|
logger.error('[updateUser:confirmPassword] ', { err: err, valid: valid });
|
|
|
|
if (callback) {
|
|
callback(err, null);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (valid) {
|
|
if (callback) {
|
|
callback(null, valid);
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
module.exports = {
|
|
|
|
adminUpdatePassword: (e, username, password) => {
|
|
const promise = new Promise((resolve, reject) => {
|
|
UserModel.findOneAndUpdate({ userName: username }, { $set: password }, { new: true }, (err, result) => {
|
|
if (err) {
|
|
reject(err);
|
|
}
|
|
|
|
if (result) {
|
|
resolve(result);
|
|
}
|
|
});
|
|
});
|
|
|
|
promise.then((result) => {
|
|
if (e) {
|
|
e.emit('adminUpdatePassword', null, result);
|
|
} else {
|
|
return result;
|
|
}
|
|
})
|
|
.catch((err) => {
|
|
if (e) {
|
|
e.emit('adminUpdatePassword', err, null);
|
|
} else {
|
|
return err;
|
|
}
|
|
});
|
|
},
|
|
|
|
authenticateUser: (e, login, headers) => {
|
|
const promise = new Promise((resolve, reject) => {
|
|
var loginObject, user;
|
|
|
|
UserModel
|
|
.findOne({ userName: login.userName }, 'username name email password can forceReset')
|
|
.exec((err, result) => {
|
|
if (err) {
|
|
loginObject = {
|
|
status: 200,
|
|
authorized: false,
|
|
err: {
|
|
id: '005',
|
|
code: '[UMAU005]',
|
|
string: 'There was an error authenticating the user.'
|
|
}
|
|
}
|
|
logger.debug('[UserModel::authenticateUser] Error finding user', { err: err, username: login.userName });
|
|
resolve(loginObject);
|
|
}
|
|
|
|
if (result) {
|
|
user = result;
|
|
|
|
if (user && !user.permission.disabled) {
|
|
if (user.forceReset) {
|
|
loginObject = {
|
|
status: 200,
|
|
authorized: false,
|
|
err: {
|
|
id: '003',
|
|
code: '[UMAU003]',
|
|
string: 'A password reset has been mandated. Please check your email for a password reset link or request a new one from the login screen.'
|
|
}
|
|
};
|
|
resolve(loginObject);
|
|
}
|
|
else {
|
|
try {
|
|
Authentication.verifyPassword(login.password, Buffer.from(user.password, 'hex'), (err, valid) => {
|
|
if (err) {
|
|
logger.debug('[UserModel::authenticateUser] Error validating password', { err: err, user: user });
|
|
reject(err);
|
|
}
|
|
|
|
loginObject = {
|
|
status: 200,
|
|
authorized: valid
|
|
};
|
|
|
|
if (valid) {
|
|
loginObject.user = {
|
|
_id: user._id,
|
|
username: user.username,
|
|
name: user.name,
|
|
email: user.email,
|
|
can: user.can
|
|
};
|
|
|
|
loginObject.timestamp = Date.now();
|
|
|
|
logger.debug('[UserModel::authenticateUser] User Validated', { user: user, loginObject: loginObject });
|
|
resolve(loginObject);
|
|
} else {
|
|
loginObject.err = {
|
|
id: '002',
|
|
code: '[UMAU002]',
|
|
string: 'The user id or password you entered was invalid.'
|
|
};
|
|
|
|
logger.debug('[UserModel::authenticateUser] Invalid Password', { user: user, loginObject: loginObject });
|
|
resolve(loginObject);
|
|
}
|
|
});
|
|
}
|
|
catch (err) {
|
|
loginObject = {
|
|
status: 200,
|
|
authorized: false,
|
|
err: {
|
|
id: '004',
|
|
code: '[UMAU004]',
|
|
string: 'There was an error authenticating the user, please contact an administrator.'
|
|
}
|
|
};
|
|
|
|
logger.error('[UserModel::authenticateUser] Error verifying password', { err: err, user: user });
|
|
resolve(loginObject);
|
|
}
|
|
}
|
|
}
|
|
else if (user && user.permission.disabled) {
|
|
loginObject = {
|
|
status: 200,
|
|
authorized: false,
|
|
err: {
|
|
id: '000',
|
|
code: '[UMAU000]',
|
|
string: 'The user is not authorized, please contact an administrator.'
|
|
}
|
|
};
|
|
logger.debug('[UserModel::authenticateUser] The user is disabled', { err: err, user: user });
|
|
resolve(loginObject);
|
|
}
|
|
else {
|
|
loginObject = {
|
|
status: 200,
|
|
authorized: false,
|
|
err: {
|
|
id: '001',
|
|
code: '[UMAU001]',
|
|
string: 'The user id or password you entered was invalid.'
|
|
}
|
|
};
|
|
logger.debug('[UserModel::authenticateUser] The user does not exist', { err: err, user: user });
|
|
resolve(loginObject);
|
|
}
|
|
}
|
|
});
|
|
});
|
|
|
|
promise.then((result) => {
|
|
e.emit('authenticateUser', null, result);
|
|
})
|
|
.catch((err) => {
|
|
e.emit('authenticateUser', err, null);
|
|
});
|
|
},
|
|
|
|
createUser: (e, user) => {
|
|
const promise = new Promise((resolve, reject) => {
|
|
var userInstance = new UserModel(user);
|
|
|
|
userInstance.save((err, result) => {
|
|
logger.debug('createUser', { err: err, result: result, user: userInstance });
|
|
|
|
if (err) {
|
|
reject(err);
|
|
}
|
|
|
|
if (result) {
|
|
Reset.sendNewUser(null, result);
|
|
resolve(result);
|
|
}
|
|
});
|
|
});
|
|
|
|
promise.then((result) => {
|
|
e.emit('createUser', null, result);
|
|
})
|
|
.catch((err) => {
|
|
e.emit('createUser', err, null);
|
|
});
|
|
},
|
|
|
|
deleteUser: (e, id) => {
|
|
const promise = new Promise((resolve, reject) => {
|
|
UserModel.remove({ _id: id }, (err, result) => {
|
|
if (err) {
|
|
reject(err);
|
|
}
|
|
|
|
if (result) {
|
|
resolve(result);
|
|
}
|
|
});
|
|
});
|
|
|
|
promise.then((result) => {
|
|
e.emit('deleteUser', null, result);
|
|
})
|
|
.catch((err) => {
|
|
e.emit('deleteUser', err, null);
|
|
});
|
|
},
|
|
|
|
findUser: (query, callback) => {
|
|
UserModel.findOne(query, (err, result) => {
|
|
if (err) {
|
|
callback(err, null);
|
|
}
|
|
|
|
if (result) {
|
|
callback(null, result);
|
|
}
|
|
});
|
|
},
|
|
|
|
forcePasswordReset: (e, id) => {
|
|
const promise = new Promise((resolve, reject) => {
|
|
UserModel.findByIdAndUpdate(id, { $set: { forceReset: true } }, { new: true }, (err, result) => {
|
|
if (err) {
|
|
reject(err);
|
|
}
|
|
|
|
if (result) {
|
|
let resetPromise = new Promise((resetResolve, resetReject) => {
|
|
Reset.forceReset(null, result, (result) => {
|
|
if (result.success) {
|
|
resetResolve({ success: true, message: 'Force password reset initiated on the user.', result: result });
|
|
} else {
|
|
resetResolve({ success: false, message: 'There was an error initiating the forced password reset.', result: result });
|
|
}
|
|
});
|
|
});
|
|
|
|
resetPromise.then((result) => {
|
|
resolve(result);
|
|
})
|
|
.catch((err) => {
|
|
reject(err);
|
|
});
|
|
}
|
|
});
|
|
});
|
|
|
|
promise.then((result) => {
|
|
e.emit('forcePasswordReset', null, result);
|
|
})
|
|
.catch((err) => {
|
|
e.emit('forcePasswordReset', err, null);
|
|
});
|
|
},
|
|
|
|
getUsers: (e, query, restricted = true) => {
|
|
query = query || { find: {}, options: { sort: { 'name.last': 1, 'name.first': 1 }, limit: 0, skip: 0 }};
|
|
|
|
const promise = new Promise((resolve, reject) => {
|
|
var projection = 'userName name' + (restricted ? '' : ' title email permission avatar settings forceReset');
|
|
var query = UserModel.find(query.find, projection, query.options);
|
|
|
|
if (!restricted) {
|
|
query.populate('permission', 'name disabled manageRoles manageUsers manageCategories manageAppPreferences deleteVendor addVendorTag addVendorSample addVendorComment editVendor addNewVendor viewPrivateDetails viewPublicDetails')
|
|
}
|
|
|
|
query.exec((err, results) => {
|
|
if (err) {
|
|
reject(err);
|
|
}
|
|
|
|
if (results) {
|
|
resolve(results);
|
|
}
|
|
});
|
|
});
|
|
|
|
promise.then((results) => {
|
|
if (e) {
|
|
e.emit('getUsers', null, results);
|
|
} else {
|
|
return results;
|
|
}
|
|
})
|
|
.catch((err) => {
|
|
if (e) {
|
|
e.emit('getUsers', err, null);
|
|
} else {
|
|
return err;
|
|
}
|
|
});
|
|
},
|
|
|
|
getUser: (e, id, restricted = true) => {
|
|
const promise = new Promise((resolve, reject) => {
|
|
var projection = 'userName name' + (restricted ? '' : ' title email permission avatar settings forceReset');
|
|
var query = UserModel
|
|
.findById(id)
|
|
.projection(projection);
|
|
|
|
if (!restricted) {
|
|
query.populate('permission', 'name disabled manageRoles manageUsers manageCategories manageAppPreferences deleteVendor addVendorTag addVendorSample addVendorComment editVendor addNewVendor viewPrivateDetails viewPublicDetails');
|
|
}
|
|
|
|
query.exec((err, result) => {
|
|
if (err) {
|
|
reject(err);
|
|
}
|
|
|
|
if (result) {
|
|
resolve(result);
|
|
}
|
|
});
|
|
});
|
|
|
|
promise.then((result) => {
|
|
if (e) {
|
|
e.emit('getUser', null, result);
|
|
} else {
|
|
return result;
|
|
}
|
|
})
|
|
.catch((err) => {
|
|
if (e) {
|
|
e.emit('getUser', err, null);
|
|
} else {
|
|
return err;
|
|
}
|
|
});
|
|
},
|
|
|
|
isUserNameUnique: (e, username) => {
|
|
const promise = new Promise((resolve, reject) => {
|
|
UserModel.findOne({ userName: username }, (err, result) => {
|
|
if (err) {
|
|
reject(err);
|
|
}
|
|
|
|
if (result) {
|
|
resolve({ unique: false, length: true });
|
|
} else {
|
|
resolve({ unique: true, length: true });
|
|
}
|
|
});
|
|
});
|
|
|
|
promise.then((result) => {
|
|
e.emit('isUserNameUnique', null, result);
|
|
})
|
|
.catch((err) => {
|
|
e.emit('isUserNameUnique', err, null);
|
|
});
|
|
},
|
|
|
|
updateUser: (e, id, user) => {
|
|
const promise = new Promise((resolve, reject) => {
|
|
UserModel
|
|
.findByIdAndUpdate(id, { $set: user }, { new: true })
|
|
.populate('permission', 'name disabled manageRoles manageUsers manageCategories manageAppPreferences deleteVendor addVendorTag addVendorSample addVendorComment editVendor addNewVendor viewPrivateDetails viewPublicDetails')
|
|
.exec((err, result) => {
|
|
if (err) {
|
|
reject(err);
|
|
}
|
|
|
|
if (result) {
|
|
resolve(result);
|
|
}
|
|
});
|
|
});
|
|
|
|
promise.then((result) => {
|
|
e.emit('updateUser', null, result);
|
|
})
|
|
.catch((err) => {
|
|
e.emit('updateUser', err, null);
|
|
});
|
|
},
|
|
|
|
updatePassword: (e, id, token, data) => {
|
|
const promise = new Promise((resolve, reject) => {
|
|
Reset.checkReset(null, id, token, (err, validatedId) => {
|
|
if (data.userId === validatedId) {
|
|
UserModel.findByIdAndUpdate(data.userId, { $set: { password: data.password, confirmPassword: data.confirmPassword, forceReset: false } }, { new: true }, (err, updated) => {
|
|
if (err) {
|
|
if (err.success === false) {
|
|
resolve(err);
|
|
} else {
|
|
reject(err);
|
|
}
|
|
}
|
|
|
|
if (updated) {
|
|
Reset.markUsed(null, id);
|
|
resolve({ success: true, updated: updated });
|
|
}
|
|
});
|
|
} else {
|
|
resolve({ success: false, message: 'The password reset link is not valid. Please request a new link.'});
|
|
}
|
|
});
|
|
|
|
});
|
|
|
|
promise.then((result) => {
|
|
e.emit('updatePassword', null, result);
|
|
})
|
|
.catch((err) => {
|
|
e.emit('updatePassword', err, null);
|
|
});
|
|
}
|
|
};
|