Account.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content;
using Waher.Content.Markdown.Web.WebScript;
using Waher.Content.Xml;
using Waher.Events;
using Waher.IoTGateway;
using Waher.Networking.FTP.Server;
using Waher.Networking.SMTP.Server;
using Waher.Networking.XMPP.Server;
using Waher.Persistence;
using Waher.Persistence.Attributes;
using Waher.Persistence.Filters;
using Waher.Persistence.FullTextSearch;
using Waher.Script.Cryptography.Functions.Encryption;
using Waher.Security.CallStack;
using Waher.Security.Users;
using Waher.Service.IoTBroker.Legal;
using Waher.Service.IoTBroker.Legal.Identity;
using Waher.Service.IoTBroker.WebServices.Agent;
 
namespace Waher.Service.IoTBroker.DataStorage
{
    [CollectionName("BrokerAccounts")]
    [TypeName(TypeNameSerialization.None)]
    [ObsoleteMethod(nameof(ObsoleteProperties))]
    [ArchivingTime]
    [Index("UserName")]
    [Index("ApiKey", "UserName")]
    [Index("EMail", "UserName")]
    [Index("PhoneNr", "UserName")]
    [FullTextSearch("FTS_Accounts")]
    public class Account : IAccount, IEncryptedProperties
    {
        public const string AccountCreatedCounterName = "Broker.Accounts.Created";
 
        public const string AccountDeletedCounterName = "Broker.Accounts.Deleted";
 
        internal static readonly Regex FromSaveUnsaved = new Regex(@"Waher[.]Persistence[.]Files[.]ObjectBTreeFile[.+]<?SaveUnsaved>?\w*[.]\w*",
            RegexOptions.Compiled | RegexOptions.Singleline);
        internal static readonly Regex FromUpdateObject = new Regex(@"Waher[.]Persistence[.]Files[.]ObjectBTreeFile[.+]<?UpdateObject>?\w*[.]\w*",
            RegexOptions.Compiled | RegexOptions.Singleline);
        private static readonly ICallStackCheck[] approvedSources = new ICallStackCheck[]
        {
            new ProhibitAssembly(typeof(Script.Expression).Assembly),
            new ProhibitAssembly(typeof(Script.Persistence.SQL.Select).Assembly),
            new ApproveAssembly(typeof(XmppServerModule).Assembly),
            new ApproveAssembly(typeof(XmppServer).Assembly),
            new ApproveAssembly(typeof(SmtpServer).Assembly),
            new ApproveAssembly(typeof(Persistence.NeuroLedger.NeuroLedgerProvider).Assembly),
            new ApproveAssembly(typeof(NeuroLedger.NeuroLedgerModule).Assembly),
            new ApproveAssembly(typeof(Networking.SASL.AuthenticationMechanism).Assembly),
            new ApproveType(typeof(Networking.HTTP.Authentication.BasicAuthentication)),
            new ApproveType(typeof(Networking.HTTP.Authentication.DigestAlgorithm)),
            new ApproveRegex(FromSaveUnsaved),
            new ApproveRegex(FromUpdateObject)
        };
        private static readonly ICallStackCheck[] approvedSources2 = new ICallStackCheck[]
        {
            new ApproveAssembly(typeof(WsToX).Assembly),
            new ApproveType(typeof(AgentApi)),
            new ApproveType(typeof(Content.Markdown.Web.MarkdownToHtmlConverter))
        };
 
        private readonly Dictionary<string, bool> privileges = new Dictionary<string, bool>();
        private string objectId = null;
        private string apiKey = string.Empty;
        private CaseInsensitiveString userName = CaseInsensitiveString.Empty;
        private string password = string.Empty;
        private CaseInsensitiveString eMail = CaseInsensitiveString.Empty;
        private CaseInsensitiveString phoneNr = CaseInsensitiveString.Empty;
        private CaseInsensitiveString latestIdentity = CaseInsensitiveString.Empty;
        private CaseInsensitiveString firstName = CaseInsensitiveString.Empty;
        private CaseInsensitiveString middleNames = CaseInsensitiveString.Empty;
        private CaseInsensitiveString lastNames = CaseInsensitiveString.Empty;
        private CaseInsensitiveString personalNumber = CaseInsensitiveString.Empty;
        private CaseInsensitiveString country = CaseInsensitiveString.Empty;
        private CaseInsensitiveString orgNumber = CaseInsensitiveString.Empty;
        private CaseInsensitiveString orgName = CaseInsensitiveString.Empty;
        private CaseInsensitiveString orgRole = CaseInsensitiveString.Empty;
        private CaseInsensitiveString orgDepartment = CaseInsensitiveString.Empty;
        private CaseInsensitiveString orgCountry = CaseInsensitiveString.Empty;
        private IdentityState? latestIdentityState = null;
        private string[] roleIds = null;
        private Role[] roles = null;
        private string ftpRootFolder = null;
        private long? ftpMaxStorage = null;
        private bool ftpCanRead = false;
        private bool ftpCanWrite = false;
        private bool enabled = true;
        private bool canRelayMessages = false;
        private DateTime created = DateTime.MinValue;
        private DateTime? updated = null;
        private DateTime? eMailVerified = null;
        private DateTime? phoneNrVerified = null;
        private AccountLogin accountLogin = null;
 
        public Account()
        {
        }
 
        [ObjectId]
        public string ObjectId
        {
            get => this.objectId;
            set => this.objectId = value;
        }
 
        public string ApiKey
        {
            get => this.apiKey;
            set => this.apiKey = value;
        }
 
        public CaseInsensitiveString UserName
        {
            get => this.userName;
            set => this.userName = value;
        }
 
        [Encrypted(32)]
        public string Password
        {
            get
            {
                Assert.CallFromSource(approvedSources2, approvedSources);
                return this.password;
            }
 
            set
            {
                if (!string.IsNullOrEmpty(this.password))
                    Assert.CallFromSource(approvedSources2, approvedSources);
 
                this.password = value;
            }
        }
 
        public string[] EncryptedProperties => new string[] { nameof(this.Password) };
 
        public CaseInsensitiveString EMail
        {
            get => this.eMail;
            set => this.eMail = value;
        }
 
        public CaseInsensitiveString PhoneNr
        {
            get => this.phoneNr;
            set => this.phoneNr = value;
        }
 
        [DefaultValueStringEmpty]
        public CaseInsensitiveString LatestIdentity
        {
            get => this.latestIdentity;
            set => this.latestIdentity = value;
        }
 
        [DefaultValueNull]
        public IdentityState? LatestIdentityState
        {
            get => this.latestIdentityState;
            set => this.latestIdentityState = value;
        }
 
        [DefaultValueStringEmpty]
        public CaseInsensitiveString FirstName
        {
            get => this.firstName;
            set => this.firstName = value;
        }
 
        [DefaultValueStringEmpty]
        public CaseInsensitiveString MiddleNames
        {
            get => this.middleNames;
            set => this.middleNames = value;
        }
 
        [DefaultValueStringEmpty]
        public CaseInsensitiveString LastNames
        {
            get => this.lastNames;
            set => this.lastNames = value;
        }
 
        [DefaultValueStringEmpty]
        public CaseInsensitiveString PersonalNumber
        {
            get => this.personalNumber;
            set => this.personalNumber = value;
        }
 
        [DefaultValueStringEmpty]
        public CaseInsensitiveString Country
        {
            get => this.country;
            set => this.country = value;
        }
 
        [DefaultValueStringEmpty]
        public CaseInsensitiveString OrgNumber
        {
            get => this.orgNumber;
            set => this.orgNumber = value;
        }
 
        [DefaultValueStringEmpty]
        public CaseInsensitiveString OrgName
        {
            get => this.orgName;
            set => this.orgName = value;
        }
 
        [DefaultValueStringEmpty]
        public CaseInsensitiveString OrgRole
        {
            get => this.orgRole;
            set => this.orgRole = value;
        }
 
        [DefaultValueStringEmpty]
        public CaseInsensitiveString OrgDepartment
        {
            get => this.orgDepartment;
            set => this.orgDepartment = value;
        }
 
        [DefaultValueStringEmpty]
        public CaseInsensitiveString OrgCountry
        {
            get => this.orgCountry;
            set => this.orgCountry = value;
        }
 
        [DefaultValueDateTimeMinValue]
        public DateTime Created
        {
            get => this.created;
            set => this.created = value;
        }
 
        [DefaultValueNull]
        public DateTime? Updated
        {
            get => this.updated;
            set => this.updated = value;
        }
 
        public DateTime? EMailVerified
        {
            get => this.eMailVerified;
            set => this.eMailVerified = value;
        }
 
        public DateTime? PhoneNrVerified
        {
            get => this.phoneNrVerified;
            set => this.phoneNrVerified = value;
        }
 
        [DefaultValue(true)]
        public bool Enabled
        {
            get => this.enabled;
            set => this.enabled = value;
        }
 
        [DefaultValue(false)]
        public bool CanRelayMessages
        {
            get => this.canRelayMessages;
            set => this.canRelayMessages = value;
        }
 
        public string FtpRootFolder
        {
            get => this.ftpRootFolder;
            set => this.ftpRootFolder = value;
        }
 
        public bool FtpCanRead
        {
            get => this.ftpCanRead;
            set => this.ftpCanRead = value;
        }
 
        public bool FtpCanWrite
        {
            get => this.ftpCanWrite;
            set => this.ftpCanWrite = value;
        }
 
        public long? FtpMaxStorage
        {
            get => this.ftpMaxStorage;
            set => this.ftpMaxStorage = value;
        }
 
        [DefaultValueNull]
        public string[] RoleIds
        {
            get => this.roleIds;
            set
            {
                this.roleIds = value;
 
                lock (this.privileges)
                {
                    this.roles = null;
                    this.privileges.Clear();
                }
            }
        }
 
        public async Task<Role[]> LoadRoles()
        {
            Role[] Roles = this.roles;
 
            if (Roles is null)
            {
                string[] Ids = this.roleIds;
                int i, c = Ids?.Length ?? 0;
 
                Roles = new Role[c];
                for (i = 0; i < c; i++)
                    Roles[i] = await Security.Users.Roles.GetRole(Ids[i]);
 
                this.roles = Roles;
            }
 
            return Roles;
        }
 
        public bool HasPrivilege(string Privilege)
        {
            if (Privilege == SmtpServer.SmtpRelayPrivilegeID)
                return this.canRelayMessages;
            
            if (Privilege.StartsWith(FtpServer.FtpReadPrivilegePrefix))
            {
                return this.ftpCanRead &&
                    !Privilege.Contains("..") &&
                    !Privilege.Contains(':') &&
                    !Privilege.Contains("//") &&
                    !Privilege.Contains("\\\\");
            }
            
            if (Privilege.StartsWith(FtpServer.FtpWritePrivilegePrefix))
            {
                return this.ftpCanWrite &&
                    !Privilege.Contains("..") &&
                    !Privilege.Contains(':') &&
                    !Privilege.Contains("//") &&
                    !Privilege.Contains("\\\\");
            }
 
            if (string.IsNullOrEmpty(Privilege))
                return true;
 
            lock (this.privileges)
            {
                if (this.privileges.TryGetValue(Privilege, out bool Result))
                    return Result;
            }
 
            Role[] Roles = this.roles ?? this.LoadRoles().Result;
 
            bool HasPrivilege = false;
 
            foreach (Role Role in Roles)
            {
                if (Role.HasPrivilege(Privilege))
                {
                    HasPrivilege = true;
                    break;
                }
            }
 
            lock (this.privileges)
            {
                this.privileges[Privilege] = HasPrivilege;
            }
 
            Task.Run(async () =>
            {
                try
                {
                    await Privileges.GetPrivilege(Privilege);
                }
                catch (Exception ex)
                {
                    Log.Exception(ex);
                }
            });
 
            return HasPrivilege;
        }
 
        public async void ObsoleteProperties(Dictionary<string, object> Properties)
        {
            try
            {
                AccountLogin Login = await this.GetAccountLogin();
                bool Updated = false;
 
                if (string.IsNullOrEmpty(Login.RemoteEndPoint) &&
                    Properties.TryGetValue("RemoteEndpoint", out object Obj) &&
                    Obj is string RemoteEndPoint)
                {
                    Login.RemoteEndPoint = RemoteEndPoint;
                    Updated = true;
                }
 
                if (Login.LastLogin == DateTime.MinValue &&
                    Properties.TryGetValue("LastLogin", out Obj) &&
                    Obj is DateTime LastLogin)
                {
                    Login.LastLogin = LastLogin;
                    Updated = true;
                }
 
                if (Updated)
                    await Database.Update(Login);
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        public async Task LoggedIn(string RemoteEndPoint)
        {
            AccountLogin Login = await this.GetAccountLogin();
 
            Login.LastLogin = DateTime.Now;
            Login.RemoteEndPoint = RemoteEndPoint;
 
            await Database.Update(Login);
        }
 
        public async Task<AccountLogin> GetAccountLogin()
        {
            if (!(this.accountLogin is null))
                return this.accountLogin;
 
            this.accountLogin = await Database.FindFirstDeleteRest<AccountLogin>(new FilterFieldEqualTo("UserName", this.userName));
            if (!(this.accountLogin is null))
                return this.accountLogin;
 
            this.accountLogin = new AccountLogin()
            {
                UserName = this.userName,
                RemoteEndPoint = string.Empty,
                LastLogin = DateTime.MinValue
            };
 
            await Database.Insert(this.accountLogin);
 
            return this.accountLogin;
        }
 
        public string FullName => Concat(" ", this.firstName, this.middleNames, this.lastNames);
 
        public string PersonalInformation => Concat(", ", this.FullName, this.personalNumber, this.country);
 
        public string OrganizationInformation => Concat(", ", this.orgRole, this.orgDepartment, this.orgName, this.orgNumber, this.orgCountry);
 
        public bool HasExtendedPersonalInformation
        {
            get
            {
                return
                    !CaseInsensitiveString.IsNullOrEmpty(this.firstName) ||
                    !CaseInsensitiveString.IsNullOrEmpty(this.middleNames) ||
                    !CaseInsensitiveString.IsNullOrEmpty(this.lastNames) ||
                    !CaseInsensitiveString.IsNullOrEmpty(this.personalNumber) ||
                    !CaseInsensitiveString.IsNullOrEmpty(this.orgNumber) ||
                    !CaseInsensitiveString.IsNullOrEmpty(this.orgName) ||
                    !CaseInsensitiveString.IsNullOrEmpty(this.orgRole) ||
                    !CaseInsensitiveString.IsNullOrEmpty(this.orgDepartment) ||
                    !CaseInsensitiveString.IsNullOrEmpty(this.orgCountry);
            }
        }
 
        private static string Concat(string Delimiter, params CaseInsensitiveString[] Segments)
        {
            StringBuilder sb = new StringBuilder();
            bool First = true;
 
            foreach (string Segment in Segments)
                Append(sb, ref First, Segment, Delimiter);
 
            return sb.ToString();
        }
 
        private static void Append(StringBuilder sb, ref bool First, CaseInsensitiveString Segment, string Delimiter)
        {
            if (!string.IsNullOrEmpty(Segment))
            {
                if (First)
                    First = false;
                else
                    sb.Append(Delimiter);
 
                sb.Append(Segment.Value);
            }
        }
 
        internal void AppendAccountXml(StringBuilder sb, bool IncludeNamespace)
        {
            sb.Append("<Account");
            if (IncludeNamespace)
                sb.Append(" xmlns=\"http://waher.se/schema/Onboarding/v1.xsd\"");
 
            sb.Append(" userName=\"");
            sb.Append(XML.Encode(this.userName));
            sb.Append("\" password=\"");
            sb.Append(XML.Encode(this.password));
            sb.Append("\" domain=\"");
            sb.Append(XML.Encode(Gateway.Domain.Value));
            sb.Append("\" enabled=\"");
            sb.Append(CommonTypes.Encode(this.enabled));
            sb.Append("\" created=\"");
            sb.Append(XML.Encode(this.created));
 
            if (this.updated.HasValue)
            {
                sb.Append("\" updated=\"");
                sb.Append(XML.Encode(this.updated.Value));
            }
 
            if (!CaseInsensitiveString.IsNullOrEmpty(this.eMail))
            {
                sb.Append("\" eMail=\"");
                sb.Append(XML.Encode(this.eMail.Value));
 
                if (this.eMailVerified.HasValue)
                {
                    sb.Append("\" eMailVerified=\"");
                    sb.Append(XML.Encode(this.eMailVerified.Value));
                }
            }
 
            if (!CaseInsensitiveString.IsNullOrEmpty(this.phoneNr))
            {
                sb.Append("\" phoneNr=\"");
                sb.Append(XML.Encode(this.phoneNr.Value));
 
                if (this.phoneNrVerified.HasValue)
                {
                    sb.Append("\" phoneNrVerified=\"");
                    sb.Append(XML.Encode(this.phoneNrVerified.Value));
                }
            }
 
            if (!CaseInsensitiveString.IsNullOrEmpty(this.latestIdentity))
            {
                sb.Append("\" latestIdentity=\"");
                sb.Append(XML.Encode(this.latestIdentity.Value));
            }
 
            if (!CaseInsensitiveString.IsNullOrEmpty(this.firstName))
            {
                sb.Append("\" firstName=\"");
                sb.Append(XML.Encode(this.firstName.Value));
            }
 
            if (!CaseInsensitiveString.IsNullOrEmpty(this.middleNames))
            {
                sb.Append("\" middleNames=\"");
                sb.Append(XML.Encode(this.middleNames.Value));
            }
 
            if (!CaseInsensitiveString.IsNullOrEmpty(this.lastNames))
            {
                sb.Append("\" lastNames=\"");
                sb.Append(XML.Encode(this.lastNames.Value));
            }
 
            if (!CaseInsensitiveString.IsNullOrEmpty(this.personalNumber))
            {
                sb.Append("\" personalNumber=\"");
                sb.Append(XML.Encode(this.personalNumber.Value));
            }
 
            if (!CaseInsensitiveString.IsNullOrEmpty(this.country))
            {
                sb.Append("\" country=\"");
                sb.Append(XML.Encode(this.country.Value));
            }
 
            if (!CaseInsensitiveString.IsNullOrEmpty(this.orgNumber))
            {
                sb.Append("\" orgNumber=\"");
                sb.Append(XML.Encode(this.orgNumber.Value));
            }
 
            if (!CaseInsensitiveString.IsNullOrEmpty(this.orgName))
            {
                sb.Append("\" orgName=\"");
                sb.Append(XML.Encode(this.orgName.Value));
            }
 
            if (!CaseInsensitiveString.IsNullOrEmpty(this.orgRole))
            {
                sb.Append("\" orgRole=\"");
                sb.Append(XML.Encode(this.orgRole.Value));
            }
 
            if (!CaseInsensitiveString.IsNullOrEmpty(this.orgDepartment))
            {
                sb.Append("\" orgDepartment=\"");
                sb.Append(XML.Encode(this.orgDepartment.Value));
            }
 
            if (!CaseInsensitiveString.IsNullOrEmpty(this.orgCountry))
            {
                sb.Append("\" orgCountry=\"");
                sb.Append(XML.Encode(this.orgCountry.Value));
            }
 
            sb.Append("\" />");
        }
 
        public async Task<string> GetOnboardingUrl(DateTime Expires)
        {
            StringBuilder sb = new StringBuilder();
 
            this.AppendAccountXml(sb, true);
 
            byte[] Bin = Encoding.UTF8.GetBytes(sb.ToString());
            byte[] Key = Gateway.NextBytes(16);
            byte[] IV = Gateway.NextBytes(16);
            Bin = Aes256Encrypt.Encrypt(Bin, Key, IV);
 
            sb.Clear();
            sb.Append("<Info xmlns=\"http://waher.se/schema/Onboarding/v1.xsd\" base64=\"");
            sb.Append(Convert.ToBase64String(Bin));
            sb.Append("\" once=\"true\" expires=\"");
            sb.Append(XML.Encode(Expires.ToUniversalTime()));
            sb.Append("\" />");
 
            string OnboardingDomainName = await LegalComponent.GetOnboardingNeuronDomainName();
 
            XmlElement Info = await Gateway.XmppClient.IqSetAsync("onboarding." + OnboardingDomainName, sb.ToString());
 
            foreach (XmlNode N in Info.ChildNodes)
            {
                if (N is XmlElement E && E.LocalName == "Code")
                {
                    string Code = XML.Attribute(E, "code");
                    return "obinfo:" + OnboardingDomainName + ":" + Code + ":" +
                        Convert.ToBase64String(Key) + ":" +
                        Convert.ToBase64String(IV);
                }
            }
 
            throw new Exception("Unexpected response returned: " + Info.OuterXml);
        }
 
    }
}