WwwFormCodec.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using Waher.Runtime.Inventory;
 
namespace Waher.Content.Multipart
{
    public class WwwFormCodec : IContentDecoder, IContentEncoder
    {
        public const string ContentType = "application/x-www-form-urlencoded";
 
        public WwwFormCodec()
        {
        }
 
        public string[] ContentTypes => new string[] { ContentType };
 
        public string[] FileExtensions => new string[] { "webform" };
 
        public bool Decodes(string ContentType, out Grade Grade)
        {
            if (ContentType == WwwFormCodec.ContentType)
            {
                Grade = Grade.Excellent;
                return true;
            }
            else
            {
                Grade = Grade.NotAtAll;
                return false;
            }
        }
 
        public Task<object> DecodeAsync(string ContentType, byte[] Data, Encoding Encoding, KeyValuePair<string, string>[] Fields, Uri BaseUri)
        {
            Dictionary<string, string> Form = new Dictionary<string, string>();
            Dictionary<string, List<string>> Form2 = null;
            string s = CommonTypes.GetString(Data, Encoding);
            string Key, Value;
            int i;
 
            foreach (string Parameter in s.Split('&'))
            {
                if (string.IsNullOrEmpty(Parameter))
                    continue;
 
                i = Parameter.IndexOf('=');
 
                if (i >= 0)
                {
                    Key = Uri.UnescapeDataString(Parameter.Substring(0, i).Replace("+", " "));
                    Value = Uri.UnescapeDataString(Parameter.Substring(i + 1).Replace("+", " "));
                }
                else
                {
                    Key = Parameter;
                    Value = string.Empty;
                }
 
                if (Form2 is null)
                {
                    if (Form.ContainsKey(Key))
                    {
                        Form2 = new Dictionary<string, List<string>>();
 
                        foreach (KeyValuePair<string, string> P in Form)
                            Form2[P.Key] = new List<string>() { P.Value };
                    }
                    else
                    {
                        Form[Key] = Value;
                        continue;
                    }
                }
 
                if (!Form2.TryGetValue(Key, out List<string> Values))
                {
                    Values = new List<string>();
                    Form2[Key] = Values;
                }
 
                Values.Add(Value);
            }
 
            if (Form2 is null)
                return Task.FromResult<object>(Form);
 
            Dictionary<string, string[]> Form3 = new Dictionary<string, string[]>();
 
            foreach (KeyValuePair<string, List<string>> P in Form2)
                Form3[P.Key] = P.Value.ToArray();
 
            return Task.FromResult<object>(Form3);
        }
 
        public bool TryGetContentType(string FileExtension, out string ContentType)
        {
            if (string.Compare(FileExtension, "webform", true) == 0)
            {
                ContentType = WwwFormCodec.ContentType;
                return true;
            }
            else
            {
                ContentType = string.Empty;
                return false;
            }
        }
 
        public bool TryGetFileExtension(string ContentType, out string FileExtension)
        {
            switch (ContentType.ToLower())
            {
                case WwwFormCodec.ContentType:
                    FileExtension = "webform";
                    return true;
 
                default:
                    FileExtension = string.Empty;
                    return false;
            }
        }
 
        public bool Encodes(object Object, out Grade Grade, params string[] AcceptedContentTypes)
        {
            if (Object is Dictionary<string, string> &&
                InternetContent.IsAccepted(this.ContentTypes, AcceptedContentTypes))
            {
                Grade = Grade.Ok;
                return true;
            }
            else
            {
                Grade = Grade.NotAtAll;
                return false;
            }
        }
 
        public Task<KeyValuePair<byte[], string>> EncodeAsync(object Object, Encoding Encoding, params string[] AcceptedContentTypes)
        {
            if (Object is Dictionary<string, string> Form)
            {
                StringBuilder sb = new StringBuilder();
                string ContentType;
                bool First = true;
                byte[] Bin;
 
                foreach (KeyValuePair<string, string> Pair in Form)
                {
                    if (First)
                        First = false;
                    else
                        sb.Append('&');
 
                    sb.Append(Uri.EscapeDataString(Pair.Key));
                    sb.Append('=');
                    sb.Append(Uri.EscapeDataString(Pair.Value));
                }
 
                if (Encoding is null)
                {
                    ContentType = WwwFormCodec.ContentType + "; charset=utf-8";
                    Bin = Encoding.UTF8.GetBytes(sb.ToString());
                }
                else
                {
                    ContentType = WwwFormCodec.ContentType + "; charset=" + Encoding.WebName;
                    Bin = Encoding.GetBytes(sb.ToString());
                }
 
                return Task.FromResult(new KeyValuePair<byte[], string>(Bin, ContentType));
            }
            else
                throw new ArgumentException("Unable to encode object, or content type not accepted.", nameof(Object));
        }
 
    }
}