[PM-36951] Add Billing Plan Migration Cohorts Admin UI

src/Admin/Billing/Controllers/OrganizationPlanMigrationCohortsController.cs

@@ -0,0 +1,274 @@
+using System.ComponentModel.DataAnnotations;
+using Bit.Admin.Billing.Models.OrganizationPlanMigrationCohorts;
+using Bit.Admin.Enums;
+using Bit.Admin.Utilities;
+using Bit.Core;
+using Bit.Core.Billing.Organizations.PlanMigration.Entities;
+using Bit.Core.Billing.Organizations.PlanMigration.Queries;
+using Bit.Core.Billing.Organizations.PlanMigration.Repositories;
+using Bit.Core.Billing.Services;
+using Bit.Core.Services;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Stripe;
+
+// ReSharper disable InconsistentNaming
+namespace Bit.Admin.Billing.Controllers;
+
+[Authorize]
+[Route("migration-cohorts")]
+public class OrganizationPlanMigrationCohortsController(
+    IOrganizationPlanMigrationCohortRepository cohortRepository,
+    IStripeAdapter stripeAdapter,
+    ILogger<OrganizationPlanMigrationCohortsController> logger,
+    IFeatureService featureService,
+    IGetCohortAssignmentStateQuery getCohortAssignmentStateQuery) : Controller
+{
+    private const int _defaultPageSize = 25;
+
+    private bool PlanMigrationCohortsFeatureEnabled() =>
+        featureService.IsEnabled(FeatureFlagKeys.PM35215_BusinessPlanPriceMigration);
+
+    [HttpGet("")]
+    [RequirePermission(Permission.Tools_ManagePlanMigrationCohorts)]
+    public async Task<IActionResult> Index(string? name = null, int page = 1, int count = _defaultPageSize)
+    {
+        if (!PlanMigrationCohortsFeatureEnabled()) return NotFound();
+
+        if (page < 1) page = 1;
+        if (count < 1) count = 1;
+        var skip = (page - 1) * count;
+
+        var items = await cohortRepository.SearchWithCountsAsync(name, skip, count);
+
+        return View(new CohortsPagedModel
+        {
+            NameSearch = name,
+            Items = items.Select(CohortListItemViewModel.From).ToList(),
+            Page = page,
+            Count = count,
+        });
+    }
+
+    [HttpGet("create")]
+    [RequirePermission(Permission.Tools_ManagePlanMigrationCohorts)]
+    public IActionResult Create()
+    {
+        if (!PlanMigrationCohortsFeatureEnabled()) return NotFound();
+
+        return View(new CohortFormModel());
+    }
+
+    [HttpPost("create")]
+    [ValidateAntiForgeryToken]
+    [RequirePermission(Permission.Tools_ManagePlanMigrationCohorts)]
+    public async Task<IActionResult> Create(CohortFormModel model)
+    {
+        if (!PlanMigrationCohortsFeatureEnabled()) return NotFound();
+
+        MergeCrossFieldValidationErrors(model);
+
+        if (!ModelState.IsValid)
+        {
+            return View(model);
+        }
+
+        try
+        {
+            if (!await ValidateNameAsync(model.Name) || !await ValidateCouponsAsync(model))
+            {
+                return View(model);
+            }
+
+            var cohort = new OrganizationPlanMigrationCohort
+            {
+                Name = model.Name,
+                MigrationPathId = model.GetMigrationPathId(),
+                ProactiveDiscountCouponCode = NormalizeCouponCode(model.ProactiveDiscountCouponCode),
+                ChurnDiscountCouponCode = NormalizeCouponCode(model.ChurnDiscountCouponCode),
+            };
+
+            await cohortRepository.CreateAsync(cohort);
+
+            TempData["Success"] = $"Cohort '{cohort.Name}' created.";
+            return RedirectToAction(nameof(Index));
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Error creating cohort. Name: {Name}", model.Name);
+            ModelState.AddModelError(string.Empty, "An error occurred while saving the cohort.");
+            return View(model);
+        }
+    }
+
+    [HttpGet("{id:guid}")]
+    [RequirePermission(Permission.Tools_ManagePlanMigrationCohorts)]
+    public async Task<IActionResult> Edit(Guid id)
+    {
+        if (!PlanMigrationCohortsFeatureEnabled()) return NotFound();
+
+        var cohort = await cohortRepository.GetByIdAsync(id);
+        if (cohort == null) return NotFound();
+
+        var assignmentState = await getCohortAssignmentStateQuery.Run(cohort);
+        return View(EditCohortViewModel.From(cohort, CohortFormModel.From(cohort), assignmentState));
+    }
+
+    [HttpPost("{id:guid}")]
+    [ValidateAntiForgeryToken]
+    [RequirePermission(Permission.Tools_ManagePlanMigrationCohorts)]
+    public async Task<IActionResult> Edit(Guid id, CohortFormModel model)
+    {
+        if (!PlanMigrationCohortsFeatureEnabled()) return NotFound();
+
+        model.Id = id;
+
+        var cohort = await cohortRepository.GetByIdAsync(id);
+        if (cohort == null) return NotFound();
+
+        var assignmentState = await getCohortAssignmentStateQuery.Run(cohort);
+
+        if (assignmentState.HasNonPendingAssignments)
+        {
+            // The locked migration path view doesn't post a value for MigrationPathSelection.
+            // Restore from the persisted cohort so [Required] passes and the eventual
+            // ReplaceAsync writes back the unchanged path.
+            model.MigrationPathSelection = cohort.MigrationPathId switch
+            {
+                null => CohortFormModel.NoMigrationPath,
+                var pathId => ((byte)pathId).ToString(),
+            };
+        }
+
+        MergeCrossFieldValidationErrors(model);
+
+        if (!ModelState.IsValid)
+        {
+            return View(EditCohortViewModel.From(cohort, model, assignmentState));
+        }
+
+        try
+        {
+            if (!await ValidateNameAsync(model.Name, id)
+                || !await ValidateCouponsAsync(model))
+            {
+                return View(EditCohortViewModel.From(cohort, model, assignmentState));
+            }
+
+            cohort.Name = model.Name;
+            cohort.MigrationPathId = model.GetMigrationPathId();
+            cohort.ProactiveDiscountCouponCode = NormalizeCouponCode(model.ProactiveDiscountCouponCode);
+            cohort.ChurnDiscountCouponCode = NormalizeCouponCode(model.ChurnDiscountCouponCode);
+            cohort.IsActive = model.IsActive;
+            cohort.RevisionDate = DateTime.UtcNow;
+
+            await cohortRepository.ReplaceAsync(cohort);
+
+            TempData["Success"] = $"Cohort '{cohort.Name}' updated.";
+            return RedirectToAction(nameof(Index));
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Error updating cohort. Id: {Id}", id);
+            ModelState.AddModelError(string.Empty, "An error occurred while saving the cohort.");
+            return View(EditCohortViewModel.From(cohort, model, assignmentState));
+        }
+    }
+
+    [HttpPost("{id:guid}/delete")]
+    [ValidateAntiForgeryToken]
+    [RequirePermission(Permission.Tools_ManagePlanMigrationCohorts)]
+    public async Task<IActionResult> Delete(Guid id)
+    {
+        if (!PlanMigrationCohortsFeatureEnabled()) return NotFound();
+
+        var cohort = await cohortRepository.GetByIdAsync(id);
+        if (cohort == null) return NotFound();
+
+        try
+        {
+            var assignmentState = await getCohortAssignmentStateQuery.Run(cohort);
+            if (assignmentState.HasNonPendingAssignments)
+            {
+                TempData["Error"] =
+                    $"Cannot delete cohort '{cohort.Name}' because {assignmentState.NonPendingAssignmentCount:N0} " +
+                    "assignment(s) have left the Pending state. Historical migration and " +
+                    "save-offer records are preserved.";
+                return RedirectToAction(nameof(Edit), new { id });
+            }
+
+            await cohortRepository.DeleteAsync(cohort);
+
+            TempData["Success"] = $"Cohort '{cohort.Name}' deleted.";
+            return RedirectToAction(nameof(Index));
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Error deleting cohort. Id: {Id}", id);
+            TempData["Error"] = "An error occurred while attempting to delete the cohort.";
+            return RedirectToAction(nameof(Edit), new { id });
+        }
+    }
+
+    private static string? NormalizeCouponCode(string? value) =>
+        string.IsNullOrWhiteSpace(value) ? null : value.Trim();
+
+    // MVC skips IValidatableObject.Validate when any property-level attribute already failed, hiding cross-field
+    // rules until the operator resubmits. Run it explicitly so every error surfaces on a single submit.
+    // See https://github.com/dotnet/aspnetcore/issues/1899.
+    private void MergeCrossFieldValidationErrors(CohortFormModel model)
+    {
+        foreach (var result in model.Validate(new ValidationContext(model)))
+        {
+            foreach (var memberName in result.MemberNames.DefaultIfEmpty(string.Empty))
+            {
+                ModelState.AddModelError(memberName, result.ErrorMessage ?? string.Empty);
+            }
+        }
+    }
+
+    private async Task<bool> ValidateNameAsync(string name, Guid? excludeId = null)
+    {
+        var existing = await cohortRepository.GetByNameAsync(name);
+        if (existing == null || existing.Id == excludeId)
+        {
+            return true;
+        }
+
+        ModelState.AddModelError(nameof(CohortFormModel.Name), "A cohort with this name already exists.");
+        return false;
+    }
+
+    private async Task<bool> ValidateCouponsAsync(CohortFormModel model)
+    {
+        var proactive = NormalizeCouponCode(model.ProactiveDiscountCouponCode);
+        var churn = NormalizeCouponCode(model.ChurnDiscountCouponCode);
+
+        var ok = !(proactive != null && !await TryValidateCouponAsync(proactive, nameof(model.ProactiveDiscountCouponCode)));
+        if (churn != null && !await TryValidateCouponAsync(churn, nameof(model.ChurnDiscountCouponCode)))
+        {
+            ok = false;
+        }
+        return ok;
+    }
+
+    private async Task<bool> TryValidateCouponAsync(string couponId, string fieldName)
+    {
+        try
+        {
+            await stripeAdapter.GetCouponAsync(couponId);
+            return true;
+        }
+        catch (StripeException ex)
+        {
+            var message = ex.StripeError?.Code == "resource_missing"
+                ? "Coupon not found in Stripe. Please verify the coupon ID."
+                : "An error occurred while fetching the coupon from Stripe.";
+
+            logger.LogError(ex, "Stripe coupon error: {CouponId}", couponId);
+            ModelState.AddModelError(fieldName, message);
+            return false;
+        }
+    }
+
+}

src/Admin/Billing/Models/OrganizationPlanMigrationCohorts/CohortFormModel.cs

@@ -0,0 +1,84 @@
+using System.ComponentModel.DataAnnotations;
+using Bit.Core.Billing.Organizations.PlanMigration.Entities;
+using Bit.Core.Billing.Organizations.PlanMigration.Enums;
+
+namespace Bit.Admin.Billing.Models.OrganizationPlanMigrationCohorts;
+
+public class CohortFormModel : IValidatableObject
+{
+    public const string NoMigrationPath = "none";
+
+    public Guid? Id { get; set; }
+
+    [Required]
+    [MaxLength(255)]
+    [Display(Name = "Name")]
+    public string Name { get; set; } = string.Empty;
+
+    [Required(ErrorMessage = "Please select a migration path or None.")]
+    [Display(Name = "Migration path")]
+    public string MigrationPathSelection { get; set; } = string.Empty;
+
+    [MaxLength(64)]
+    [Display(Name = "Proactive discount coupon")]
+    public string? ProactiveDiscountCouponCode { get; set; }
+
+    [MaxLength(64)]
+    [Display(Name = "Churn discount coupon")]
+    public string? ChurnDiscountCouponCode { get; set; }
+
+    [Display(Name = "Active")]
+    public bool IsActive { get; set; }
+
+    public MigrationPathId? GetMigrationPathId()
+    {
+        if (MigrationPathSelection == NoMigrationPath)
+        {
+            return null;
+        }
+
+        if (byte.TryParse(MigrationPathSelection, out var id))
+        {
+            return (MigrationPathId)id;
+        }
+
+        throw new InvalidOperationException(
+            $"MigrationPathSelection '{MigrationPathSelection}' cannot be converted to MigrationPathId.");
+    }
+
+    public bool IsChurnOnly => MigrationPathSelection == NoMigrationPath;
+
+    public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
+    {
+        if (MigrationPathSelection != NoMigrationPath)
+            yield break;
+
+        if (!string.IsNullOrEmpty(ProactiveDiscountCouponCode))
+        {
+            yield return new ValidationResult(
+                "Churn-only cohorts cannot have a proactive discount coupon.",
+                [nameof(ProactiveDiscountCouponCode)]);
+        }
+
+        if (string.IsNullOrEmpty(ChurnDiscountCouponCode))
+        {
+            yield return new ValidationResult(
+                "Churn discount coupon is required for Churn-only cohorts.",
+                [nameof(ChurnDiscountCouponCode)]);
+        }
+    }
+
+    public static CohortFormModel From(OrganizationPlanMigrationCohort cohort) => new()
+    {
+        Id = cohort.Id,
+        Name = cohort.Name,
+        MigrationPathSelection = cohort.MigrationPathId switch
+        {
+            null => NoMigrationPath,
+            var id => ((byte)id).ToString(),
+        },
+        ProactiveDiscountCouponCode = cohort.ProactiveDiscountCouponCode,
+        ChurnDiscountCouponCode = cohort.ChurnDiscountCouponCode,
+        IsActive = cohort.IsActive,
+    };
+}

src/Admin/Billing/Models/OrganizationPlanMigrationCohorts/CohortListItemViewModel.cs

@@ -0,0 +1,31 @@
+using Bit.Core.Billing.Organizations.PlanMigration.Models;
+using Bit.Core.Billing.Organizations.PlanMigration.ValueObjects;
+
+namespace Bit.Admin.Billing.Models.OrganizationPlanMigrationCohorts;
+
+public class CohortListItemViewModel
+{
+    public Guid Id { get; set; }
+    public string Name { get; set; } = string.Empty;
+    public CohortType CohortType { get; set; } = new CohortType.ChurnOnly();
+    public bool IsChurnOnly => CohortType is CohortType.ChurnOnly;
+    public bool IsActive { get; set; }
+    public string? ProactiveDiscountCouponCode { get; set; }
+    public string? ChurnDiscountCouponCode { get; set; }
+    public int Pending { get; set; }
+    public int Scheduled { get; set; }
+    public int Migrated { get; set; }
+
+    public static CohortListItemViewModel From(CohortListItem item) => new()
+    {
+        Id = item.Cohort.Id,
+        Name = item.Cohort.Name,
+        CohortType = CohortType.From(item.Cohort.MigrationPathId),
+        IsActive = item.Cohort.IsActive,
+        ProactiveDiscountCouponCode = item.Cohort.ProactiveDiscountCouponCode,
+        ChurnDiscountCouponCode = item.Cohort.ChurnDiscountCouponCode,
+        Pending = item.Pending,
+        Scheduled = item.Scheduled,
+        Migrated = item.Migrated,
+    };
+}