CreateUser.cs

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using Waher.Content;
using Waher.IoTGateway;
using Waher.Networking.HTTP;
using Waher.Script;
using Waher.Security;
using Waher.Security.Users;
 
namespace Waher.Service.IoTBroker.Admin.Security
{
    public class CreateUser : CommandRegEx
    {
        public CreateUser()
            : base(@"^create\s+user\s+(?'Name'[^\s]+)\s+(?'Roles'[^\s\{\}]+(\s+[^\s\{\}]+)*)(\s+(?'MetaData'\{[^\}]*\})(\s+(?'Password'[^\s]+))?)?$")
        {
        }
 
        public override string Name => "Create";
 
        public override async Task Execute(ChatState State, string[] Arguments, string OrgMessage, Match Details,
            ResponseCallbackHandler ResponseCallback)
        {
            string Name = Details.Groups["Name"].Value;
            string[] RoleIds = Details.Groups["Roles"].Value.Split(CommonTypes.WhiteSpace, System.StringSplitOptions.RemoveEmptyEntries);
            string MetaDataStr = Details.Groups["MetaData"].Value;
            string Password = Details.Groups["Password"].Value;
 
            IUser User = await Waher.Security.Users.Users.GetUser(Name, false);
            if (!(User is null))
                throw new Exception("User already exists.");
 
            foreach (string RoleId in RoleIds)
            {
                Role _ = await Waher.Security.Users.Roles.GetRole(RoleId, false)
                    ?? throw new Exception("Role `" + RoleId + "` does not exist.");
            }
 
            List<UserMetaData> MetaData = new List<UserMetaData>();
 
            if (!string.IsNullOrEmpty(MetaDataStr))
            {
                Expression Exp = new Expression(MetaDataStr);
                object Result = await Exp.EvaluateAsync(HttpServer.CreateVariables());
                if (Result is IDictionary<string, object> Obj)
                {
                    foreach (KeyValuePair<string, object> P in Obj)
                    {
                        MetaData.Add(new UserMetaData()
                        {
                            Name = P.Key,
                            Value = P.Value?.ToString() ?? string.Empty
                        });
                    }
                };
            }
 
            if (string.IsNullOrEmpty(Password))
            {
                Password = Base64Url.Encode(Gateway.NextBytes(32));
                await ResponseCallback("Generating password: `" + Password + "`", string.Empty);
            }
            else if (Password.Length < 16)
                throw new Exception("Password too short.");
 
            User NewUser = new User()
            {
                UserName = Name,
                RoleIds = RoleIds,
                MetaData = MetaData.ToArray(),
                PasswordHash = Convert.ToBase64String(Waher.Security.Users.Users.ComputeHash(Name, Password))
            };
 
            await Persistence.Database.Insert(NewUser);
 
            Waher.Security.Users.Users.ClearCache();
 
            await ResponseCallback("User created: `" + Name + "`", string.Empty);
        }
 
        public override HelpItem[] GetHelp()
        {
            return new HelpItem[]
            {
                new HelpItem("create user NAME ROLES[ METADATA[ PASSWORD]]", "Creates a new user with the user name given by `NAME` and privileges defined by `ROLES`. `ROLES` is one or more roles separated by whitespace. `METADATA` is an object-exnihilo definition of meta-data associated with the user. `PASSWORD` is an optional password string to assign to the user account. If not provided, a random password is provided.")
            };
        }
    }
}