From 3e2e9c842aef39647e05309760b39acbe2be43a4 Mon Sep 17 00:00:00 2001 From: AJ Isaacs Date: Sun, 15 Nov 2026 14:08:02 -0500 Subject: [PATCH] feat(drawing-library): export drawings as DXF, SVG or .nest Export... saves the selected drawing's listed revision; Export Listed Drawings writes every drawing on the page to a folder, numbering names the batch already used and asking once before replacing files. Files are written beside the target and moved into place. Co-Authored-By: Claude Opus 5.5 --- .../LibraryDrawingExportTests.cs | 159 ++++++++++++++ OpenNest.Desktop/LibraryDrawingExport.cs | 194 ++++++++++++++++++ OpenNest.Desktop/PlateExport.cs | 14 +- .../Forms/DrawingLibraryFormTests.cs | 50 +++++ .../Controls/DrawingLibraryView.Designer.cs | 66 +++++- OpenNest/Controls/DrawingLibraryView.cs | 146 +++++++++++++ docs/nest-storage.md | 23 +++ 7 files changed, 647 insertions(+), 5 deletions(-) create mode 100644 OpenNest.Desktop.Tests/LibraryDrawingExportTests.cs create mode 100644 OpenNest.Desktop/LibraryDrawingExport.cs diff --git a/OpenNest.Desktop.Tests/LibraryDrawingExportTests.cs b/OpenNest.Desktop.Tests/LibraryDrawingExportTests.cs new file mode 100644 index 00000000..2a13b513 --- /dev/null +++ b/OpenNest.Desktop.Tests/LibraryDrawingExportTests.cs @@ -0,0 +1,159 @@ +using System.Xml.Linq; +using OpenNest.Data; +using OpenNest.Geometry; +using OpenNest.IO; + +namespace OpenNest.Desktop.Tests; + +public sealed class LibraryDrawingExportTests : IDisposable +{ + private readonly string folder = Path.Combine(Path.GetTempPath(), $"opennest-library-export-{Guid.NewGuid():N}"); + + public LibraryDrawingExportTests() => Directory.CreateDirectory(folder); + + public void Dispose() => Directory.Delete(folder, true); + + [Theory] + [InlineData(1, LibraryExportFormat.Dxf)] + [InlineData(2, LibraryExportFormat.Svg)] + [InlineData(3, LibraryExportFormat.Nest)] + public void FromFilterIndex_FollowsTheDialogFilter(int index, LibraryExportFormat expected) + { + Assert.Equal(expected, LibraryDrawingExport.FromFilterIndex(index)); + var patterns = LibraryDrawingExport.DialogFilter.Split('|').Where((_, i) => i % 2 == 1).ToArray(); + Assert.Equal("*" + LibraryDrawingExport.Extension(expected), patterns[index - 1]); + } + + [Theory] + [InlineData(0)] + [InlineData(4)] + public void FromFilterIndex_RefusesOtherIndexes(int index) => + Assert.Throws(() => LibraryDrawingExport.FromFilterIndex(index)); + + [Theory] + [InlineData("BRKT-1", LibraryExportFormat.Dxf, "BRKT-1.dxf")] + [InlineData(" A/B:C ", LibraryExportFormat.Svg, "A_B_C.svg")] + [InlineData("", LibraryExportFormat.Nest, "Drawing.nest")] + public void SuggestedFileName_IsTheSafeDrawingName(string name, LibraryExportFormat format, string expected) => + Assert.Equal(expected, LibraryDrawingExport.SuggestedFileName(new DrawingLibraryRecord { Name = name }, format)); + + [Fact] + public void PlanFolder_NumbersNamesTheBatchAlreadyTook() + { + var records = new[] { "Plate", "plate", "Other", "Plate" } + .Select(name => new DrawingLibraryRecord { Id = Guid.NewGuid(), Name = name }); + + var targets = LibraryDrawingExport.PlanFolder(records, folder, LibraryExportFormat.Dxf); + + Assert.Equal(new[] { "Plate.dxf", "plate (2).dxf", "Other.dxf", "Plate (3).dxf" }, + targets.Select(target => Path.GetFileName(target.Path))); + Assert.All(targets, target => Assert.Equal(folder, Path.GetDirectoryName(target.Path))); + } + + [Fact] + public void Write_Dxf_ReadsBackAsTheDrawingsGeometry() + { + var path = Path.Combine(folder, "part.dxf"); + + LibraryDrawingExport.Write(Package(Units.Inches), path, LibraryExportFormat.Dxf); + + var box = Dxf.GetGeometry(path).Cast().GetBoundingBox(); + Assert.Equal(4, box.Width, 6); + Assert.Equal(4, box.Length, 6); + Assert.Empty(Directory.GetFiles(folder, "*.tmp")); + } + + [Fact] + public void Write_Svg_UsesThePackagesUnits() + { + var path = Path.Combine(folder, "part.svg"); + + LibraryDrawingExport.Write(Package(Units.Millimeters), path, LibraryExportFormat.Svg); + + Assert.EndsWith("mm", XDocument.Load(path).Root!.Attribute("width")!.Value); + } + + [Fact] + public void Write_Nest_IsThePackageAsStored() + { + var path = Path.Combine(folder, "part.nest"); + var package = Package(Units.Inches); + + LibraryDrawingExport.Write(package, path, LibraryExportFormat.Nest); + + Assert.Equal(package, File.ReadAllBytes(path)); + } + + [Fact] + public void Write_ADamagedPackage_LeavesTheExistingFileAlone() + { + var path = Path.Combine(folder, "part.nest"); + File.WriteAllText(path, "keep me"); + + Assert.Throws(() => + LibraryDrawingExport.Write(new byte[] { 1, 2, 3 }, path, LibraryExportFormat.Nest)); + + Assert.Equal("keep me", File.ReadAllText(path)); + Assert.Single(Directory.GetFiles(folder)); + } + + [Fact] + public async Task ExportAsync_WritesWhatItCan_AndReportsTheRest() + { + var library = new FakeLibrary(); + var good = library.Add("Good", Package(Units.Inches)); + var gone = new DrawingLibraryRecord { Id = Guid.NewGuid(), Revision = 1, Name = "Gone" }; + var damaged = library.Add("Damaged", new byte[] { 9 }); + var targets = LibraryDrawingExport.PlanFolder(new[] { good, gone, damaged }, folder, LibraryExportFormat.Dxf); + var reported = new List(); + + var result = await LibraryDrawingExport.ExportAsync(library, targets, LibraryExportFormat.Dxf, + new SynchronousProgress(reported.Add)); + + Assert.Equal(new[] { targets[0].Path }, result.Written); + Assert.Same(gone, Assert.Single(result.Missing)); + Assert.Same(damaged, Assert.Single(result.Failed).Record); + Assert.Equal(new[] { 1, 2, 3 }, reported); + Assert.Equal(new[] { "Good.dxf" }, Directory.GetFiles(folder).Select(Path.GetFileName)); + } + + [Fact] + public async Task ExportAsync_StopsWhenCanceled() + { + var library = new FakeLibrary(); + var targets = LibraryDrawingExport.PlanFolder(new[] { library.Add("A", Package(Units.Inches)) }, + folder, LibraryExportFormat.Dxf); + using var cancel = new CancellationTokenSource(); + cancel.Cancel(); + + await Assert.ThrowsAnyAsync(() => + LibraryDrawingExport.ExportAsync(library, targets, LibraryExportFormat.Dxf, null, cancel.Token)); + Assert.Empty(Directory.GetFiles(folder)); + } + + private static byte[] Package(Units units) => + DrawingPackage.Write(new Drawing("square", PlateExportTests.Square(4)), units); + + private sealed class SynchronousProgress(Action report) : IProgress + { + public void Report(int value) => report(value); + } + + private sealed class FakeLibrary : IDrawingLibrary + { + private readonly Dictionary<(Guid, int), byte[]> packages = new(); + + public DrawingLibraryRecord Add(string name, byte[] package) + { + var record = new DrawingLibraryRecord { Id = Guid.NewGuid(), Revision = 1, Name = name }; + packages[(record.Id, record.Revision)] = package; + return record; + } + + public Task QueryAsync(DrawingLibraryQuery query, CancellationToken cancellationToken = default) => + throw new NotSupportedException(); + + public Task GetRevisionPackageAsync(Guid id, int revision, CancellationToken cancellationToken = default) => + Task.FromResult(packages.TryGetValue((id, revision), out var package) ? package : null); + } +} diff --git a/OpenNest.Desktop/LibraryDrawingExport.cs b/OpenNest.Desktop/LibraryDrawingExport.cs new file mode 100644 index 00000000..1a7ea53f --- /dev/null +++ b/OpenNest.Desktop/LibraryDrawingExport.cs @@ -0,0 +1,194 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Net.Http; +using System.Threading; +using System.Threading.Tasks; +using OpenNest.Data; +using OpenNest.IO; + +namespace OpenNest.Desktop; + +/// What exporting a drawing from the drawing library writes. +public enum LibraryExportFormat +{ + /// The drawing's program as DXF geometry. + Dxf, + + /// The drawing's program as SVG in the units it was saved in. + Svg, + + /// The revision's package as stored: a .nest holding the one drawing. + Nest, +} + +/// One drawing to export and the file it goes to. +public sealed record LibraryExportTarget(DrawingLibraryRecord Record, string Path); + +/// What a library export wrote, and what it could not. +public sealed class LibraryExportResult +{ + /// The files written, in order. + public List Written { get; } = new(); + + /// The drawings whose listed revision is no longer on the server. + public List Missing { get; } = new(); + + /// The drawings that could not be read or written, with the reason. + public List<(DrawingLibraryRecord Record, string Reason)> Failed { get; } = new(); +} + +/// +/// Export from the drawing library for both desktop apps: downloads each listed revision's +/// exact package and writes it as DXF, SVG or the package itself. Nothing on the server or in +/// an open nest changes. The package leaves customer, color and nesting settings to the +/// library record, so a .nest export carries the geometry, units, bends and cut settings only. +/// +public static class LibraryDrawingExport +{ + /// The save dialog's file types in order: its 1-based filter index picks the format. + public static IReadOnlyList DialogFormats { get; } = new[] + { + LibraryExportFormat.Dxf, + LibraryExportFormat.Svg, + LibraryExportFormat.Nest, + }; + + /// The WinForms save dialog filter, in order. + public const string DialogFilter = "DXF (*.dxf)|*.dxf|SVG (*.svg)|*.svg|OpenNest nest (*.nest)|*.nest"; + + /// The format for the save dialog's 1-based . + public static LibraryExportFormat FromFilterIndex(int filterIndex) => + filterIndex >= 1 && filterIndex <= DialogFormats.Count + ? DialogFormats[filterIndex - 1] + : throw new ArgumentException("Unsupported drawing export format.", nameof(filterIndex)); + + /// The file extension a format is written with, including the dot. + public static string Extension(LibraryExportFormat format) => format switch + { + LibraryExportFormat.Dxf => ".dxf", + LibraryExportFormat.Svg => ".svg", + LibraryExportFormat.Nest => ".nest", + _ => throw new ArgumentException("Unsupported drawing export format.", nameof(format)), + }; + + /// + /// The file a drawing is suggested to be saved as: its name, made safe for a file name on + /// every platform ("Drawing" when blank), with the format's extension. + /// + public static string SuggestedFileName(DrawingLibraryRecord record, LibraryExportFormat format) + { + ArgumentNullException.ThrowIfNull(record); + return PlateExport.SafeFileName(record.Name, "Drawing") + Extension(format); + } + + /// + /// The file in each drawing is exported to: its suggested name, with + /// " (2)", " (3)"... added when another drawing in the batch already took it (names compared + /// ignoring case, as Windows does). Files already in the folder are not considered; callers + /// ask before overwriting them. + /// + public static IReadOnlyList PlanFolder( + IEnumerable records, string folder, LibraryExportFormat format) + { + ArgumentNullException.ThrowIfNull(records); + ArgumentException.ThrowIfNullOrWhiteSpace(folder); + var taken = new HashSet(StringComparer.OrdinalIgnoreCase); + var targets = new List(); + foreach (var record in records) + { + var name = SuggestedFileName(record, format); + var stem = System.IO.Path.GetFileNameWithoutExtension(name); + var extension = Extension(format); + for (var copy = 2; !taken.Add(name); copy++) + name = $"{stem} ({copy}){extension}"; + targets.Add(new LibraryExportTarget(record, System.IO.Path.Combine(folder, name))); + } + return targets; + } + + /// + /// Writes one revision's to . The file + /// is written beside it under a temporary name and then moved over it, so a failure never + /// leaves a partial file or damages one already there. Throws + /// for an unreadable package. + /// + public static void Write(byte[] package, string destination, LibraryExportFormat format) + { + ArgumentNullException.ThrowIfNull(package); + ArgumentException.ThrowIfNullOrWhiteSpace(destination); + Extension(format); + + // Reading first refuses a damaged package, even when it would be copied as is. + var contents = DrawingPackage.Read(package); + var folder = System.IO.Path.GetDirectoryName(System.IO.Path.GetFullPath(destination))!; + var temporary = System.IO.Path.Combine(folder, $".{System.IO.Path.GetFileName(destination)}.{Guid.NewGuid():N}.tmp"); + try + { + switch (format) + { + case LibraryExportFormat.Dxf: + Dxf.ExportProgram(contents.Drawing.Program, temporary); + break; + case LibraryExportFormat.Svg: + Svg.ExportProgram(contents.Drawing.Program, temporary, contents.Units); + break; + case LibraryExportFormat.Nest: + File.WriteAllBytes(temporary, package); + break; + } + File.Move(temporary, destination, overwrite: true); + } + finally + { + if (File.Exists(temporary)) + File.Delete(temporary); + } + } + + /// + /// Downloads each target's listed revision and writes it in , in + /// order. A revision no longer on the server, an unreadable package or a file that cannot be + /// written is recorded and the rest still export; cancellation stops the batch. + /// receives the number of drawings finished so far. + /// + public static async Task ExportAsync( + IDrawingLibrary library, + IReadOnlyList targets, + LibraryExportFormat format, + IProgress progress = null, + CancellationToken cancellationToken = default) + { + ArgumentNullException.ThrowIfNull(library); + ArgumentNullException.ThrowIfNull(targets); + Extension(format); + + var result = new LibraryExportResult(); + for (var i = 0; i < targets.Count; i++) + { + cancellationToken.ThrowIfCancellationRequested(); + var (record, path) = targets[i]; + try + { + var package = await library.GetRevisionPackageAsync(record.Id, record.Revision, cancellationToken); + if (package == null) + result.Missing.Add(record); + else + { + await Task.Run(() => Write(package, path, format), cancellationToken); + result.Written.Add(path); + } + } + catch (Exception ex) when (!cancellationToken.IsCancellationRequested + && (ex is IOException || ex is InvalidDataException || ex is UnauthorizedAccessException + || ex is HttpRequestException || ex is TaskCanceledException)) + { + // ServerTooOldException is an IOException; InvalidDataException (an unreadable package) is not. + result.Failed.Add((record, ex.Message)); + } + progress?.Report(i + 1); + } + return result; + } +} diff --git a/OpenNest.Desktop/PlateExport.cs b/OpenNest.Desktop/PlateExport.cs index 8bd1f089..11f62ae8 100644 --- a/OpenNest.Desktop/PlateExport.cs +++ b/OpenNest.Desktop/PlateExport.cs @@ -76,11 +76,17 @@ public static class PlateExport /// "-P" with the 1-based plate number ("job-P2"). Characters a file name cannot hold on any /// platform become underscores; a blank nest name is "Nest". /// - public static string SuggestedFileName(string nestName, int plateNumber) + public static string SuggestedFileName(string nestName, int plateNumber) => + $"{SafeFileName(nestName, "Nest")}-P{plateNumber}"; + + /// + /// trimmed, with characters a file name cannot hold on any platform + /// turned into underscores; when it is blank. + /// + internal static string SafeFileName(string name, string fallback) { - var baseName = string.IsNullOrWhiteSpace(nestName) ? "Nest" : nestName.Trim(); - var chars = baseName.Select(c => Array.IndexOf(InvalidFileNameChars, c) >= 0 ? '_' : c).ToArray(); - return $"{new string(chars)}-P{plateNumber}"; + var baseName = string.IsNullOrWhiteSpace(name) ? fallback : name.Trim(); + return new string(baseName.Select(c => Array.IndexOf(InvalidFileNameChars, c) >= 0 ? '_' : c).ToArray()); } /// The DXF that View in CAD writes for the plate and opens: .dxf. diff --git a/OpenNest.WinForms.Tests/Forms/DrawingLibraryFormTests.cs b/OpenNest.WinForms.Tests/Forms/DrawingLibraryFormTests.cs index 07b1cb74..2a0dc44f 100644 --- a/OpenNest.WinForms.Tests/Forms/DrawingLibraryFormTests.cs +++ b/OpenNest.WinForms.Tests/Forms/DrawingLibraryFormTests.cs @@ -578,6 +578,56 @@ public class DrawingLibraryFormTests "The drawing library filter test did not complete."); } + [Fact] + public void Export_SavesTheSelectedDrawing_AndTheListedPageToAFolder() + { + var folder = Path.Combine(Path.GetTempPath(), $"opennest-library-export-{Guid.NewGuid():N}"); + Directory.CreateDirectory(folder); + try + { + StaTestThread.Run( + () => + { + var library = new FakeLibrary(); + var record = library.Add("SYN-EXPORT", "", "", 0, Units.Millimeters, ""); + var messages = new List(); + + using var form = new DrawingLibraryForm(library, Server, nest: null); + form.View.ShowMessage = (text, _, _) => { messages.Add(text); return DialogResult.OK; }; + form.View.LoadPreview = (_, _) => Task.FromResult(null!); + var single = Path.Combine(folder, "one.svg"); + form.View.ChooseExportFile = chosen => + { + Assert.Same(record, chosen); + return (single, OpenNest.Desktop.LibraryExportFormat.Svg); + }; + form.View.ChooseExportFolder = () => folder; + form.Show(); + var grid = Field(form, "drawingGrid"); + PumpUntilListed(grid, "the library page"); + Assert.True(Field