StackEndpoints.cs

using System.Text.Json;
using Exceptionless.Core.Authorization;
using Exceptionless.Core.Extensions;
using Exceptionless.Core.Models;
using Exceptionless.Web.Api.Filters;
using Exceptionless.Web.Api.Infrastructure;
using Exceptionless.Web.Api.Messages;
using Exceptionless.Web.Api.Results;
using Exceptionless.Web.Models;
using Foundatio.Mediator;
using HttpIResult = Microsoft.AspNetCore.Http.IResult;
using Microsoft.AspNetCore.Mvc;
using Exceptionless.Web.Utility.OpenApi;

namespace Exceptionless.Web.Api.Endpoints;

public static class StackEndpoints
{
    public static IEndpointRouteBuilder MapStackEndpoints(this IEndpointRouteBuilder endpoints)
    {
        var group = endpoints.MapGroup("api/v2")
            .AddEndpointFilter<AutoValidationEndpointFilter>()
            .WithTags("Stack");

        // GET by id
        group.MapGet("stacks/{id:objectid}", async (string id, HttpContext httpContext, IMediator mediator, IMediatorResultMapper<HttpIResult> resultMapper, string? offset = null)
            => (await mediator.InvokeAsync<Result<Stack>>(new GetStackById(id, offset, httpContext))).ToHttpResult(resultMapper))
        .WithName("GetStackById")
        .RequireAuthorization(AuthorizationRoles.StacksReadPolicy)
        .Produces<Stack>()
        .ProducesProblem(StatusCodes.Status404NotFound)
        .WithSummary("Get by id")
        .WithMetadata(new EndpointDocumentation {
            ParameterDescriptions = new() {
                ["id"] = "The identifier of the stack.",
                ["offset"] = "The time offset in minutes that controls what data is returned based on the `time` filter. This is used for time zone support.",
            },
            ResponseDescriptions = new() {
                ["404"] = "The stack could not be found.",
            }
        });

        // Mark fixed
        group.MapPost("stacks/{ids:objectids}/mark-fixed", async (string ids, HttpContext httpContext, IMediator mediator, IMediatorResultMapper<HttpIResult> resultMapper, string? version = null)
            => (await mediator.InvokeAsync<Result>(new MarkStacksFixed(ids, version, httpContext))).ToHttpResult(resultMapper))
        .RequireAuthorization(AuthorizationRoles.StacksWritePolicy)
        .Produces(StatusCodes.Status200OK)
        .ProducesProblem(StatusCodes.Status404NotFound)
        .WithSummary("Mark fixed")
        .WithMetadata(new EndpointDocumentation {
            ParameterDescriptions = new() {
                ["ids"] = "A comma-delimited list of stack identifiers.",
                ["version"] = "A version number that the stack was fixed in.",
            },
            ResponseDescriptions = new() {
                ["200"] = "The stacks were marked as fixed.",
                ["404"] = "One or more stacks could not be found.",
            }
        });

        // Mark fixed - Zapier legacy v1
        endpoints.MapPost("api/v1/stack/markfixed", async (HttpContext httpContext, IMediator mediator, IMediatorResultMapper<HttpIResult> resultMapper, [FromBody] JsonDocument data)
            => (await mediator.InvokeAsync<Result>(new MarkStacksFixedByZapier(data, httpContext))).ToHttpResult(resultMapper))
        .RequireAuthorization(AuthorizationRoles.StacksWritePolicy)
        .ExcludeFromDescription();

        // Mark fixed - Zapier v2 (no id in route)
        group.MapPost("stacks/mark-fixed", async (HttpContext httpContext, IMediator mediator, IMediatorResultMapper<HttpIResult> resultMapper, [FromBody] JsonDocument data)
            => (await mediator.InvokeAsync<Result>(new MarkStacksFixedByZapier(data, httpContext))).ToHttpResult(resultMapper))
        .RequireAuthorization(AuthorizationRoles.StacksWritePolicy)
        .ExcludeFromDescription();

        // Snooze
        group.MapPost("stacks/{ids:objectids}/mark-snoozed", async (string ids, HttpContext httpContext, IMediator mediator, IMediatorResultMapper<HttpIResult> resultMapper, DateTime? snoozeUntilUtc = null)
            => (await mediator.InvokeAsync<Result>(new SnoozeStacks(ids, snoozeUntilUtc ?? DateTime.MinValue, httpContext))).ToHttpResult(resultMapper))
        .RequireAuthorization(AuthorizationRoles.StacksWritePolicy)
        .Produces(StatusCodes.Status200OK)
        .ProducesProblem(StatusCodes.Status404NotFound)
        .WithSummary("Mark the selected stacks as snoozed")
        .WithMetadata(new EndpointDocumentation {
            ParameterDescriptions = new() {
                ["ids"] = "A comma-delimited list of stack identifiers.",
                ["snoozeUntilUtc"] = "A time that the stack should be snoozed until.",
            },
            ResponseDescriptions = new() {
                ["200"] = "The stacks were snoozed.",
                ["404"] = "One or more stacks could not be found.",
            }
        });

        // Add link
        group.MapPost("stacks/{id:objectid}/add-link", async (string id, HttpContext httpContext, IMediator mediator, IMediatorResultMapper<HttpIResult> resultMapper, [FromBody] ValueFromBody<string?> url)
            => (await mediator.InvokeAsync<Result>(new AddStackLink(id, url, httpContext))).ToHttpResult(resultMapper))
        .RequireAuthorization(AuthorizationRoles.StacksWritePolicy)
        .Accepts<ValueFromBody<string?>>("application/json", "application/*+json")
        .Produces(StatusCodes.Status200OK)
        .ProducesProblem(StatusCodes.Status400BadRequest)
        .ProducesProblem(StatusCodes.Status404NotFound)
        .WithSummary("Add reference link")
        .WithMetadata(new EndpointDocumentation {
            RequestBodyDescription = "The reference link.",
            ParameterDescriptions = new() {
                ["id"] = "The identifier of the stack.",
            },
            ResponseDescriptions = new() {
                ["400"] = "Invalid reference link.",
                ["404"] = "The stack could not be found.",
            }
        });

        // Add link - Zapier legacy v1
        endpoints.MapPost("api/v1/stack/addlink", async (HttpContext httpContext, IMediator mediator, IMediatorResultMapper<HttpIResult> resultMapper, [FromBody] JsonDocument data)
            => (await mediator.InvokeAsync<Result>(new AddStackLinkByZapier(data, httpContext))).ToHttpResult(resultMapper))
        .RequireAuthorization(AuthorizationRoles.StacksWritePolicy)
        .ExcludeFromDescription();

        // Add link - Zapier v2 (no id in route)
        group.MapPost("stacks/add-link", async (HttpContext httpContext, IMediator mediator, IMediatorResultMapper<HttpIResult> resultMapper, [FromBody] JsonDocument data)
            => (await mediator.InvokeAsync<Result>(new AddStackLinkByZapier(data, httpContext))).ToHttpResult(resultMapper))
        .RequireAuthorization(AuthorizationRoles.StacksWritePolicy)
        .ExcludeFromDescription();

        // Remove link
        group.MapPost("stacks/{id:objectid}/remove-link", async (string id, HttpContext httpContext, IMediator mediator, IMediatorResultMapper<HttpIResult> resultMapper, [FromBody] ValueFromBody<string> url)
            => (await mediator.InvokeAsync<Result>(new RemoveStackLink(id, url, httpContext))).ToHttpResult(resultMapper))
        .RequireAuthorization(AuthorizationRoles.StacksWritePolicy)
        .Accepts<ValueFromBody<string>>("application/json", "application/*+json")
        .Produces(StatusCodes.Status204NoContent)
        .ProducesProblem(StatusCodes.Status400BadRequest)
        .ProducesProblem(StatusCodes.Status404NotFound)
        .WithSummary("Remove reference link")
        .WithMetadata(new EndpointDocumentation {
            RequestBodyDescription = "The reference link.",
            ParameterDescriptions = new() {
                ["id"] = "The identifier of the stack.",
            },
            ResponseDescriptions = new() {
                ["204"] = "The reference link was removed.",
                ["400"] = "Invalid reference link.",
                ["404"] = "The stack could not be found.",
            }
        });

        // Mark critical
        group.MapPost("stacks/{ids:objectids}/mark-critical", async (string ids, HttpContext httpContext, IMediator mediator, IMediatorResultMapper<HttpIResult> resultMapper)
            => (await mediator.InvokeAsync<Result>(new MarkStacksCritical(ids, httpContext))).ToHttpResult(resultMapper))
        .RequireAuthorization(AuthorizationRoles.StacksWritePolicy)
        .Produces(StatusCodes.Status200OK)
        .ProducesProblem(StatusCodes.Status404NotFound)
        .WithSummary("Mark future occurrences as critical")
        .WithMetadata(new EndpointDocumentation {
            ParameterDescriptions = new() {
                ["ids"] = "A comma-delimited list of stack identifiers.",
            },
            ResponseDescriptions = new() {
                ["404"] = "One or more stacks could not be found.",
            }
        });

        // Mark not critical
        group.MapDelete("stacks/{ids:objectids}/mark-critical", async (string ids, HttpContext httpContext, IMediator mediator, IMediatorResultMapper<HttpIResult> resultMapper)
            => (await mediator.InvokeAsync<Result>(new MarkStacksNotCritical(ids, httpContext))).ToHttpResult(resultMapper))
        .RequireAuthorization(AuthorizationRoles.StacksWritePolicy)
        .Produces(StatusCodes.Status204NoContent)
        .ProducesProblem(StatusCodes.Status404NotFound)
        .WithSummary("Mark future occurrences as not critical")
        .WithMetadata(new EndpointDocumentation {
            ParameterDescriptions = new() {
                ["ids"] = "A comma-delimited list of stack identifiers.",
            },
            ResponseDescriptions = new() {
                ["204"] = "The stacks were marked as not critical.",
                ["404"] = "One or more stacks could not be found.",
            }
        });

        // Change status
        group.MapPost("stacks/{ids:objectids}/change-status", async (string ids, HttpContext httpContext, IMediator mediator, IMediatorResultMapper<HttpIResult> resultMapper, StackStatus? status = null)
            => (await mediator.InvokeAsync<Result>(new ChangeStacksStatus(ids, status ?? StackStatus.Open, httpContext))).ToHttpResult(resultMapper))
        .RequireAuthorization(AuthorizationRoles.StacksWritePolicy)
        .Produces(StatusCodes.Status200OK)
        .ProducesProblem(StatusCodes.Status404NotFound)
        .WithSummary("Change stack status")
        .WithMetadata(new EndpointDocumentation {
            ParameterDescriptions = new() {
                ["ids"] = "A comma-delimited list of stack identifiers.",
                ["status"] = "The status that the stack should be changed to.",
            },
            ResponseDescriptions = new() {
                ["404"] = "One or more stacks could not be found.",
            }
        });

        // Promote
        group.MapPost("stacks/{id:objectid}/promote", async (string id, HttpContext httpContext, IMediator mediator, IMediatorResultMapper<HttpIResult> resultMapper)
            => (await mediator.InvokeAsync<Result>(new PromoteStack(id, httpContext))).ToHttpResult(resultMapper))
        .RequireAuthorization(AuthorizationRoles.UserPolicy)
        .Produces(StatusCodes.Status200OK)
        .ProducesProblem(StatusCodes.Status404NotFound)
        .ProducesProblem(StatusCodes.Status426UpgradeRequired)
        .Produces(StatusCodes.Status501NotImplemented)
        .WithSummary("Promote to external service")
        .WithMetadata(new EndpointDocumentation {
            ParameterDescriptions = new() {
                ["id"] = "The identifier of the stack.",
            },
            ResponseDescriptions = new() {
                ["404"] = "The stack could not be found.",
                ["426"] = "Promote to External is a premium feature used to promote an error stack to an external system.",
                ["501"] = "No promoted web hooks are configured for this project.",
            }
        });

        // Delete
        group.MapDelete("stacks/{ids:objectids}", async (string ids, HttpContext httpContext, IMediator mediator, IMediatorResultMapper<HttpIResult> resultMapper)
            => (await mediator.InvokeAsync<Result<WorkInProgressResult>>(new DeleteStacks(ids, httpContext))).ToHttpResult(resultMapper))
        .RequireAuthorization(AuthorizationRoles.UserPolicy)
        .Produces<WorkInProgressResult>(StatusCodes.Status202Accepted)
        .ProducesProblem(StatusCodes.Status400BadRequest)
        .ProducesProblem(StatusCodes.Status404NotFound)
        .ProducesProblem(StatusCodes.Status500InternalServerError)
        .WithSummary("Remove")
        .WithMetadata(new EndpointDocumentation {
            ParameterDescriptions = new() {
                ["ids"] = "A comma-delimited list of stack identifiers.",
            },
            ResponseDescriptions = new() {
                ["202"] = "Accepted",
                ["400"] = "One or more validation errors occurred.",
                ["404"] = "One or more stacks were not found.",
                ["500"] = "An error occurred while deleting one or more stacks.",
            }
        });

        // Get all
        group.MapGet("stacks", async (HttpContext httpContext, IMediator mediator, IMediatorResultMapper<HttpIResult> resultMapper, string? filter = null, string? sort = null, string? time = null, string? offset = null, string? mode = null, int page = 1, int limit = 10)
            => (await mediator.InvokeAsync<Result<PagedResult<object>>>(new GetAllStacks(filter, sort, time, offset, mode, page, limit, httpContext))).ToHttpResult(resultMapper))
        .RequireAuthorization(AuthorizationRoles.StacksReadPolicy)
        .Produces<IReadOnlyCollection<Stack>>()
        .ProducesProblem(StatusCodes.Status400BadRequest)
        .ProducesProblem(StatusCodes.Status426UpgradeRequired)
        .WithSummary("Get all")
        .WithMetadata(new EndpointDocumentation {
            ParameterDescriptions = new() {
                ["filter"] = "A filter that controls what data is returned from the server.",
                ["sort"] = "Controls the sort order that the data is returned in. In this example -date returns the results descending by date.",
                ["time"] = "The time filter that limits the data being returned to a specific date range.",
                ["offset"] = "The time offset in minutes that controls what data is returned based on the time filter. This is used for time zone support.",
                ["mode"] = "If no mode is set then the whole stack object will be returned. If the mode is set to summary than a lightweight object will be returned.",
                ["page"] = "The page parameter is used for pagination. This value must be greater than 0.",
                ["limit"] = "A limit on the number of objects to be returned. Limit can range between 1 and 100 items.",
            },
            ResponseDescriptions = new() {
                ["400"] = "Invalid filter.",
                ["426"] = ApiFilterPolicy.PremiumSearchUpgradeMessage,
            }
        });

        // Get by organization
        group.MapGet("organizations/{organizationId:objectid}/stacks", async (string organizationId, HttpContext httpContext, IMediator mediator, IMediatorResultMapper<HttpIResult> resultMapper, string? filter = null, string? sort = null, string? time = null, string? offset = null, string? mode = null, int page = 1, int limit = 10)
            => (await mediator.InvokeAsync<Result<PagedResult<object>>>(new GetStacksByOrganization(organizationId, filter, sort, time, offset, mode, page, limit, httpContext))).ToHttpResult(resultMapper))
        .RequireAuthorization(AuthorizationRoles.StacksReadPolicy)
        .Produces<IReadOnlyCollection<Stack>>()
        .ProducesProblem(StatusCodes.Status400BadRequest)
        .ProducesProblem(StatusCodes.Status404NotFound)
        .ProducesProblem(StatusCodes.Status426UpgradeRequired)
        .WithSummary("Get by organization")
        .WithMetadata(new EndpointDocumentation {
            ParameterDescriptions = new() {
                ["organizationId"] = "The identifier of the organization.",
                ["filter"] = "A filter that controls what data is returned from the server.",
                ["sort"] = "Controls the sort order that the data is returned in. In this example -date returns the results descending by date.",
                ["time"] = "The time filter that limits the data being returned to a specific date range.",
                ["offset"] = "The time offset in minutes that controls what data is returned based on the time filter. This is used for time zone support.",
                ["mode"] = "If no mode is set then the whole stack object will be returned. If the mode is set to summary than a lightweight object will be returned.",
                ["page"] = "The page parameter is used for pagination. This value must be greater than 0.",
                ["limit"] = "A limit on the number of objects to be returned. Limit can range between 1 and 100 items.",
            },
            ResponseDescriptions = new() {
                ["400"] = "Invalid filter.",
                ["404"] = "The organization could not be found.",
                ["426"] = ApiFilterPolicy.SuspendedOrPremiumSearchUpgradeDescription,
            }
        });

        // Get by project
        group.MapGet("projects/{projectId:objectid}/stacks", async (string projectId, HttpContext httpContext, IMediator mediator, IMediatorResultMapper<HttpIResult> resultMapper, string? filter = null, string? sort = null, string? time = null, string? offset = null, string? mode = null, int page = 1, int limit = 10)
            => (await mediator.InvokeAsync<Result<PagedResult<object>>>(new GetStacksByProject(projectId, filter, sort, time, offset, mode, page, limit, httpContext))).ToHttpResult(resultMapper))
        .RequireAuthorization(AuthorizationRoles.StacksReadPolicy)
        .Produces<IReadOnlyCollection<Stack>>()
        .ProducesProblem(StatusCodes.Status400BadRequest)
        .ProducesProblem(StatusCodes.Status404NotFound)
        .ProducesProblem(StatusCodes.Status426UpgradeRequired)
        .WithSummary("Get by project")
        .WithMetadata(new EndpointDocumentation {
            ParameterDescriptions = new() {
                ["projectId"] = "The identifier of the project.",
                ["filter"] = "A filter that controls what data is returned from the server.",
                ["sort"] = "Controls the sort order that the data is returned in. In this example -date returns the results descending by date.",
                ["time"] = "The time filter that limits the data being returned to a specific date range.",
                ["offset"] = "The time offset in minutes that controls what data is returned based on the time filter. This is used for time zone support.",
                ["mode"] = "If no mode is set then the whole stack object will be returned. If the mode is set to summary than a lightweight object will be returned.",
                ["page"] = "The page parameter is used for pagination. This value must be greater than 0.",
                ["limit"] = "A limit on the number of objects to be returned. Limit can range between 1 and 100 items.",
            },
            ResponseDescriptions = new() {
                ["400"] = "Invalid filter.",
                ["404"] = "The organization could not be found.",
                ["426"] = ApiFilterPolicy.SuspendedOrPremiumSearchUpgradeDescription,
            }
        });

        return endpoints;
    }
}