XmppS2SOverParentEndpoint.cs

using System;
using System.Text;
using System.Threading.Tasks;
using Waher.Content.Xml;
using Waher.Persistence;
 
namespace Waher.Networking.XMPP.Server
{
    public class XmppS2SOverParentEndpoint : ServerConnection
    {
        private readonly XmppClient client;
 
        public XmppS2SOverParentEndpoint(XmppClient Client, CaseInsensitiveString LocalDomain, 
            CaseInsensitiveString RemoteDomain)
            : base(LocalDomain, RemoteDomain)
        {
            this.client = Client;
        }
 
        public override string Type => "XMPP";
 
        private static string GetForwardedContent(string Content, XmppAddress From)
        {
            StringBuilder sb = new StringBuilder();
 
            if (!string.IsNullOrEmpty(Content))
                sb.Append(Content);
 
            sb.Append("<addresses xmlns='http://jabber.org/protocol/address'>");
            sb.Append("<address type='ofrom' jid='");
            sb.Append(XML.Encode(From.Address));
            sb.Append("'/></addresses>");
 
            return sb.ToString();
        }
 
        private static MessageType GetMessageType(string Type)
        {
            return Type.ToLower() switch
            {
                "chat" => MessageType.Chat,
                "error" => MessageType.Error,
                "groupchat" => MessageType.GroupChat,
                "headline" => MessageType.Headline,
                _ => MessageType.Normal,
            };
        }
 
        public override Task<bool> IQ(string Type, string Id, XmppAddress To, XmppAddress From, string Language, Stanza Stanza, ISender Sender)
        {
            return this.IQ(Type, Id, To, From, Language, Stanza.Content, Sender);
        }
 
        public override async Task<bool> IQ(string Type, string Id, XmppAddress To, XmppAddress From, string Language, string ContentXml, ISender Sender)
        {
            string ForwardedContent = GetForwardedContent(ContentXml, From);
 
            await this.client.SendIq(string.Empty, To.Address, ForwardedContent, Type, async (sender, e) =>
            {
                string Content = e.Response?.InnerXml.ToString() ?? string.Empty;
 
                if (e.Ok)
                    await Sender.IqResult(Id, From, To, Content);
                else
                    await Sender.IqError(Id, From, To, Content);
 
            }, null);
 
            return true;
        }
 
        public override Task<bool> Message(string Type, string Id, XmppAddress To, XmppAddress From, string Language, Stanza Stanza, ISender Sender)
        {
            return this.Message(Type, Id, To, From, Language, Stanza.Content, Sender);
        }
 
        public override async Task<bool> Message(string Type, string Id, XmppAddress To, XmppAddress From, string Language, string ContentXml, ISender Sender)
        {
            string ForwardedContent = GetForwardedContent(ContentXml, From);
 
            await this.client.SendMessage(QoSLevel.Unacknowledged, GetMessageType(Type), Id, 
                To.Address, ForwardedContent, string.Empty, string.Empty, Language, 
                string.Empty, string.Empty, null, null);
            return true;
        }
 
        public override Task<bool> Presence(string Type, string Id, XmppAddress To, XmppAddress From, string Language, Stanza Stanza, ISender Sender)
        {
            string ForwardedContent = GetForwardedContent(Stanza.Content, From);
 
            return this.Presence(Type, Id, To, From, Language, ForwardedContent, Sender);
        }
 
        public override async Task<bool> Presence(string Type, string Id, XmppAddress To, XmppAddress From, string Language, string ContentXml, ISender Sender)
        {
            string ForwardedContent = GetForwardedContent(ContentXml, From);
 
            await this.client.SendDirectedPresence(Type, To.Address, ForwardedContent);
            return true;
        }
 
        public override async Task<bool> IqError(string Id, XmppAddress To, XmppAddress From, string ErrorXml)
        {
            string ForwardedContent = GetForwardedContent(ErrorXml, From);
 
            await this.client.SendIqError(Id, To.Address, ForwardedContent);
            return true;
        }
 
        public override async Task<string> IqError(string Id, XmppAddress To, XmppAddress From, Exception ex)
        {
            string ForwardedContent = GetForwardedContent(this.client.ExceptionToXmppXml(ex), From);
 
            await this.client.SendIqError(Id, To.Address, ForwardedContent);
            return string.Empty;
        }
 
        public override async Task<bool> IqResult(string Id, XmppAddress To, XmppAddress From, string ResultXml)
        {
            string ForwardedContent = GetForwardedContent(ResultXml, From);
 
            await this.client.SendIqResult(Id, To.Address, ForwardedContent);
            return true;
        }
 
        public override async Task<bool> Presence(string Type, string Id, XmppAddress To, XmppAddress From, string Language, string ContentXml)
        {
            string ForwardedContent = GetForwardedContent(ContentXml, From);
 
            await this.client.SendDirectedPresence(Type, To.Address, ForwardedContent);
            return true;
        }
 
        public override async Task<bool> PresenceError(string Id, XmppAddress To, XmppAddress From, string ErrorXml)
        {
            string ForwardedContent = GetForwardedContent(ErrorXml, From);
 
            await this.client.SendDirectedPresence("error", To.Address, ForwardedContent);
            return true;
        }
 
        public override async Task<bool> PresenceError(string Id, XmppAddress To, XmppAddress From, Exception ex)
        {
            string ForwardedContent = GetForwardedContent(this.client.ExceptionToXmppXml(ex), From);
 
            await this.client.SendDirectedPresence("error", To.Address, ForwardedContent);
            return true;
        }
 
        public override async Task<bool> Message(string Type, string Id, XmppAddress To, XmppAddress From, string Language, string ContentXml)
        {
            string ForwardedContent = GetForwardedContent(ContentXml, From);
 
            await this.client.SendMessage(QoSLevel.Unacknowledged, GetMessageType(Type), Id, 
                To.Address, ForwardedContent, string.Empty, string.Empty, Language, 
                string.Empty, string.Empty, null, null);
 
            return true;
        }
 
        public override async Task<bool> MessageError(string Id, XmppAddress To, XmppAddress From, Exception ex)
        {
            string ForwardedContent = GetForwardedContent(this.client.ExceptionToXmppXml(ex), From);
 
            await this.client.SendMessage(QoSLevel.Unacknowledged, MessageType.Error, Id,
                To.Address, ForwardedContent, string.Empty, string.Empty, string.Empty, 
                string.Empty, string.Empty, null, null);
 
            return true;
        }
    }
}