HtmlCodec.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using Waher.Runtime.Inventory;
 
namespace Waher.Content.Html
{
    public class HtmlCodec : IContentDecoder, IContentEncoder
    {
        public HtmlCodec()
        {
        }
 
        public const string DefaultContentType = "text/html";
 
        public static readonly string[] HtmlContentTypes = new string[]
        {
            DefaultContentType,
            "application/xhtml+xml"
        };
 
        public static readonly string[] HtmlFileExtensions = new string[]
        {
            "htm",
            "html",
            "xhtml",
            "xhtm"
        };
 
        public string[] ContentTypes => HtmlContentTypes;
 
        public string[] FileExtensions => HtmlFileExtensions;
 
        public bool Decodes(string ContentType, out Grade Grade)
        {
            if (Array.IndexOf(HtmlContentTypes, ContentType) >= 0)
            {
                Grade = Grade.Ok;
                return true;
            }
            else
            {
                Grade = Grade.NotAtAll;
                return false;
            }
        }
 
        public Task<object> DecodeAsync(string ContentType, byte[] Data, Encoding Encoding, KeyValuePair<string, string>[] Fields, Uri BaseUri)
        {
            string Html = CommonTypes.GetString(Data, Encoding);
            return Task.FromResult<object>(new HtmlDocument(Html));
        }
 
        public bool TryGetContentType(string FileExtension, out string ContentType)
        {
            switch (FileExtension.ToLower())
            {
                case "htm":
                case "html":
                    ContentType = DefaultContentType;
                    return true;
 
                case "xhtml":
                case "xhtm":
                    ContentType = "application/xhtml+xml";
                    return true;
 
                default:
                    ContentType = string.Empty;
                    return false;
            }
        }
 
        public bool TryGetFileExtension(string ContentType, out string FileExtension)
        {
            switch (ContentType.ToLower())
            {
                case DefaultContentType:
                    FileExtension = "html";
                    return true;
 
                case "application/xhtml+xml":
                    FileExtension = "xhtml";
                    return true;
 
                default:
                    FileExtension = string.Empty;
                    return false;
            }
        }
 
        public bool Encodes(object Object, out Grade Grade, params string[] AcceptedContentTypes)
        {
            if (Object is HtmlDocument || (Object is string s && s.TrimEnd().EndsWith("</html>", StringComparison.OrdinalIgnoreCase)))
            {
                if (InternetContent.IsAccepted(HtmlContentTypes, AcceptedContentTypes))
                {
                    Grade = Grade.Ok;
                    return true;
                }
            }
 
            Grade = Grade.NotAtAll;
            return false;
        }
 
        public Task<KeyValuePair<byte[], string>> EncodeAsync(object Object, Encoding Encoding, params string[] AcceptedContentTypes)
        {
            if (!InternetContent.IsAccepted(HtmlContentTypes, out string ContentType, AcceptedContentTypes))
                throw new ArgumentException("Unable to encode object, or content type not accepted.", nameof(Object));
 
            string Html = null;
            byte[] Bin;
 
            if (Object is HtmlDocument HtmlDoc)
                Html = HtmlDoc.HtmlText;
            else if (Object is string s)
                Html = s;
 
            if (Html is null)
                Bin = null;
            else
            {
                if (Encoding is null)
                {
                    ContentType += "; charset=utf-8";
                    Bin = Encoding.UTF8.GetBytes(Html);
                }
                else
                {
                    ContentType += "; charset=" + Encoding.WebName;
                    Bin = Encoding.GetBytes(Html);
                }
            }
 
            return Task.FromResult(new KeyValuePair<byte[], string>(Bin, ContentType));
        }
    }
}