PersistenceLayer.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content;
using Waher.Content.Markdown;
using Waher.Events;
using Waher.IoTGateway;
using Waher.Networking.SASL;
using Waher.Networking.XMPP.Server;
using Waher.Networking.XMPP.Server.PushNotification;
using Waher.Persistence;
using Waher.Persistence.Filters;
using Waher.Runtime.Settings;
using Waher.Script;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Model;
using Waher.Script.Objects;
using Waher.Security.LoginMonitor;
using Waher.Service.IoTBroker.PubSub;
using Waher.Service.IoTBroker.Setup;
 
namespace Waher.Service.IoTBroker.DataStorage
{
    public delegate Task PushNotificationEventHandler(PushNotificationToken Token, object Content);
 
    public class PersistenceLayer : IXmppServerPersistenceLayer
    {
        private static readonly Dictionary<CaseInsensitiveString, Dictionary<string, Dictionary<string, string>>> functionsPerTabIdPerFqnPerBareJid = new Dictionary<CaseInsensitiveString, Dictionary<string, Dictionary<string, string>>>();
 
        private readonly Dictionary<CaseInsensitiveString, Account> accounts = new Dictionary<CaseInsensitiveString, Account>();
        private readonly Dictionary<CaseInsensitiveString, Dictionary<CaseInsensitiveString, RosterItem>> rosters = new Dictionary<CaseInsensitiveString, Dictionary<CaseInsensitiveString, RosterItem>>();
        private readonly Dictionary<CaseInsensitiveString, Dictionary<CaseInsensitiveString, Block>> blocks = new Dictionary<CaseInsensitiveString, Dictionary<CaseInsensitiveString, Block>>();
        private XmppServer server = null;
 
        public PersistenceLayer()
        {
        }
 
        public XmppServer Server
        {
            get => this.server;
            set
            {
                if (this.server is null)
                    this.server = value;
                else if (this.server != value)
                    throw new InvalidOperationException("Not allowed to change server reference in runtime.");
            }
        }
 
        public string Domain => this.server.Domain;
        public LoginAuditor Auditor => Gateway.LoginAuditor;
 
        #region API keys
 
        internal async Task<ApiKey> GetApiKey(string ApiKey)
        {
            return await Database.FindFirstDeleteRest<ApiKey>(new FilterFieldEqualTo("Key", ApiKey));
        }
 
        public async Task<string> GetApiKeySecret(string ApiKey)
        {
            return (await this.GetApiKey(ApiKey))?.Secret;
        }
 
        #endregion
 
        #region Accounts
 
        internal async Task<Account> GetAccountEx(CaseInsensitiveString UserName)
        {
            lock (this.accounts)
            {
                if (this.accounts.TryGetValue(UserName, out Account Account))
                    return Account;
            }
 
            foreach (Account Account in await Database.Find<Account>(new FilterFieldEqualTo("UserName", UserName)))
            {
                lock (this.accounts)
                {
                    this.accounts[Account.UserName] = Account;
                }
 
                return Account;
            }
 
            return null;
        }
 
        public async Task<KeyValuePair<Networking.XMPP.Server.IAccount, string[]>> CreateAccount(string ApiKey, CaseInsensitiveString UserName, string Password,
            CaseInsensitiveString EMail, CaseInsensitiveString PhoneNr, string RemoteEndpoint)
        {
            ApiKey ApiKeyObject = null;
            Account Account = await this.GetAccountEx(UserName);
            if (!(Account is null))
                return new KeyValuePair<Networking.XMPP.Server.IAccount, string[]>(null, await GetAlternativeAccountNames(UserName));
 
            if (!(XmppServerModule.PubSub is null))
            {
                PubSubNode Node = await XmppServerModule.PubSub.GetNodeAsync(string.Empty, UserName, null, XmppAddress.Empty, null);
                if (!(Node is null))
                    return new KeyValuePair<Networking.XMPP.Server.IAccount, string[]>(null, await GetAlternativeAccountNames(UserName));
            }
 
            try
            {
                string s = Path.Combine(Gateway.RootFolder, UserName);
 
                if (File.Exists(s) || Directory.Exists(s))
                    return new KeyValuePair<Networking.XMPP.Server.IAccount, string[]>(null, await GetAlternativeAccountNames(UserName));
            }
            catch (Exception)
            {
                // Ignore.
            }
 
            if (string.IsNullOrEmpty(ApiKey))
            {
                Account = new Account()
                {
                    ApiKey = string.Empty,
                    UserName = UserName,
                    Password = Password,
                    EMail = EMail,
                    EMailVerified = null,
                    PhoneNr = PhoneNr,
                    PhoneNrVerified = null,
                    Created = DateTime.Now
                };
 
                await Database.Insert(Account);
            }
            else
            {
                foreach (ApiKey Key in await Database.Find<ApiKey>(new FilterFieldEqualTo("Key", ApiKey)))
                {
                    if (Key.NrCreated - Key.NrDeleted >= Key.MaxAccounts)
                        return new KeyValuePair<Networking.XMPP.Server.IAccount, string[]>(null, null);
 
                    ApiKeyObject = Key;
 
                    Account = new Account()
                    {
                        ApiKey = ApiKey,
                        UserName = UserName,
                        Password = Password,
                        EMail = EMail,
                        EMailVerified = null,
                        PhoneNr = PhoneNr,
                        PhoneNrVerified = null,
                        Created = DateTime.Now
                    };
 
                    await Database.Insert(Account);
 
                    Key.NrCreated++;
                    await Database.Update(Key);
 
                    break;
                }
            }
 
            if (!(Account is null) && !(XmppServerModule.Instance is null))
                await AccountCreated(Account, ApiKeyObject, this.server.Domain, RemoteEndpoint);
 
            return new KeyValuePair<Networking.XMPP.Server.IAccount, string[]>(Account, null);
        }
 
        internal static async Task<string[]> GetAlternativeAccountNames(string UserName)
        {
            List<string> Suggestions = new List<string>();
            int NrDigits = 2;
            int Max = 100;
 
            while (Suggestions.Count < 3 && NrDigits < 9)
            {
                string AlternativeName = UserName + Gateway.NextInteger(Max).ToString("D" + NrDigits.ToString());
 
                Account AlternativeAccount = await Database.FindFirstIgnoreRest<Account>(
                    new FilterFieldEqualTo("UserName", AlternativeName));
 
                if (!(AlternativeAccount is null))
                {
                    NrDigits++;
                    Max *= 10;
                    continue;
                }
 
                if (!(XmppServerModule.PubSub is null))
                {
                    PubSubNode Node = await XmppServerModule.PubSub.GetNodeAsync(string.Empty, AlternativeName, null, XmppAddress.Empty, null);
                    if (!(Node is null))
                    {
                        NrDigits++;
                        Max *= 10;
                        continue;
                    }
                }
 
                try
                {
                    string s = Path.Combine(Gateway.RootFolder, AlternativeName);
 
                    if (File.Exists(s) || Directory.Exists(s))
                    {
                        NrDigits++;
                        Max *= 10;
                        continue;
                    }
                }
                catch (Exception)
                {
                    // Ignore.
                }
 
                Suggestions.Add(AlternativeName);
            }
 
            Suggestions.Sort();
 
            return Suggestions.ToArray();
        }
 
        internal static async Task AccountCreated(Account Account, ApiKey ApiKeyObject,
            string Domain, string RemoteEndpoint)
        {
            await Account.LoggedIn(RemoteEndpoint);
 
            KeyValuePair<string, object>[] Tags = await LoginAuditor.Annotate(RemoteEndpoint,
                new KeyValuePair<string, object>("ApiKey", Account.ApiKey),
                new KeyValuePair<string, object>("Created", Account.Created),
                new KeyValuePair<string, object>("EMail", Account.EMail?.Value),
                new KeyValuePair<string, object>("PhoneNr", Account.PhoneNr?.Value),
                new KeyValuePair<string, object>("Enabled", Account.Enabled),
                new KeyValuePair<string, object>("ObjectId", Account.ObjectId),
                new KeyValuePair<string, object>("RemoteEndpoint", RemoteEndpoint));
 
            StringBuilder sb = new StringBuilder();
            string WhoIsInfo = string.Empty;
 
            sb.Append("Account created.");
            await LoginAuditor.AppendWhoIsInfo(sb, RemoteEndpoint);
 
            Log.Informational(sb.ToString(), Account.UserName, string.Empty, "AccountCreated", EventLevel.Medium, Tags);
 
            StringBuilder Markdown = new StringBuilder();
            string UserNameEncoded = MarkdownDocument.Encode(Account.UserName.Value);
            DateTime Now = DateTime.Now;
 
            Markdown.AppendLine("XMPP Account created:");
            Markdown.AppendLine();
            Markdown.AppendLine("| Account Information ||");
            Markdown.AppendLine("|:-----|:------|");
            Markdown.Append("| User Name: | [");
            Markdown.Append(UserNameEncoded);
            Markdown.Append("](");
            Markdown.Append(Gateway.GetUrl("/Account.md?UserName=" + UserNameEncoded));
            Markdown.AppendLine(") |");
            Markdown.Append("| JID: | [");
            Markdown.Append(UserNameEncoded);
            Markdown.Append('@');
            Markdown.Append(Domain);
            Markdown.Append("](xmpp:");
            Markdown.Append(UserNameEncoded);
            Markdown.Append('@');
            Markdown.Append(Domain);
            Markdown.Append(")");
            Markdown.AppendLine(" |");
 
            if (!CaseInsensitiveString.IsNullOrEmpty(Account.EMail))
            {
                Markdown.Append("| e-Mail: | <mailto:");
                Markdown.Append(Account.EMail.Value);
                Markdown.AppendLine("> |");
            }
 
            if (!CaseInsensitiveString.IsNullOrEmpty(Account.PhoneNr))
            {
                Markdown.Append("| Phone Nr: | <tel:");
                Markdown.Append(Account.PhoneNr.Value);
                Markdown.AppendLine("> |");
            }
 
            await XmppServerModule.AppendRemoteEndpointToTable(Markdown, RemoteEndpoint);
 
            Markdown.Append("| Date | ");
            Markdown.Append(MarkdownDocument.Encode(Now.ToShortDateString()));
            Markdown.AppendLine(" |");
            Markdown.Append("| Time | ");
            Markdown.Append(MarkdownDocument.Encode(Now.ToLongTimeString()));
            Markdown.AppendLine(" |");
 
            if (!(ApiKeyObject is null))
            {
                Markdown.AppendLine();
                Markdown.AppendLine("| API Key information ||");
                Markdown.AppendLine("|:-----|:------|");
                Markdown.Append("| API Key: | [");
                Markdown.Append(ApiKeyObject.Key);
                Markdown.Append("](");
                Markdown.Append(Gateway.GetUrl("/ApiKey.md?Key=" + ApiKeyObject.Key));
                Markdown.AppendLine(") |");
                Markdown.Append("| Owner: | ");
                Markdown.Append(MarkdownDocument.Encode(ApiKeyObject.Owner));
                Markdown.AppendLine(" |");
                Markdown.Append("| e-Mail: | <");
                Markdown.Append(ApiKeyObject.EMail.Value);
                Markdown.AppendLine("> |");
                Markdown.Append("| Accounts created: | ");
                Markdown.Append(ApiKeyObject.NrCreated.ToString());
                Markdown.AppendLine(" |");
                Markdown.Append("| Accounts deleted: | ");
                Markdown.Append(ApiKeyObject.NrDeleted.ToString());
                Markdown.AppendLine(" |");
                Markdown.Append("| Accounts left: | ");
                Markdown.Append((ApiKeyObject.MaxAccounts - ApiKeyObject.NrCreated + ApiKeyObject.NrDeleted).ToString());
                Markdown.AppendLine(" |");
            }
 
            if (!string.IsNullOrEmpty(WhoIsInfo))
            {
                Markdown.AppendLine();
                Markdown.AppendLine();
                Markdown.AppendLine("WHOIS Information:");
                Markdown.AppendLine();
                Markdown.AppendLine("```");
                Markdown.AppendLine(WhoIsInfo);
                Markdown.AppendLine("```");
            }
 
            await Gateway.SendNotification(Markdown.ToString());
        }
 
        public async Task<bool> DeleteAccount(CaseInsensitiveString UserName, string RemoteEndpoint)
        {
            ApiKey ApiKeyObject = null;
            Account Account = await this.GetAccountEx(UserName);
            if (!(Account is null))
                return false;
 
            AccountLogin Login = await Account.GetAccountLogin();
 
            await Database.Delete(Account);
            await Database.Delete(Login);
 
            lock (this.accounts)
            {
                this.accounts.Remove(UserName);
            }
 
            if (!string.IsNullOrEmpty(Account.ApiKey))
            {
                foreach (ApiKey Key in await Database.Find<ApiKey>(new FilterFieldEqualTo("Key", Account.ApiKey)))
                {
                    ApiKeyObject = Key;
                    Key.NrDeleted++;
                    await Database.Update(Key);
 
                    break;
                }
            }
 
            KeyValuePair<string, object>[] Tags = await LoginAuditor.Annotate(Login.RemoteEndpoint,
                new KeyValuePair<string, object>("ApiKey", Account.ApiKey),
                new KeyValuePair<string, object>("Created", Account.Created),
                new KeyValuePair<string, object>("EMail", Account.EMail?.Value),
                new KeyValuePair<string, object>("PhoneNr", Account.PhoneNr?.Value),
                new KeyValuePair<string, object>("Enabled", Account.Enabled),
                new KeyValuePair<string, object>("LastLogin", Login.LastLogin),
                new KeyValuePair<string, object>("ObjectId", Account.ObjectId),
                new KeyValuePair<string, object>("RemoteEndpoint", Login.RemoteEndpoint));
 
            Log.Informational("Account deleted.", Account.UserName, string.Empty, "AccountDeleted", EventLevel.Medium, Tags);
 
            if (!(XmppServerModule.Instance is null))
            {
                StringBuilder Markdown = new StringBuilder();
                string UserNameEncoded = MarkdownDocument.Encode(UserName);
                DateTime Now = DateTime.Now;
 
                Markdown.AppendLine("XMPP Account deleted:");
                Markdown.AppendLine();
                Markdown.AppendLine("| Account Information ||");
                Markdown.AppendLine("|:-----|:------|");
                Markdown.Append("| User Name: | ");
                Markdown.Append(UserNameEncoded);
                Markdown.AppendLine(" |");
                Markdown.Append("| JID: | ");
                Markdown.Append(UserNameEncoded);
                Markdown.Append('@');
                Markdown.Append(this.server.Domain);
                Markdown.AppendLine(" |");
 
                if (!CaseInsensitiveString.IsNullOrEmpty(Account.EMail))
                {
                    Markdown.Append("| e-Mail: | <mailto:");
                    Markdown.Append(Account.EMail.Value);
                    Markdown.AppendLine("> |");
                }
 
                if (!CaseInsensitiveString.IsNullOrEmpty(Account.PhoneNr))
                {
                    Markdown.Append("| Phone Nr: | <tel:");
                    Markdown.Append(Account.PhoneNr.Value);
                    Markdown.AppendLine("> |");
                }
 
                await XmppServerModule.AppendRemoteEndpointToTable(Markdown, RemoteEndpoint);
 
                Markdown.Append("| Date | ");
                Markdown.Append(MarkdownDocument.Encode(Now.ToShortDateString()));
                Markdown.AppendLine(" |");
                Markdown.Append("| Time | ");
                Markdown.Append(MarkdownDocument.Encode(Now.ToLongTimeString()));
                Markdown.AppendLine(" |");
 
                if (!(ApiKeyObject is null))
                {
                    Markdown.AppendLine();
                    Markdown.AppendLine("| API Key information ||");
                    Markdown.AppendLine("|:-----|:------|");
                    Markdown.Append("| API Key: | [");
                    Markdown.Append(Account.ApiKey);
                    Markdown.Append("](");
                    Markdown.Append(Gateway.GetUrl("/ApiKey.md?Key=" + Account.ApiKey));
                    Markdown.AppendLine(") |");
                    Markdown.Append("| Owner: | ");
                    Markdown.Append(MarkdownDocument.Encode(ApiKeyObject.Owner));
                    Markdown.AppendLine(" |");
                    Markdown.Append("| e-Mail: | <");
                    Markdown.Append(ApiKeyObject.EMail);
                    Markdown.AppendLine("> |");
                    Markdown.Append("| Accounts created: | ");
                    Markdown.Append(ApiKeyObject.NrCreated.ToString());
                    Markdown.AppendLine(" |");
                    Markdown.Append("| Accounts deleted: | ");
                    Markdown.Append(ApiKeyObject.NrDeleted.ToString());
                    Markdown.AppendLine(" |");
                    Markdown.Append("| Accounts left: | ");
                    Markdown.Append((ApiKeyObject.MaxAccounts - ApiKeyObject.NrCreated + ApiKeyObject.NrDeleted).ToString());
                    Markdown.AppendLine(" |");
                }
 
                await Gateway.SendNotification(Markdown.ToString());
            }
 
            return true;
        }
 
        public async Task<bool> ChangePassword(CaseInsensitiveString UserName, string Password)
        {
            Account Account = await this.GetAccountEx(UserName);
            if (Account is null)
                return false;
 
            if (Account.Password != Password)
            {
                Account.Password = Password;
                await Database.Update(Account);
 
                Log.Informational("Password updated.", Account.UserName, string.Empty, "PasswordUpdated", EventLevel.Medium);
            }
 
            return true;
        }
 
        public async void AccountLogin(CaseInsensitiveString UserName, string RemoteEndpoint)
        {
            try
            {
                Account Account = await this.GetAccountEx(UserName);
                if (!(Account is null))
                    await Account.LoggedIn(RemoteEndpoint);
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        #endregion
 
        #region Roster
 
        public async Task<IEnumerable<IRosterItem>> GetRoster(CaseInsensitiveString UserName)
        {
            Dictionary<CaseInsensitiveString, RosterItem> Roster;
 
            lock (this.rosters)
            {
                if (this.rosters.TryGetValue(UserName, out Roster))
                    return this.ToArrayLocked(Roster);
            }
 
            if (await this.GetAccountEx(UserName) is null)
                return null;
 
            Roster = new Dictionary<CaseInsensitiveString, RosterItem>();
 
            foreach (RosterItem Item in await Database.Find<RosterItem>(new FilterFieldEqualTo("UserName", UserName)))
            {
                if (Roster.ContainsKey(Item.BareJid))
                    await Database.Delete(Item);
                else
                    Roster[Item.BareJid] = Item;
            }
 
            lock (this.rosters)
            {
                this.rosters[UserName] = Roster;
                return this.ToArrayLocked(Roster);
            }
        }
 
        private IRosterItem[] ToArrayLocked(Dictionary<CaseInsensitiveString, RosterItem> Roster)
        {
            IRosterItem[] Result;
 
            int i = 0;
            int c = Roster.Count;
 
            Result = new IRosterItem[c];
            foreach (RosterItem Item in Roster.Values)
                Result[i++] = Item;
 
            return Result;
        }
 
        public async Task<IRosterItem> GetRosterItem(CaseInsensitiveString UserName, CaseInsensitiveString Jid)
        {
            lock (this.rosters)
            {
                if (this.rosters.TryGetValue(UserName, out Dictionary<CaseInsensitiveString, RosterItem> Roster) &&
                    Roster.TryGetValue(Jid, out RosterItem Item))
                {
                    return Item;
                }
            }
 
            if (await this.GetRoster(UserName) is null)
                return null;
 
            lock (this.rosters)
            {
                if (this.rosters.TryGetValue(UserName, out Dictionary<CaseInsensitiveString, RosterItem> Roster) &&
                    Roster.TryGetValue(Jid, out RosterItem Item))
                {
                    return Item;
                }
            }
 
            return null;
        }
 
        public async Task<IRosterItem> SetRosterItem(CaseInsensitiveString UserName, CaseInsensitiveString Jid, string Name, SubscriptionStatus? Subscription, bool? PendingSubscription,
            string[] Groups)
        {
            Dictionary<CaseInsensitiveString, RosterItem> Roster;
            RosterItem Item;
            bool Load = false;
 
            lock (this.rosters)
            {
                if (this.rosters.TryGetValue(UserName, out Roster))
                {
                    if (!Roster.TryGetValue(Jid, out Item))
                        Item = null;
                }
                else
                {
                    Item = null;
                    Load = true;
                }
            }
 
            if (Load)
            {
                if (await this.GetRoster(UserName) is null)
                    return null;
 
                lock (this.rosters)
                {
                    if (this.rosters.TryGetValue(UserName, out Roster))
                    {
                        if (!Roster.TryGetValue(Jid, out Item))
                            Item = null;
                    }
                    else
                        return null;
                }
            }
 
            if (!(Item is null))
            {
                Item.Name = Name;
                Item.Groups = Groups;
 
                if (Subscription.HasValue)
                    Item.Subscription = Subscription.Value;
 
                if (PendingSubscription.HasValue)
                    Item.PendingSubscription = PendingSubscription.Value;
 
                await Database.Update(Item);
 
                Log.Informational("Roster item updated.", Item.BareJid, UserName, "RosterItemUpdated", EventLevel.Minor,
                    new KeyValuePair<string, object>("Name", Item.Name),
                    new KeyValuePair<string, object>("ObjectId", Item.ObjectId),
                    new KeyValuePair<string, object>("PendingSubscription", Item.PendingSubscription),
                    new KeyValuePair<string, object>("Subscription", Item.Subscription),
                    new KeyValuePair<string, object>("NrGroups", Item.Groups is null ? 0 : Item.Groups.Length));
 
                return Item;
            }
 
            lock (this.rosters)
            {
                Item = new RosterItem()
                {
                    UserName = UserName,
                    BareJid = Jid,
                    Name = Name,
                    Groups = Groups,
                    Subscription = Subscription ?? SubscriptionStatus.none,
                    PendingSubscription = PendingSubscription ?? false
                };
 
                Roster[Jid] = Item;
 
                Log.Informational("Roster item created.", Item.BareJid, UserName, "RosterItemCreated", EventLevel.Minor,
                    new KeyValuePair<string, object>("Name", Item.Name),
                    new KeyValuePair<string, object>("ObjectId", Item.ObjectId),
                    new KeyValuePair<string, object>("PendingSubscription", Item.PendingSubscription),
                    new KeyValuePair<string, object>("Subscription", Item.Subscription),
                    new KeyValuePair<string, object>("NrGroups", Item.Groups is null ? 0 : Item.Groups.Length));
            }
 
            await Database.Insert(Item);
 
            return Item;
        }
 
        public async Task<bool> RemoveRosterItem(CaseInsensitiveString UserName, CaseInsensitiveString Jid)
        {
            Dictionary<CaseInsensitiveString, RosterItem> Roster;
            RosterItem Item = null;
 
            lock (this.rosters)
            {
                if (this.rosters.TryGetValue(UserName, out Roster))
                {
                    if (Roster.TryGetValue(Jid, out Item))
                        Roster.Remove(Jid);
                    else
                        return false;
                }
            }
 
            if (Item is null)
            {
                if (await this.GetRoster(UserName) is null)
                    return false;
 
                lock (this.rosters)
                {
                    if (this.rosters.TryGetValue(UserName, out Roster))
                    {
                        if (Roster.TryGetValue(Jid, out Item))
                            Roster.Remove(Jid);
                        else
                            return false;
                    }
                }
            }
 
            await Database.Delete(Item);
 
            Log.Informational("Roster item deleted.", Item.BareJid, UserName, "RosterItemDeleted", EventLevel.Minor,
                new KeyValuePair<string, object>("Name", Item.Name),
                new KeyValuePair<string, object>("ObjectId", Item.ObjectId),
                new KeyValuePair<string, object>("PendingSubscription", Item.PendingSubscription),
                new KeyValuePair<string, object>("Subscription", Item.Subscription),
                new KeyValuePair<string, object>("NrGroups", Item.Groups is null ? 0 : Item.Groups.Length));
 
            return true;
        }
 
        #endregion
 
        #region Blocks
 
        public async Task<bool> AddBlock(CaseInsensitiveString UserName, CaseInsensitiveString BareJid, BlockingReason Reason, string Text, string TextLanguage)
        {
            Dictionary<CaseInsensitiveString, Block> Blocks;
            Block Item = null;
            bool Load = false;
            bool Found = false;
 
            lock (this.blocks)
            {
                if (this.blocks.TryGetValue(UserName, out Blocks))
                    Found = Blocks.TryGetValue(BareJid, out Item);
                else
                    Load = true;
            }
 
            if (Load)
            {
                if (await this.GetBlockList(UserName) is null)
                    return false;
 
                lock (this.blocks)
                {
                    if (this.blocks.TryGetValue(UserName, out Blocks))
                        Found = Blocks.TryGetValue(BareJid, out Item);
                    else
                        return false;
                }
            }
 
            if (Found && !(Item is null))
            {
                Item.Reason = Reason;
                Item.Text = Text;
                Item.Language = TextLanguage;
 
                await Database.Update(Item);
 
                Log.Informational("Block updated.", Item.Jid, UserName, "BlockUpdated", EventLevel.Minor,
                    new KeyValuePair<string, object>("ObjectId", Item.ObjectId),
                    new KeyValuePair<string, object>("Reason", Item.Reason),
                    new KeyValuePair<string, object>("Text", Item.Text),
                    new KeyValuePair<string, object>("Language", Item.Language));
 
                return true;
            }
 
            lock (this.blocks)
            {
                Item = new Block()
                {
                    UserName = UserName,
                    Jid = BareJid,
                    Reason = Reason,
                    Text = Text,
                    Language = TextLanguage
                };
 
                Blocks[BareJid] = Item;
            }
 
            await Database.Insert(Item);
 
            Log.Informational("Block added.", Item.Jid, UserName, "BlockAdded", EventLevel.Minor,
                new KeyValuePair<string, object>("ObjectId", Item.ObjectId),
                new KeyValuePair<string, object>("Reason", Item.Reason),
                new KeyValuePair<string, object>("Text", Item.Text),
                new KeyValuePair<string, object>("Language", Item.Language));
 
            return true;
        }
 
        public async Task<bool> Unblock(CaseInsensitiveString UserName, CaseInsensitiveString BareJid)
        {
            Dictionary<CaseInsensitiveString, Block> Blocks;
            Block Item = null;
 
            lock (this.blocks)
            {
                if (this.blocks.TryGetValue(UserName, out Blocks))
                {
                    if (Blocks.TryGetValue(BareJid, out Item) && !(Item is null))
                        Blocks[BareJid] = null;
                    else
                        return false;
                }
            }
 
            if (Item is null)
            {
                if (await this.GetBlockList(UserName) is null)
                    return false;
 
                lock (this.blocks)
                {
                    if (this.blocks.TryGetValue(UserName, out Blocks))
                    {
                        if (Blocks.TryGetValue(BareJid, out Item) && !(Item is null))
                            Blocks[BareJid] = null;
                        else
                            return false;
                    }
                }
            }
 
            await Database.Delete(Item);
 
            Log.Informational("Block removed.", Item.Jid, UserName, "BlockRemoved", EventLevel.Minor,
                new KeyValuePair<string, object>("ObjectId", Item.ObjectId),
                new KeyValuePair<string, object>("Reason", Item.Reason),
                new KeyValuePair<string, object>("Text", Item.Text),
                new KeyValuePair<string, object>("Language", Item.Language));
 
            return true;
        }
 
        public async Task<bool> ClearBlocks(CaseInsensitiveString UserName)
        {
            Dictionary<CaseInsensitiveString, Block> Blocks;
 
            lock (this.blocks)
            {
                if (this.blocks.TryGetValue(UserName, out Blocks))
                    this.blocks.Remove(UserName);
            }
 
            if (Blocks is null)
            {
                if (await this.GetBlockList(UserName) is null)
                    return false;
 
                lock (this.blocks)
                {
                    if (this.blocks.TryGetValue(UserName, out Blocks))
                    {
                        if (this.blocks.TryGetValue(UserName, out Blocks))
                            this.blocks.Remove(UserName);
                        else
                            return false;
                    }
                }
            }
 
            foreach (Block Item in Blocks.Values)
            {
                await Database.Delete(Item);
 
                Log.Informational("Block removed.", Item.Jid, UserName, "BlockRemoved", EventLevel.Minor,
                    new KeyValuePair<string, object>("ObjectId", Item.ObjectId),
                    new KeyValuePair<string, object>("Reason", Item.Reason),
                    new KeyValuePair<string, object>("Text", Item.Text),
                    new KeyValuePair<string, object>("Language", Item.Language));
            }
 
            return true;
        }
 
        public async Task<IEnumerable<CaseInsensitiveString>> GetBlockList(CaseInsensitiveString UserName)
        {
            Dictionary<CaseInsensitiveString, Block> Blocks;
 
            lock (this.blocks)
            {
                if (this.blocks.TryGetValue(UserName, out Blocks))
                    return this.ToArrayLocked(Blocks);
            }
 
            if (await this.GetAccountEx(UserName) is null)
                return null;
 
            Blocks = new Dictionary<CaseInsensitiveString, Block>();
 
            foreach (Block Item in await Database.Find<Block>(new FilterFieldEqualTo("UserName", UserName)))
                Blocks[Item.Jid] = Item;
 
            lock (this.blocks)
            {
                this.blocks[UserName] = Blocks;
                return this.ToArrayLocked(Blocks);
            }
        }
 
        private CaseInsensitiveString[] ToArrayLocked(Dictionary<CaseInsensitiveString, Block> Blocks)
        {
            List<CaseInsensitiveString> Result = new List<CaseInsensitiveString>();
 
            foreach (Block Item in Blocks.Values)
            {
                if (!(Item is null))
                    Result.Add(Item.Jid);
            }
 
            return Result.ToArray();
        }
 
        private async Task<Block> GetBlock(CaseInsensitiveString UserName, CaseInsensitiveString Jid)
        {
            lock (this.blocks)
            {
                if (this.blocks.TryGetValue(UserName, out Dictionary<CaseInsensitiveString, Block> Blocks) &&
                    Blocks.TryGetValue(Jid, out Block Block))
                {
                    return Block;
                }
            }
 
            if (await this.GetBlockList(UserName) is null)
                return null;
 
            lock (this.blocks)
            {
                if (this.blocks.TryGetValue(UserName, out Dictionary<CaseInsensitiveString, Block> Blocks))
                {
                    if (Blocks.TryGetValue(Jid, out Block Block))
                        return Block;
                    else
                        Blocks[Jid] = null;
                }
            }
 
            return null;
        }
 
        public async Task<bool> IsBlocked(CaseInsensitiveString FromBareJid, CaseInsensitiveString ToBareJid)
        {
            int i = ToBareJid.IndexOf('@');
            if (i < 0)
                return false;
 
            CaseInsensitiveString Domain = ToBareJid.Substring(i + 1);
            if (!this.server.IsServerDomain(Domain, true))
                return false;
 
            CaseInsensitiveString ToUserName = ToBareJid.Substring(0, i);
            Block Block = await this.GetBlock(ToUserName, FromBareJid);
 
            return !(Block is null);
        }
 
        #endregion
 
        #region Avatars
 
        public async Task<Tuple<string, byte[]>> GetAvatar(CaseInsensitiveString UserName)
        {
            foreach (Avatar Avatar in await Database.Find<Avatar>(new FilterFieldEqualTo("UserName", UserName)))
                return new Tuple<string, byte[]>(Avatar.ContentType, Avatar.Data);
 
            return null;
        }
 
        public async Task<bool> SetAvatar(CaseInsensitiveString UserName, string ContentType, byte[] Data)
        {
            Account Account = await this.GetAccountEx(UserName);
            if (Account is null)
                return false;
 
            foreach (Avatar Avatar in await Database.Find<Avatar>(new FilterFieldEqualTo("UserName", UserName)))
            {
                Avatar.ContentType = ContentType;
                Avatar.Data = Data;
 
                await Database.Update(Avatar);
 
                Log.Informational("Avatar updated.", UserName, string.Empty, "AvatarUpdated", EventLevel.Minor,
                    new KeyValuePair<string, object>("ObjectId", Avatar.ObjectId),
                    new KeyValuePair<string, object>("ContentType", Avatar.ContentType),
                    new KeyValuePair<string, object>("Bytes", Avatar.Data.Length));
 
                return true;
            }
 
            Avatar Avatar2 = new Avatar()
            {
                UserName = UserName,
                ContentType = ContentType,
                Data = Data
            };
 
            await Database.Insert(Avatar2);
 
            Log.Informational("Avatar created.", UserName, string.Empty, "AvatarCreated", EventLevel.Minor,
                new KeyValuePair<string, object>("ObjectId", Avatar2.ObjectId),
                new KeyValuePair<string, object>("ContentType", Avatar2.ContentType),
                new KeyValuePair<string, object>("Bytes", Avatar2.Data.Length));
 
            return true;
        }
 
        #endregion
 
        #region vCard
 
        public async Task<string> GetVCard(CaseInsensitiveString UserName)
        {
            foreach (VCard VCard in await Database.Find<VCard>(new FilterFieldEqualTo("UserName", UserName)))
                return VCard.VCardXml;
 
            return null;
        }
 
        public async Task<bool> SetVCard(CaseInsensitiveString UserName, string VCard)
        {
            Account Account = await this.GetAccountEx(UserName);
            if (Account is null)
                return false;
 
            foreach (VCard VCard2 in await Database.Find<VCard>(new FilterFieldEqualTo("UserName", UserName)))
            {
                VCard2.VCardXml = VCard;
                await Database.Update(VCard2);
 
                Log.Informational("vCard updated.", UserName, string.Empty, "vCardUpdated", EventLevel.Minor,
                    new KeyValuePair<string, object>("ObjectId", VCard2.ObjectId));
 
                return true;
            }
 
            VCard VCard3 = new VCard()
            {
                UserName = UserName,
                VCardXml = VCard
            };
 
            await Database.Insert(VCard3);
 
            Log.Informational("vCard created.", UserName, string.Empty, "vCardCreated", EventLevel.Minor,
                new KeyValuePair<string, object>("ObjectId", VCard3.ObjectId));
 
            return true;
        }
 
        #endregion
 
        #region Settings
 
        public Task<bool> IsPermitted(CaseInsensitiveString BareJid, string Setting)
        {
            return RuntimeSettings.GetAsync(BareJid + " " + Setting, true);
        }
 
        public async Task<byte[]> GetDialbackSecret()
        {
            string s = await RuntimeSettings.GetAsync("Dialback Secret", string.Empty);
 
            if (string.IsNullOrEmpty(s))
            {
                byte[] Data = Gateway.NextBytes(32);
 
                s = Convert.ToBase64String(Data, Base64FormattingOptions.None);
 
                await RuntimeSettings.SetAsync("Dialback Secret", s);
            }
 
            return Convert.FromBase64String(s);
        }
 
        #endregion
 
        #region Offline messages
 
        internal static bool RegisterEventsTab(CaseInsensitiveString BareJid,
            string MessageType, string LocalName, string Namespace, string Function,
            string TabId)
        {
            string Fqn = EventHandlerKey(MessageType, LocalName, Namespace);
            bool Unregistering = string.IsNullOrEmpty(Function);
 
            lock (functionsPerTabIdPerFqnPerBareJid)
            {
                if (!functionsPerTabIdPerFqnPerBareJid.TryGetValue(BareJid, out Dictionary<string, Dictionary<string, string>> FunctionsPerTabIdPerFqn))
                {
                    if (Unregistering)
                        return false;
 
                    FunctionsPerTabIdPerFqn = new Dictionary<string, Dictionary<string, string>>();
                    functionsPerTabIdPerFqnPerBareJid[BareJid] = FunctionsPerTabIdPerFqn;
                }
 
                if (!FunctionsPerTabIdPerFqn.TryGetValue(Fqn, out Dictionary<string, string> FunctionsPerTabId))
                {
                    if (Unregistering)
                        return false;
 
                    FunctionsPerTabId = new Dictionary<string, string>();
                    FunctionsPerTabIdPerFqn[Fqn] = FunctionsPerTabId;
                }
 
                if (Unregistering)
                {
                    if (!FunctionsPerTabId.Remove(TabId))
                        return false;
 
                    if (FunctionsPerTabId.Count > 0)
                        return true;
 
                    if (!FunctionsPerTabIdPerFqn.Remove(Fqn))
                        return false;
 
                    if (FunctionsPerTabIdPerFqn.Count > 0)
                        return true;
 
                    return functionsPerTabIdPerFqnPerBareJid.Remove(BareJid);
                }
                else if (FunctionsPerTabId.TryGetValue(TabId, out string s) && s == Function)
                    return false;
                else
                {
                    FunctionsPerTabId[TabId] = Function;
                    return true;
                }
            }
        }
 
        private static string EventHandlerKey(string MessageType, string LocalName, string Namespace)
        {
            StringBuilder sb = new StringBuilder();
 
            sb.Append(Namespace);
            sb.Append('#');
            sb.Append(LocalName);
            sb.Append('?');
            sb.Append(MessageType);
 
            return sb.ToString();
        }
 
        internal static bool UnregisterEventsTab(CaseInsensitiveString BareJid,
            string MessageType, string LocalName, string Namespace, string TabId)
        {
            return RegisterEventsTab(BareJid, MessageType, LocalName, Namespace, string.Empty, TabId);
        }
 
        internal static ClientPushRecord[] GetEventTabs(CaseInsensitiveString BareJid,
            string Type, string XmlContent, XmlElement StanzaElement)
        {
            lock (functionsPerTabIdPerFqnPerBareJid)
            {
                XmlElement FirstContent = null;
 
                if (!functionsPerTabIdPerFqnPerBareJid.TryGetValue(BareJid, out Dictionary<string, Dictionary<string, string>> FunctionsPerTabIdPerFqn))
                    return null;
 
                if (StanzaElement is null)
                {
                    try
                    {
                        StringBuilder Xml = new StringBuilder();
 
                        Xml.Append("<message xmlns=\"");
                        Xml.Append(ClientConnection.C2SNamespace);
                        Xml.Append('>');
                        Xml.Append(XmlContent);
                        Xml.Append("</message>");
 
                        XmlDocument Doc = new XmlDocument();
                        Doc.LoadXml(XmlContent);
                        StanzaElement = Doc.DocumentElement;
                    }
                    catch (Exception)
                    {
                        return null;
                    }
                }
 
                Dictionary<string, string> FunctionsPerTabId;
                List<ClientPushRecord> Result = null;
                string Key;
 
                foreach (XmlNode N in StanzaElement.ChildNodes)
                {
                    if (N is XmlElement E)
                    {
                        if (FirstContent is null)
                            FirstContent = E;
 
                        Key = EventHandlerKey(Type, E.LocalName, E.NamespaceURI);
                        if (FunctionsPerTabIdPerFqn.TryGetValue(Key, out FunctionsPerTabId))
                        {
                            if (Result is null)
                                Result = new List<ClientPushRecord>();
 
                            foreach (KeyValuePair<string, string> P in FunctionsPerTabId)
                            {
                                Result.Add(new ClientPushRecord()
                                {
                                    Type = Type,
                                    LocalName = E.LocalName,
                                    Namespace = E.NamespaceURI,
                                    Function = P.Value,
                                    TabId = P.Key,
                                    Data = E
                                });
                            }
                        }
 
                        Key = EventHandlerKey(Type, string.Empty, E.NamespaceURI);
                        if (FunctionsPerTabIdPerFqn.TryGetValue(Key, out FunctionsPerTabId))
                        {
                            if (Result is null)
                                Result = new List<ClientPushRecord>();
 
                            foreach (KeyValuePair<string, string> P in FunctionsPerTabId)
                            {
                                Result.Add(new ClientPushRecord()
                                {
                                    Type = Type,
                                    LocalName = string.Empty,
                                    Namespace = E.NamespaceURI,
                                    Function = P.Key,
                                    TabId = P.Value,
                                    Data = E
                                });
                            }
                        }
 
                        Key = EventHandlerKey(string.Empty, string.Empty, E.NamespaceURI);
                        if (FunctionsPerTabIdPerFqn.TryGetValue(Key, out FunctionsPerTabId))
                        {
                            if (Result is null)
                                Result = new List<ClientPushRecord>();
 
                            foreach (KeyValuePair<string, string> P in FunctionsPerTabId)
                            {
                                Result.Add(new ClientPushRecord()
                                {
                                    Type = string.Empty,
                                    LocalName = string.Empty,
                                    Namespace = E.NamespaceURI,
                                    Function = P.Key,
                                    TabId = P.Value,
                                    Data = E
                                });
                            }
                        }
                    }
                }
 
                if (!(FirstContent is null))
                {
                    Key = EventHandlerKey(string.Empty, string.Empty, string.Empty);
                    if (FunctionsPerTabIdPerFqn.TryGetValue(Key, out FunctionsPerTabId))
                    {
                        if (Result is null)
                            Result = new List<ClientPushRecord>();
 
                        foreach (KeyValuePair<string, string> P in FunctionsPerTabId)
                        {
                            Result.Add(new ClientPushRecord()
                            {
                                Type = string.Empty,
                                LocalName = string.Empty,
                                Namespace = string.Empty,
                                Function = P.Key,
                                TabId = P.Value,
                                Data = FirstContent
                            });
                        }
                    }
                }
 
                return Result?.ToArray();
            }
        }
 
        internal class ClientPushRecord
        {
            public string Type;
            public string LocalName;
            public string Namespace;
            public string Function;
            public string TabId;
            public XmlElement Data;
        }
 
        public async Task<IEnumerable<IOfflineMessage>> GetOfflineMessages(CaseInsensitiveString ToUserName, int Max)
        {
            return await Database.Find<OfflineMessage>(0, Max, new FilterFieldEqualTo("ToUserName", ToUserName), "Timestamp");
        }
 
        public async Task DeleteOfflineMessages(IEnumerable<IOfflineMessage> Messages)
        {
            await Database.Delete(Messages);
        }
 
        public async Task<int> DeleteOfflineMessages(CaseInsensitiveString ToUserName)
        {
            int Count = 0;
 
            foreach (OfflineMessage Message in await Database.FindDelete<OfflineMessage>(new FilterFieldEqualTo("ToUserName", ToUserName)))
                Count++;
 
            return Count;
        }
 
        public async Task<bool> StoreOfflineMessage(string Type, string Id, XmppAddress To, XmppAddress From, string Language, string ContentXml)
        {
            CaseInsensitiveString BareJid = To.BareJid;
            ClientPushRecord[] ClientPushRecords = GetEventTabs(BareJid, Type, ContentXml, null);
 
            if (!(ClientPushRecords is null) && await PushMessageToClients(BareJid, ClientPushRecords))
                return true;
 
            OfflineMessage Msg = new OfflineMessage()
            {
                ToUserName = To.Account,
                Type = Type,
                Id = Id,
                To = BareJid,
                From = From.Address,
                Language = Language,
                ContentXml = ContentXml,
                Timestamp = DateTime.UtcNow
            };
 
            await Database.Insert(Msg);
 
            PushNotificationToken Token = await XmppServer.TryGetPushNotificationToken(BareJid);
            if (!(Token is null))
            {
                PushNotificationRule Rule = await XmppServer.TryGetPushNotificationRule(BareJid, Type, string.Empty, string.Empty);
                if (!(Rule is null))
                {
                    XmlElement StanzaElement = this.RecreateStanza(ContentXml);
                    if (!(StanzaElement is null))
                        await this.ProcessOfflineRule(Rule, StanzaElement, Token, Type, Id, To.Address.Value, From.Address.Value);
                }
                else if (!string.IsNullOrEmpty(ContentXml))
                {
                    XmlElement StanzaElement = this.RecreateStanza(ContentXml);
                    if (!(StanzaElement is null))
                        await this.ProcessOfflineStanza(BareJid, Type, StanzaElement, Token, Id, To.Address.Value, From.Address.Value);
                }
            }
 
            return true;
        }
 
        private static async Task<bool> PushMessageToClients(CaseInsensitiveString BareJid,
            ClientPushRecord[] ClientPushRecords)
        {
            if (ClientPushRecords is null)
                return false;
 
            bool Sent = false;
 
            foreach (ClientPushRecord Rec in ClientPushRecords)
            {
                if (await ClientEvents.PushEvent(new string[] { Rec.TabId }, Rec.Function, JSON.Encode(Rec.Data, false), true) > 0)
                    Sent = true;
                else
                    UnregisterEventsTab(BareJid, Rec.Type, Rec.LocalName, Rec.Namespace, Rec.TabId);
            }
 
            return Sent;
        }
 
        private XmlElement RecreateStanza(string ContentXml)
        {
            if (string.IsNullOrEmpty(ContentXml))
                return null;
 
            try
            {
                XmlDocument Doc = new XmlDocument();
                Doc.LoadXml("<message xmlns='jabber:client'>" + ContentXml + "</message>");
                return Doc.DocumentElement;
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
                return null;
            }
        }
 
        private async Task ProcessOfflineStanza(CaseInsensitiveString BareJid, string Type, XmlElement StanzaElement,
            PushNotificationToken Token, string Id, string To, string From)
        {
            foreach (XmlNode N in StanzaElement.ChildNodes)
            {
                if (N is XmlElement E)
                {
                    PushNotificationRule Rule = await XmppServer.TryGetPushNotificationRule(BareJid, Type, E.LocalName, E.NamespaceURI);
                    if (!(Rule is null))
                    {
                        await this.ProcessOfflineRule(Rule, StanzaElement, Token, Type, Id, To, From);
                        return;
                    }
                }
            }
        }
 
        private bool NoXPath(ScriptNode Node, out ScriptNode NewNode, object State)
        {
            NewNode = null;
            return !(Node is Script.Persistence.Functions.XPath);
        }
 
        private async Task ProcessOfflineRule(PushNotificationRule Rule, XmlElement StanzaElement, PushNotificationToken Token,
            string Type, string Id, string To, string From)
        {
            try
            {
                if (!string.IsNullOrEmpty(Type) && !StanzaElement.HasAttribute("type"))
                    StanzaElement.SetAttribute("type", Type);
 
                if (!string.IsNullOrEmpty(Id) && !StanzaElement.HasAttribute("id"))
                    StanzaElement.SetAttribute("id", Id);
 
                if (!string.IsNullOrEmpty(To) && !StanzaElement.HasAttribute("to"))
                    StanzaElement.SetAttribute("to", To);
 
                if (!string.IsNullOrEmpty(From) && !StanzaElement.HasAttribute("from"))
                    StanzaElement.SetAttribute("from", From);
 
                Variables v = new Variables();
                Expression ContentExpression = Rule.ContentExpression;
                Expression PatternMatchingExpression = Rule.PatternMatchingExpression;
                bool HasXPath = !((ContentExpression?.ForAll(this.NoXPath, null, SearchMethod.TreeOrder) ?? true) &&
                    (PatternMatchingExpression?.ForAll(this.NoXPath, null, SearchMethod.TreeOrder) ?? true));
 
                if (!string.IsNullOrEmpty(Rule.MessageVariable))
                    v[Rule.MessageVariable] = StanzaElement;
 
                if (!(PatternMatchingExpression is null))
                {
                    Dictionary<string, IElement> AlreadyFound = new Dictionary<string, IElement>();
 
                    if (PatternMatchingExpression.Root.PatternMatch(new ObjectValue(StanzaElement), AlreadyFound) != PatternMatchResult.Match)
                        return;
 
                    foreach (KeyValuePair<string, IElement> P in AlreadyFound)
                        v[P.Key] = P.Value;
                }
 
                object Content;
 
                if (ContentExpression is null)
                    Content = StanzaElement;
                else
                    Content = await ContentExpression.EvaluateAsync(v);
 
                PushNotificationEventHandler h = this.OnPushNotification;
                if (!(h is null))
                    await h(Token, Content);
 
                PushNotificationConfiguration.PushNotification(Token, Content);
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        public event PushNotificationEventHandler OnPushNotification;
 
        public async Task<bool> StoreOfflineMessage(string Type, string Id, XmppAddress To, XmppAddress From, string Language, Stanza Stanza)
        {
            CaseInsensitiveString BareJid = To.BareJid;
            ClientPushRecord[] ClientPushRecords = GetEventTabs(BareJid, Type, Stanza.Content, Stanza.StanzaElement);
 
            if (!(ClientPushRecords is null) && await PushMessageToClients(BareJid, ClientPushRecords))
                return true;
 
            OfflineMessage Msg = new OfflineMessage()
            {
                ToUserName = To.Account,
                Type = Type,
                Id = Id,
                To = BareJid,
                From = From.Address,
                Language = Language,
                ContentXml = Stanza.Content,
                Timestamp = DateTime.UtcNow
            };
 
            await Database.Insert(Msg);
 
            PushNotificationToken Token = await XmppServer.TryGetPushNotificationToken(BareJid);
            if (!(Token is null))
            {
                PushNotificationRule Rule = await XmppServer.TryGetPushNotificationRule(BareJid, Type, string.Empty, string.Empty);
                if (!(Rule is null))
                    await this.ProcessOfflineRule(Rule, Stanza.StanzaElement, Token, Type, Id, To.Address.Value, From.Address.Value);
                else if (Stanza.HasContent)
                    await this.ProcessOfflineStanza(BareJid, Type, Stanza.StanzaElement, Token, Id, To.Address.Value, From.Address.Value);
            }
 
            return true;
        }
 
        public async Task<int> DeleteOfflineMessages(DateTime OlderThan)
        {
            int Nr = 0;
 
            foreach (OfflineMessage Msg in await Database.FindDelete<OfflineMessage>(new FilterFieldLesserOrEqualTo("Timestamp", OlderThan)))
                Nr++;
 
            return Nr;
        }
 
        async Task<Networking.SASL.IAccount> ISaslPersistenceLayer.GetAccount(CaseInsensitiveString UserName)
        {
            return await this.GetAccountEx(UserName);
        }
 
        async Task<Networking.XMPP.Server.IAccount> IXmppServerPersistenceLayer.GetAccount(CaseInsensitiveString UserName)
        {
            return await this.GetAccountEx(UserName);
        }
 
        public Task AccountUpdated(CaseInsensitiveString UserName)
        {
            lock (this.accounts)
            {
                this.accounts.Remove(UserName);
            }
 
            return Task.CompletedTask;
        }
 
        public byte[] GetRandomNumbers(int NrBytes)
        {
            return XmppServer.GetRandomNumbers(NrBytes);
        }
 
        #endregion
 
    }
}