AccountRecipient.cs

using System.Threading.Tasks;
using Waher.Networking.Sniffers;
 
namespace Waher.Networking.XMPP.Server
{
    internal class AccountRecipient : IRecipient
    {
        private readonly Accounts accounts;
        private readonly IAccount account;
 
        internal AccountRecipient(Accounts Accounts, IAccount Account)
        {
            this.accounts = Accounts;
            this.account = Account;
        }
 
        internal Accounts Accounts => this.accounts;
        internal IAccount Account => this.account;
 
        public Task<bool> IQ(string Type, string Id, XmppAddress To, XmppAddress From, string Language, Stanza Stanza, ISender Sender)
        {
            return this.accounts.IQ(Type, Id, To, From, Language, Stanza, Sender);
        }
 
        public Task<bool> IQ(string Type, string Id, XmppAddress To, XmppAddress From, string Language, string ContentXml, ISender Sender)
        {
            return this.accounts.IQ(Type, Id, To, From, Language, ContentXml, Sender);
        }
 
        public async Task<bool> Message(string Type, string Id, XmppAddress To, XmppAddress From, string Language, Stanza Stanza, ISender Sender)
        {
            if (string.IsNullOrEmpty(Type) || Type == "normal" || Type == "chat" || Type == "headline")
            {
                // Rules defined in §8.5.2 of RFC 6121.
 
                IClientConnection[] Connections = this.accounts.Server.GetClientConnections(To.BareJid);
                bool Forwarded = false;
 
                if (!(Connections is null) && Connections.Length > 0)
                {
                    foreach (IClientConnection Connection in Connections)
                    {
                        if (Connection.State == XmppConnectionState.Active)
                        {
                            PresenceEventArgs e = Connection.LastPresence;
 
                            if (!(e is null) && e.Priority >= 0)
                            {
                                if (await Connection.Message(Type, Id, Connection.Address, From, Language, Stanza, Sender))
                                    Forwarded = true;
                            }
                        }
                    }
                }
 
                if (!Forwarded && Type != "headline")
                {
                    if (await this.accounts.Server.PersistenceLayer.StoreOfflineMessage(Type, Id, To, From, Language, Stanza))
                    {
                        if (!(Sender is null) && Sender is ICommunicationLayer ComLayer)
                            await ComLayer.Information("Message stored for later delivery.");
                    }
                    else if (!(Sender is null))
                        await (Sender?.MessageErrorServiceUnavailable(From, To, string.Empty, string.Empty) ?? Task.CompletedTask);
                }
            }
 
            return true;
        }
 
        public async Task<bool> Message(string Type, string Id, XmppAddress To, XmppAddress From, string Language, string ContentXml, ISender Sender)
        {
            if (string.IsNullOrEmpty(Type) || Type == "normal" || Type == "chat" || Type == "headline")
            {
                // Rules defined in §8.5.2 of RFC 6121.
 
                IClientConnection[] Connections = this.accounts.Server.GetClientConnections(To.BareJid);
                bool Forwarded = false;
 
                if (!(Connections is null) && Connections.Length > 0)
                {
                    foreach (IClientConnection Connection in Connections)
                    {
                        if (Connection.State == XmppConnectionState.Active)
                        {
                            PresenceEventArgs e = Connection.LastPresence;
 
                            if (!(e is null) && e.Priority >= 0)
                            {
                                if (await Connection.Message(Type, Id, Connection.Address, From, Language, ContentXml, Sender))
                                    Forwarded = true;
                            }
                        }
                    }
                }
 
                if (!Forwarded && Type != "headline")
                {
                    if (await this.accounts.Server.PersistenceLayer.StoreOfflineMessage(Type, Id, To, From, Language, ContentXml))
                    {
                        if (!(Sender is null) && Sender is ICommunicationLayer ComLayer)
                            await ComLayer.Information("Message stored for later delivery.");
                    }
                    else if (!(Sender is null))
                        await (Sender?.MessageErrorServiceUnavailable(From, To, string.Empty, string.Empty) ?? Task.CompletedTask);
                }
            }
 
            return true;
        }
 
        public Task<bool> Presence(string Type, string Id, XmppAddress To, XmppAddress From, string Language, Stanza Stanza, ISender Sender)
        {
            return this.accounts.Presence(Type, Id, To, From, Language, Stanza, Sender);
        }
 
        public Task<bool> Presence(string Type, string Id, XmppAddress To, XmppAddress From, string Language, string ContentXml, ISender Sender)
        {
            return this.accounts.Presence(Type, Id, To, From, Language, ContentXml, Sender);
        }
    }
}