meteor-user-roles/dist/index.js

"use strict";

Object.defineProperty(exports, "__esModule", {
	value: true
});
exports.isUserInRoles = exports.isUserInRole = exports.isAdmin = exports.Users = undefined;

var _typeof2 = require("babel-runtime/helpers/typeof");

var _typeof3 = _interopRequireDefault(_typeof2);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var Users = exports.Users = Meteor.users;

Users.isInRole = function (userId, role) {
	var user = Users.findOne({ _id: userId });
	return !!(user && user.roles && user.roles.indexOf(role) != -1);
};

Users.isInRoles = function (userId, roleList) {
	var user = Users.findOne({ _id: userId });
	if (!user || !user.roles) {
		return false;
	}

	//	let granted = new Set([...roleList].filter(x => user.roles.has(x)));
	var granted = roleList.filter(function (value) {
		return user.roles.indexOf(value) > -1;
	});

	if (!granted || granted.length == 0) {
		return false;
	}
	return true;
};

Users.isAdmin = function (userId) {
	return Users.isInRole(userId, "admin");
};

Users.isAdminOrInRole = function (userId, role) {
	return Users.isInRole(userId, "admin") || Users.isInRole(userId, role);
};

var isAdmin = exports.isAdmin = function isAdmin() {
	return Users.isAdmin(Meteor.userId());
};

var isUserInRole = exports.isUserInRole = function isUserInRole(role, options) {
	return Users.isInRole(Meteor.userId(), role);
};

var isUserInRoles = exports.isUserInRoles = function isUserInRoles(roleList, options) {
	return Users.isInRoles(Meteor.userId(), roleList);
};

if (Meteor.isServer) {
	(function () {
		var _extendFilter = function _extendFilter(originalFilter, extraOptions) {
			originalFilter = originalFilter || {};
			extraOptions = extraOptions || {};

			var searchText = extraOptions.searchText || "";
			var searchFields = extraOptions.searchFields || [];

			var addFilter = {};

			// search
			if (searchText && searchFields && searchFields.length) {
				(function () {
					var searchList = [];
					var searchRegExp = new RegExp(searchText, "i");
					searchFields.map(function (fieldName) {
						var searchItem = {};
						searchItem[fieldName] = searchRegExp;
						searchList.push(searchItem);
					});
					addFilter["$or"] = searchList;
				})();
			}

			var filter = originalFilter;
			if (!_.isEmpty(addFilter) && !_.isEmpty(originalFilter)) {
				filter = { "$and": [originalFilter, addFilter] };
			} else {
				if (!_.isEmpty(addFilter)) {
					filter = addFilter;
				} else {
					filter = originalFilter;
				}
			}

			return filter;
		};

		var _extendOptions = function _extendOptions(originalOptions, extraOptions) {
			originalOptions = originalOptions || {};
			extraOptions = extraOptions || {};

			var sortBy = extraOptions.sortBy || "";
			var pageNo = typeof extraOptions.pageNo == "undefined" ? -1 : extraOptions.pageNo;
			var pageSize = extraOptions.pageSize || 0;
			var doSkip = extraOptions.doSkip || false;

			var addOptions = {};

			// sort
			if (sortBy) {
				addOptions.sort = {};
				addOptions.sort[sortBy] = typeof extraOptions.sortAscending == "undefined" || exraOptions.sortAscending ? 1 : -1;
			}

			// skip & limit
			if (!extraOptions.noPaging && pageNo >= 0 && pageSize > 0) {
				if (doSkip) {
					addOptions.skip = pageNo * pageSize;
				}
				addOptions.limit = pageSize;
			}

			var options = originalOptions;

			if (!_.isEmpty(addOptions)) {
				_mergeObjects(options, addOptions);
			}

			return options;
		};

		var _mergeObjects = function _mergeObjects(target, source) {

			/* Merges two (or more) objects,
   giving the last one precedence */

			if ((typeof target === "undefined" ? "undefined" : (0, _typeof3.default)(target)) !== "object") {
				target = {};
			}

			for (var property in source) {

				if (source.hasOwnProperty(property)) {

					var sourceProperty = source[property];

					if ((typeof sourceProperty === "undefined" ? "undefined" : (0, _typeof3.default)(sourceProperty)) === 'object') {
						target[property] = _mergeObjects(target[property], sourceProperty);
						continue;
					}

					target[property] = sourceProperty;
				}
			}

			for (var a = 2, l = arguments.length; a < l; a++) {
				_mergeObjects(target, arguments[a]);
			}

			return target;
		};

		Users.allow({
			// doesn't allow insert or removal of users from untrusted code
			update: function update(userId, doc, fieldNames, modifier) {
				// only admins can update user roles via the client
				return Users.isAdmin(userId) || doc._id === userId && fieldNames.indexOf("roles") < 0;
			}
		});

		// Add roles array to user document
		Users.before.insert(function (userId, doc) {
			if (!doc.createdAt) doc.createdAt = new Date();
			if (!doc.modifiedAt) doc.modifiedAt = doc.createdAt;
			if (!doc.roles) doc.roles = [];
		});

		Users.before.update(function (userId, doc, fieldNames, modifier, options) {
			modifier.$set = modifier.$set || {};
			modifier.$set.modifiedAt = Date.now();
		});

		Meteor.publish("admin_user", function (_id) {
			if (!Users.isAdmin(this.userId)) {
				return this.ready();
			}
			var user = Meteor.users.find({ _id: _id });
			if (Users.publishJoinedCursors) {
				return Users.publishJoinedCursors(user);
			}
			return user;
		});

		Meteor.publish("admin_users", function () {
			if (!Users.isAdmin(this.userId)) {
				return this.ready();
			}
			var users = Meteor.users.find({});
			if (Users.publishJoinedCursors) {
				return Users.publishJoinedCursors(users);
			}
			return users;
		});

		Meteor.publish("admin_users_paged", function (extraOptions) {
			extraOptions.doSkip = true;
			if (!Users.isAdmin(this.userId)) {
				return this.ready();
			}
			var users = Meteor.users.find(_extendFilter({}, extraOptions), _extendOptions({}, extraOptions));
			if (Users.publishJoinedCursors) {
				return Users.publishJoinedCursors(users);
			}
			return users;
		});

		Meteor.publish("admin_users_paged_count", function (extraOptions) {
			if (typeof Counts == "undefined" || !Users.isAdmin(this.userId)) {
				return this.ready();
			}
			Counts.publish(this, "admin_users_paged_count", Meteor.users.find(_extendFilter({}, extraOptions), { fields: { _id: 1 } }));
		});

		Meteor.publish("current_user_data", function () {
			var user = Meteor.users.find({ _id: this.userId }, { fields: { username: 1, profile: 1, private: 1, public: 1, roles: 1, emails: 1 } });
			if (Users.publishJoinedCursors) {
				return Users.publishJoinedCursors(user);
			}
			return user;
		});
	})();
}