Restapi.cs

using System.IO;
using System.Reflection;

namespace Webtech3;

/// <summary>
/// Delegate for wrap endpoint implementation functions.
/// Functions must be async.
/// </summary>
/// <param name="req">Request data</param>
/// <param name="res">Response data</param>
/// <returns>Task obj</returns>
public delegate Task APIAction(Request req, Response res);
internal record APIEndpoint(APIInfo Info, APIAction Action);
/// <summary>
/// Class, that makes whole api on the functions set 
/// </summary>
public sealed class RestAPI {
    private static APIInfo ExtractAPIInfo(MethodInfo m)
        => m.GetCustomAttribute<APIInfo>()
        ?? throw new Exception($"Endpoint {m.Name} hasn't API info.");
    
    internal APIEndpoint? this[HTTP.Methods method, string url] {
        get => endpoints.FirstOrDefault(
            ep => ep.Info.IsMatch(url, method) 
        );
    }
    readonly List<APIEndpoint> endpoints;
    /// <summary>
    /// Construct API instance without endpoints
    /// </summary>
    public RestAPI() {
        endpoints = new();
    }
    /// <summary>
    /// Construct API instance with endpoints from static methods of given class
    /// </summary>
    /// <param name="APIimpl">Type of class, that implements api endpoints</param>
    public RestAPI(Type APIimpl) {
        endpoints = new(
            from m in APIimpl.GetMethods()
            where m.IsStatic
            select new APIEndpoint(
                ExtractAPIInfo(m), m.CreateDelegate<APIAction>()
            )
        );
    }
    /// <summary>
    /// Routes endpoint without APIinfo attr
    /// </summary>
    /// <param name="url">URL for endpoint</param>
    /// <param name="action">APIaction delegate from endpoint function</param>
    /// <param name="auth">Flag meaning need or not do auth</param>
    /// <param name="roles">Roles array for filter access to endpoint</param>
    /// <param name="methods">Array of HTTP methods for endpoint</param>
    public void Route(
        string url,
        APIAction action,
        bool auth = false,
        byte[]? roles = null,
        HTTP.Methods[]? methods = null
    ) => endpoints.Add(new(
            new APIInfo(url, auth, methods, roles),
            action
        )
    );
    /// <summary>
    /// Adding simply endpoint to API.
    /// Function must have a APIinfo attr.
    /// </summary>
    /// <param name="action">APIaction delegate instance from function</param>
    public void Add(APIAction action) => endpoints.Add(new(
            ExtractAPIInfo(action.Method),
            action
        )
    );
    /// <summary>
    /// Disable endpoint by URL and method.
    /// </summary>
    /// <param name="url">URL of endpoint</param>
    /// <param name="method">HTTP method of endpoint</param>
    public void DisableEndpoint(string url, HTTP.Methods method) {
        var ep = this[method, url];
        if (ep is not null) {
            endpoints.Remove(ep);
        }
    }
    /// <summary>
    /// Map current API to file.
    /// </summary>
    /// <param name="path">Path for output file</param>
    /// <returns>Task obj</returns>
    public async Task MapAPI(string path) {
        using var fs = new FileStream(path, FileMode.Create);
        using var writer = new StreamWriter(fs);
        foreach(var ep in endpoints)
            await writer.WriteLineAsync(
                $"""

                {ep.Action.Method.Name}:
                    URL regex pattern: {ep.Info.Url}
                    Methods: {string.Join(", ", ep.Info.Methods)}
                    Auth: {(ep.Info.Authentication ? "Required" : "Not required")}
                    Roles: {(ep.Info.Roles is null ? "Any" : string.Join(", ", ep.Info.Roles))}
                    Description: {ep.Info.Description?.Trim() ?? "No description specified"}

                """
            );
    }
    IAuthManager? auther;
    /// <summary>
    /// Property for get/set obj, implements IAuthManager
    /// </summary>
    /// <value>Instance of class, that implements IAuthManager or null</value>
    /// <exception cref="Exception">
    /// Just exception with message if you trying set auth-or null
    /// </exception>
    public IAuthManager? Authentificator {
        get => auther;
        set => auther = value ?? throw new Exception("Not allowed to set null for Authentificator.");
    }
}