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<ContentBinaryResponse> PostAsync(Uri Uri, byte[] EncodedData, string ContentType, 
            X509Certificate Certificate, EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator, int TimeoutMs, 
            params KeyValuePair<string, string>[] Headers)
        {
            HttpClientHandler Handler = WebGetter.GetClientHandler(Certificate, RemoteCertificateValidator, Uri);
            using (HttpClient HttpClient = new HttpClient(Handler, true)
            {
                Timeout = TimeSpan.FromMilliseconds(TimeoutMs)
            })
            {
                using (HttpRequestMessage Request = new HttpRequestMessage()
                {
                    Method = HttpMethod.Post,
                })
                {
                    if (EncodedData?.Length > 0 || !string.IsNullOrEmpty(ContentType))
                        Request.Content = new ByteArrayContent(EncodedData);
 
                    Request.RequestUri = WebGetter.CheckUri(Uri, Request);
 
                    if (!string.IsNullOrEmpty(ContentType))
                        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<ContentBinaryResponse> ProcessResponse(HttpResponseMessage Response, Uri Uri)
        {
            if (!Response.IsSuccessStatusCode)
            {
                ContentResponse Temp = await WebGetter.ProcessResponse(Response, Uri);
                return new ContentBinaryResponse(Temp.Error);
            }
 
            byte[] Bin = await Response.Content.ReadAsByteArrayAsync();
 
            string ContentType = Response.Content.Headers.ContentType?.ToString() 
                ?? (Bin.Length == 0 ? string.Empty : BinaryCodec.DefaultContentType);
 
            return new ContentBinaryResponse(ContentType, Bin);
        }
 
    }
}