352 lines
14 KiB
C#
352 lines
14 KiB
C#
using System.Text;
|
|
using System.Text.Json;
|
|
using System.Text.RegularExpressions;
|
|
using ExperionCrawler.Core.Application.DTOs;
|
|
using ExperionCrawler.Core.Application.Interfaces;
|
|
using ExperionCrawler.Core.Domain.Entities;
|
|
using ExperionCrawler.Infrastructure.Database;
|
|
using ExperionCrawler.Infrastructure.Mcp;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using netDxf;
|
|
using UglyToad.PdfPig;
|
|
|
|
namespace ExperionCrawler.Core.Application.Services;
|
|
|
|
public class PidExtractorService : IPidExtractorService
|
|
{
|
|
private readonly McpClient _mcp;
|
|
private readonly ExperionDbContext _dbContext;
|
|
private readonly ILogger<PidExtractorService> _logger;
|
|
|
|
public PidExtractorService(McpClient mcp, ExperionDbContext dbContext, ILogger<PidExtractorService> logger)
|
|
{
|
|
_mcp = mcp;
|
|
_dbContext = dbContext;
|
|
_logger = logger;
|
|
}
|
|
|
|
public async Task<PidExtractionResult> ExtractFromFileAsync(string filePath, bool useImageMode = false)
|
|
{
|
|
await using var stream = File.OpenRead(filePath);
|
|
return await ExtractFromStreamAsync(stream, Path.GetFileName(filePath), useImageMode);
|
|
}
|
|
|
|
public async Task<PidExtractionResult> ExtractFromStreamAsync(Stream stream, string fileName, bool useImageMode = false)
|
|
{
|
|
var ext = Path.GetExtension(fileName).ToLowerInvariant();
|
|
|
|
string text = ext switch
|
|
{
|
|
".dxf" => ExtractDxfText(stream),
|
|
".pdf" => ExtractPdfText(stream),
|
|
_ => throw new NotSupportedException($"지원 형식: .dxf .pdf (스캔본 이미지는 Vision 모드 필요)")
|
|
};
|
|
|
|
if (string.IsNullOrWhiteSpace(text))
|
|
return new PidExtractionResult(0, 0, 0);
|
|
|
|
// MCP → vLLM 태그 추출
|
|
var sourceType = ext.TrimStart('.');
|
|
var json = await _mcp.ExtractPidTagsAsync(text, sourceType);
|
|
var extractedItems = ParseJson(json);
|
|
|
|
if (extractedItems.Count == 0)
|
|
{
|
|
_logger.LogWarning("P&ID 추출 결과 0건 — 파일: {FileName}", fileName);
|
|
return new PidExtractionResult(0, 0, 0);
|
|
}
|
|
|
|
// MCP → vLLM 태그 매핑 제안
|
|
var pidTagNos = extractedItems.Select(i => i.TagNo).Distinct().ToList();
|
|
var experionTagNames = await _dbContext.RealtimePoints.Select(r => r.TagName).ToListAsync();
|
|
var mappingJson = await _mcp.MatchPidTagsAsync(pidTagNos, experionTagNames);
|
|
var mappings = ParseMappingJson(mappingJson);
|
|
|
|
// DB 저장
|
|
var dbItems = new List<PidEquipment>();
|
|
foreach (var item in extractedItems)
|
|
{
|
|
mappings.TryGetValue(item.TagNo, out var matched);
|
|
var experionTag = matched != null
|
|
? await _dbContext.RealtimePoints.FirstOrDefaultAsync(r => r.TagName == matched)
|
|
: await FindFallbackTagAsync(item.TagNo);
|
|
|
|
dbItems.Add(new PidEquipment
|
|
{
|
|
TagNo = item.TagNo,
|
|
EquipmentName = item.EquipmentName,
|
|
InstrumentType = item.InstrumentType,
|
|
LineNumber = item.LineNumber,
|
|
PidDrawingNo = item.PidDrawingNo,
|
|
Confidence = item.Confidence,
|
|
ExperionTagId = experionTag?.Id,
|
|
ExtractedAt = DateTime.UtcNow,
|
|
UpdatedAt = DateTime.UtcNow
|
|
});
|
|
}
|
|
|
|
await _dbContext.PidEquipment.AddRangeAsync(dbItems);
|
|
await _dbContext.SaveChangesAsync();
|
|
|
|
_logger.LogInformation("P&ID 추출 완료: {Total}건 저장 (파일: {FileName})", dbItems.Count, fileName);
|
|
|
|
return new PidExtractionResult(
|
|
TotalCount: dbItems.Count,
|
|
ConfidenceItems: dbItems.Count(i => i.Confidence >= 0.7),
|
|
LowConfidenceItems: dbItems.Count(i => i.Confidence < 0.5));
|
|
}
|
|
|
|
private string ExtractDxfText(Stream stream)
|
|
{
|
|
var tmp = Path.GetTempFileName() + ".dxf";
|
|
try
|
|
{
|
|
using (var fs = File.Create(tmp))
|
|
stream.CopyTo(fs);
|
|
|
|
var doc = DxfDocument.Load(tmp);
|
|
var sb = new StringBuilder();
|
|
|
|
foreach (var txt in doc.Entities.Texts)
|
|
sb.AppendLine(txt.Value);
|
|
foreach (var mtxt in doc.Entities.MTexts)
|
|
sb.AppendLine(mtxt.PlainText());
|
|
foreach (var blk in doc.Blocks)
|
|
foreach (var attr in blk.AttributeDefinitions.Values)
|
|
sb.AppendLine(attr.Value);
|
|
|
|
var text = sb.ToString();
|
|
|
|
// P&ID 태그 관련 정보만 필터링하여 MCP 서버로 전달
|
|
return FilterDxfText(text);
|
|
}
|
|
finally
|
|
{
|
|
if (File.Exists(tmp)) File.Delete(tmp);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// DXF 텍스트에서 P&ID 태그 패턴에 해당하는 라인만 필터링
|
|
/// 불필요한 텍스트를 제거하여 MCP 서버 부하 감소 및 JSON 파싱 오류 방지
|
|
/// </summary>
|
|
private string FilterDxfText(string text)
|
|
{
|
|
var lines = text.Split('\n');
|
|
var filteredLines = new List<string>();
|
|
|
|
foreach (var line in lines)
|
|
{
|
|
var trimmed = line.Trim();
|
|
|
|
// P&ID 태그 패턴 포함 라인만 유지
|
|
// - 단일 글자 장비 태그 포함: P-10101, T-10100, E-10119, C-10111
|
|
// - 다중 글자 계측 태그: FCV-101, FICQ-6113, PSV-6203
|
|
// - 복합 태그: VG-6203-15A-F1A-n, CD-10513-40A
|
|
if (Regex.IsMatch(trimmed, @"[A-Z]{1,6}-\d{2,6}(-[A-Z0-9]+)*"))
|
|
{
|
|
filteredLines.Add(trimmed);
|
|
}
|
|
}
|
|
|
|
return string.Join("\n", filteredLines);
|
|
}
|
|
|
|
private string ExtractPdfText(Stream stream)
|
|
{
|
|
using var pdf = PdfDocument.Open(stream);
|
|
var sb = new StringBuilder();
|
|
foreach (var page in pdf.GetPages())
|
|
sb.AppendLine(page.Text);
|
|
return sb.ToString();
|
|
}
|
|
|
|
private List<ExtractedItem> ParseJson(string json)
|
|
{
|
|
try
|
|
{
|
|
// MCP 서버 응답 형식: {"success": ..., "count": ..., "tags": [...]}
|
|
// 또는 기존 형식: [...]
|
|
using var doc = JsonDocument.Parse(json);
|
|
var root = doc.RootElement;
|
|
|
|
// "tags" 필드가 있으면 중첩 구조로 간주
|
|
if (root.TryGetProperty("tags", out var tagsElement))
|
|
{
|
|
return JsonSerializer.Deserialize<List<ExtractedItem>>(tagsElement.GetRawText(),
|
|
new JsonSerializerOptions { PropertyNameCaseInsensitive = true }) ?? [];
|
|
}
|
|
|
|
// 루트가 배열이면 직접 파싱
|
|
if (root.ValueKind == JsonValueKind.Array)
|
|
{
|
|
return JsonSerializer.Deserialize<List<ExtractedItem>>(json,
|
|
new JsonSerializerOptions { PropertyNameCaseInsensitive = true }) ?? [];
|
|
}
|
|
|
|
_logger.LogWarning("P&ID JSON 파싱 실패: 'tags' 필드 또는 배열 형식 없음");
|
|
return [];
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogWarning("P&ID JSON 파싱 실패: {Msg} / raw: {Raw}", ex.Message, json[..Math.Min(200, json.Length)]);
|
|
return [];
|
|
}
|
|
}
|
|
|
|
private Dictionary<string, string> ParseMappingJson(string json)
|
|
{
|
|
try
|
|
{
|
|
using var doc = JsonDocument.Parse(json);
|
|
var root = doc.RootElement;
|
|
|
|
// MCP 응답: {"success": ..., "count": ..., "mappings": [...]}
|
|
JsonElement arrayEl = root.ValueKind == JsonValueKind.Array
|
|
? root
|
|
: root.TryGetProperty("mappings", out var m) ? m : default;
|
|
|
|
if (arrayEl.ValueKind != JsonValueKind.Array)
|
|
return [];
|
|
|
|
var list = JsonSerializer.Deserialize<List<MappingItem>>(arrayEl.GetRawText(),
|
|
new JsonSerializerOptions { PropertyNameCaseInsensitive = true }) ?? [];
|
|
return list
|
|
.Where(m => m.Confidence >= 0.7 && !string.IsNullOrEmpty(m.ExperionTag))
|
|
.ToDictionary(m => m.PidTag, m => m.ExperionTag!);
|
|
}
|
|
catch { return []; }
|
|
}
|
|
|
|
private async Task<RealtimePoint?> FindFallbackTagAsync(string tagNo)
|
|
{
|
|
var normalized = tagNo.Split('.')[0];
|
|
return await _dbContext.RealtimePoints
|
|
.FirstOrDefaultAsync(t => t.TagName == normalized
|
|
|| t.TagName.StartsWith(normalized + "."));
|
|
}
|
|
|
|
public async Task<(int Total, IEnumerable<PidEquipment> Items)> GetEquipmentAsync(
|
|
string? tagNo, int page, int pageSize)
|
|
{
|
|
var q = _dbContext.PidEquipment.AsQueryable();
|
|
if (!string.IsNullOrEmpty(tagNo))
|
|
q = q.Where(e => e.TagNo.Contains(tagNo));
|
|
var total = await q.CountAsync();
|
|
var items = await q.OrderByDescending(e => e.ExtractedAt)
|
|
.Skip((page - 1) * pageSize).Take(pageSize).ToListAsync();
|
|
return (total, items);
|
|
}
|
|
|
|
public async Task<PidEquipment?> GetByIdAsync(long id)
|
|
=> await _dbContext.PidEquipment.Include(e => e.ExperionTag).FirstOrDefaultAsync(e => e.Id == id);
|
|
|
|
public async Task UpdateConfidenceAsync(long id, double confidence)
|
|
{
|
|
var e = await _dbContext.PidEquipment.FindAsync(id);
|
|
if (e == null) return;
|
|
e.Confidence = confidence; e.UpdatedAt = DateTime.UtcNow;
|
|
await _dbContext.SaveChangesAsync();
|
|
}
|
|
|
|
public async Task ActivateAsync(long id)
|
|
{
|
|
var e = await _dbContext.PidEquipment.FindAsync(id);
|
|
if (e == null) return;
|
|
e.IsActive = true; e.UpdatedAt = DateTime.UtcNow;
|
|
await _dbContext.SaveChangesAsync();
|
|
}
|
|
|
|
public async Task DeactivateAsync(long id)
|
|
{
|
|
var e = await _dbContext.PidEquipment.FindAsync(id);
|
|
if (e == null) return;
|
|
e.IsActive = false; e.UpdatedAt = DateTime.UtcNow;
|
|
await _dbContext.SaveChangesAsync();
|
|
}
|
|
|
|
public Task<int> GetTotalCountAsync() => _dbContext.PidEquipment.CountAsync();
|
|
public Task<int> GetConfidenceItemsCountAsync() => _dbContext.PidEquipment.CountAsync(e => e.Confidence >= 0.7);
|
|
public Task<int> GetLowConfidenceItemsCountAsync() => _dbContext.PidEquipment.CountAsync(e => e.Confidence < 0.5);
|
|
public Task<int> GetDrawingCountAsync() => _dbContext.PidEquipment.Select(e => e.PidDrawingNo).Distinct().CountAsync();
|
|
|
|
public async Task<IDictionary<string, int>> GetConfidenceDistributionAsync()
|
|
{
|
|
var items = await _dbContext.PidEquipment.ToListAsync();
|
|
return new Dictionary<string, int>
|
|
{
|
|
["High (>=0.7)"] = items.Count(i => i.Confidence >= 0.7),
|
|
["Medium (0.5-0.7)"] = items.Count(i => i.Confidence >= 0.5 && i.Confidence < 0.7),
|
|
["Low (<0.5)"] = items.Count(i => i.Confidence < 0.5)
|
|
};
|
|
}
|
|
|
|
public Task<string> ExportToCsvAsync(IEnumerable<PidEquipment> items)
|
|
{
|
|
var sb = new StringBuilder();
|
|
sb.AppendLine("TagNo,EquipmentName,InstrumentType,LineNumber,PidDrawingNo,Confidence,IsActive,ExtractedAt,ExperionTagId");
|
|
foreach (var i in items)
|
|
sb.AppendLine($"{Csv(i.TagNo)},{Csv(i.EquipmentName)},{Csv(i.InstrumentType)},{Csv(i.LineNumber)},{Csv(i.PidDrawingNo)},{i.Confidence},{i.IsActive},{i.ExtractedAt:O},{i.ExperionTagId}");
|
|
return Task.FromResult(sb.ToString());
|
|
}
|
|
|
|
private static string Csv(string? v)
|
|
{
|
|
if (string.IsNullOrEmpty(v)) return "";
|
|
return (v.Contains(',') || v.Contains('"') || v.Contains('\n'))
|
|
? $"\"{v.Replace("\"", "\"\"")}\"" : v;
|
|
}
|
|
|
|
public Task<byte[]> ExportToExcelAsync(IEnumerable<PidEquipment> items)
|
|
{
|
|
using var package = new OfficeOpenXml.ExcelPackage();
|
|
var worksheet = package.Workbook.Worksheets.Add("P&ID Equipment");
|
|
|
|
// 헤더
|
|
worksheet.Cells[1, 1].Value = "태그번호";
|
|
worksheet.Cells[1, 2].Value = "장비명";
|
|
worksheet.Cells[1, 3].Value = "계기유형";
|
|
worksheet.Cells[1, 4].Value = "라인번호";
|
|
worksheet.Cells[1, 5].Value = "도면번호";
|
|
worksheet.Cells[1, 6].Value = "신뢰도";
|
|
worksheet.Cells[1, 7].Value = "상태";
|
|
worksheet.Cells[1, 8].Value = "추출일시";
|
|
worksheet.Cells[1, 9].Value = "Experion 태그";
|
|
|
|
int row = 2;
|
|
foreach (var item in items)
|
|
{
|
|
worksheet.Cells[row, 1].Value = item.TagNo;
|
|
worksheet.Cells[row, 2].Value = item.EquipmentName ?? "";
|
|
worksheet.Cells[row, 3].Value = item.InstrumentType ?? "";
|
|
worksheet.Cells[row, 4].Value = item.LineNumber ?? "";
|
|
worksheet.Cells[row, 5].Value = item.PidDrawingNo ?? "";
|
|
worksheet.Cells[row, 6].Value = item.Confidence;
|
|
worksheet.Cells[row, 7].Value = item.IsActive ? "활성" : "비활성";
|
|
worksheet.Cells[row, 8].Value = item.ExtractedAt;
|
|
worksheet.Cells[row, 9].Value = item.ExperionTag?.TagName ?? "";
|
|
row++;
|
|
}
|
|
|
|
return Task.FromResult(package.GetAsByteArray());
|
|
}
|
|
}
|
|
|
|
// ── 내부 파싱용 모델 ──────────────────────────────────────────────────────────
|
|
public class ExtractedItem
|
|
{
|
|
public string TagNo { get; set; } = "";
|
|
public string? EquipmentName { get; set; }
|
|
public string? InstrumentType { get; set; }
|
|
public string? LineNumber { get; set; }
|
|
public string? PidDrawingNo { get; set; }
|
|
public double Confidence { get; set; } = 0.5;
|
|
}
|
|
|
|
public class MappingItem
|
|
{
|
|
public string PidTag { get; set; } = "";
|
|
public string? ExperionTag { get; set; }
|
|
public double Confidence { get; set; }
|
|
}
|