FluentHttpRequest.cs

// This Source Code Form is subject to the terms of the MIT License.
// If a copy of the MIT was not distributed with this file, You can obtain one at https://opensource.org/licenses/MIT.
// Copyright (C) Leszek Pomianowski and Fluent Framework Contributors.
// All Rights Reserved.

using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;

namespace Fluent.Client;

/// <summary>
/// Represents a fluent HTTP request.
/// </summary>
/// <param name="client"><see cref="System.Net.Http.HttpClient"/> to use for sending the request.</param>
/// <param name="contents">Contents of the HTTP request.</param>
public sealed class FluentHttpRequest(HttpClient client, FluentHttpRequestContents? contents = null)
{
    /// <summary>
    /// Default JSON options for serialization.
    /// </summary>
    public static JsonSerializerOptions DefaultJsonOptions = new()
    {
        PropertyNameCaseInsensitive = true,
        AllowTrailingCommas = true,
        WriteIndented = true,
        IncludeFields = false,
        Converters = { new JsonStringEnumConverter() },
    };

    /// <summary>
    /// Gets the encoded parameters for the request URI.
    /// </summary>
    public Uri Uri
    {
        get
        {
            string query = Contents.Path ?? "";

            if (Contents.QueryParameters is not null && Contents.QueryParameters.Count > 0)
            {
                query +=
                    $"?{string.Join(
                    "&",
                    Contents.QueryParameters.Select(p =>
                        $"{Uri.EscapeDataString(p.Key)}={(p.Value is null ? "" : Uri.EscapeDataString(p.Value))}"
                    )
                )}";
            }

            return new Uri(query, UriKind.RelativeOrAbsolute);
        }
    }

    /// <summary>
    /// Gets the contents of the Fluent HTTP request.
    /// </summary>
    public FluentHttpRequestContents Contents
    {
        get
        {
            if (field is not null)
            {
                return field;
            }

            field = contents ?? new FluentHttpRequestContents();

            return field;
        }
    }

    /// <summary>
    /// Sends the HTTP request asynchronously.
    /// </summary>
    /// <param name="cancellationToken">The cancellation token.</param>
    /// <returns>The HTTP response message.</returns>
    public Task<HttpResponseMessage> SendAsync(CancellationToken cancellationToken = default)
    {
        HttpRequestMessage request = new()
        {
            Method = Contents.HttpMethod ?? HttpMethod.Get,
            RequestUri = Uri,
        };

        request.Headers.TryAddWithoutValidation("User-Agent", Contents.UserAgent);
        request.Headers.TryAddWithoutValidation("Accept", Contents.AcceptedContentType);
        request.Headers.TryAddWithoutValidation("Accept-Language", Contents.Culture);
        request.Headers.TryAddWithoutValidation("Lang", Contents.Culture);

        foreach (KeyValuePair<string, string> header in Contents.Headers ?? [])
        {
            request.Headers.TryAddWithoutValidation(header.Key, header.Value);
        }

        if (Contents.Body is not null)
        {
            string jsonContent = JsonSerializer.Serialize(
                Contents.Body,
                Contents.JsonOptions ?? DefaultJsonOptions
            );

#if NETFRAMEWORK
            HttpContent httpContent = new StringContent(jsonContent, Encoding.UTF8, Contents.ContentType);
#else
            HttpContent httpContent = new StringContent(
                jsonContent,
                Encoding.UTF8,
                new System.Net.Http.Headers.MediaTypeHeaderValue(Contents.ContentType)
            );
#endif

            request.Content = httpContent;
        }

        if (Contents.Timeout.HasValue)
        {
            using CancellationTokenSource cts = new(Contents.Timeout.Value);
            using CancellationTokenSource linkedCts = CancellationTokenSource.CreateLinkedTokenSource(
                cancellationToken,
                cts.Token
            );

            return client.SendAsync(request, linkedCts.Token);
        }

        return client.SendAsync(request, cancellationToken);
    }
}