476 lines
22 KiB
C#
476 lines
22 KiB
C#
using System.Globalization;
|
|
using System.IO.Compression;
|
|
using System.Text;
|
|
using System.Text.Json;
|
|
using System.Xml.Linq;
|
|
|
|
namespace LMEMappeCatastaliApp.Services;
|
|
|
|
public sealed class MapExportService
|
|
{
|
|
private static readonly XNamespace Kml = "http://www.opengis.net/kml/2.2";
|
|
|
|
public async Task<MapExportFile> CreateAsync(
|
|
string requestedName,
|
|
string requestedFormat,
|
|
string geoJson,
|
|
CancellationToken cancellationToken = default)
|
|
{
|
|
using var document = JsonDocument.Parse(geoJson);
|
|
var root = document.RootElement;
|
|
if (!root.TryGetProperty("type", out var type) || type.GetString() != "FeatureCollection"
|
|
|| !root.TryGetProperty("features", out var features)
|
|
|| features.ValueKind != JsonValueKind.Array)
|
|
{
|
|
throw new InvalidDataException("I dati raccolti dalla mappa non sono validi.");
|
|
}
|
|
|
|
var featureCount = features.GetArrayLength();
|
|
if (featureCount == 0)
|
|
{
|
|
throw new InvalidOperationException("Nessun oggetto selezionato e disponibile da esportare.");
|
|
}
|
|
|
|
var format = requestedFormat.Trim().ToLowerInvariant() switch
|
|
{
|
|
"kml" => "kml",
|
|
"kmz" => "kmz",
|
|
"gpx" => "gpx",
|
|
"pdf" => "pdf",
|
|
_ => "geojson"
|
|
};
|
|
var baseName = NormalizeFileName(requestedName);
|
|
var exportDirectory = Path.Combine(FileSystem.CacheDirectory, "Exports");
|
|
Directory.CreateDirectory(exportDirectory);
|
|
var path = Path.Combine(exportDirectory, $"{baseName}.{format}");
|
|
|
|
if (format == "geojson")
|
|
{
|
|
using var output = File.Create(path);
|
|
await JsonSerializer.SerializeAsync(output, root, new JsonSerializerOptions { WriteIndented = true }, cancellationToken);
|
|
return new(path, "application/geo+json", featureCount, Path.GetFileName(path));
|
|
}
|
|
|
|
if (format == "gpx")
|
|
{
|
|
await File.WriteAllTextAsync(path, BuildGpx(features, baseName), new UTF8Encoding(false), cancellationToken);
|
|
return new(path, "application/gpx+xml", featureCount, Path.GetFileName(path));
|
|
}
|
|
|
|
if (format == "pdf")
|
|
{
|
|
await File.WriteAllBytesAsync(path, BuildPdfReport(features, baseName), cancellationToken);
|
|
return new(path, "application/pdf", featureCount, Path.GetFileName(path));
|
|
}
|
|
|
|
var kml = BuildKml(features, baseName);
|
|
if (format == "kml")
|
|
{
|
|
await File.WriteAllTextAsync(path, kml, new UTF8Encoding(false), cancellationToken);
|
|
return new(path, "application/vnd.google-earth.kml+xml", featureCount, Path.GetFileName(path));
|
|
}
|
|
|
|
await using (var output = File.Create(path))
|
|
using (var archive = new ZipArchive(output, ZipArchiveMode.Create))
|
|
{
|
|
var entry = archive.CreateEntry("doc.kml", CompressionLevel.Optimal);
|
|
await using var entryStream = entry.Open();
|
|
await using var writer = new StreamWriter(entryStream, new UTF8Encoding(false));
|
|
await writer.WriteAsync(kml.AsMemory(), cancellationToken);
|
|
}
|
|
return new(path, "application/vnd.google-earth.kmz", featureCount, Path.GetFileName(path));
|
|
}
|
|
|
|
private static string BuildGpx(JsonElement features, string name)
|
|
{
|
|
var root = new XElement("gpx",
|
|
new XAttribute("version", "1.1"),
|
|
new XAttribute("creator", "LME Mappe Catastali 0.4.1"),
|
|
new XAttribute(XNamespace.Xmlns + "xsi", "http://www.w3.org/2001/XMLSchema-instance"),
|
|
new XElement("metadata", new XElement("name", name)));
|
|
foreach (var feature in features.EnumerateArray())
|
|
{
|
|
if (!feature.TryGetProperty("geometry", out var geometry) || geometry.ValueKind != JsonValueKind.Object) continue;
|
|
var properties = feature.TryGetProperty("properties", out var value) ? value : default;
|
|
var featureName = FeatureName(properties, GetString(properties, "_lmeCategory") ?? "drawing");
|
|
var type = geometry.GetProperty("type").GetString();
|
|
var coordinates = geometry.GetProperty("coordinates");
|
|
if (type == "Point")
|
|
{
|
|
root.Add(GpxPoint("wpt", coordinates, featureName));
|
|
}
|
|
else
|
|
{
|
|
foreach (var line in EnumerateGpxLines(type, coordinates))
|
|
{
|
|
root.Add(new XElement("trk", new XElement("name", featureName),
|
|
new XElement("trkseg", line.Select(point => GpxPoint("trkpt", point, null)))));
|
|
}
|
|
}
|
|
}
|
|
return new XDocument(new XDeclaration("1.0", "utf-8", null), root).ToString();
|
|
}
|
|
|
|
private static XElement GpxPoint(string element, JsonElement coordinate, string? name)
|
|
{
|
|
var values = coordinate.EnumerateArray().ToArray();
|
|
var point = new XElement(element,
|
|
new XAttribute("lat", values[1].GetDouble().ToString("G17", CultureInfo.InvariantCulture)),
|
|
new XAttribute("lon", values[0].GetDouble().ToString("G17", CultureInfo.InvariantCulture)));
|
|
if (!string.IsNullOrWhiteSpace(name)) point.Add(new XElement("name", name));
|
|
return point;
|
|
}
|
|
|
|
private static IEnumerable<JsonElement[]> EnumerateGpxLines(string? type, JsonElement coordinates)
|
|
{
|
|
if (type == "LineString") yield return coordinates.EnumerateArray().ToArray();
|
|
else if (type == "Polygon")
|
|
foreach (var ring in coordinates.EnumerateArray()) yield return ring.EnumerateArray().ToArray();
|
|
else if (type == "MultiLineString")
|
|
foreach (var line in coordinates.EnumerateArray()) yield return line.EnumerateArray().ToArray();
|
|
else if (type == "MultiPolygon")
|
|
foreach (var polygon in coordinates.EnumerateArray())
|
|
foreach (var ring in polygon.EnumerateArray()) yield return ring.EnumerateArray().ToArray();
|
|
}
|
|
|
|
private static byte[] BuildPdfReport(JsonElement features, string title)
|
|
{
|
|
var paths = features.EnumerateArray()
|
|
.Where(feature => feature.TryGetProperty("geometry", out _))
|
|
.SelectMany(feature => PdfCoordinatePaths(feature.GetProperty("geometry")))
|
|
.Where(path => path.Count > 0)
|
|
.ToArray();
|
|
var points = paths.SelectMany(path => path).ToArray();
|
|
var minLon = points.Length == 0 ? 0 : points.Min(point => point.Lon);
|
|
var maxLon = points.Length == 0 ? 1 : points.Max(point => point.Lon);
|
|
var minLat = points.Length == 0 ? 0 : points.Min(point => point.Lat);
|
|
var maxLat = points.Length == 0 ? 1 : points.Max(point => point.Lat);
|
|
var lonSpan = Math.Max(0.0000001, maxLon - minLon);
|
|
var latSpan = Math.Max(0.0000001, maxLat - minLat);
|
|
const double mapLeft = 48, mapBottom = 438, mapWidth = 499, mapHeight = 330;
|
|
var scale = Math.Min(mapWidth / lonSpan, mapHeight / latSpan);
|
|
var drawing = new StringBuilder("0.08 0.44 0.37 RG 0.86 0.94 0.91 rg 1.4 w ");
|
|
foreach (var path in paths.Take(400))
|
|
{
|
|
for (var pointIndex = 0; pointIndex < path.Count; pointIndex++)
|
|
{
|
|
var x = mapLeft + (path[pointIndex].Lon - minLon) * scale;
|
|
var y = mapBottom + (path[pointIndex].Lat - minLat) * scale;
|
|
drawing.AppendFormat(CultureInfo.InvariantCulture, "{0:0.##} {1:0.##} {2} ", x, y, pointIndex == 0 ? "m" : "l");
|
|
}
|
|
drawing.Append("S ");
|
|
}
|
|
drawing.Append("0 0 0 RG 1 w 497 730 m 497 758 l S 497 758 m 491 746 l 503 746 l h f ");
|
|
var middleLatitude = (minLat + maxLat) / 2;
|
|
var widthMeters = lonSpan * 111_320 * Math.Cos(middleLatitude * Math.PI / 180);
|
|
var scaleMeters = Math.Max(1, NiceScaleDistance(widthMeters / 4));
|
|
var scalePixels = widthMeters <= 0 ? 80 : Math.Clamp(scaleMeters / widthMeters * mapWidth, 35, 150);
|
|
drawing.AppendFormat(CultureInfo.InvariantCulture, "48 422 m {0:0.##} 422 l S 48 418 m 48 426 l S {0:0.##} 418 m {0:0.##} 426 l S ", 48 + scalePixels);
|
|
var lines = new List<string>
|
|
{
|
|
title,
|
|
$"Rapporto LME Mappe Catastali - {DateTime.Now:dd/MM/yyyy HH:mm}",
|
|
$"Oggetti: {features.GetArrayLength()}",
|
|
$"Scala grafica: {scaleMeters:0} m | Nord: alto pagina",
|
|
""
|
|
};
|
|
var index = 1;
|
|
foreach (var feature in features.EnumerateArray())
|
|
{
|
|
var properties = feature.TryGetProperty("properties", out var value) ? value : default;
|
|
var category = GetString(properties, "_lmeCategory") ?? "drawing";
|
|
var geometry = feature.TryGetProperty("geometry", out var geo) ? geo.GetProperty("type").GetString() : "-";
|
|
var sheet = GetString(properties, "foglio") ?? GetString(properties, "FOGLIO");
|
|
var parcel = GetString(properties, "particella") ?? GetString(properties, "PARTICELLA") ?? GetString(properties, "LABEL");
|
|
var reference = string.Join(" ", new[] { sheet is null ? null : $"F.{sheet}", parcel is null ? null : $"P.{parcel}" }.Where(item => item is not null));
|
|
lines.Add($"{index++}. {FeatureName(properties, category)} [{category}, {geometry}] {reference}".TrimEnd());
|
|
}
|
|
var content = drawing.Append("BT /F1 12 Tf 48 810 Td ");
|
|
foreach (var line in lines.Take(21))
|
|
{
|
|
var safe = line.Replace("\\", "\\\\").Replace("(", "\\(").Replace(")", "\\)")
|
|
.Select(character => character <= 255 ? character : '?').ToArray();
|
|
content.Append('(').Append(safe).Append(") Tj 0 -16 Td ");
|
|
}
|
|
content.Append("ET");
|
|
var stream = Encoding.Latin1.GetBytes(content.ToString());
|
|
var objects = new[]
|
|
{
|
|
"<< /Type /Catalog /Pages 2 0 R >>",
|
|
"<< /Type /Pages /Kids [3 0 R] /Count 1 >>",
|
|
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 595 842] /Resources << /Font << /F1 5 0 R >> >> /Contents 4 0 R >>",
|
|
$"<< /Length {stream.Length} >>\nstream\n{Encoding.Latin1.GetString(stream)}\nendstream",
|
|
"<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>"
|
|
};
|
|
using var output = new MemoryStream();
|
|
using var writer = new StreamWriter(output, Encoding.Latin1, leaveOpen: true) { NewLine = "\n" };
|
|
writer.Write("%PDF-1.4\n"); writer.Flush();
|
|
var offsets = new List<long> { 0 };
|
|
for (var i = 0; i < objects.Length; i++)
|
|
{
|
|
offsets.Add(output.Position); writer.Write($"{i + 1} 0 obj\n{objects[i]}\nendobj\n"); writer.Flush();
|
|
}
|
|
var xref = output.Position;
|
|
writer.Write($"xref\n0 {objects.Length + 1}\n0000000000 65535 f \n");
|
|
foreach (var offset in offsets.Skip(1)) writer.Write($"{offset:0000000000} 00000 n \n");
|
|
writer.Write($"trailer << /Size {objects.Length + 1} /Root 1 0 R >>\nstartxref\n{xref}\n%%EOF");
|
|
writer.Flush();
|
|
return output.ToArray();
|
|
}
|
|
|
|
private static double NiceScaleDistance(double value)
|
|
{
|
|
if (value <= 0) return 1;
|
|
var power = Math.Pow(10, Math.Floor(Math.Log10(value)));
|
|
var normalized = value / power;
|
|
var nice = normalized >= 5 ? 5 : normalized >= 2 ? 2 : 1;
|
|
return nice * power;
|
|
}
|
|
|
|
private static IEnumerable<List<(double Lon, double Lat)>> PdfCoordinatePaths(JsonElement geometry)
|
|
{
|
|
if (!geometry.TryGetProperty("type", out var typeElement) || !geometry.TryGetProperty("coordinates", out var coordinates)) yield break;
|
|
var type = typeElement.GetString();
|
|
if (type == "Point") { yield return [PdfPoint(coordinates)]; yield break; }
|
|
if (type == "LineString") { yield return coordinates.EnumerateArray().Select(PdfPoint).ToList(); yield break; }
|
|
if (type == "Polygon" || type == "MultiLineString")
|
|
{
|
|
foreach (var path in coordinates.EnumerateArray()) yield return path.EnumerateArray().Select(PdfPoint).ToList();
|
|
yield break;
|
|
}
|
|
if (type == "MultiPolygon")
|
|
{
|
|
foreach (var polygon in coordinates.EnumerateArray())
|
|
foreach (var path in polygon.EnumerateArray()) yield return path.EnumerateArray().Select(PdfPoint).ToList();
|
|
}
|
|
}
|
|
|
|
private static (double Lon, double Lat) PdfPoint(JsonElement coordinate) =>
|
|
(coordinate[0].GetDouble(), coordinate[1].GetDouble());
|
|
|
|
private static string BuildKml(JsonElement features, string documentName)
|
|
{
|
|
var document = new XElement(Kml + "Document",
|
|
new XElement(Kml + "name", documentName),
|
|
BuildStyle("imported", "ff2ecc71", "402ecc71"),
|
|
BuildStyle("imported-sheet", "ff22803d", "1022803d"),
|
|
BuildStyle("cadastral", "ff4444ef", "4224bffb"),
|
|
BuildStyle("cadastral-gps", "ffff7a00", "337aff00"),
|
|
BuildStyle("drawing", "ff1679f9", "333c92fb"),
|
|
BuildStyle("poi", "ffff7a00", "33ff7a00"),
|
|
BuildStyle("gps-trail", "ff00a5ff", "2200a5ff"));
|
|
var categoryFolders = new Dictionary<string, XElement>(StringComparer.Ordinal);
|
|
var groupFolders = new Dictionary<(string Category, string Group), XElement>();
|
|
|
|
foreach (var feature in features.EnumerateArray())
|
|
{
|
|
if (!feature.TryGetProperty("geometry", out var geometry)
|
|
|| geometry.ValueKind is JsonValueKind.Null or JsonValueKind.Undefined)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var properties = feature.TryGetProperty("properties", out var propertyElement)
|
|
&& propertyElement.ValueKind == JsonValueKind.Object
|
|
? propertyElement
|
|
: default;
|
|
var category = GetString(properties, "_lmeCategory") ?? "drawing";
|
|
var placemark = new XElement(Kml + "Placemark",
|
|
new XElement(Kml + "name", FeatureName(properties, category)),
|
|
new XElement(Kml + "styleUrl", $"#{NormalizeStyleId(category)}"));
|
|
var featureStyle = BuildFeatureStyle(properties);
|
|
if (featureStyle is not null)
|
|
{
|
|
placemark.Add(featureStyle);
|
|
}
|
|
|
|
var extendedData = BuildExtendedData(properties);
|
|
if (extendedData is not null)
|
|
{
|
|
placemark.Add(extendedData);
|
|
}
|
|
placemark.Add(BuildGeometry(geometry));
|
|
var categoryName = GetString(properties, "_lmeCategoryName")?.Trim();
|
|
var groupName = GetString(properties, "_lmeGroupName")?.Trim();
|
|
var parent = document;
|
|
if (!string.IsNullOrWhiteSpace(categoryName))
|
|
{
|
|
if (!categoryFolders.TryGetValue(categoryName, out var categoryFolder))
|
|
{
|
|
categoryFolder = new XElement(Kml + "Folder", new XElement(Kml + "name", categoryName));
|
|
categoryFolders[categoryName] = categoryFolder;
|
|
document.Add(categoryFolder);
|
|
}
|
|
parent = categoryFolder;
|
|
}
|
|
if (!string.IsNullOrWhiteSpace(groupName))
|
|
{
|
|
var key = (categoryName ?? string.Empty, groupName);
|
|
if (!groupFolders.TryGetValue(key, out var groupFolder))
|
|
{
|
|
groupFolder = new XElement(Kml + "Folder", new XElement(Kml + "name", groupName));
|
|
groupFolders[key] = groupFolder;
|
|
parent.Add(groupFolder);
|
|
}
|
|
parent = groupFolder;
|
|
}
|
|
parent.Add(placemark);
|
|
}
|
|
|
|
return new XDocument(new XDeclaration("1.0", "utf-8", null), new XElement(Kml + "kml", document)).ToString();
|
|
}
|
|
|
|
private static XElement BuildStyle(string id, string lineColor, string fillColor) =>
|
|
new(Kml + "Style",
|
|
new XAttribute("id", id),
|
|
new XElement(Kml + "LineStyle",
|
|
new XElement(Kml + "color", lineColor),
|
|
new XElement(Kml + "width", 3)),
|
|
new XElement(Kml + "PolyStyle", new XElement(Kml + "color", fillColor)));
|
|
|
|
private static XElement? BuildFeatureStyle(JsonElement properties)
|
|
{
|
|
var color = GetString(properties, "_lmeColor");
|
|
var fillColor = GetString(properties, "_lmeFillColor") ?? color;
|
|
if (string.IsNullOrWhiteSpace(color) && string.IsNullOrWhiteSpace(fillColor)) return null;
|
|
var weight = GetNumber(properties, "_lmeWeight", 3);
|
|
var opacity = GetNumber(properties, "_lmeOpacity", 1);
|
|
var fillOpacity = GetNumber(properties, "_lmeFillOpacity", 0.2);
|
|
return new XElement(Kml + "Style",
|
|
new XElement(Kml + "LineStyle",
|
|
new XElement(Kml + "color", ToKmlColor(color ?? "#f97316", opacity)),
|
|
new XElement(Kml + "width", weight.ToString("0.##", CultureInfo.InvariantCulture))),
|
|
new XElement(Kml + "PolyStyle",
|
|
new XElement(Kml + "color", ToKmlColor(fillColor ?? "#fb923c", fillOpacity))));
|
|
}
|
|
|
|
private static double GetNumber(JsonElement properties, string name, double fallback) =>
|
|
properties.ValueKind == JsonValueKind.Object
|
|
&& properties.TryGetProperty(name, out var value)
|
|
&& value.ValueKind == JsonValueKind.Number
|
|
? value.GetDouble()
|
|
: fallback;
|
|
|
|
private static string ToKmlColor(string html, double opacity)
|
|
{
|
|
var value = html.TrimStart('#');
|
|
if (value.Length != 6) value = "f97316";
|
|
var alpha = (int)Math.Round(Math.Clamp(opacity, 0, 1) * 255);
|
|
return $"{alpha:x2}{value[4..6]}{value[2..4]}{value[0..2]}";
|
|
}
|
|
|
|
private static XElement? BuildExtendedData(JsonElement properties)
|
|
{
|
|
if (properties.ValueKind != JsonValueKind.Object)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var data = properties.EnumerateObject()
|
|
.Where(item => item.Name != "_lmeCategory"
|
|
&& item.Value.ValueKind is JsonValueKind.String or JsonValueKind.Number or JsonValueKind.True or JsonValueKind.False)
|
|
.Select(item => new XElement(Kml + "Data",
|
|
new XAttribute("name", item.Name),
|
|
new XElement(Kml + "value", ScalarText(item.Value))))
|
|
.ToArray();
|
|
return data.Length == 0 ? null : new XElement(Kml + "ExtendedData", data);
|
|
}
|
|
|
|
private static XElement BuildGeometry(JsonElement geometry)
|
|
{
|
|
var type = geometry.GetProperty("type").GetString();
|
|
if (type == "GeometryCollection")
|
|
{
|
|
return new XElement(Kml + "MultiGeometry",
|
|
geometry.GetProperty("geometries").EnumerateArray().Select(BuildGeometry));
|
|
}
|
|
|
|
var coordinates = geometry.GetProperty("coordinates");
|
|
return type switch
|
|
{
|
|
"Point" => new XElement(Kml + "Point", CoordinatesElement([coordinates])),
|
|
"LineString" => new XElement(Kml + "LineString", CoordinatesElement(coordinates.EnumerateArray())),
|
|
"Polygon" => BuildPolygon(coordinates),
|
|
"MultiPoint" => new XElement(Kml + "MultiGeometry",
|
|
coordinates.EnumerateArray().Select(point => new XElement(Kml + "Point", CoordinatesElement([point])))),
|
|
"MultiLineString" => new XElement(Kml + "MultiGeometry",
|
|
coordinates.EnumerateArray().Select(line => new XElement(Kml + "LineString", CoordinatesElement(line.EnumerateArray())))),
|
|
"MultiPolygon" => new XElement(Kml + "MultiGeometry", coordinates.EnumerateArray().Select(BuildPolygon)),
|
|
_ => throw new InvalidDataException($"Geometria GeoJSON non supportata: {type}.")
|
|
};
|
|
}
|
|
|
|
private static XElement BuildPolygon(JsonElement rings)
|
|
{
|
|
var ringList = rings.EnumerateArray().ToArray();
|
|
var polygon = new XElement(Kml + "Polygon");
|
|
if (ringList.Length > 0)
|
|
{
|
|
polygon.Add(new XElement(Kml + "outerBoundaryIs",
|
|
new XElement(Kml + "LinearRing", CoordinatesElement(ringList[0].EnumerateArray()))));
|
|
}
|
|
foreach (var ring in ringList.Skip(1))
|
|
{
|
|
polygon.Add(new XElement(Kml + "innerBoundaryIs",
|
|
new XElement(Kml + "LinearRing", CoordinatesElement(ring.EnumerateArray()))));
|
|
}
|
|
return polygon;
|
|
}
|
|
|
|
private static XElement CoordinatesElement(IEnumerable<JsonElement> points) =>
|
|
new(Kml + "coordinates", string.Join(" ", points.Select(FormatCoordinate)));
|
|
|
|
private static string FormatCoordinate(JsonElement coordinate)
|
|
{
|
|
var values = coordinate.EnumerateArray().Take(3)
|
|
.Select(value => value.GetDouble().ToString("G17", CultureInfo.InvariantCulture));
|
|
return string.Join(",", values);
|
|
}
|
|
|
|
private static string FeatureName(JsonElement properties, string category) =>
|
|
GetString(properties, "_lmeDisplayName")
|
|
?? GetString(properties, "name")
|
|
?? GetString(properties, "Name")
|
|
?? GetString(properties, "LABEL")
|
|
?? GetString(properties, "NATIONALCADASTRALREFERENCE")
|
|
?? category switch
|
|
{
|
|
"imported-sheet" => "Cornice o foglio importato",
|
|
"cadastral" => "Particella catastale",
|
|
"cadastral-gps" => "Particella GPS",
|
|
"poi" => "Punto di interesse",
|
|
"gps-trail" => "Traccia GPS",
|
|
_ => "Oggetto mappa"
|
|
};
|
|
|
|
private static string? GetString(JsonElement element, string name) =>
|
|
element.ValueKind == JsonValueKind.Object
|
|
&& element.TryGetProperty(name, out var value)
|
|
&& value.ValueKind == JsonValueKind.String
|
|
? value.GetString()
|
|
: null;
|
|
|
|
private static string ScalarText(JsonElement value) => value.ValueKind == JsonValueKind.String
|
|
? value.GetString() ?? string.Empty
|
|
: value.GetRawText();
|
|
|
|
private static string NormalizeStyleId(string category) => category switch
|
|
{
|
|
"imported" or "imported-sheet" or "cadastral" or "cadastral-gps" or "drawing" or "poi" or "gps-trail" => category,
|
|
_ => "drawing"
|
|
};
|
|
|
|
private static string NormalizeFileName(string requestedName)
|
|
{
|
|
var name = string.IsNullOrWhiteSpace(requestedName) ? "Mappa" : requestedName.Trim();
|
|
foreach (var invalid in Path.GetInvalidFileNameChars())
|
|
{
|
|
name = name.Replace(invalid, '_');
|
|
}
|
|
name = Path.GetFileNameWithoutExtension(name).Trim().TrimEnd('.');
|
|
return string.IsNullOrWhiteSpace(name) ? "Mappa" : name[..Math.Min(name.Length, 80)];
|
|
}
|
|
}
|
|
|
|
public sealed record MapExportFile(string Path, string MimeType, int FeatureCount, string FileName);
|