TekH
41f97ce533
- Implement AddAnnotationAsync using DevExpress PdfDocumentProcessor - Add 5 private helper methods (one per annotation type) - Add ParseColor helper (hex string to PdfRGBColor) - Validation: content required for FreeText/StickyNote, style for TextMarkup - Default colors: Yellow for TextMarkup, Red for others - Handle DevExpress API quirks (TextMarkupStyle.StrikeOut capitalization)
818 lines
32 KiB
C#
818 lines
32 KiB
C#
using DevExpress.Pdf;
|
|
using DocumentOperator.Application.Common.DTOs;
|
|
using DocumentOperator.Application.Common.Interfaces;
|
|
using DocumentOperator.Domain.Common.Exceptions;
|
|
|
|
namespace DocumentOperator.Infrastructure.Services.PdfProcessing;
|
|
|
|
/// <summary>
|
|
/// PDF processor implementation using DevExpress.Pdf library.
|
|
/// Handles PDF validation, metadata extraction, and attachment operations.
|
|
/// </summary>
|
|
public class DevExpressPdfProcessor : IPdfProcessor
|
|
{
|
|
#region PDF Validation
|
|
/// <summary>
|
|
/// Validates a PDF document and returns metadata.
|
|
/// </summary>
|
|
/// <param name="pdfStream">PDF content as stream (caller is responsible for disposal)</param>
|
|
/// <returns>PDF metadata (page count, file size, version, etc.)</returns>
|
|
/// <exception cref="BadRequestException">Thrown when stream is empty or invalid</exception>
|
|
public async Task<Application.Common.DTOs.PdfMetadata> ValidateAsync(Stream pdfStream)
|
|
{
|
|
// 1. Input Validation
|
|
ArgumentNullException.ThrowIfNull(pdfStream, nameof(pdfStream));
|
|
|
|
if (pdfStream.Length == 0)
|
|
{
|
|
throw new BadRequestException("PDF stream cannot be empty");
|
|
}
|
|
|
|
// Defensive validation: Seekable streams must be at Position = 0
|
|
if (pdfStream.CanSeek && pdfStream.Position != 0)
|
|
{
|
|
throw new BadRequestException("PDF stream must be positioned at the beginning (Position = 0).");
|
|
}
|
|
|
|
// 2. Read stream to byte array for raw data analysis
|
|
// (DevExpress needs byte[] for some operations like attachment detection)
|
|
byte[] pdfBytes;
|
|
if (pdfStream is MemoryStream ms && ms.TryGetBuffer(out var buffer))
|
|
{
|
|
// Fast path: reuse MemoryStream buffer
|
|
pdfBytes = buffer.Array!;
|
|
}
|
|
else
|
|
{
|
|
// Slow path: copy stream to byte array
|
|
using var memoryStream = new MemoryStream();
|
|
await pdfStream.CopyToAsync(memoryStream);
|
|
pdfBytes = memoryStream.ToArray();
|
|
}
|
|
|
|
// 3. Load PDF with DevExpress Document API
|
|
// Reset position for DevExpress (seekable streams only)
|
|
if (pdfStream.CanSeek)
|
|
{
|
|
pdfStream.Position = 0;
|
|
}
|
|
|
|
using var processor = new PdfDocumentProcessor();
|
|
processor.LoadDocument(pdfStream);
|
|
|
|
// 4. Extract metadata
|
|
var document = processor.Document;
|
|
|
|
int pageCount = document.Pages.Count;
|
|
string pdfVersion = document.Version.ToString(); // e.g., "1.4", "1.7"
|
|
|
|
// Attachments (embedded files)
|
|
// DevExpress PdfDocument API doesn't expose EmbeddedFiles directly in old API.
|
|
// We scan PDF raw data for "/EmbeddedFiles" and parse the name tree to get count.
|
|
var (hasAttachments, attachmentCount) = DetectEmbeddedFiles(pdfBytes);
|
|
|
|
// 5. Create and return PdfMetadata DTO
|
|
return new Application.Common.DTOs.PdfMetadata(
|
|
pageCount: pageCount,
|
|
fileSizeBytes: pdfBytes.Length,
|
|
pdfVersion: pdfVersion,
|
|
hasAttachments: hasAttachments,
|
|
attachmentCount: attachmentCount
|
|
);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Validates a PDF/A document and checks conformance level.
|
|
/// </summary>
|
|
/// <param name="pdfStream">PDF content as stream (caller is responsible for disposal)</param>
|
|
/// <returns>PDF/A metadata including conformance level and validation errors/warnings</returns>
|
|
/// <exception cref="BadRequestException">Thrown when stream is empty or invalid</exception>
|
|
public async Task<PdfAMetadata> ValidatePdfAAsync(Stream pdfStream)
|
|
{
|
|
// 1. Input Validation
|
|
ArgumentNullException.ThrowIfNull(pdfStream, nameof(pdfStream));
|
|
|
|
if (pdfStream.Length == 0)
|
|
{
|
|
throw new BadRequestException("PDF stream cannot be empty");
|
|
}
|
|
|
|
// Defensive validation: Seekable streams must be at Position = 0
|
|
if (pdfStream.CanSeek && pdfStream.Position != 0)
|
|
{
|
|
throw new BadRequestException("PDF stream must be positioned at the beginning (Position = 0).");
|
|
}
|
|
|
|
// 2. Read stream to byte array for raw data analysis
|
|
byte[] pdfBytes;
|
|
if (pdfStream is MemoryStream ms && ms.TryGetBuffer(out var buffer))
|
|
{
|
|
pdfBytes = buffer.Array!;
|
|
}
|
|
else
|
|
{
|
|
using var memoryStream = new MemoryStream();
|
|
await pdfStream.CopyToAsync(memoryStream);
|
|
pdfBytes = memoryStream.ToArray();
|
|
}
|
|
|
|
// 3. Load PDF with DevExpress Document API
|
|
// Reset position for DevExpress (seekable streams only)
|
|
if (pdfStream.CanSeek)
|
|
{
|
|
pdfStream.Position = 0;
|
|
}
|
|
|
|
using var processor = new PdfDocumentProcessor();
|
|
processor.LoadDocument(pdfStream);
|
|
|
|
var document = processor.Document;
|
|
|
|
// 4. Extract basic metadata
|
|
int pageCount = document.Pages.Count;
|
|
string pdfVersion = document.Version.ToString();
|
|
|
|
// 5. Check encryption (scan PDF raw data for /Encrypt keyword)
|
|
bool encrypted = DetectEncryption(pdfBytes);
|
|
|
|
// 6. Check PDF/A conformance (scan PDF raw data for PDF/A identifier)
|
|
var (isPdfACompliant, pdfaVersion) = DetectPdfAConformance(pdfBytes);
|
|
|
|
// 7. Collect errors and warnings
|
|
var errors = new List<string>();
|
|
var warnings = new List<string>();
|
|
|
|
// If encrypted, PDF/A compliance is not possible
|
|
if (encrypted && isPdfACompliant)
|
|
{
|
|
errors.Add("PDF/A documents cannot be encrypted");
|
|
isPdfACompliant = false;
|
|
}
|
|
|
|
// Basic PDF/A validation checks
|
|
if (isPdfACompliant)
|
|
{
|
|
// Add generic warning for manual verification
|
|
warnings.Add("Manual verification recommended: All fonts must be embedded");
|
|
warnings.Add("Manual verification recommended: No JavaScript or multimedia content");
|
|
}
|
|
|
|
// 8. Determine overall validity
|
|
bool isValid = errors.Count == 0;
|
|
|
|
// 9. Create and return PdfAMetadata DTO
|
|
return new PdfAMetadata(
|
|
isValid: isValid,
|
|
pdfVersion: pdfVersion,
|
|
pageCount: pageCount,
|
|
fileSizeBytes: pdfBytes.Length,
|
|
encrypted: encrypted,
|
|
pdfaVersion: pdfaVersion,
|
|
pdfaCompliant: isPdfACompliant,
|
|
errors: errors,
|
|
warnings: warnings
|
|
);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Attachment Operations
|
|
|
|
/// <summary>
|
|
/// Checks for embedded files (attachments) in a PDF document and returns detailed metadata.
|
|
/// Uses DevExpress PdfDocument.FileAttachments collection to retrieve attachment details.
|
|
/// </summary>
|
|
/// <param name="pdfStream">PDF content as stream (caller is responsible for disposal)</param>
|
|
/// <returns>Attachment information including count, file names, MIME types, and sizes</returns>
|
|
/// <exception cref="BadRequestException">Thrown when stream is empty</exception>
|
|
public async Task<AttachmentInfo> CheckAttachmentsAsync(Stream pdfStream)
|
|
{
|
|
// 1. Input Validation
|
|
ArgumentNullException.ThrowIfNull(pdfStream, nameof(pdfStream));
|
|
|
|
if (pdfStream.Length == 0)
|
|
{
|
|
throw new BadRequestException("PDF stream cannot be empty");
|
|
}
|
|
|
|
// Defensive validation: Seekable streams must be at Position = 0
|
|
if (pdfStream.CanSeek && pdfStream.Position != 0)
|
|
{
|
|
throw new BadRequestException("PDF stream must be positioned at the beginning (Position = 0).");
|
|
}
|
|
|
|
// 2. Load PDF with DevExpress Document API
|
|
// DevExpress LoadDocument may throw exceptions for corrupted PDFs - let them propagate naturally
|
|
// Middleware will catch and convert to 500 Internal Server Error
|
|
using var processor = new PdfDocumentProcessor();
|
|
processor.LoadDocument(pdfStream);
|
|
|
|
var document = processor.Document;
|
|
|
|
// 3. Extract attachment details using DevExpress FileAttachments collection
|
|
var fileAttachments = document.FileAttachments;
|
|
|
|
// 4. No attachments case (FileAttachments is IEnumerable<PdfFileAttachment>)
|
|
if (fileAttachments == null || !fileAttachments.Any())
|
|
{
|
|
return AttachmentInfo.Empty;
|
|
}
|
|
|
|
// 5. Map DevExpress PdfFileAttachment to our DTO AttachmentMetadata
|
|
var attachments = fileAttachments.Select(devExpressAttachment =>
|
|
new AttachmentMetadata(
|
|
fileName: devExpressAttachment.FileName ?? "unnamed",
|
|
mimeType: devExpressAttachment.MimeType ?? "application/octet-stream",
|
|
sizeBytes: devExpressAttachment.Size
|
|
)).ToList();
|
|
|
|
// 6. Return AttachmentInfo DTO
|
|
return new AttachmentInfo(
|
|
hasAttachments: true,
|
|
attachmentCount: attachments.Count,
|
|
attachments: attachments.AsReadOnly()
|
|
);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Extracts all embedded files from a PDF document and returns them as a ZIP archive.
|
|
/// Uses DevExpress PdfDocument.FileAttachments to retrieve attachment data.
|
|
/// </summary>
|
|
/// <param name="pdfStream">PDF content as stream (caller is responsible for disposal)</param>
|
|
/// <returns>ZIP archive byte array containing all extracted attachments</returns>
|
|
/// <exception cref="BadRequestException">Thrown when stream is empty</exception>
|
|
/// <exception cref="NotFoundException">Thrown when PDF contains no attachments</exception>
|
|
public async Task<byte[]> ExtractAttachmentsAsync(Stream pdfStream)
|
|
{
|
|
// 1. Input Validation
|
|
ArgumentNullException.ThrowIfNull(pdfStream, nameof(pdfStream));
|
|
|
|
if (pdfStream.Length == 0)
|
|
{
|
|
throw new BadRequestException("PDF stream cannot be empty");
|
|
}
|
|
|
|
// Defensive validation: Seekable streams must be at Position = 0
|
|
if (pdfStream.CanSeek && pdfStream.Position != 0)
|
|
{
|
|
throw new BadRequestException("PDF stream must be positioned at the beginning (Position = 0).");
|
|
}
|
|
|
|
// 2. Load PDF with DevExpress Document API
|
|
using var processor = new PdfDocumentProcessor();
|
|
processor.LoadDocument(pdfStream);
|
|
|
|
var document = processor.Document;
|
|
|
|
// 3. Extract attachment data using DevExpress FileAttachments collection
|
|
var fileAttachments = document.FileAttachments;
|
|
|
|
// 4. No attachments case
|
|
if (fileAttachments == null || !fileAttachments.Any())
|
|
{
|
|
throw new NotFoundException("PDF does not contain any attachments");
|
|
}
|
|
|
|
// 5. Create ZIP archive in memory
|
|
using var zipStream = new MemoryStream();
|
|
using (var zipArchive = new System.IO.Compression.ZipArchive(zipStream, System.IO.Compression.ZipArchiveMode.Create, leaveOpen: true))
|
|
{
|
|
foreach (var attachment in fileAttachments)
|
|
{
|
|
// Get attachment metadata
|
|
string fileName = attachment.FileName ?? "unnamed";
|
|
byte[] fileData = attachment.Data;
|
|
|
|
// Create entry in ZIP
|
|
var entry = zipArchive.CreateEntry(fileName, System.IO.Compression.CompressionLevel.Optimal);
|
|
|
|
// Write attachment data to ZIP entry
|
|
using var entryStream = entry.Open();
|
|
await entryStream.WriteAsync(fileData, 0, fileData.Length);
|
|
}
|
|
}
|
|
|
|
// 6. Return ZIP byte array
|
|
return zipStream.ToArray();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region PDF Merge Operations
|
|
|
|
public async Task<byte[]> MergePdfsAsync(IReadOnlyList<Stream> pdfStreams, IReadOnlyList<string?>? pageRanges = null)
|
|
{
|
|
// 1. Validate input: minimum 2 PDFs required
|
|
if (pdfStreams == null || pdfStreams.Count < 2)
|
|
throw new BadRequestException("At least 2 PDF files are required for merging");
|
|
|
|
// 2. Validate page ranges length (if provided)
|
|
if (pageRanges != null && pageRanges.Count != pdfStreams.Count)
|
|
throw new BadRequestException($"Page ranges count ({pageRanges.Count}) must match PDF files count ({pdfStreams.Count})");
|
|
|
|
// 3. Defensive validation: all streams must be at Position = 0
|
|
for (int i = 0; i < pdfStreams.Count; i++)
|
|
{
|
|
var stream = pdfStreams[i];
|
|
|
|
if (stream == null)
|
|
throw new BadRequestException($"PDF stream at index {i} is null");
|
|
|
|
if (stream.Length == 0)
|
|
throw new BadRequestException($"PDF stream at index {i} is empty");
|
|
|
|
if (stream.CanSeek && stream.Position != 0)
|
|
throw new BadRequestException(null, new ArgumentException(
|
|
$"PDF stream at index {i} must be positioned at the beginning (Position = 0).",
|
|
nameof(pdfStreams)));
|
|
}
|
|
|
|
// 4. Create merged PDF using DevExpress
|
|
using var mergedProcessor = new PdfDocumentProcessor();
|
|
|
|
// Load first PDF as base document
|
|
mergedProcessor.LoadDocument(pdfStreams[0]);
|
|
|
|
// Apply page range to first PDF if specified
|
|
if (pageRanges != null && !string.IsNullOrWhiteSpace(pageRanges[0]))
|
|
{
|
|
var pageIndices = ParsePageRange(pageRanges[0]!, mergedProcessor.Document.Pages.Count);
|
|
// Remove pages not in range (process in reverse to maintain indices)
|
|
for (int i = mergedProcessor.Document.Pages.Count - 1; i >= 0; i--)
|
|
{
|
|
if (!pageIndices.Contains(i))
|
|
mergedProcessor.Document.Pages.RemoveAt(i);
|
|
}
|
|
}
|
|
|
|
// Append remaining PDFs
|
|
for (int i = 1; i < pdfStreams.Count; i++)
|
|
{
|
|
string? pageRange = pageRanges?[i];
|
|
|
|
if (string.IsNullOrWhiteSpace(pageRange))
|
|
{
|
|
// Append all pages
|
|
mergedProcessor.AppendDocument(pdfStreams[i]);
|
|
}
|
|
else
|
|
{
|
|
// Parse page range and append selected pages
|
|
// Note: We need to load the document first to validate page range
|
|
using var tempProcessor = new PdfDocumentProcessor();
|
|
tempProcessor.LoadDocument(pdfStreams[i]);
|
|
|
|
var pageIndices = ParsePageRange(pageRange, tempProcessor.Document.Pages.Count);
|
|
|
|
// DevExpress AppendDocument doesn't support arbitrary page selection
|
|
// Workaround: Create temp PDF with selected pages, then append
|
|
using var tempStream = new MemoryStream();
|
|
|
|
// Remove unwanted pages from temp document (in reverse order)
|
|
for (int j = tempProcessor.Document.Pages.Count - 1; j >= 0; j--)
|
|
{
|
|
if (!pageIndices.Contains(j))
|
|
tempProcessor.Document.Pages.RemoveAt(j);
|
|
}
|
|
|
|
tempProcessor.SaveDocument(tempStream);
|
|
tempStream.Position = 0;
|
|
mergedProcessor.AppendDocument(tempStream);
|
|
}
|
|
}
|
|
|
|
// 5. Save merged PDF to byte array
|
|
using var outputStream = new MemoryStream();
|
|
mergedProcessor.SaveDocument(outputStream);
|
|
|
|
return await Task.FromResult(outputStream.ToArray());
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region PDF Annotation
|
|
|
|
/// <summary>
|
|
/// Adds an annotation to a PDF document at the specified page and rectangle.
|
|
/// </summary>
|
|
public async Task<byte[]> AddAnnotationAsync(
|
|
Stream pdfStream,
|
|
Domain.Models.ValueObjects.AnnotationType annotationType,
|
|
int pageNumber,
|
|
(double X1, double Y1, double X2, double Y2) rectangle,
|
|
string? content = null,
|
|
string? author = null,
|
|
string? color = null,
|
|
Domain.Models.ValueObjects.TextMarkupStyle? textMarkupStyle = null)
|
|
{
|
|
// 1. Input validation
|
|
ArgumentNullException.ThrowIfNull(pdfStream, nameof(pdfStream));
|
|
|
|
if (pdfStream.Length == 0)
|
|
throw new BadRequestException("PDF stream cannot be empty");
|
|
|
|
if (pdfStream.Position != 0)
|
|
throw new BadRequestException($"PDF stream must be at position 0 (current position: {pdfStream.Position})");
|
|
|
|
if (pageNumber < 1)
|
|
throw new BadRequestException($"Page number must be >= 1 (provided: {pageNumber})");
|
|
|
|
// Validate content requirement
|
|
if (annotationType is Domain.Models.ValueObjects.AnnotationType.FreeText
|
|
or Domain.Models.ValueObjects.AnnotationType.StickyNote)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(content))
|
|
throw new BadRequestException($"{annotationType} annotation requires content");
|
|
}
|
|
|
|
// Validate TextMarkup style requirement
|
|
if (annotationType == Domain.Models.ValueObjects.AnnotationType.TextMarkup && textMarkupStyle == null)
|
|
throw new BadRequestException("TextMarkup annotation requires textMarkupStyle parameter");
|
|
|
|
byte[] annotatedPdfBytes;
|
|
|
|
try
|
|
{
|
|
// 2. Load PDF
|
|
using var processor = new PdfDocumentProcessor();
|
|
processor.LoadDocument(pdfStream);
|
|
|
|
// 3. Validate page number
|
|
int pageCount = processor.Document.Pages.Count;
|
|
if (pageNumber > pageCount)
|
|
throw new BadRequestException($"Page number {pageNumber} exceeds document page count ({pageCount})");
|
|
|
|
// 4. Get page facade (zero-based index)
|
|
var pageFacade = processor.DocumentFacade.Pages[pageNumber - 1];
|
|
|
|
// 5. Create annotation rectangle
|
|
var pdfRectangle = new PdfRectangle(rectangle.X1, rectangle.Y1, rectangle.X2, rectangle.Y2);
|
|
|
|
// 6. Parse color (default to yellow for highlights, red for others)
|
|
PdfRGBColor annotationColor = ParseColor(color) ?? (annotationType == Domain.Models.ValueObjects.AnnotationType.TextMarkup
|
|
? new PdfRGBColor(1.0, 1.0, 0) // Yellow
|
|
: new PdfRGBColor(1.0, 0, 0)); // Red
|
|
|
|
// 7. Add annotation based on type
|
|
switch (annotationType)
|
|
{
|
|
case Domain.Models.ValueObjects.AnnotationType.TextMarkup:
|
|
AddTextMarkupAnnotation(pageFacade, pdfRectangle, textMarkupStyle!.Value, content, author, annotationColor);
|
|
break;
|
|
|
|
case Domain.Models.ValueObjects.AnnotationType.FreeText:
|
|
AddFreeTextAnnotation(pageFacade, pdfRectangle, content!, author, annotationColor);
|
|
break;
|
|
|
|
case Domain.Models.ValueObjects.AnnotationType.StickyNote:
|
|
AddStickyNoteAnnotation(pageFacade, pdfRectangle, content!, author, annotationColor);
|
|
break;
|
|
|
|
case Domain.Models.ValueObjects.AnnotationType.Circle:
|
|
AddCircleAnnotation(pageFacade, pdfRectangle, content, author, annotationColor);
|
|
break;
|
|
|
|
case Domain.Models.ValueObjects.AnnotationType.Square:
|
|
AddSquareAnnotation(pageFacade, pdfRectangle, content, author, annotationColor);
|
|
break;
|
|
|
|
default:
|
|
throw new BadRequestException($"Unsupported annotation type: {annotationType}");
|
|
}
|
|
|
|
// 8. Save annotated PDF
|
|
using var outputStream = new MemoryStream();
|
|
processor.SaveDocument(outputStream);
|
|
annotatedPdfBytes = outputStream.ToArray();
|
|
}
|
|
catch (BadRequestException)
|
|
{
|
|
throw; // Re-throw our own exceptions
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new BadRequestException($"Failed to add annotation: {ex.Message}");
|
|
}
|
|
|
|
return await Task.FromResult(annotatedPdfBytes);
|
|
}
|
|
|
|
private void AddTextMarkupAnnotation(
|
|
PdfPageFacade pageFacade,
|
|
PdfRectangle rectangle,
|
|
Domain.Models.ValueObjects.TextMarkupStyle style,
|
|
string? content,
|
|
string? author,
|
|
PdfRGBColor color)
|
|
{
|
|
// Map our enum to DevExpress enum
|
|
var devExpressStyle = style switch
|
|
{
|
|
Domain.Models.ValueObjects.TextMarkupStyle.Highlight => PdfTextMarkupAnnotationType.Highlight,
|
|
Domain.Models.ValueObjects.TextMarkupStyle.Underline => PdfTextMarkupAnnotationType.Underline,
|
|
Domain.Models.ValueObjects.TextMarkupStyle.Strikeout => PdfTextMarkupAnnotationType.StrikeOut,
|
|
_ => throw new BadRequestException($"Unsupported text markup style: {style}")
|
|
};
|
|
|
|
var annotation = pageFacade.AddTextMarkupAnnotation(rectangle, devExpressStyle);
|
|
|
|
if (annotation != null)
|
|
{
|
|
annotation.Color = color;
|
|
if (!string.IsNullOrWhiteSpace(author))
|
|
annotation.Author = author;
|
|
if (!string.IsNullOrWhiteSpace(content))
|
|
annotation.Contents = content;
|
|
}
|
|
}
|
|
|
|
private void AddFreeTextAnnotation(
|
|
PdfPageFacade pageFacade,
|
|
PdfRectangle rectangle,
|
|
string content,
|
|
string? author,
|
|
PdfRGBColor color)
|
|
{
|
|
var annotation = pageFacade.AddFreeTextAnnotation(rectangle, content);
|
|
|
|
if (annotation != null)
|
|
{
|
|
annotation.Color = color;
|
|
if (!string.IsNullOrWhiteSpace(author))
|
|
annotation.Author = author;
|
|
}
|
|
}
|
|
|
|
private void AddStickyNoteAnnotation(
|
|
PdfPageFacade pageFacade,
|
|
PdfRectangle rectangle,
|
|
string content,
|
|
string? author,
|
|
PdfRGBColor color)
|
|
{
|
|
// Sticky note uses a point (top-left corner of rectangle)
|
|
var point = new PdfPoint(rectangle.Left, rectangle.Top);
|
|
var annotation = pageFacade.AddTextAnnotation(point);
|
|
|
|
if (annotation != null)
|
|
{
|
|
annotation.Color = color;
|
|
annotation.Contents = content;
|
|
if (!string.IsNullOrWhiteSpace(author))
|
|
annotation.Author = author;
|
|
}
|
|
}
|
|
|
|
private void AddCircleAnnotation(
|
|
PdfPageFacade pageFacade,
|
|
PdfRectangle rectangle,
|
|
string? content,
|
|
string? author,
|
|
PdfRGBColor color)
|
|
{
|
|
var annotation = pageFacade.AddCircleAnnotation(rectangle);
|
|
|
|
if (annotation != null)
|
|
{
|
|
annotation.Color = color;
|
|
if (!string.IsNullOrWhiteSpace(author))
|
|
annotation.Author = author;
|
|
if (!string.IsNullOrWhiteSpace(content))
|
|
annotation.Contents = content;
|
|
}
|
|
}
|
|
|
|
private void AddSquareAnnotation(
|
|
PdfPageFacade pageFacade,
|
|
PdfRectangle rectangle,
|
|
string? content,
|
|
string? author,
|
|
PdfRGBColor color)
|
|
{
|
|
var annotation = pageFacade.AddSquareAnnotation(rectangle);
|
|
|
|
if (annotation != null)
|
|
{
|
|
annotation.Color = color;
|
|
if (!string.IsNullOrWhiteSpace(author))
|
|
annotation.Author = author;
|
|
if (!string.IsNullOrWhiteSpace(content))
|
|
annotation.Contents = content;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Parses hex color string (e.g., "FF0000" for red) to PdfRGBColor
|
|
/// </summary>
|
|
private PdfRGBColor? ParseColor(string? hexColor)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(hexColor))
|
|
return null;
|
|
|
|
try
|
|
{
|
|
// Remove '#' if present
|
|
hexColor = hexColor.TrimStart('#');
|
|
|
|
if (hexColor.Length != 6)
|
|
throw new BadRequestException($"Color must be 6-digit hex (e.g., 'FF0000'), got: '{hexColor}'");
|
|
|
|
int r = Convert.ToInt32(hexColor.Substring(0, 2), 16);
|
|
int g = Convert.ToInt32(hexColor.Substring(2, 2), 16);
|
|
int b = Convert.ToInt32(hexColor.Substring(4, 2), 16);
|
|
|
|
return new PdfRGBColor(r / 255.0, g / 255.0, b / 255.0);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new BadRequestException($"Invalid color format: '{hexColor}'. Expected 6-digit hex (e.g., 'FF0000'). Error: {ex.Message}");
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Private Helpers
|
|
|
|
/// <summary>
|
|
/// Detects if PDF is encrypted by scanning for /Encrypt keyword.
|
|
/// </summary>
|
|
private static bool DetectEncryption(byte[] pdfBytes)
|
|
{
|
|
string pdfText = System.Text.Encoding.ASCII.GetString(pdfBytes);
|
|
return pdfText.Contains("/Encrypt", StringComparison.Ordinal);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Detects PDF/A conformance level by scanning PDF metadata.
|
|
/// PDF/A documents contain an XMP metadata stream with pdfaid:conformance and pdfaid:part.
|
|
/// </summary>
|
|
private static (bool isPdfACompliant, string? pdfaVersion) DetectPdfAConformance(byte[] pdfBytes)
|
|
{
|
|
string pdfText = System.Text.Encoding.ASCII.GetString(pdfBytes);
|
|
|
|
// Look for PDF/A identifier in XMP metadata
|
|
// Example: <pdfaid:part>1</pdfaid:part><pdfaid:conformance>B</pdfaid:conformance>
|
|
if (pdfText.Contains("pdfaid:part", StringComparison.Ordinal))
|
|
{
|
|
// Try to extract part and conformance level
|
|
var partMatch = System.Text.RegularExpressions.Regex.Match(pdfText, @"pdfaid:part>(\d+)</pdfaid:part");
|
|
var conformanceMatch = System.Text.RegularExpressions.Regex.Match(pdfText, @"pdfaid:conformance>([ABU])</pdfaid:conformance");
|
|
|
|
if (partMatch.Success && conformanceMatch.Success)
|
|
{
|
|
string part = partMatch.Groups[1].Value; // "1", "2", "3"
|
|
string conformance = conformanceMatch.Groups[1].Value; // "A", "B", "U"
|
|
string pdfaVersion = $"PDF/A-{part}{conformance.ToLower()}";
|
|
return (true, pdfaVersion);
|
|
}
|
|
|
|
// Found pdfaid:part but couldn't parse details
|
|
return (true, "PDF/A (unknown level)");
|
|
}
|
|
|
|
return (false, null);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Detects embedded files in PDF by scanning raw PDF data for /EmbeddedFiles keyword
|
|
/// and parsing the name tree to count attachments.
|
|
/// This is a pragmatic approach as DevExpress PdfDocument API doesn't expose EmbeddedFiles directly.
|
|
/// </summary>
|
|
/// <param name="pdfBytes">PDF raw bytes</param>
|
|
/// <returns>Tuple: (hasAttachments, attachmentCount)</returns>
|
|
private static (bool hasAttachments, int attachmentCount) DetectEmbeddedFiles(byte[] pdfBytes)
|
|
{
|
|
// PDF embedded files are declared in the document catalog:
|
|
// /Names << /EmbeddedFiles << /Names [...] >> >>
|
|
// The /Names array contains pairs: [name1, filespec1, name2, filespec2, ...]
|
|
|
|
string pdfText = System.Text.Encoding.ASCII.GetString(pdfBytes);
|
|
|
|
// Search for /EmbeddedFiles in the context of /Names dictionary
|
|
// Must appear after a /Names keyword to be valid
|
|
int searchStart = 0;
|
|
|
|
while (true)
|
|
{
|
|
// Find next occurrence of /EmbeddedFiles
|
|
int embeddedFilesIndex = pdfText.IndexOf("/EmbeddedFiles", searchStart, StringComparison.Ordinal);
|
|
|
|
if (embeddedFilesIndex == -1)
|
|
return (false, 0); // Not found
|
|
|
|
// Check if there's a /Names keyword BEFORE this /EmbeddedFiles
|
|
// within a reasonable distance (e.g., within the same PDF object, max 5000 chars back)
|
|
int contextStart = Math.Max(0, embeddedFilesIndex - 5000);
|
|
string contextBefore = pdfText.Substring(contextStart, embeddedFilesIndex - contextStart);
|
|
|
|
// Look for /Names in the context before /EmbeddedFiles
|
|
int lastNamesIndex = contextBefore.LastIndexOf("/Names", StringComparison.Ordinal);
|
|
|
|
if (lastNamesIndex != -1)
|
|
{
|
|
// Found /Names before /EmbeddedFiles - this is likely a valid embedded files declaration
|
|
// Now try to parse the /Names array
|
|
int namesArrayStart = pdfText.IndexOf("/Names", embeddedFilesIndex, StringComparison.Ordinal);
|
|
if (namesArrayStart == -1)
|
|
return (true, 0); // Has EmbeddedFiles but can't count
|
|
|
|
int arrayStart = pdfText.IndexOf('[', namesArrayStart);
|
|
if (arrayStart == -1)
|
|
return (true, 0); // Has EmbeddedFiles but can't count
|
|
|
|
int arrayEnd = pdfText.IndexOf(']', arrayStart);
|
|
if (arrayEnd == -1)
|
|
return (true, 0); // Has EmbeddedFiles but can't count
|
|
|
|
// Extract array content and count entries
|
|
string arrayContent = pdfText.Substring(arrayStart + 1, arrayEnd - arrayStart - 1);
|
|
|
|
// Count object references in array
|
|
// The /Names array contains pairs: (filename) objectReference (filename) objectReference ...
|
|
// Each object reference (pattern: "123 0 R") points to one embedded file
|
|
// So the number of object references = number of attachments
|
|
int objectCount = System.Text.RegularExpressions.Regex.Matches(arrayContent, @"\d+ \d+ R").Count;
|
|
|
|
return (true, Math.Max(1, objectCount)); // At least 1 if EmbeddedFiles found
|
|
}
|
|
|
|
// This /EmbeddedFiles was not in the right context, search for next occurrence
|
|
searchStart = embeddedFilesIndex + 1;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Parses page range string into list of zero-based page indices.
|
|
/// </summary>
|
|
/// <param name="pageRange">Page range string (e.g., "1-3,5" or "1,3,5")</param>
|
|
/// <param name="totalPages">Total page count in PDF (for validation)</param>
|
|
/// <returns>List of zero-based page indices</returns>
|
|
/// <exception cref="BadRequestException">Invalid format or page number out of range</exception>
|
|
private static List<int> ParsePageRange(string pageRange, int totalPages)
|
|
{
|
|
var pageIndices = new HashSet<int>(); // Use HashSet to avoid duplicates
|
|
|
|
try
|
|
{
|
|
// Split by comma
|
|
string[] parts = pageRange.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
|
|
|
|
foreach (string part in parts)
|
|
{
|
|
if (part.Contains('-'))
|
|
{
|
|
// Range format: "1-3"
|
|
string[] rangeParts = part.Split('-', StringSplitOptions.TrimEntries);
|
|
if (rangeParts.Length != 2)
|
|
throw new BadRequestException($"Invalid page range format: '{part}'. Expected format: '1-3'");
|
|
|
|
if (!int.TryParse(rangeParts[0], out int start) || !int.TryParse(rangeParts[1], out int end))
|
|
throw new BadRequestException($"Invalid page numbers in range: '{part}'");
|
|
|
|
if (start < 1 || end < 1)
|
|
throw new BadRequestException($"Page numbers must be >= 1 in range: '{part}'");
|
|
|
|
if (start > end)
|
|
throw new BadRequestException($"Start page must be <= end page in range: '{part}'");
|
|
|
|
if (start > totalPages || end > totalPages)
|
|
throw new BadRequestException($"Page range '{part}' exceeds document page count ({totalPages})");
|
|
|
|
// Add pages (convert to zero-based indices)
|
|
for (int i = start; i <= end; i++)
|
|
pageIndices.Add(i - 1);
|
|
}
|
|
else
|
|
{
|
|
// Single page: "5"
|
|
if (!int.TryParse(part, out int pageNum))
|
|
throw new BadRequestException($"Invalid page number: '{part}'");
|
|
|
|
if (pageNum < 1)
|
|
throw new BadRequestException($"Page number must be >= 1: '{part}'");
|
|
|
|
if (pageNum > totalPages)
|
|
throw new BadRequestException($"Page number {pageNum} exceeds document page count ({totalPages})");
|
|
|
|
pageIndices.Add(pageNum - 1); // Convert to zero-based index
|
|
}
|
|
}
|
|
}
|
|
catch (BadRequestException)
|
|
{
|
|
throw; // Re-throw BadRequestException as-is
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new BadRequestException($"Invalid page range format: '{pageRange}'. Error: {ex.Message}");
|
|
}
|
|
|
|
if (pageIndices.Count == 0)
|
|
throw new BadRequestException($"Page range '{pageRange}' resulted in no pages");
|
|
|
|
return pageIndices.OrderBy(x => x).ToList(); // Return sorted list
|
|
}
|
|
|
|
#endregion
|
|
}
|