WebPoster.cs

using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Security.Cryptography.X509Certificates;
using System.Threading.Tasks;
using Waher.Content.Binary;
using Waher.Content.Getters;
using Waher.Runtime.Inventory;
 
namespace Waher.Content.Posters
{
    public class WebPoster : PosterBase
    {
        public WebPoster()
        {
        }
 
        public override string[] UriSchemes => new string[] { "http", "https" };
 
        public override bool CanPost(Uri Uri, out Grade Grade)
        {
            switch (Uri.Scheme.ToLower())
            {
                case "http":
                case "https":
                    Grade = Grade.Ok;
                    return true;
 
                default:
                    Grade = Grade.NotAtAll;
                    return false;
            }
        }
 
        public override async Task<KeyValuePair<byte[], string>> PostAsync(Uri Uri, byte[] EncodedData, string ContentType, 
            X509Certificate Certificate, RemoteCertificateEventHandler RemoteCertificateValidator, int TimeoutMs, 
            params KeyValuePair<string, string>[] Headers)
        {
            HttpClientHandler Handler = WebGetter.GetClientHandler(Certificate, RemoteCertificateValidator);
            using (HttpClient HttpClient = new HttpClient(Handler, true)
            {
                Timeout = TimeSpan.FromMilliseconds(TimeoutMs)
            })
            {
                using (HttpRequestMessage Request = new HttpRequestMessage()
                {
                    RequestUri = Uri,
                    Method = HttpMethod.Post, 
                    Content = new ByteArrayContent(EncodedData),
                })
                {
                    Request.Content.Headers.ContentType = MediaTypeHeaderValue.Parse(ContentType);
                    WebGetter.PrepareHeaders(Request, Headers, Handler);
 
                    HttpResponseMessage Response = await HttpClient.SendAsync(Request);
 
                    return await ProcessResponse(Response, Uri);
                }
            }
        }
 
        public static async Task<KeyValuePair<byte[], string>> ProcessResponse(HttpResponseMessage Response, Uri Uri)
        {
            if (!Response.IsSuccessStatusCode)
                await WebGetter.ProcessResponse(Response, Uri);
 
            byte[] Bin = await Response.Content.ReadAsByteArrayAsync();
            string ContentType = Response.Content.Headers.ContentType?.ToString() ?? BinaryCodec.DefaultContentType;
 
            return new KeyValuePair<byte[], string>(Bin, ContentType);
        }
 
    }
}