XmlCodec.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.ExceptionServices;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Waher.Events;
using Waher.Runtime.Inventory;
using Waher.Runtime.IO;
using Waher.Script.Abstraction.Elements;
 
namespace Waher.Content.Xml.Text
{
    public class XmlCodec : IContentDecoder, IContentEncoder
    {
        public XmlCodec()
        {
        }
 
        public const string DefaultContentType = "text/xml";
 
        public const string SchemaContentType = "application/xml";
 
        public static readonly string[] XmlContentTypes = new string[]
        {
            DefaultContentType,
            SchemaContentType
        };
 
        public static readonly string[] XmlFileExtensions = new string[]
        {
            "xml",
            "xsd"
        };
 
        public string[] ContentTypes => XmlContentTypes;
 
        public string[] FileExtensions => XmlFileExtensions;
 
        public bool Decodes(string ContentType, out Grade Grade)
        {
            if (Array.IndexOf(XmlContentTypes, ContentType) >= 0)
            {
                Grade = Grade.Excellent;
                return true;
            }
            else if (ContentType.StartsWith("application/") && ContentType.EndsWith("+xml"))
            {
                Grade = Grade.Barely;
                return true;
            }
            else
            {
                Grade = Grade.NotAtAll;
                return false;
            }
        }
 
        public Task<ContentResponse> DecodeAsync(string ContentType, byte[] Data, Encoding Encoding,
            KeyValuePair<string, string>[] Fields, Uri BaseUri, ICodecProgress Progress)
        {
            XmlDocument Doc;
 
            if (Encoding is null)
            {
                Doc = new XmlDocument()
                {
                    PreserveWhitespace = true
                };
 
                using (MemoryStream ms = new MemoryStream(Data))
                {
                    XmlReaderSettings Settings = new XmlReaderSettings()
                    {
                        CheckCharacters = false,
                        ConformanceLevel = ConformanceLevel.Document,
                        DtdProcessing = DtdProcessing.Ignore,
                        IgnoreComments = true,
                        IgnoreProcessingInstructions = true,
                        IgnoreWhitespace = false
                    };
 
                    using (XmlReader xr = XmlReader.Create(ms, Settings))
                    {
                        Doc.Load(xr);
                    }
                }
            }
            else
            {
                string s = Strings.GetString(Data, Encoding);
 
                try
                {
                    Doc = XML.ParseXml(s, true);
                }
                catch (XmlException ex)
                {
                    Doc = XML.ParseXml(XML.RepairXml(s), true);
                    
                    Log.Warning("Invalid XML was received and repaired.",
                        new KeyValuePair<string, object>("BaseUri", BaseUri?.OriginalString),
                        new KeyValuePair<string, object>("Error", ex.Message));
                }
            }
 
            return Task.FromResult(new ContentResponse(ContentType, Doc, Data));
        }
 
        public bool TryGetContentType(string FileExtension, out string ContentType)
        {
            switch (FileExtension.ToLower())
            {
                case "xml":
                    ContentType = DefaultContentType;
                    return true;
 
                case "xsd":
                    ContentType = SchemaContentType;
                    return true;
 
                default:
                    ContentType = string.Empty;
                    return false;
            }
        }
 
        public bool TryGetFileExtension(string ContentType, out string FileExtension)
        {
            ContentType = ContentType.ToLower();
 
            switch (ContentType.ToLower())
            {
                case DefaultContentType:
                    FileExtension = "xml";
                    return true;
 
                case SchemaContentType:
                    FileExtension = "xsd";
                    return true;
 
                default:
                    if (ContentType.StartsWith("application/") && ContentType.EndsWith("+xml"))
                    {
                        FileExtension = ContentType.Substring(12, ContentType.Length - 4 - 12);
                        return true;
                    }
                    else
                    {
                        FileExtension = string.Empty;
                        return false;
                    }
            }
        }
 
        public bool Encodes(object Object, out Grade Grade, params string[] AcceptedContentTypes)
        {
            if ((Object is XmlDocument || Object is XmlElement || Object is NamedDictionary<string, object>) &&
                InternetContent.IsAccepted(XmlContentTypes, AcceptedContentTypes))
            {
                Grade = Grade.Ok;
                return true;
            }
 
            if ((Object is NamedDictionary<string, IElement>) &&
                InternetContent.IsAccepted(XmlContentTypes, AcceptedContentTypes))
            {
                Grade = Grade.Barely;
                return true;
            }
 
            Grade = Grade.NotAtAll;
            return false;
        }
 
        public Task<ContentResponse> EncodeAsync(object Object, Encoding Encoding, ICodecProgress Progress, params string[] AcceptedContentTypes)
        {
            if (InternetContent.IsAccepted(XmlContentTypes, out string ContentType, AcceptedContentTypes))
            {
                if (Object is XmlDocument Doc)
                    return EncodeXmlAsync(Doc, Encoding, ContentType);
                else if (Object is XmlElement E)
                {
                    Doc = new XmlDocument();
                    Doc.AppendChild(Doc.ImportNode(E, true));
                    return EncodeXmlAsync(Doc, Encoding, ContentType);
                }
                else if (Object is NamedDictionary<string, object> Obj)
                {
                    string Xml = XML.Encode(Obj);
                    return EncodeXmlAsync(Xml, Encoding, ContentType);
                }
                else if (Object is NamedDictionary<string, IElement> Obj2)
                {
                    string Xml = XML.Encode(NamedDictionary<string, object>.ToNamedDictionary(Obj2));
                    return EncodeXmlAsync(Xml, Encoding, ContentType);
                }
            }
 
            return Task.FromResult(new ContentResponse(new ArgumentException("Unable to encode object, or content type not accepted.", nameof(Object))));
        }
 
        public static Task<ContentResponse> EncodeXmlAsync(XmlDocument Xml, Encoding Encoding, string ContentType)
        {
            MemoryStream ms = null;
            XmlWriterSettings Settings;
            XmlWriter w = null;
            byte[] Result;
 
            try
            {
                ms = new MemoryStream();
                Settings = XML.WriterSettings(false, false);
 
                if (Encoding is null)
                {
                    Settings.Encoding = Encoding.UTF8;
                    ContentType += "; charset=utf-8";
                }
                else
                {
                    Settings.Encoding = Encoding;
                    ContentType += "; charset=" + Encoding.WebName;
                }
 
                w = XmlWriter.Create(ms, Settings);
 
                Xml.Save(w);
                w.Flush();
 
                Result = ms.ToArray();
            }
            finally
            {
                w?.Dispose();
                ms?.Dispose();
            }
 
            return Task.FromResult(new ContentResponse(ContentType, Xml, Result));
        }
 
        public static Task<ContentResponse> EncodeXmlAsync(string Xml, Encoding Encoding, string ContentType)
        {
            byte[] Bin;
 
            if (Encoding is null)
            {
                ContentType += "; charset=utf-8";
                Bin = Encoding.UTF8.GetBytes(Xml);
            }
            else
            {
                ContentType += "; charset=" + Encoding.WebName;
                Bin = Encoding.GetBytes(Xml);
            }
 
            return Task.FromResult(new ContentResponse(ContentType, Xml, Bin));
        }
    }
}