Account.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using Waher.Events;
using Waher.Networking.SMTP.Server;
using Waher.Networking.XMPP.Server;
using Waher.Persistence;
using Waher.Persistence.Attributes;
using Waher.Persistence.Filters;
using Waher.Security.CallStack;
 
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")]
    public class Account : IAccount
    {
        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 object[] approvedSources = new object[]
        {
            typeof(XmppServerModule).Assembly,
            typeof(XmppServer).Assembly,
            typeof(SmtpServer).Assembly,
            typeof(Persistence.NeuroLedger.NeuroLedgerProvider),
            typeof(Networking.SASL.AuthenticationMechanism).Assembly,
            typeof(Content.Markdown.Web.MarkdownToHtmlConverter),
            FromSaveUnsaved,
            FromUpdateObject
        };
 
        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 bool enabled = true;
        private bool canRelayMessages = false;
        private DateTime created = DateTime.MinValue;
        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;
        }
 
        [DefaultValueStringEmpty]
        public string Password
        {
            get
            {
                Assert.CallFromSource(approvedSources);
                return this.password;
            }
 
            set
            {
                if (!string.IsNullOrEmpty(this.password))
                    Assert.CallFromSource(approvedSources);
 
                this.password = value;
            }
        }
 
        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;
        }
 
        [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;
        }
 
        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 bool HasPrivilege(string PrivilegeID)
        {
            switch (PrivilegeID)
            {
                case SmtpServer.SmtpRelayPrivilegeID: return this.canRelayMessages;
                default: return false;
            }
        }
 
        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.UpdateLazy(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.UpdateLazy(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.InsertLazy(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);
 
        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);
            }
        }
 
    }
}