SimpleRestRequest.cs

Go to the documentation of this file.

using System.Collections;
using System.Collections.ObjectModel;
using System.Diagnostics.CodeAnalysis;
using System.Net;
using System.Text;
using System.Text.Json;
using System.Text.Json.Nodes;
using System.Text.Json.Serialization;
using SimpleRest.Extensions;
 
namespace SimpleRest.Api;
 
 
public class SimpleRestRequest : ISimpleRestHttpObject
{
    public string Endpoint { get; private set; } = "";
    public object[]? Path { get; private set; }
    public Dictionary<string, object?> Query { get; private set; } = new Dictionary<string, object?>();
    public Dictionary<string, object?> Params { get; set; } = new Dictionary<string, object?>();
 
    public SimpleRestBody Body { get; private set; }
    public WebHeaderCollection Headers { get; private set; } = new WebHeaderCollection();
    public string? ContentType { get; private set; }
    public long ContentLength { get; private set; }
    public SimpleRestMethod Method { get; private set; }
    public string? UserAgent { get; private set; }
    JsonSerializerOptions m_SerializerOptions;
    private SimpleRestRequest() { }
 
 
    public object? this[string key]
    {
        get => Params[key];
    }
 
    public static SimpleRestRequest FromHttpListenerContext(
        HttpListenerContext listenerContext, JsonSerializerOptions jsonOptions,
        ISimpleRestEndpointFormatter? endpointFormatter = null
    )
    {
        HttpListenerRequest contextRequest = listenerContext.Request;
        SimpleRestRequest request = new SimpleRestRequest();
        request.m_SerializerOptions = jsonOptions;
        if (contextRequest.QueryString.Count > 0)
        {
            request.Query =
                contextRequest.QueryString.AllKeys.ToDictionary(
                    k => k ?? "",
                    k =>
                    {
                        object? value = contextRequest.QueryString[k]?.SafeDeserialize(contextRequest.QueryString[k], jsonOptions);
                        if (value is JsonElement element)
                        {
                            return element.ValueKind switch
                            {
                                JsonValueKind.Number when element.TryGetInt32(out int intValue) => intValue, // Integer
                                JsonValueKind.Number => element.GetDouble(), // Floating-point
                                JsonValueKind.String => element.GetString(), // String
                                JsonValueKind.True => true, // Boolean true
                                JsonValueKind.False => false, // Boolean false
                                JsonValueKind.Null => null, // Null
                                JsonValueKind.Object => element.Deserialize<JsonObject>(jsonOptions),
                                _ => throw new InvalidOperationException($"Unsupported JSON value: {value}"), // Handle unexpected types
                            };
                        }
                        return value;
                    }
 
                );
 
 
        }
        else
        {
            request.Query = new Dictionary<string, object?>();
        }
 
        request.Body = new SimpleRestBody(contextRequest, request.m_SerializerOptions);
        request.Headers = contextRequest
            .Headers?.AllKeys.ToDictionary(k => k, k => contextRequest.Headers[k])
            .ToWebHeaderCollection();
        request.ContentType = contextRequest.ContentType;
        request.ContentLength = contextRequest.ContentLength64;
        string pathAndQuery = contextRequest.Url?.PathAndQuery ?? "/";
        request.Endpoint =
            (pathAndQuery.Contains('?') ? pathAndQuery?.Split("?")[0] : pathAndQuery) ?? "/";
        Console.WriteLine("Endpoint:" + request.Endpoint);
 
        request.Endpoint = endpointFormatter?.GetEndpoint(request.Endpoint) ?? request.Endpoint;
        Console.WriteLine("Endpoint:" + request.Endpoint);
 
        request.Method = Enum.Parse<SimpleRestMethod>(contextRequest.HttpMethod);
        // Get the raw URL and extract the path
        string? rawUrl = contextRequest.RawUrl;
        string? path = rawUrl?.Split('?')[0]; // Exclude any query string
        string[]? pathSegments = path?.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries); // Split by slash
        request.Path = pathSegments.Length <= 0 ? new string[] { "/" } : pathSegments;
 
        return request;
    }
}
 
//TODO seperate SimpleRestRequestBody from SimpleRestRequest in a smart way
public class SimpleRestBody
{
    JsonSerializerOptions m_SerializerOptions;
    public SimpleRestBody(string contents, JsonSerializerOptions jsonOptions)
    {
        Bytes = Encoding.UTF8.GetBytes(contents);
        m_SerializerOptions = jsonOptions;
        Content = contents;
    }
 
    public SimpleRestBody(HttpListenerRequest request, JsonSerializerOptions jsonOptions)
    {
        using (var memoryStream = new MemoryStream())
        {
            request.InputStream.CopyTo(memoryStream);
            Bytes = memoryStream.ToArray();
        }
        m_SerializerOptions = jsonOptions;
 
        Content = Encoding.UTF8.GetString(Bytes);
    }
 
    public string Content { get; private set; }
 
    public byte[] Bytes { get; private set; }
 
    public T? As<T>()
    {
        return GetContent<T>();
    }
 
    public TBody? GetContent<TBody>()
    {
        return JsonSerializer.Deserialize<TBody>(Content, m_SerializerOptions);
    }
}