325 lines
16 KiB
C#
325 lines
16 KiB
C#
using Amazon.Runtime;
|
|
using DocumentFormat.OpenXml.Packaging;
|
|
using Microsoft.AspNetCore.Authorization;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using Microsoft.Extensions.Options;
|
|
using WordVersioning.Api.Data;
|
|
using WordVersioning.Api.Models;
|
|
using WordVersioning.Api.Services;
|
|
|
|
namespace WordVersioning.Api.Controllers;
|
|
|
|
/// <summary>FR-9 — template CRUD + auto-detect fields (SDT tags) ตอน upload/replace ไฟล์</summary>
|
|
[ApiController]
|
|
[Authorize]
|
|
[Route("api/templates")]
|
|
public class TemplatesController(
|
|
AppDbContext db,
|
|
IObjectStorageService storage,
|
|
IDocxGenerationService docxGeneration,
|
|
ICurrentUser currentUser,
|
|
IOptions<MinioOptions> minioOptions,
|
|
ILogger<TemplatesController> logger) : ControllerBase
|
|
{
|
|
private const long MaxUploadBytes = 100L * 1024 * 1024; // 100MB ตาม spec
|
|
|
|
/// <summary>รายการ template — default เฉพาะ active (หน้าเลือกสร้างเอกสาร), ส่ง includeInactive=true สำหรับหน้า admin</summary>
|
|
[HttpGet]
|
|
[ProducesResponseType(typeof(IReadOnlyList<TemplateListItem>), StatusCodes.Status200OK)]
|
|
public async Task<ActionResult<IReadOnlyList<TemplateListItem>>> List(
|
|
[FromQuery] bool includeInactive = false, CancellationToken ct = default)
|
|
{
|
|
var query = db.Templates.AsNoTracking().AsQueryable();
|
|
if (!includeInactive)
|
|
query = query.Where(t => t.IsActive);
|
|
|
|
var rows = await query
|
|
.OrderBy(t => t.Name)
|
|
.Select(t => new
|
|
{
|
|
t.Id,
|
|
t.Name,
|
|
t.Description,
|
|
t.IsActive,
|
|
FieldCount = t.Fields.Count,
|
|
t.CreatedAt,
|
|
t.UpdatedAt,
|
|
})
|
|
.ToListAsync(ct);
|
|
|
|
return Ok(rows.Select(r => new TemplateListItem(
|
|
r.Id, r.Name, r.Description, r.IsActive, r.FieldCount, r.CreatedAt, r.UpdatedAt)).ToList());
|
|
}
|
|
|
|
/// <summary>รายละเอียด template พร้อม field definitions (สำหรับหน้า edit)</summary>
|
|
[HttpGet("{id:guid}")]
|
|
[ProducesResponseType(typeof(TemplateDetail), StatusCodes.Status200OK)]
|
|
[ProducesResponseType(StatusCodes.Status404NotFound)]
|
|
public async Task<ActionResult<TemplateDetail>> Get(Guid id, CancellationToken ct)
|
|
{
|
|
var template = await db.Templates.AsNoTracking()
|
|
.Include(t => t.Fields)
|
|
.FirstOrDefaultAsync(t => t.Id == id, ct);
|
|
if (template is null)
|
|
return NotFound($"ไม่พบ template {id}");
|
|
|
|
return Ok(ToDetail(template));
|
|
}
|
|
|
|
/// <summary>upload template ใหม่ — parse SDT tags ออกมาเป็น field list อัตโนมัติ
|
|
/// (สร้าง TemplateField พร้อมค่า default ทันที: label = tag, type = text, required = false)</summary>
|
|
[HttpPost]
|
|
[RequestSizeLimit(MaxUploadBytes)]
|
|
[RequestFormLimits(MultipartBodyLengthLimit = MaxUploadBytes)]
|
|
[ProducesResponseType(typeof(CreateTemplateResponse), StatusCodes.Status201Created)]
|
|
[ProducesResponseType(StatusCodes.Status400BadRequest)]
|
|
[ProducesResponseType(StatusCodes.Status413PayloadTooLarge)]
|
|
[ProducesResponseType(StatusCodes.Status502BadGateway)]
|
|
public async Task<IActionResult> Create([FromForm] CreateTemplateRequest request, CancellationToken ct)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(request.Name))
|
|
return BadRequest("ต้องระบุ `name`");
|
|
if (request.File is null || request.File.Length == 0)
|
|
return BadRequest("ต้องแนบไฟล์ `file` (docx)");
|
|
if (request.File.Length > MaxUploadBytes)
|
|
return StatusCode(StatusCodes.Status413PayloadTooLarge, $"ไฟล์ใหญ่เกิน {MaxUploadBytes / (1024 * 1024)}MB");
|
|
if (!DocxUploadValidation.IsValidDocx(request.File))
|
|
return BadRequest("รองรับเฉพาะไฟล์ .docx (Word document)");
|
|
|
|
// detect fields จากไฟล์ที่อัปโหลด (IFormFile spool ลง disk แล้ว — stream seek ได้)
|
|
List<string> tags;
|
|
try
|
|
{
|
|
await using var detectStream = request.File.OpenReadStream();
|
|
tags = docxGeneration.DetectFieldTags(detectStream).ToList();
|
|
}
|
|
catch (OpenXmlPackageException ex)
|
|
{
|
|
logger.LogWarning(ex, "Template upload: ไฟล์เปิดไม่ได้ userId={UserId} fileName={FileName}",
|
|
currentUser.UserId, request.File.FileName);
|
|
return BadRequest("ไฟล์ .docx ไม่ถูกต้อง (เปิดด้วย OpenXML ไม่ได้)");
|
|
}
|
|
|
|
var now = DateTimeOffset.UtcNow;
|
|
var template = new Template
|
|
{
|
|
Id = Guid.NewGuid(),
|
|
Name = request.Name.Trim(),
|
|
Description = string.IsNullOrWhiteSpace(request.Description) ? null : request.Description.Trim(),
|
|
ObjectKey = string.Empty, // จะเติมหลัง upload สำเร็จ — ไม่บันทึก row ที่ชี้ไฟล์ที่ไม่มีจริง
|
|
IsActive = true,
|
|
CreatedAt = now,
|
|
UpdatedAt = now,
|
|
};
|
|
var sortOrder = 0;
|
|
foreach (var tag in tags)
|
|
{
|
|
template.Fields.Add(new TemplateField
|
|
{
|
|
TemplateId = template.Id,
|
|
Key = tag,
|
|
Label = tag, // default — admin ไปตั้งต่อผ่าน PUT
|
|
Type = "text",
|
|
IsRequired = false,
|
|
SortOrder = sortOrder++,
|
|
});
|
|
}
|
|
|
|
// upload ไฟล์ก่อน insert row — ถ้า DB fail ทีหลังจะเหลือ object กำพร้าใน bucket (log ไว้ ไม่กระทบกระเสีย)
|
|
var objectKey = $"{template.Id}/{now:yyyyMMddHHmmss}.docx";
|
|
try
|
|
{
|
|
await using var uploadStream = request.File.OpenReadStream();
|
|
uploadStream.Seek(0, SeekOrigin.Begin);
|
|
await storage.PutAsync(minioOptions.Value.TemplatesBucket, objectKey, uploadStream,
|
|
DocxUploadValidation.DocxContentType, ct);
|
|
}
|
|
catch (AmazonServiceException ex)
|
|
{
|
|
logger.LogError(ex, "Template file upload failed templateId={TemplateId} userId={UserId}",
|
|
template.Id, currentUser.UserId);
|
|
return StatusCode(StatusCodes.Status502BadGateway, "อัปโหลดไฟล์ขึ้น storage ไม่สำเร็จ");
|
|
}
|
|
|
|
template.ObjectKey = objectKey;
|
|
db.Templates.Add(template);
|
|
await db.SaveChangesAsync(ct);
|
|
|
|
logger.LogInformation(
|
|
"Template created templateId={TemplateId} name={TemplateName} fields={FieldCount} userId={UserId}",
|
|
template.Id, template.Name, template.Fields.Count, currentUser.UserId);
|
|
|
|
return CreatedAtAction(nameof(Get), new { id = template.Id },
|
|
new CreateTemplateResponse(template.Id, FieldDtos(template)));
|
|
}
|
|
|
|
/// <summary>แก้ metadata + บันทึก field definitions (label/type/required/sortOrder)
|
|
/// — key ต้องเป็นชุดที่ detect ไว้เท่านั้น จะเพิ่ม/ลบ key ต้องผ่านการ replace ไฟล์</summary>
|
|
[HttpPut("{id:guid}")]
|
|
[ProducesResponseType(typeof(TemplateDetail), StatusCodes.Status200OK)]
|
|
[ProducesResponseType(StatusCodes.Status404NotFound)]
|
|
[ProducesResponseType(StatusCodes.Status400BadRequest)]
|
|
public async Task<IActionResult> Update(Guid id, [FromBody] UpdateTemplateRequest request, CancellationToken ct)
|
|
{
|
|
var template = await db.Templates
|
|
.Include(t => t.Fields)
|
|
.FirstOrDefaultAsync(t => t.Id == id, ct);
|
|
if (template is null)
|
|
return NotFound($"ไม่พบ template {id}");
|
|
|
|
if (request.Name is not null)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(request.Name))
|
|
return BadRequest("`name` ห้ามว่าง");
|
|
template.Name = request.Name.Trim();
|
|
}
|
|
if (request.Description is not null)
|
|
template.Description = string.IsNullOrWhiteSpace(request.Description) ? null : request.Description.Trim();
|
|
if (request.IsActive.HasValue)
|
|
template.IsActive = request.IsActive.Value;
|
|
|
|
if (request.Fields is not null)
|
|
{
|
|
var unknown = request.Fields
|
|
.Select(f => f.Key)
|
|
.Distinct()
|
|
.Except(template.Fields.Select(f => f.Key))
|
|
.ToList();
|
|
if (unknown.Count > 0)
|
|
return BadRequest($"ไม่รู้จัก field key: {string.Join(", ", unknown)} (key มาจากไฟล์ — เพิ่ม/ลบต้อง replace ไฟล์)");
|
|
|
|
foreach (var def in request.Fields)
|
|
{
|
|
if (!TemplateField.ValidTypes.Contains(def.Type))
|
|
return BadRequest($"type ของ `{def.Key}` ต้องเป็น text/number/date (ได้ `{def.Type}`)");
|
|
if (string.IsNullOrWhiteSpace(def.Label))
|
|
return BadRequest($"label ของ `{def.Key}` ห้ามว่าง");
|
|
|
|
var row = template.Fields.First(f => f.Key == def.Key);
|
|
row.Label = def.Label.Trim();
|
|
row.Type = def.Type;
|
|
row.IsRequired = def.IsRequired;
|
|
row.SortOrder = def.SortOrder;
|
|
}
|
|
}
|
|
|
|
template.UpdatedAt = DateTimeOffset.UtcNow;
|
|
await db.SaveChangesAsync(ct);
|
|
|
|
logger.LogInformation("Template updated templateId={TemplateId} userId={UserId}", template.Id, currentUser.UserId);
|
|
return Ok(ToDetail(template));
|
|
}
|
|
|
|
/// <summary>แทนที่ไฟล์ template — re-detect fields: tag ใหม่เพิ่มเป็น default, tag ที่หายไปลบนิยามทิ้ง
|
|
/// (document เก่าที่สร้างไปแล้วไม่กระทบ — field values เก็บแยกที่ตัว document)</summary>
|
|
[HttpPut("{id:guid}/file")]
|
|
[RequestSizeLimit(MaxUploadBytes)]
|
|
[RequestFormLimits(MultipartBodyLengthLimit = MaxUploadBytes)]
|
|
[ProducesResponseType(typeof(ReplaceTemplateFileResponse), StatusCodes.Status200OK)]
|
|
[ProducesResponseType(StatusCodes.Status404NotFound)]
|
|
[ProducesResponseType(StatusCodes.Status400BadRequest)]
|
|
[ProducesResponseType(StatusCodes.Status502BadGateway)]
|
|
public async Task<IActionResult> ReplaceFile(Guid id, [FromForm] ReplaceTemplateFileRequest request, CancellationToken ct)
|
|
{
|
|
var template = await db.Templates
|
|
.Include(t => t.Fields)
|
|
.FirstOrDefaultAsync(t => t.Id == id, ct);
|
|
if (template is null)
|
|
return NotFound($"ไม่พบ template {id}");
|
|
if (request.File is null || request.File.Length == 0)
|
|
return BadRequest("ต้องแนบไฟล์ `file` (docx)");
|
|
if (request.File.Length > MaxUploadBytes)
|
|
return StatusCode(StatusCodes.Status413PayloadTooLarge, $"ไฟล์ใหญ่เกิน {MaxUploadBytes / (1024 * 1024)}MB");
|
|
if (!DocxUploadValidation.IsValidDocx(request.File))
|
|
return BadRequest("รองรับเฉพาะไฟล์ .docx (Word document)");
|
|
|
|
List<string> newTags;
|
|
try
|
|
{
|
|
await using var detectStream = request.File.OpenReadStream();
|
|
newTags = docxGeneration.DetectFieldTags(detectStream).ToList();
|
|
}
|
|
catch (OpenXmlPackageException ex)
|
|
{
|
|
logger.LogWarning(ex, "Template replace: ไฟล์เปิดไม่ได้ templateId={TemplateId} userId={UserId}",
|
|
template.Id, currentUser.UserId);
|
|
return BadRequest("ไฟล์ .docx ไม่ถูกต้อง (เปิดด้วย OpenXML ไม่ได้)");
|
|
}
|
|
|
|
var existingKeys = template.Fields.Select(f => f.Key).ToList();
|
|
var addedTags = newTags.Except(existingKeys).ToList();
|
|
var removedTags = existingKeys.Except(newTags).ToList();
|
|
|
|
var now = DateTimeOffset.UtcNow;
|
|
var objectKey = $"{template.Id}/{now:yyyyMMddHHmmss}.docx";
|
|
try
|
|
{
|
|
await using var uploadStream = request.File.OpenReadStream();
|
|
uploadStream.Seek(0, SeekOrigin.Begin);
|
|
await storage.PutAsync(minioOptions.Value.TemplatesBucket, objectKey, uploadStream,
|
|
DocxUploadValidation.DocxContentType, ct);
|
|
}
|
|
catch (AmazonServiceException ex)
|
|
{
|
|
logger.LogError(ex, "Template file upload failed templateId={TemplateId} userId={UserId}",
|
|
template.Id, currentUser.UserId);
|
|
return StatusCode(StatusCodes.Status502BadGateway, "อัปโหลดไฟล์ขึ้น storage ไม่สำเร็จ");
|
|
}
|
|
|
|
template.ObjectKey = objectKey;
|
|
template.UpdatedAt = now;
|
|
|
|
foreach (var removed in template.Fields.Where(f => removedTags.Contains(f.Key)).ToList())
|
|
template.Fields.Remove(removed);
|
|
var nextSort = template.Fields.Count == 0 ? 0 : template.Fields.Max(f => f.SortOrder) + 1;
|
|
foreach (var tag in addedTags)
|
|
{
|
|
// ห้าม set Id เอง — Guid PK ที่มีค่าทำให้ EF ตีเป็น Modified (update แถวที่ไม่มี) แทน Added
|
|
template.Fields.Add(new TemplateField
|
|
{
|
|
TemplateId = template.Id,
|
|
Key = tag,
|
|
Label = tag,
|
|
Type = "text",
|
|
IsRequired = false,
|
|
SortOrder = nextSort++,
|
|
});
|
|
}
|
|
|
|
await db.SaveChangesAsync(ct);
|
|
|
|
logger.LogInformation(
|
|
"Template file replaced templateId={TemplateId} userId={UserId} added={AddedTags} removed={RemovedTags}",
|
|
template.Id, currentUser.UserId, string.Join(",", addedTags), string.Join(",", removedTags));
|
|
|
|
return Ok(new ReplaceTemplateFileResponse(template.Id, FieldDtos(template), addedTags, removedTags));
|
|
}
|
|
|
|
/// <summary>deactivate (soft-delete) — document เก่าที่อ้างอยู่ยังใช้ได้ต่อ แต่สร้างเอกสารใหม่ไม่ได้</summary>
|
|
[HttpDelete("{id:guid}")]
|
|
[ProducesResponseType(StatusCodes.Status204NoContent)]
|
|
[ProducesResponseType(StatusCodes.Status404NotFound)]
|
|
public async Task<IActionResult> Deactivate(Guid id, CancellationToken ct)
|
|
{
|
|
var template = await db.Templates.FirstOrDefaultAsync(t => t.Id == id, ct);
|
|
if (template is null)
|
|
return NotFound($"ไม่พบ template {id}");
|
|
|
|
template.IsActive = false;
|
|
template.UpdatedAt = DateTimeOffset.UtcNow;
|
|
await db.SaveChangesAsync(ct);
|
|
|
|
logger.LogInformation("Template deactivated templateId={TemplateId} userId={UserId}", template.Id, currentUser.UserId);
|
|
return NoContent();
|
|
}
|
|
|
|
private static TemplateDetail ToDetail(Template template) => new(
|
|
template.Id, template.Name, template.Description, template.IsActive,
|
|
template.CreatedAt, template.UpdatedAt, FieldDtos(template));
|
|
|
|
private static List<TemplateFieldDto> FieldDtos(Template template) => template.Fields
|
|
.OrderBy(f => f.SortOrder)
|
|
.Select(f => new TemplateFieldDto(f.Id, f.Key, f.Label, f.Type, f.IsRequired, f.SortOrder))
|
|
.ToList();
|
|
}
|