BinaryPdfDocumentCodec.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Runtime.Inventory;
 
namespace Waher.IoTGateway.Encoding
{
    public class BinaryPdfDocumentCodec : IContentDecoder, IContentEncoder
    {
        public const string DefaultContentType = "application/pdf";
 
        public const string DefaultFileExtension = "pdf";
 
        public static readonly string[] PdfContentTypes = new string[]
        {
            DefaultContentType
        };
 
        public static readonly string[] PdfFileExtensions = new string[]
        {
            DefaultFileExtension
        };
 
        public string[] ContentTypes => PdfContentTypes;
 
        public string[] FileExtensions => PdfFileExtensions;
 
        public bool TryGetContentType(string FileExtension, out string ContentType)
        {
            if (string.Compare(FileExtension, DefaultFileExtension, true) == 0)
            {
                ContentType = DefaultContentType;
                return true;
            }
            else
            {
                ContentType = string.Empty;
                return false;
            }
        }
 
        public bool TryGetFileExtension(string ContentType, out string FileExtension)
        {
            switch (ContentType.ToLower())
            {
                case DefaultContentType:
                    FileExtension = DefaultFileExtension;
                    return true;
 
                default:
                    FileExtension = string.Empty;
                    return false;
            }
        }
 
        public bool Decodes(string ContentType, out Grade Grade)
        {
            if (Array.IndexOf(PdfContentTypes, ContentType) >= 0)
            {
                Grade = Grade.Barely;
                return true;
            }
            else
            {
                Grade = Grade.NotAtAll;
                return false;
            }
        }
 
        public Task<ContentResponse> DecodeAsync(string ContentType, byte[] Data, System.Text.Encoding Encoding,
            KeyValuePair<string, string>[] Fields, Uri BaseUri, ICodecProgress Progress)
        {
            if (IsPdf(Data))
                return Task.FromResult(new ContentResponse(ContentType, new BinaryPdfDocument(Data), Data));
            else
                return Task.FromResult(new ContentResponse(new Exception("Not a valid PDF document.")));
        }
 
        public static bool IsPdf(byte[] Data)
        {
            if (Data is null || Data.Length < 12)
                return false;
 
            string Header = System.Text.Encoding.ASCII.GetString(Data, 0, 10);
            if (!Header.TrimStart().StartsWith("%PDF-"))
                return false;
 
            string Footer = System.Text.Encoding.ASCII.GetString(
                Data, Data.Length - 10, 10);
 
            if (!Footer.TrimEnd().EndsWith("%%EOF"))
                return false;
 
            return true;
        }
 
        public bool Encodes(object Object, out Grade Grade, params string[] AcceptedContentTypes)
        {
            if (InternetContent.IsAccepted(PdfContentTypes, AcceptedContentTypes) &&
                (Object is BinaryPdfDocument))
            {
                Grade = Grade.Ok;
                return true;
            }
            else
            {
                Grade = Grade.NotAtAll;
                return false;
            }
        }
 
        public Task<ContentResponse> EncodeAsync(object Object, System.Text.Encoding Encoding, ICodecProgress Progress,
            params string[] AcceptedContentTypes)
        {
            if (Object is BinaryPdfDocument Doc)
                return Task.FromResult(new ContentResponse(DefaultContentType, Doc, Doc.Document));
            else
                return Task.FromResult(new ContentResponse(new ArgumentException("Unable to encode as PDF document.", nameof(Object))));
        }
    }
}