tiku-backend.net/Tiku.Api/Controllers/CatalogController.cs

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Tiku.Api.Contracts;
using Tiku.Application.Catalog;
using Tiku.Application.Content;
using Tiku.Application.Security;
using Tiku.Domain.Tenancy;
using Tiku.Infrastructure.Persistence;

namespace Tiku.Api.Controllers;

[ApiController]
[AllowAnonymous]
[Produces("application/json")]
[Route("api/catalog")]
public sealed class CatalogController(
    ICatalogQueryService catalogQueryService,
    IContentNavigationQueryService contentNavigationQueryService,
    ICurrentTenant currentTenant,
    TikuDbContext dbContext) : ControllerBase
{
    [HttpGet("regions")]
    [EndpointSummary("查询可用地区")]
    [ProducesResponseType<CatalogList<RegionCatalogItem>>(StatusCodes.Status200OK)]
    [ProducesResponseType<ProblemDetails>(StatusCodes.Status404NotFound)]
    public async Task<ActionResult<CatalogList<RegionCatalogItem>>> GetRegions(
        [FromQuery] CatalogQueryDto query,
        CancellationToken cancellationToken)
    {
        return Ok(await catalogQueryService.GetRegionsAsync(
            query.ToFilter(await ResolveTenantIdAsync(query, cancellationToken)),
            cancellationToken));
    }

    [HttpGet("region-modules")]
    [EndpointSummary("查询地区功能模块")]
    [ProducesResponseType<CatalogList<RegionModuleCatalogItem>>(StatusCodes.Status200OK)]
    [ProducesResponseType<ProblemDetails>(StatusCodes.Status404NotFound)]
    public async Task<ActionResult<CatalogList<RegionModuleCatalogItem>>> GetRegionModules(
        [FromQuery] CatalogQueryDto query,
        CancellationToken cancellationToken)
    {
        return Ok(await catalogQueryService.GetRegionModulesAsync(
            query.ToFilter(await ResolveTenantIdAsync(query, cancellationToken)),
            cancellationToken));
    }

    [HttpGet("module-nodes")]
    [EndpointSummary("查询模块导航节点")]
    [ProducesResponseType<CatalogList<ModuleNodeCatalogItem>>(StatusCodes.Status200OK)]
    [ProducesResponseType<ProblemDetails>(StatusCodes.Status404NotFound)]
    public async Task<ActionResult<CatalogList<ModuleNodeCatalogItem>>> GetModuleNodes(
        [FromQuery] CatalogQueryDto query,
        CancellationToken cancellationToken)
    {
        return Ok(await catalogQueryService.GetModuleNodesAsync(
            query.ToFilter(await ResolveTenantIdAsync(query, cancellationToken)),
            cancellationToken));
    }

    [HttpGet("schools")]
    [EndpointSummary("查询院校目录")]
    [ProducesResponseType<CatalogList<SchoolCatalogItem>>(StatusCodes.Status200OK)]
    [ProducesResponseType<ProblemDetails>(StatusCodes.Status404NotFound)]
    public async Task<ActionResult<CatalogList<SchoolCatalogItem>>> GetSchools(
        [FromQuery] CatalogQueryDto query,
        CancellationToken cancellationToken)
    {
        return Ok(await catalogQueryService.GetSchoolsAsync(
            query.ToFilter(await ResolveTenantIdAsync(query, cancellationToken)),
            cancellationToken));
    }

    [HttpGet("majors")]
    [EndpointSummary("查询专业目录")]
    [ProducesResponseType<CatalogList<MajorCatalogItem>>(StatusCodes.Status200OK)]
    [ProducesResponseType<ProblemDetails>(StatusCodes.Status404NotFound)]
    public async Task<ActionResult<CatalogList<MajorCatalogItem>>> GetMajors(
        [FromQuery] CatalogQueryDto query,
        CancellationToken cancellationToken)
    {
        return Ok(await catalogQueryService.GetMajorsAsync(
            query.ToFilter(await ResolveTenantIdAsync(query, cancellationToken)),
            cancellationToken));
    }

    [HttpGet("subjects")]
    [EndpointSummary("查询科目目录")]
    [ProducesResponseType<CatalogList<SubjectCatalogItem>>(StatusCodes.Status200OK)]
    [ProducesResponseType<ProblemDetails>(StatusCodes.Status404NotFound)]
    public async Task<ActionResult<CatalogList<SubjectCatalogItem>>> GetSubjects(
        [FromQuery] CatalogQueryDto query,
        CancellationToken cancellationToken)
    {
        return Ok(await catalogQueryService.GetSubjectsAsync(
            query.ToFilter(await ResolveTenantIdAsync(query, cancellationToken)),
            cancellationToken));
    }

    [HttpGet("categories")]
    [HttpGet("question-categories")]
    [EndpointSummary("查询题目分类")]
    [ProducesResponseType<CatalogList<CategoryCatalogItem>>(StatusCodes.Status200OK)]
    [ProducesResponseType<ProblemDetails>(StatusCodes.Status404NotFound)]
    public async Task<ActionResult<CatalogList<CategoryCatalogItem>>> GetCategories(
        [FromQuery] CatalogQueryDto query,
        CancellationToken cancellationToken)
    {
        return Ok(await catalogQueryService.GetCategoriesAsync(
            query.ToFilter(await ResolveTenantIdAsync(query, cancellationToken)),
            cancellationToken));
    }

    [HttpGet("content-entries")]
    [EndpointSummary("查询内容入口")]
    [ProducesResponseType<CatalogList<ContentEntryCatalogItem>>(StatusCodes.Status200OK)]
    [ProducesResponseType<ProblemDetails>(StatusCodes.Status404NotFound)]
    public async Task<ActionResult<CatalogList<ContentEntryCatalogItem>>> GetContentEntries(
        [FromQuery] ContentNavigationQueryDto query,
        CancellationToken cancellationToken)
    {
        return Ok(await contentNavigationQueryService.GetContentEntriesAsync(
            query.ToFilter(await ResolveTenantIdAsync(query, cancellationToken)),
            cancellationToken));
    }

    [HttpGet("content-nodes")]
    [EndpointSummary("查询内容导航节点")]
    [ProducesResponseType<CatalogList<ContentNodeCatalogItem>>(StatusCodes.Status200OK)]
    [ProducesResponseType<ProblemDetails>(StatusCodes.Status400BadRequest)]
    [ProducesResponseType<ProblemDetails>(StatusCodes.Status404NotFound)]
    public async Task<ActionResult<CatalogList<ContentNodeCatalogItem>>> GetContentNodes(
        [FromQuery] ContentNavigationQueryDto query,
        CancellationToken cancellationToken)
    {
        return Ok(await contentNavigationQueryService.GetContentNodesAsync(
            query.ToFilter(await ResolveTenantIdAsync(query, cancellationToken)),
            cancellationToken));
    }

    [HttpGet("question-collections")]
    [EndpointSummary("查询可用题集")]
    [ProducesResponseType<CatalogList<QuestionCollectionCatalogItem>>(StatusCodes.Status200OK)]
    [ProducesResponseType<ProblemDetails>(StatusCodes.Status404NotFound)]
    public async Task<ActionResult<CatalogList<QuestionCollectionCatalogItem>>> GetQuestionCollections(
        [FromQuery] ContentNavigationQueryDto query,
        CancellationToken cancellationToken)
    {
        return Ok(await contentNavigationQueryService.GetQuestionCollectionsAsync(
            query.ToFilter(await ResolveTenantIdAsync(query, cancellationToken)),
            cancellationToken));
    }

    [HttpGet("question-collections/questions")]
    [EndpointSummary("查询题集内题目")]
    [ProducesResponseType<CatalogList<CollectionQuestionCatalogItem>>(StatusCodes.Status200OK)]
    [ProducesResponseType<ProblemDetails>(StatusCodes.Status400BadRequest)]
    [ProducesResponseType<ProblemDetails>(StatusCodes.Status404NotFound)]
    public async Task<ActionResult<CatalogList<CollectionQuestionCatalogItem>>> GetCollectionQuestions(
        [FromQuery] ContentNavigationQueryDto query,
        CancellationToken cancellationToken)
    {
        return Ok(await contentNavigationQueryService.GetCollectionQuestionsAsync(
            query.ToFilter(await ResolveTenantIdAsync(query, cancellationToken)),
            cancellationToken));
    }

    [HttpGet("practice-blueprints")]
    [EndpointSummary("查询练习蓝图")]
    [ProducesResponseType<CatalogList<PracticeBlueprintCatalogItem>>(StatusCodes.Status200OK)]
    [ProducesResponseType<ProblemDetails>(StatusCodes.Status404NotFound)]
    public async Task<ActionResult<CatalogList<PracticeBlueprintCatalogItem>>> GetPracticeBlueprints(
        [FromQuery] ContentNavigationQueryDto query,
        CancellationToken cancellationToken)
    {
        return Ok(await contentNavigationQueryService.GetPracticeBlueprintsAsync(
            query.ToFilter(await ResolveTenantIdAsync(query, cancellationToken)),
            cancellationToken));
    }

    private async Task<Guid> ResolveTenantIdAsync(
        CatalogQueryDto query,
        CancellationToken cancellationToken)
    {
        if (currentTenant.TenantId.HasValue)
        {
            return currentTenant.TenantId.Value;
        }

        var tenantCode = query.TenantCode ?? Request.Headers["x-tenant-code"].FirstOrDefault();
        if (string.IsNullOrWhiteSpace(tenantCode))
        {
            throw new TenantNotFoundException();
        }

        var tenantId = await dbContext.Tenants
            .Where(tenant =>
                tenant.Slug == tenantCode.Trim() &&
                tenant.Status == TenantStatus.Active)
            .Select(tenant => (Guid?)tenant.Id)
            .SingleOrDefaultAsync(cancellationToken);

        return tenantId ?? throw new TenantNotFoundException();
    }

    private Task<Guid> ResolveTenantIdAsync(
        ContentNavigationQueryDto query,
        CancellationToken cancellationToken)
    {
        return ResolveTenantIdAsync(
            new CatalogQueryDto
            {
                TenantCode = query.TenantCode
            },
            cancellationToken);
    }
}

public sealed class TenantNotFoundException : Exception
{
    public TenantNotFoundException()
        : base("Tenant was not found.")
    {
    }
}