AdminController.cs

using Exceptionless.Core;
using Exceptionless.Core.Authorization;
using Exceptionless.Core.Billing;
using Exceptionless.Core.Extensions;
using Exceptionless.Core.Messaging.Models;
using Exceptionless.Core.Models;
using Exceptionless.Core.Models.WorkItems;
using Exceptionless.Core.Queues.Models;
using Exceptionless.Core.Repositories;
using Exceptionless.Core.Repositories.Configuration;
using Exceptionless.Core.Utility;
using Exceptionless.DateTimeExtensions;
using Exceptionless.Web.Extensions;
using Foundatio.Jobs;
using Foundatio.Messaging;
using Foundatio.Queues;
using Foundatio.Repositories;
using Foundatio.Storage;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Exceptionless.Web.Controllers;

[Route(API_PREFIX + "/admin")]
[Authorize(Policy = AuthorizationRoles.GlobalAdminPolicy)]
[ApiExplorerSettings(IgnoreApi = true)]
public class AdminController : ExceptionlessApiController
{
    private readonly ExceptionlessElasticConfiguration _configuration;
    private readonly IFileStorage _fileStorage;
    private readonly IMessagePublisher _messagePublisher;
    private readonly IOrganizationRepository _organizationRepository;
    private readonly IQueue<EventPost> _eventPostQueue;
    private readonly IQueue<WorkItemData> _workItemQueue;
    private readonly AppOptions _appOptions;
    private readonly BillingManager _billingManager;
    private readonly BillingPlans _plans;

    public AdminController(
        ExceptionlessElasticConfiguration configuration,
        IFileStorage fileStorage,
        IMessagePublisher messagePublisher,
        IOrganizationRepository organizationRepository,
        IQueue<EventPost> eventPostQueue,
        IQueue<WorkItemData> workItemQueue,
        AppOptions appOptions,
        BillingManager billingManager,
        BillingPlans plans,
        TimeProvider timeProvider) : base(timeProvider)
    {
        _configuration = configuration;
        _fileStorage = fileStorage;
        _messagePublisher = messagePublisher;
        _organizationRepository = organizationRepository;
        _eventPostQueue = eventPostQueue;
        _workItemQueue = workItemQueue;
        _appOptions = appOptions;
        _billingManager = billingManager;
        _plans = plans;
    }

    [HttpGet("settings")]
    public ActionResult SettingsRequest()
    {
        return Ok(_appOptions);
    }

    [HttpGet("echo")]
    public ActionResult EchoRequest()
    {
        return Ok(new
        {
            Request.Headers,
            IpAddress = Request.GetClientIpAddress()
        });
    }

    [HttpGet("assemblies")]
    public ActionResult<IEnumerable<AssemblyDetail>> Assemblies()
    {
        var details = AssemblyDetail.ExtractAll();
        return Ok(details);
    }

    [HttpPost("change-plan")]
    public async Task<IActionResult> ChangePlanAsync(string organizationId, string planId)
    {
        if (String.IsNullOrEmpty(organizationId) || !CanAccessOrganization(organizationId))
            return Ok(new { Success = false, Message = "Invalid Organization Id." });

        var organization = await _organizationRepository.GetByIdAsync(organizationId);
        if (organization is null)
            return Ok(new { Success = false, Message = "Invalid Organization Id." });

        var plan = _billingManager.GetBillingPlan(planId);
        if (plan is null)
            return Ok(new { Success = false, Message = "Invalid PlanId." });

        organization.BillingStatus = !String.Equals(plan.Id, _plans.FreePlan.Id) ? BillingStatus.Active : BillingStatus.Trialing;
        organization.RemoveSuspension();
        _billingManager.ApplyBillingPlan(organization, plan, CurrentUser, false);

        await _organizationRepository.SaveAsync(organization, o => o.Cache().Originals());
        await _messagePublisher.PublishAsync(new PlanChanged
        {
            OrganizationId = organization.Id
        });

        return Ok(new { Success = true });
    }

    /// <summary>
    /// Applies a bonus event count to the specified organization, optionally with an expiration date.
    /// </summary>
    /// <param name="organizationId">The unique identifier of the organization to receive the bonus.</param>
    /// <param name="bonusEvents">The number of bonus events to apply.</param>
    /// <param name="expires">The optional expiration date for the bonus events.</param>
    /// <response code="200">Bonus was applied successfully.</response>
    /// <response code="422">Validation error occurred.</response>
    [HttpPost("set-bonus")]
    public async Task<IActionResult> SetBonusAsync(string organizationId, int bonusEvents, DateTime? expires = null)
    {
        if (String.IsNullOrEmpty(organizationId) || !CanAccessOrganization(organizationId))
        {
            ModelState.AddModelError(nameof(organizationId), "Invalid Organization Id");
            return ValidationProblem(ModelState);
        }

        var organization = await _organizationRepository.GetByIdAsync(organizationId);
        if (organization is null)
        {
            ModelState.AddModelError(nameof(organizationId), "Invalid Organization Id");
            return ValidationProblem(ModelState);
        }

        _billingManager.ApplyBonus(organization, bonusEvents, expires);
        await _organizationRepository.SaveAsync(organization, o => o.Cache().Originals());

        return Ok();
    }

    [HttpGet("requeue")]
    public async Task<IActionResult> RequeueAsync(string? path = null, bool archive = false)
    {
        if (String.IsNullOrEmpty(path))
            path = @"q\*";

        int enqueued = 0;
        foreach (var file in await _fileStorage.GetFileListAsync(path))
        {
            await _eventPostQueue.EnqueueAsync(new EventPost(_appOptions.EnableArchive && archive) { FilePath = file.Path });
            enqueued++;
        }

        return Ok(new { Enqueued = enqueued });
    }

    [HttpGet("maintenance/{name:minlength(1)}")]
    public async Task<IActionResult> RunJobAsync(string name, DateTime? utcStart = null, DateTime? utcEnd = null, string? organizationId = null)
    {
        if (!ModelState.IsValid)
            return ValidationProblem(ModelState);

        switch (name.ToLowerInvariant())
        {
            case "fix-stack-stats":
                var defaultUtcStart = new DateTime(2026, 2, 10, 0, 0, 0, DateTimeKind.Utc);
                var effectiveUtcStart = utcStart ?? defaultUtcStart;

                if (utcEnd.HasValue && utcEnd.Value.IsBefore(effectiveUtcStart))
                {
                    ModelState.AddModelError(nameof(utcEnd), "utcEnd must be greater than or equal to utcStart.");
                    return ValidationProblem(ModelState);
                }

                await _workItemQueue.EnqueueAsync(new FixStackStatsWorkItem
                {
                    UtcStart = effectiveUtcStart,
                    UtcEnd = utcEnd,
                    OrganizationId = organizationId
                });
                break;
            case "increment-project-configuration-version":
                await _workItemQueue.EnqueueAsync(new ProjectMaintenanceWorkItem { IncrementConfigurationVersion = true });
                break;
            case "indexes":
                if (!_appOptions.ElasticsearchOptions.DisableIndexConfiguration)
                    await _configuration.ConfigureIndexesAsync(beginReindexingOutdated: false);
                break;
            case "normalize-user-email-address":
                await _workItemQueue.EnqueueAsync(new UserMaintenanceWorkItem { Normalize = true });
                break;
            case "remove-old-organization-usage":
                await _workItemQueue.EnqueueAsync(new OrganizationMaintenanceWorkItem { RemoveOldUsageStats = true });
                break;
            case "remove-old-project-usage":
                await _workItemQueue.EnqueueAsync(new ProjectMaintenanceWorkItem { RemoveOldUsageStats = true });
                break;
            case "reset-verify-email-address-token-and-expiration":
                await _workItemQueue.EnqueueAsync(new UserMaintenanceWorkItem { ResetVerifyEmailAddressToken = true });
                break;
            case "update-organization-plans":
                await _workItemQueue.EnqueueAsync(new OrganizationMaintenanceWorkItem { UpgradePlans = true });
                break;
            case "update-project-default-bot-lists":
                await _workItemQueue.EnqueueAsync(new ProjectMaintenanceWorkItem { UpdateDefaultBotList = true, IncrementConfigurationVersion = true });
                break;
            case "update-project-notification-settings":
                await _workItemQueue.EnqueueAsync(new UpdateProjectNotificationSettingsWorkItem
                {
                    OrganizationId = organizationId
                });
                break;
            default:
                return NotFound();
        }

        return Ok();
    }
}