MailClient.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content.Multipart;
using Waher.Content.Text;
using Waher.Content.Xml;
using Waher.Events;
using Waher.Networking.XMPP.Events;
 
namespace Waher.Networking.XMPP.Mail
{
    public class MailClient : XmppExtension
    {
        public const string NamespaceMail = "urn:xmpp:smtp";
 
        public MailClient(XmppClient Client)
            : base(Client)
        {
            Client.RegisterMessageHandler("mailInfo", NamespaceMail, this.MailHandler, true);
        }
 
        public override void Dispose()
        {
            this.Client.UnregisterMessageHandler("mailInfo", NamespaceMail, this.MailHandler, true);
 
            base.Dispose();
        }
 
        public override string[] Extensions => new string[] { };
 
        private Task MailHandler(object Sender, MessageEventArgs e)
        {
            string ContentType = XML.Attribute(e.Content, "contentType");
            string MessageId = XML.Attribute(e.Content, "id");
            int Priority = XML.Attribute(e.Content, "priority", 3);
            DateTimeOffset Date = XML.Attribute(e.Content, "date", DateTimeOffset.Now);
            string FromMail = XML.Attribute(e.Content, "fromMail");
            string FromHeader = XML.Attribute(e.Content, "fromHeader");
            string Sender2 = XML.Attribute(e.Content, "sender");
            int Size = XML.Attribute(e.Content, "size", 0);
            string MailObjectId = XML.Attribute(e.Content, "cid");
            List<KeyValuePair<string, string>> Headers = new List<KeyValuePair<string, string>>();
            List<EmbeddedObjectReference> Attachments = null;
            List<EmbeddedObjectReference> Inline = null;
 
            foreach (XmlNode N in e.Content.ChildNodes)
            {
                if (N is XmlElement E)
                {
                    switch (E.LocalName)
                    {
                        case "headers":
                            foreach (XmlNode N2 in E.ChildNodes)
                            {
                                switch (N2.LocalName)
                                {
                                    case "header":
                                        string Key = XML.Attribute((XmlElement)N2, "name");
                                        string Value = N2.InnerText;
 
                                        Headers.Add(new KeyValuePair<string, string>(Key, Value));
                                        break;
                                }
                            }
                            break;
 
                        case "attachment":
                        case "inline":
                            string ContentType2 = XML.Attribute(E, "contentType");
                            string Description = XML.Attribute(E, "description");
                            string FileName = XML.Attribute(E, "fileName");
                            string Name = XML.Attribute(E, "name");
                            string ContentId = XML.Attribute(E, "id");
                            string EmbeddedObjectId = XML.Attribute(E, "cid");
                            int Size2 = XML.Attribute(E, "size", 0);
 
                            EmbeddedObjectReference Ref = new EmbeddedObjectReference(ContentType2, Description, FileName, Name,
                                ContentId, EmbeddedObjectId, Size);
 
                            if (E.LocalName == "inline")
                            {
                                if (Inline is null)
                                    Inline = new List<EmbeddedObjectReference>();
 
                                Inline.Add(Ref);
                            }
                            else
                            {
                                if (Attachments is null)
                                    Attachments = new List<EmbeddedObjectReference>();
 
                                Attachments.Add(Ref);
                            }
                            break;
                    }
                }
            }
 
            string PlainText = e.Body;
            string Html = null;
            string Markdown = null;
 
            foreach (XmlNode N in e.Message.ChildNodes)
            {
                if (N is XmlElement E)
                {
                    switch (E.LocalName)
                    {
                        case "content":
                            if (E.NamespaceURI == "urn:xmpp:content")
                            {
                                switch (XML.Attribute(E, "type").ToLower())
                                {
                                    case PlainTextCodec.DefaultContentType:
                                        PlainText = E.InnerText;
                                        break;
 
                                    case "text/html":
                                        Html = E.InnerText;
                                        break;
 
                                    case "text/markdown":
                                        Markdown = E.InnerText;
                                        break;
                                }
                            }
                            break;
 
                        case "html":
                            if (E.NamespaceURI == "http://jabber.org/protocol/xhtml-im")
                            {
                                foreach (XmlNode N2 in E.ChildNodes)
                                {
                                    if (N2 is XmlElement E2 && E2.LocalName == "body")
                                    {
                                        Html = E2.OuterXml;     // InnerXml introduces xmlns attributes on all child elements.
 
                                        int i = Html.IndexOf('>');
                                        Html = Html.Substring(i + 1);
 
                                        i = Html.LastIndexOf('<');
                                        Html = Html.Substring(0, i);
                                        break;
                                    }
                                }
                            }
                            break;
                    }
                }
            }
 
            return this.MailReceived.Raise(this, new MailEventArgs(this, e, ContentType, MessageId, (Priority)Priority,
                Date, FromMail, FromHeader, Sender2, Size, MailObjectId, Headers.ToArray(), Attachments?.ToArray(),
                Inline?.ToArray(), PlainText, Html, Markdown));
        }
 
        public event EventHandlerAsync<MailEventArgs> MailReceived = null;
 
        public Task Get(string ObjectId, EventHandlerAsync<MessageObjectEventArgs> Callback, object State)
        {
            return this.Get(ObjectId, string.Empty, Callback, State);
        }
 
        public Task Get(string ObjectId, string ContentType, EventHandlerAsync<MessageObjectEventArgs> Callback, object State)
        {
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<get xmlns='");
            Xml.Append(NamespaceMail);
            Xml.Append("' cid='");
            Xml.Append(XML.Encode(ObjectId));
 
            if (!string.IsNullOrEmpty(ContentType))
            {
                Xml.Append("' type='");
                Xml.Append(XML.Encode(ContentType));
            }
 
            Xml.Append("'/>");
 
            return this.client.SendIqGet(this.client.Domain, Xml.ToString(), async (Sender, e) =>
                {
                    XmlElement E;
                    string ResponseContentType = null;
                    byte[] Data = null;
 
                    if (e.Ok && !((E = e.FirstElement) is null) && E.LocalName == "content" && E.NamespaceURI == NamespaceMail)
                    {
                        try
                        {
                            ResponseContentType = XML.Attribute(E, "type");
                            Data = Convert.FromBase64String(E.InnerText);
                        }
                        catch (Exception)
                        {
                            e.Ok = false;
                        }
                    }
                    else
                        e.Ok = false;
 
                    await Callback.Raise(this, new MessageObjectEventArgs(e, ResponseContentType, Data));
                }, State);
        }
 
        public Task<MessageObject> GetAsync(string ObjectId)
        {
            return this.GetAsync(ObjectId, string.Empty);
        }
 
        public async Task<MessageObject> GetAsync(string ObjectId, string ContentType)
        {
            TaskCompletionSource<MessageObject> Result = new TaskCompletionSource<MessageObject>();
 
            await this.Get(ObjectId, ContentType, (Sender, e) =>
            {
                if (e.Ok)
                    Result.TrySetResult(new MessageObject(e.Data, e.ContentType));
                else
                    Result.TrySetException(e.StanzaError ?? new Exception("Unable to get message object."));
 
                return Task.CompletedTask;
 
            }, null);
 
            return await Result.Task;
        }
 
        public Task Delete(string ObjectId, EventHandlerAsync<IqResultEventArgs> Callback, object State)
        {
            return this.client.SendIqSet(this.client.Domain, "<delete xmlns='" + NamespaceMail + "' cid='" + XML.Encode(ObjectId) + "'/>",
                Callback, State);
        }
 
        public async Task DeleteAsync(string ObjectId)
        {
            TaskCompletionSource<bool> Result = new TaskCompletionSource<bool>();
 
            await this.Delete(ObjectId, (Sender, e) =>
            {
                if (e.Ok)
                    Result.TrySetResult(true);
                else
                    Result.TrySetException(e.StanzaError ?? new Exception("Unable to delete message object."));
 
                return Task.CompletedTask;
 
            }, null);
 
            await Result.Task;
        }
 
        public Task AppendContent(string ContentId, string ContentType, byte[] ContentData, ContentDisposition Disposition,
            string Name, string FileName, string Description, StringBuilder Xml)
        {
            Xml.Append("<content xmlns='");
            Xml.Append(NamespaceMail);
            Xml.Append("' cid='");
            Xml.Append(XML.Encode(ContentId));
            Xml.Append("' type='");
            Xml.Append(XML.Encode(ContentType));
 
            if (Disposition != ContentDisposition.Unknown)
            {
                Xml.Append("' disposition='");
                Xml.Append(XML.Encode(Disposition.ToString()));
            }
 
            if (!string.IsNullOrEmpty(Name))
            {
                Xml.Append("' name='");
                Xml.Append(XML.Encode(Name));
            }
 
            if (!string.IsNullOrEmpty(FileName))
            {
                Xml.Append("' fileName='");
                Xml.Append(XML.Encode(FileName));
            }
 
            if (!string.IsNullOrEmpty(Description))
            {
                Xml.Append("' description='");
                Xml.Append(XML.Encode(Description));
            }
 
            Xml.Append("'>");
            Xml.Append(Convert.ToBase64String(ContentData));        // TODO: Chunked transfer
            Xml.Append("</content>");
 
            return Task.CompletedTask;
        }
 
    }
}