垂直切片架构：以业务用例为核心的高内聚解耦

using System;
using System.Threading;
using System.Threading.Tasks;
using BitzOrcas.Application.Abstractions.Tenancy;
using BitzOrcas.Application.Authorization;
using BitzOrcas.Domain.Abstractions;
using BitzOrcas.Domain.Results;
using BitzOrcas.Endpoint.Attributes;
using BitzOrcas.Modules.Legal.Contracts;
using BitzOrcas.Modules.Legal.Domain;
using Mediator;

namespace BitzOrcas.Modules.Legal.Application.Matters;

/// <summary>
/// 提交民商事立案申请命令
/// </summary>
/// <remarks>
/// 由 Roslyn 增量生成器在编译期直接映射为 Minimal API 端点。
/// </remarks>
[GenerateEndpoint(HttpRoute.Post, "/api/legal/matters", Tag = "Matters")]
public sealed record CreateMatterIntakeCommand(
    string MatterTitle,
    string ClientName,
    string OpposingPartyName,
    decimal ClaimAmount,
    bool IsCrossBorder) : ICommand<Result<string>>, IAuthorizedRequest
{
    /// <summary>
    /// 受保护资源
    /// </summary>
    public ResourceDescriptor Resource { get; } = new("legal", "matter");

    /// <summary>
    /// 授权动作
    /// </summary>
    public AuthorizationAction Action { get; } = AuthorizationAction.Create;
}

/// <summary>
/// 案件立案前置校验规则
/// </summary>
/// <remarks>
/// 由 10 级管道中的验证中间件在进入 Handler 前自动执行。
/// </remarks>
public sealed class CreateMatterIntakeCommandRule : IRequestRule<CreateMatterIntakeCommand>
{
    public Result Validate(CreateMatterIntakeCommand command)
    {
        // 1. 标题长度校验
        if (string.IsNullOrWhiteSpace(command.MatterTitle) || command.MatterTitle.Length > 200)
        {
            return Result.Failure(LegalErrors.MatterTitleInvalid);
        }

        // 2. 诉讼标的额必须为正数
        if (command.ClaimAmount <= 0)
        {
            return Result.Failure(LegalErrors.ClaimAmountPositive);
        }

        return Result.Success();
    }
}

/// <summary>
/// 案件立案命令处理器
/// </summary>
/// <remarks>
/// 聚焦于纯粹的领域业务编排，事务与审计由 10 级管道治理。
/// </remarks>
public sealed class CreateMatterIntakeCommandHandler(
    ICommandRepository<MatterIntake, string> repository,
    ICurrentTenant currentTenant) : ICommandHandler<CreateMatterIntakeCommand, Result<string>>
{
    public async ValueTask<Result<string>> Handle(
        CreateMatterIntakeCommand request,
        CancellationToken cancellationToken)
    {
        var tenant = currentTenant.Tenant;
        if (!tenant.IsAvailable)
        {
            return Result.Failure<string>(LegalErrors.TenantRequired);
        }

        // 1. 编排业务流水号
        var matterCode = $"MAT-{DateTimeOffset.UtcNow:yyyyMMdd}-{Random.Shared.Next(10000, 99999)}";

        // 2. 调用领域聚合根工厂校验领域不变量
        var intakeResult = MatterIntake.CreateIntake(
            tenantId: tenant.EffectiveTenantId,
            matterCode: matterCode,
            matterTitle: request.MatterTitle,
            clientName: request.ClientName,
            opposingPartyName: request.OpposingPartyName,
            claimAmount: request.ClaimAmount,
            isCrossBorder: request.IsCrossBorder);

        if (intakeResult.IsFailure)
        {
            return Result.Failure<string>(intakeResult.Error);
        }

        var matter = intakeResult.GetValueOrThrow();

        // 3. 提交持久化 (事务、CAP 领域事件发布与结构化审计 Diff 均由 10 级管道接管)
        var saveResult = await repository.SaveAsync(matter, cancellationToken);
        return saveResult.IsFailure
            ? Result.Failure<string>(saveResult.Error)
            : Result.Success(matterCode);
    }
}