src/MdToDocx.Server/Controllers/ConversionController.cs - develop - iRumba/MdToDocx

src/MdToDocx.Server/Controllers/ConversionController.cs
145 строк5 KB
iRumba
refactor: restructure project to src/ modules, remove .opencode/
25 май 2026, 07:05
25 май 2026, 07:05c692142
using Microsoft.AspNetCore.Mvc;
using MdToDocx.Server.Models;
using MdToDocx.Server.Services;

namespace MdToDocx.Server.Controllers;

[ApiController]
[Route("api/[controller]")]
public class ConversionController : ControllerBase
{
    private readonly IMarkdownConverter _markdownConverter;
    private readonly IDocxBuilder _docxBuilder;
    private readonly IFileValidator _fileValidator;
    private readonly ILogger<ConversionController> _logger;
    private readonly HttpClient _httpClient;

    public ConversionController(
        IMarkdownConverter markdownConverter,
        IDocxBuilder docxBuilder,
        IFileValidator fileValidator,
        ILogger<ConversionController> logger,
        HttpClient httpClient)
    {
        _markdownConverter = markdownConverter;
        _docxBuilder = docxBuilder;
        _fileValidator = fileValidator;
        _logger = logger;
        _httpClient = httpClient;
    }

    [HttpPost("convert")]
    [RequestSizeLimit(15 * 1024 * 1024)] // 15 MB total limit
    public async Task<IActionResult> Convert([FromForm] ConvertRequest request)
    {
        try
        {
            string markdownContent;
            string outputFileName = "converted.docx";

            if (request.File != null)
            {
                // Validate MD file
                var (isValid, error) = _fileValidator.ValidateMdFile(request.File);
                if (!isValid)
                {
                    _logger.LogWarning("Invalid MD file: {Error}", error);
                    return BadRequest(new ConvertResponse { Success = false, ErrorMessage = error });
                }

                using var reader = new StreamReader(request.File.OpenReadStream());
                markdownContent = await reader.ReadToEndAsync();
                outputFileName = Path.GetFileNameWithoutExtension(request.File.FileName) + ".docx";

                _logger.LogInformation("Converting uploaded file: {FileName}", request.File.FileName);
            }
            else if (!string.IsNullOrWhiteSpace(request.Url))
            {
                // Validate URL
                var (isValid, error) = _fileValidator.ValidateUrl(request.Url);
                if (!isValid)
                {
                    _logger.LogWarning("Invalid URL: {Error}", error);
                    return BadRequest(new ConvertResponse { Success = false, ErrorMessage = error });
                }

                // Download markdown from URL
                _logger.LogInformation("Downloading markdown from URL: {Url}", request.Url);
                var response = await _httpClient.GetAsync(request.Url);

                if (!response.IsSuccessStatusCode)
                {
                    return BadRequest(new ConvertResponse
                    {
                        Success = false,
                        ErrorMessage = $"Failed to download file from URL. HTTP {response.StatusCode}"
                    });
                }

                // Check content size (limit 10 MB)
                var contentLength = response.Content.Headers.ContentLength ?? 0;
                if (contentLength > 10 * 1024 * 1024)
                {
                    return BadRequest(new ConvertResponse
                    {
                        Success = false,
                        ErrorMessage = "File at URL exceeds maximum size of 10 MB."
                    });
                }

                markdownContent = await response.Content.ReadAsStringAsync();
                outputFileName = "webpage.docx";
            }
            else
            {
                return BadRequest(new ConvertResponse
                {
                    Success = false,
                    ErrorMessage = "Either a file or a URL must be provided."
                });
            }

            // Validate template if provided
            Stream? templateStream = null;
            if (request.Template != null)
            {
                var (isValid, error) = _fileValidator.ValidateDotxFile(request.Template);
                if (!isValid)
                {
                    _logger.LogWarning("Invalid template file: {Error}", error);
                    return BadRequest(new ConvertResponse { Success = false, ErrorMessage = error });
                }

                templateStream = new MemoryStream();
                await request.Template.CopyToAsync(templateStream);
                _logger.LogInformation("Using template: {TemplateName}", request.Template.FileName);
            }

            // Convert markdown to blocks
            _logger.LogInformation("Parsing markdown content ({Length} chars)", markdownContent.Length);
            var blocks = _markdownConverter.ConvertToBlocks(markdownContent);
            _logger.LogInformation("Parsed {BlockCount} blocks", blocks.Count);

            // Build the Word document
            using var docStream = _docxBuilder.CreateDocument(blocks, templateStream);

            _logger.LogInformation("Document created successfully: {OutputFileName}", outputFileName);

            // Return the file
            return File(
                docStream.ToArray(),
                "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
                outputFileName
            );
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Conversion failed");
            return StatusCode(500, new ConvertResponse
            {
                Success = false,
                ErrorMessage = $"Conversion failed: {ex.Message}"
            });
        }
    }
}