RelatedCodec.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using Waher.Runtime.Collections;
using Waher.Runtime.Inventory;
 
namespace Waher.Content.Multipart
{
    public class RelatedCodec : IContentDecoder, IContentEncoder
    {
        public const string ContentType = "multipart/related";
 
        public RelatedCodec()
        {
        }
 
        public string[] ContentTypes => contentTypes;
 
        private static readonly string[] contentTypes = new string[] { ContentType };
 
        public string[] FileExtensions => new string[] { "related" };
 
        public bool Decodes(string ContentType, out Grade Grade)
        {
            if (ContentType == RelatedCodec.ContentType)
            {
                Grade = Grade.Excellent;
                return true;
            }
            else
            {
                Grade = Grade.NotAtAll;
                return false;
            }
        }
 
        public async Task<ContentResponse> DecodeAsync(string ContentType, byte[] Data, Encoding Encoding,
            KeyValuePair<string, string>[] Fields, Uri BaseUri, ICodecProgress Progress)
        {
            ChunkedList<EmbeddedContent> List = new ChunkedList<EmbeddedContent>();
 
            Exception Error = await FormDataDecoder.Decode(Data, Fields, null, List, BaseUri, Progress);
            if (!(Error is null))
                return new ContentResponse(Error);
 
            string Type = string.Empty;
 
            foreach (KeyValuePair<string, string> P in Fields)
            {
                switch (P.Key.ToUpper())
                {
                    case "TYPE":
                        Type = P.Value.Trim();
                        break;
                }
            }
 
            return new ContentResponse(ContentType, new RelatedContent(List.ToArray(), Type), Data);
        }
 
        public bool TryGetContentType(string FileExtension, out string ContentType)
        {
            if (string.Compare(FileExtension, "related", true) == 0)
            {
                ContentType = RelatedCodec.ContentType;
                return true;
            }
            else
            {
                ContentType = string.Empty;
                return false;
            }
        }
 
        public bool TryGetFileExtension(string ContentType, out string FileExtension)
        {
            switch (ContentType.ToLower())
            {
                case RelatedCodec.ContentType:
                    FileExtension = "related";
                    return true;
 
                default:
                    FileExtension = string.Empty;
                    return false;
            }
        }
 
        public bool Encodes(object Object, out Grade Grade, params string[] AcceptedContentTypes)
        {
            if (Object is RelatedContent &&
                InternetContent.IsAccepted(contentTypes, AcceptedContentTypes))
            {
                Grade = Grade.Ok;
                return true;
            }
            else
            {
                Grade = Grade.NotAtAll;
                return false;
            }
        }
 
        public async Task<ContentResponse> EncodeAsync(object Object, Encoding Encoding,
            ICodecProgress Progress, params string[] AcceptedContentTypes)
        {
            if (Object is RelatedContent Related &&
                InternetContent.IsAccepted(contentTypes, AcceptedContentTypes))
            {
                string Boundary = Guid.NewGuid().ToString();
                string ContentType = RelatedCodec.ContentType + "; boundary=\"" + Boundary + "\"; type=\"" + Related.Type.Replace("\"", "\\\"") + "\"";
                return new ContentResponse(ContentType, Object, await FormDataDecoder.Encode(Related.Content, Boundary, Progress));
            }
            else
                return new ContentResponse(new ArgumentException("Unable to encode object, or content type not accepted.", nameof(Object)));
        }
    }
}