3rdpartylibs/fastreports.wpf/FastReport.DesignExt/Cloud/FastReport/HttpMessages.cs

using System;
using System.Globalization;
using System.Text;
using System.Threading.Tasks;

using FastReport.Auth;
using FastReport.Cloud.FastReport.Models;
using System.Net;
using FastReport.Utils.Json.Serialization;
using System.IO;
using System.Net.Security;

namespace FastReport.Cloud.FastReport
{

    internal abstract class HttpMessages
    {
        private readonly AuthService _authService;
        internal static IdnMapping Idn { get; } = new IdnMapping();
        static HttpMessages()
        {
#if !COREWIN
            ServicePointManager.Expect100Continue = true;
            ServicePointManager.SecurityProtocol = (SecurityProtocolType)3072;
            ServicePointManager.ServerCertificateValidationCallback += (sender, certificate, chain, sslPolicyErrors) =>
            {
                return (sslPolicyErrors & SslPolicyErrors.RemoteCertificateNotAvailable) != SslPolicyErrors.RemoteCertificateNotAvailable;
            };
#endif
        }

        private void AddAuthenticationHeader(WebHeaderCollection headers)
        {
            string headerValue;
            var user = _authService.User;

            if (!string.IsNullOrEmpty(user.ApiKey))
            {
                headerValue = "Basic " + Convert.ToBase64String(Encoding.UTF8.GetBytes("apikey:" + user.ApiKey));
            }
            else if (!string.IsNullOrEmpty(user.Token))
            {
                headerValue = "Bearer " + user.Token;
            }
            else
                throw new Exception("Auth not found");

            headers.Add("Authorization", headerValue);
        }

        protected HttpWebRequest GetHttpWebRequest(string url, string method = HttpMethod.Get,
            string accept = "application/json")
        {
            var host = FRCloudOptions.Instance.BackendHost;

            var uri = new UriBuilder();
            if (host.StartsWith("http://"))
            {
                uri.Scheme = "http://";
                uri.Host = host.Substring(7).Trim('/');
            }
            else if (host.StartsWith("https://"))
            {
                uri.Scheme = "https://";
                uri.Host = host.Substring(8).Trim('/');
            }
            else
            {
                uri.Host = host.Trim('/');
            }
            uri.Host = Idn.GetAscii(uri.Host);
            var splittedUrl = url.Split('?');
            uri.Path = splittedUrl[0];
            uri.Query = splittedUrl.Length == 2 ? splittedUrl[1] : "";
#if COREWIN || MONO // .NET 4.5 or greater
            HttpWebRequest request = WebRequest.CreateHttp(uri.ToString());
#else
            HttpWebRequest request = (HttpWebRequest)WebRequest.Create((uri.ToString()));
#endif
#if DEBUG && (MONO || COREWIN) // doesn`t supported in .NET 4.0
            request.ServerCertificateValidationCallback += (sender, certificate, chain, sslPolicyErrors) => true;
#endif
            //request.Host = HOST;
            request.Method = method;
            //RequestUtils.SetProxySettings(request, ProxySettings);
            request.Accept = accept;
            request.Timeout = 5000;
            AddAuthenticationHeader(request.Headers);

            return request;
        }

        protected HttpWebRequest GetHttpWebRequestContent<TContent>(string url, TContent content,
            string method = HttpMethod.Post,
            string contentType = "application/json",
            string accept = "application/json")
        {
            HttpWebRequest request = GetHttpWebRequest(url, method, accept);

            request.ContentType = contentType;
            using (Stream requestStream = request.GetRequestStream())
            {
                byte[] bytes = JsonConverter.SerializeToBytes(content);

                requestStream.Write(bytes, 0, bytes.Length);
            }

            return request;
        }

#if ASYNC
        protected async Task<HttpWebRequest> GetHttpWebRequestContentAsync<TContent>(string url, TContent content,
            string method = HttpMethod.Post,
            string contentType = "application/json",
            string accept = "application/json")
        {
            HttpWebRequest request = GetHttpWebRequest(url, method, accept);

            request.ContentType = contentType;
            using (Stream requestStream = request.GetRequestStream())
            {
                byte[] bytes = JsonConverter.SerializeToBytes(content);

                await requestStream.WriteAsync(bytes, 0, bytes.Length);
            }

            return request;
        }
#endif


        protected static void Send(HttpWebRequest request)
        {
#if !COREWIN
            request.Timeout = 10000;
#endif
            using (var response = (HttpWebResponse)request.GetResponse())
            {
                var statusCode = response.StatusCode;
                if (statusCode == HttpStatusCode.OK
                    || statusCode == HttpStatusCode.NoContent)
                {
                    return;
                }
                else
                {
                    throw new Exception($"Status code is {statusCode}");
                }
            }

            //}
            //catch
            //{

            //}
        }


        protected static TOut Send<TOut>(HttpWebRequest request)
        {
#if !COREWIN
            request.Timeout = 10000;
#endif
            using (var response = (HttpWebResponse)request.GetResponse())
            {
                if (response.StatusCode == HttpStatusCode.OK)
                {
                    using (StreamReader reader = new StreamReader(response.GetResponseStream(), Encoding.GetEncoding(response.CharacterSet)))
                    {
                        var json = reader.ReadToEnd();
                        TOut result = JsonConverter.Deserialize<TOut>(json);
                        return result;
                    }
                }
                else
                {
                    throw new Exception($"Status code is {response.StatusCode}");
                }
            }

            //}
            //catch
            //{

            //}
        }

        protected static FileResponse DownloadFile(HttpWebRequest request)
        {
            using (var response = (HttpWebResponse)request.GetResponse())
            {
                var statusCode = response.StatusCode;
                if (statusCode == HttpStatusCode.OK)
                {
                    var ms = new MemoryStream();
                    var responseStream_ = response.GetResponseStream();
                    responseStream_.CopyTo(ms);
                    ms.Position = 0;
                    responseStream_.Dispose();

                    var fileResponse = new FileResponse((int)statusCode, ms);
                    return fileResponse;
                }
                else
                {
                    throw new Exception($"Status code is {statusCode}");
                }
            }

            //}
            //catch
            //{

            //}
        }

#if ASYNC
        protected static async Task SendAsync(HttpWebRequest request)
        {
            using (var response = (HttpWebResponse)await request.GetResponseAsync())
            {
                var statusCode = response.StatusCode;
                if (statusCode == HttpStatusCode.OK
                    || statusCode == HttpStatusCode.NoContent)
                {
                    return;
                }
                else
                {
                    throw new Exception($"Status code is {statusCode}");
                }
            }

            //}
            //catch
            //{

            //}
        }


        protected static async Task<TOut> SendAsync<TOut>(HttpWebRequest request)
        {
            using (var response = (HttpWebResponse)await request.GetResponseAsync())
            {
                if (response.StatusCode == HttpStatusCode.OK)
                {
                    using (StreamReader reader = new StreamReader(response.GetResponseStream(), Encoding.GetEncoding(response.CharacterSet)))
                    {
                        var json = await reader.ReadToEndAsync();

                        TOut result = JsonConverter.Deserialize<TOut>(json);
                        return result;
                    }
                }
                else
                {
                    throw new Exception($"Status code is {response.StatusCode}");
                }
            }

            //}
            //catch
            //{

            //}
        }

        protected static async Task<FileResponse> DownloadFileAsync(HttpWebRequest request)
        {
            using (var response = (HttpWebResponse)request.GetResponse())
            {
                var statusCode = response.StatusCode;
                if (statusCode == HttpStatusCode.OK)
                {
                    var ms = new MemoryStream();
                    var responseStream_ = response.GetResponseStream();
                    await responseStream_.CopyToAsync(ms);
                    ms.Position = 0;
                    responseStream_.Dispose();

                    var fileResponse = new FileResponse((int)statusCode, ms);
                    return fileResponse;
                }
                else
                {
                    throw new Exception($"Status code is {statusCode}");
                }
            }

            //}
            //catch
            //{

            //}
        }

#endif



        protected HttpMessages(AuthService authService)
        {
            _authService = authService;
        }
    }
}