1085 lines
44 KiB
C#
1085 lines
44 KiB
C#
#nullable enable
|
|
|
|
using System;
|
|
using System.Collections.ObjectModel;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text.Json;
|
|
using System.Threading.Tasks;
|
|
using Avalonia.Platform.Storage;
|
|
using Avalonia.Themes.Fluent;
|
|
using DialogHostAvalonia;
|
|
using ImageMagick;
|
|
using MigraDoc.DocumentObjectModel;
|
|
using MigraDoc.Rendering;
|
|
using PdfSharp.Fonts;
|
|
using PdfSharp.Pdf.IO;
|
|
using PdfSharp.Snippets.Font;
|
|
using MayShow.Helpers;
|
|
using MayShow.Interfaces;
|
|
using MayShow.Models;
|
|
|
|
using Docnet.Core.Models;
|
|
using Docnet.Core;
|
|
using SixLabors.ImageSharp;
|
|
using SixLabors.ImageSharp.PixelFormats;
|
|
using SixLabors.ImageSharp.Processing;
|
|
using System.Reflection.Metadata.Ecma335;
|
|
using Docnet.Core.Readers;
|
|
using MigraDoc.DocumentObjectModel.Visitors;
|
|
using System.Collections.Generic;
|
|
|
|
namespace MayShow.ViewModels;
|
|
|
|
class MainViewModel : BaseViewModel, IFontResolver, ICanCheckShutdown
|
|
{
|
|
private bool _isPerformingInitialLoad;
|
|
private string _processDir;
|
|
private bool _isCreatingPDF;
|
|
private string _programLog;
|
|
private string _workingFolder;
|
|
|
|
private string _reportTitle;
|
|
private ObservableCollection<ReportFile> _reportFiles;
|
|
private DateTime? _lastGeneratedTime;
|
|
|
|
private Settings _settings;
|
|
private List<DateDisplayFormat> _dateDisplayFormats;
|
|
|
|
private bool _hasUnsavedWork;
|
|
|
|
public MainViewModel(IChangeViewModel viewModelChanger) : base(viewModelChanger)
|
|
{
|
|
_isPerformingInitialLoad = true;
|
|
_processDir = Path.GetDirectoryName(Environment.ProcessPath) ?? "";
|
|
Console.WriteLine("Internal storage directory is: {0}", Utilities.GetInternalDataPath());
|
|
_isCreatingPDF = false;
|
|
var quotes = Constants.GetQuotes();
|
|
Random random = new Random();
|
|
var quoteIndex = random.Next(0, quotes.Length);
|
|
_programLog = "----- MayShow v" + Constants.AppVersion + " ------" + Environment.NewLine;
|
|
_programLog += quotes[quoteIndex] + Environment.NewLine;
|
|
_programLog += "---------------------------------------" + Environment.NewLine;
|
|
_programLog += "Loaded and ready to create report!" + Environment.NewLine;
|
|
_programLog += "Please copy and send this Program Log when reporting any issues with the software.";
|
|
_workingFolder = "";
|
|
ReportFiles = _reportFiles = new ObservableCollection<ReportFile>();
|
|
_reportTitle = "";
|
|
_lastGeneratedTime = null;
|
|
_settings = Settings.LoadSettings();
|
|
_dateDisplayFormats = Constants.GetDateDisplayFormats();
|
|
NotifyPropertyChanged(nameof(DataGridDateFormat));
|
|
NotifyPropertyChanged(nameof(DataGridDateFormatWatermark));
|
|
if (!string.IsNullOrWhiteSpace(_settings.LastUsedPath))
|
|
{
|
|
LogInfo("Loading data at last used path of {0}", _settings.LastUsedPath);
|
|
ScanFolder(_settings.LastUsedPath);
|
|
}
|
|
else
|
|
{
|
|
LogInfo("Choose a receipt folder to begin...");
|
|
}
|
|
HasUnsavedWork = false;
|
|
_isPerformingInitialLoad = false;
|
|
}
|
|
|
|
public string ReportTitle
|
|
{
|
|
get => _reportTitle;
|
|
set
|
|
{
|
|
_reportTitle = value;
|
|
NotifyPropertyChanged();
|
|
NotifyPropertyChanged(nameof(IsTitleBoxVisible));
|
|
NotifyPropertyChanged(nameof(CanAddItem));
|
|
}
|
|
}
|
|
|
|
public bool IsTitleBoxVisible
|
|
{
|
|
get => !string.IsNullOrWhiteSpace(WorkingFolder);
|
|
}
|
|
|
|
public bool CanAddItem
|
|
{
|
|
get => IsTitleBoxVisible && !IsCreatingPDF;
|
|
}
|
|
|
|
public bool IsCreatingPDF
|
|
{
|
|
get => _isCreatingPDF;
|
|
set
|
|
{
|
|
_isCreatingPDF = value;
|
|
NotifyPropertyChanged();
|
|
NotifyPropertyChanged(nameof(IsCreatePDFButtonEnabled));
|
|
NotifyPropertyChanged(nameof(HasWorkingFolderAndNotMakingPDF));
|
|
NotifyPropertyChanged(nameof(CanAddItem));
|
|
}
|
|
}
|
|
|
|
public bool IsCreatePDFButtonEnabled
|
|
{
|
|
get => !_isCreatingPDF && _reportFiles.Count > 0;
|
|
}
|
|
|
|
public bool HasWorkingFolder
|
|
{
|
|
get => !string.IsNullOrWhiteSpace(WorkingFolder) && Directory.Exists(WorkingFolder);
|
|
}
|
|
|
|
public bool HasWorkingFolderAndNotMakingPDF
|
|
{
|
|
get => !string.IsNullOrWhiteSpace(WorkingFolder) && Directory.Exists(WorkingFolder) && !_isCreatingPDF;
|
|
}
|
|
|
|
public string WorkingFolder
|
|
{
|
|
get => _workingFolder;
|
|
set
|
|
{
|
|
_workingFolder = value;
|
|
NotifyPropertyChanged();
|
|
NotifyPropertyChanged(nameof(HasWorkingFolder));
|
|
NotifyPropertyChanged(nameof(HasWorkingFolderAndNotMakingPDF));
|
|
}
|
|
}
|
|
|
|
public string ProgramLog
|
|
{
|
|
get => _programLog;
|
|
set { _programLog = value; NotifyPropertyChanged(); }
|
|
}
|
|
|
|
public bool HasUnsavedWork
|
|
{
|
|
get => _hasUnsavedWork;
|
|
set
|
|
{
|
|
_hasUnsavedWork = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
|
|
public ObservableCollection<ReportFile> ReportFiles
|
|
{
|
|
get => _reportFiles;
|
|
set
|
|
{
|
|
_reportFiles = value;
|
|
NotifyPropertyChanged();
|
|
_reportFiles.CollectionChanged += ( sender, e ) =>
|
|
{
|
|
NotifyPropertyChanged(nameof(IsCreatePDFButtonEnabled));
|
|
HasUnsavedWork = true;
|
|
};
|
|
}
|
|
}
|
|
|
|
public string DataGridDateFormat
|
|
{
|
|
get => _settings.DataGridDateFormat;
|
|
}
|
|
|
|
public string DataGridDateFormatWatermark
|
|
{
|
|
get => _dateDisplayFormats.Where(x => x.Value == _settings.DataGridDateFormat).FirstOrDefault()?.Example ?? "2025-12-04";
|
|
}
|
|
|
|
private void LogInfo(string message, params object[]? arguments)
|
|
{
|
|
var timestamp = string.Format("[{0:s}]", DateTime.Now);
|
|
Console.WriteLine(timestamp + " " + message, arguments);
|
|
ProgramLog += Environment.NewLine + string.Format(message, arguments ?? []);
|
|
}
|
|
|
|
public async void ChooseFolder()
|
|
{
|
|
var topLevel = TopLevelGrabber?.GetTopLevel();
|
|
if (topLevel is not null)
|
|
{
|
|
var folders = await topLevel.StorageProvider.OpenFolderPickerAsync(new FolderPickerOpenOptions()
|
|
{
|
|
Title = "Pick a folder of files...",
|
|
AllowMultiple = false,
|
|
});
|
|
if (folders.Count == 1)
|
|
{
|
|
var folder = folders[0];
|
|
LogInfo("Clearing existing list and loading items in folder: " + folder.Path.LocalPath);
|
|
ReportFiles.Clear();
|
|
ScanFolder(folder.Path.LocalPath);
|
|
_settings.LastUsedPath = folder.Path.LocalPath;
|
|
await _settings.SaveSettingsAsync();
|
|
ResortPDFItemsByDate();
|
|
HasUnsavedWork = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
private string GetReportSavedDataPath(string folderPath)
|
|
{
|
|
if (_settings.SaveReportJsonDataInInternalDir)
|
|
{
|
|
var internalPath = Utilities.GetInternalDataPath();
|
|
if (!_settings.WorkingFolderToInternalFolderName.ContainsKey(folderPath))
|
|
{
|
|
var uuid = "";
|
|
var potentialPath = "";
|
|
var isDone = false;
|
|
// make sure uuid not already used...just in case...because paranoia...
|
|
do
|
|
{
|
|
uuid = Guid.NewGuid().ToString();
|
|
potentialPath = Path.Combine(internalPath, uuid);
|
|
isDone = !Directory.Exists(potentialPath);
|
|
} while (!isDone);
|
|
// make internal dir -- using dir so we have option to copy data into dir later if needed
|
|
// (if we ever implement a more robust report system where we keep all files)
|
|
Directory.CreateDirectory(potentialPath);
|
|
_settings.WorkingFolderToInternalFolderName[folderPath] = uuid;
|
|
_settings.SaveSettingsNotAsync(); // save new key/value pair
|
|
}
|
|
return Path.Combine(
|
|
internalPath,
|
|
_settings.WorkingFolderToInternalFolderName[folderPath],
|
|
Constants.ReportSavedDataFileName
|
|
);
|
|
}
|
|
else
|
|
{
|
|
return Path.Combine(folderPath, Constants.ReportSavedDataFileName);
|
|
}
|
|
}
|
|
|
|
private void ScanFolder(string path)
|
|
{
|
|
if (Directory.Exists(path))
|
|
{
|
|
WorkingFolder = path;
|
|
NotifyPropertyChanged(nameof(IsTitleBoxVisible));
|
|
NotifyPropertyChanged(nameof(CanAddItem));
|
|
var reportFilePath = GetReportSavedDataPath(path);
|
|
var successfullyLoadedPriorReport = false;
|
|
if (File.Exists(reportFilePath))
|
|
{
|
|
// load prior report
|
|
var json = File.ReadAllText(reportFilePath);
|
|
var jsonContext = new SourceGenerationContext(Utilities.GetSerializerOptions());
|
|
var report = JsonSerializer.Deserialize<PDFReport>(json, jsonContext.PDFReport);
|
|
if (report != null && report.Files.Count > 0)
|
|
{
|
|
Console.WriteLine("Loading prior report data at {0}", reportFilePath);
|
|
ReportFiles = new ObservableCollection<ReportFile>(report.Files);
|
|
ReportTitle = report.Title;
|
|
WorkingFolder = report.BaseFolder;
|
|
_lastGeneratedTime = report.LastGenerated ?? null;
|
|
LogInfo("Reloaded report last saved at {0}", report.LastSaved);
|
|
successfullyLoadedPriorReport = true;
|
|
}
|
|
}
|
|
if (!successfullyLoadedPriorReport)
|
|
{
|
|
// Scan folder for files and display in DataGrid
|
|
ReportFiles.Clear();
|
|
ReportTitle = "";
|
|
var filePaths = Directory.GetFiles(WorkingFolder);
|
|
foreach (var filePath in filePaths)
|
|
{
|
|
AddFileBasedOnPath(filePath);
|
|
}
|
|
ResortPDFItemsByDate();
|
|
HasUnsavedWork = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LogInfo("Error: The directory {0} does not exist. Please select another folder.", path);
|
|
}
|
|
NotifyPropertyChanged(nameof(IsCreatePDFButtonEnabled));
|
|
}
|
|
|
|
public void ShowAbout()
|
|
{
|
|
DialogHost.Show(new AboutViewModel());
|
|
}
|
|
|
|
public async Task ShowSettings()
|
|
{
|
|
var updatedSettings = await DialogHost.Show(new SettingsViewModel(_settings, TopLevelGrabber));
|
|
if (updatedSettings != null)
|
|
{
|
|
_settings = (Settings)updatedSettings;
|
|
await _settings.SaveSettingsAsync();
|
|
LogInfo("Saved updated settings!");
|
|
NotifyPropertyChanged(nameof(DataGridDateFormat));
|
|
NotifyPropertyChanged(nameof(DataGridDateFormatWatermark));
|
|
}
|
|
}
|
|
|
|
public void RemoveFile(object f) => RemoveFileImpl((ReportFile)f);
|
|
|
|
public async void RemoveFileImpl(ReportFile file)
|
|
{
|
|
var result = await DialogHost.Show(new WarningDeleteItemViewModel(file));
|
|
if (result != null && (bool)result)
|
|
{
|
|
var idx = ReportFiles.IndexOf(file);
|
|
if (idx != -1)
|
|
{
|
|
ReportFiles.RemoveAt(idx);
|
|
HasUnsavedWork = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// https://github.com/AvaloniaUI/Avalonia/issues/10075
|
|
public void EditFileProperties(object f) => EditFilePropertiesImpl((ReportFile)f);
|
|
|
|
public async void EditFilePropertiesImpl(ReportFile file)
|
|
{
|
|
var result = await DialogHost.Show(new EditFileViewModel(file, ViewModelChanger));
|
|
if (result != null && result is ReportFile updatedData)
|
|
{
|
|
file.Title = updatedData.Title;
|
|
file.ReceiptDateTime = updatedData.ReceiptDateTime;
|
|
file.Notes = updatedData.Notes;
|
|
HasUnsavedWork = true;
|
|
}
|
|
}
|
|
|
|
public async void AddItem()
|
|
{
|
|
var topLevel = TopLevelGrabber?.GetTopLevel();
|
|
if (topLevel is not null)
|
|
{
|
|
var files = await topLevel.StorageProvider.OpenFilePickerAsync(new FilePickerOpenOptions()
|
|
{
|
|
Title = "Choose image or PDF files...",
|
|
AllowMultiple = true,
|
|
FileTypeFilter = [
|
|
new FilePickerFileType("All Types")
|
|
{
|
|
Patterns = Constants.AllowedFileExtensionPatterns,
|
|
AppleUniformTypeIdentifiers = [ "public.image", "com.adobe.pdf", "public.heic" ],
|
|
MimeTypes = [ "image/*", "application/pdf", "image/heic" ]
|
|
},
|
|
FilePickerFileTypes.ImageAll,
|
|
new FilePickerFileType("HEIC Images")
|
|
{
|
|
Patterns = [ "*.heic" ],
|
|
AppleUniformTypeIdentifiers = [ "public.heic" ],
|
|
MimeTypes = [ "image/heic" ]
|
|
},
|
|
FilePickerFileTypes.Pdf,
|
|
],
|
|
});
|
|
if (files.Count > 0)
|
|
{
|
|
foreach (var file in files)
|
|
{
|
|
var filePath = file.TryGetLocalPath();
|
|
AddFileBasedOnPath(filePath);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void AddFileBasedOnPath(string? filePath)
|
|
{
|
|
if (!string.IsNullOrWhiteSpace(filePath) && File.Exists(filePath) && !filePath.EndsWith(".DS_Store"))
|
|
{
|
|
// make sure extensions are OK
|
|
var fileExtensions = Constants.AllowedFileExtensionsNoStar;
|
|
var didMatch = false;
|
|
foreach (var fileExtension in fileExtensions)
|
|
{
|
|
if (filePath.ToLower().EndsWith("." + fileExtension.ToLower()))
|
|
{
|
|
didMatch = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!didMatch)
|
|
{
|
|
if (!filePath.EndsWith(Constants.ReportSavedDataFileName))
|
|
{
|
|
LogInfo("File {0} did not match allowed file extension types, so it was not added.", filePath);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var date = Utilities.CheckValidDateInString(filePath);
|
|
ReportFiles.Add(new ReportFile()
|
|
{
|
|
Title = Path.GetFileName(filePath),
|
|
ReceiptDateTime = date.HasValue ? date.Value.ToDateTime(TimeOnly.MinValue) : File.GetCreationTime(filePath),
|
|
Notes = "",
|
|
FilePath = filePath,
|
|
});
|
|
HasUnsavedWork = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
public async void RemoveAllItems()
|
|
{
|
|
var result = await DialogHost.Show(new ConfirmViewModel("Warning!", "Are you sure you want to remove all items from this report?", "Remove All Items", "Cancel"));
|
|
if (result != null && (bool)result)
|
|
{
|
|
ReportFiles.Clear();
|
|
HasUnsavedWork = true;
|
|
NotifyPropertyChanged(nameof(IsCreatePDFButtonEnabled));
|
|
}
|
|
}
|
|
|
|
public void LocateFile(object f) => LocateFileImpl((ReportFile) f);
|
|
public async void LocateFileImpl(ReportFile reportFile)
|
|
{
|
|
var topLevel = TopLevelGrabber?.GetTopLevel();
|
|
if (topLevel is not null)
|
|
{
|
|
var files = await topLevel.StorageProvider.OpenFilePickerAsync(new FilePickerOpenOptions()
|
|
{
|
|
Title = "Choose image or PDF file...",
|
|
AllowMultiple = false,
|
|
FileTypeFilter = [
|
|
new FilePickerFileType("All Types")
|
|
{
|
|
Patterns = Constants.AllowedFileExtensionPatterns,
|
|
AppleUniformTypeIdentifiers = [ "public.image", "com.adobe.pdf", "public.heic" ],
|
|
MimeTypes = [ "image/*", "application/pdf", "image/heic" ]
|
|
},
|
|
FilePickerFileTypes.ImageAll,
|
|
new FilePickerFileType("HEIC Images")
|
|
{
|
|
Patterns = [ "*.heic" ],
|
|
AppleUniformTypeIdentifiers = [ "public.heic" ],
|
|
MimeTypes = [ "image/heic" ]
|
|
},
|
|
FilePickerFileTypes.Pdf,
|
|
],
|
|
});
|
|
if (files.Count > 0)
|
|
{
|
|
var file = files[0];
|
|
reportFile.FilePath = file.Path.LocalPath;
|
|
HasUnsavedWork = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// https://github.com/AvaloniaUI/Avalonia/issues/10075
|
|
public void OpenFile(object f) => OpenFileImpl((ReportFile)f);
|
|
public void OpenFileImpl(ReportFile file)
|
|
{
|
|
var topLevel = TopLevelGrabber?.GetTopLevel();
|
|
if (topLevel is not null)
|
|
{
|
|
var launcher = topLevel.Launcher;
|
|
launcher.LaunchUriAsync(new Uri(file.FilePath));
|
|
}
|
|
}
|
|
|
|
public void OpenFileLocation(object f) => OpenFileLocationImpl((ReportFile)f);
|
|
|
|
private void OpenFileLocationImpl(ReportFile file)
|
|
{
|
|
OpenFolderForFileInFileViewer(file.FilePath);
|
|
}
|
|
|
|
private void OpenFolderForFileInFileViewer(string fullPathToFile)
|
|
{
|
|
var topLevel = TopLevelGrabber?.GetTopLevel();
|
|
var dirName = Path.GetDirectoryName(fullPathToFile);
|
|
if (topLevel is not null && dirName != null)
|
|
{
|
|
var launcher = topLevel.Launcher;
|
|
launcher.LaunchUriAsync(new Uri(dirName));
|
|
}
|
|
}
|
|
|
|
public void ResortPDFItemsByDate()
|
|
{
|
|
LogInfo("Sorting report files list...");
|
|
ReportFiles = new ObservableCollection<ReportFile>(ReportFiles.OrderBy(x => x.ReceiptDateTime));
|
|
HasUnsavedWork = true;
|
|
}
|
|
|
|
public async void BuildPDF()
|
|
{
|
|
if (string.IsNullOrWhiteSpace(ReportTitle))
|
|
{
|
|
await DialogHost.Show(new WarningViewModel("You must provide a report title!"));
|
|
}
|
|
else
|
|
{
|
|
try
|
|
{
|
|
await Task.Run(() => CreatePDF(WorkingFolder));
|
|
} catch (Exception e)
|
|
{
|
|
LogInfo("PDF process failed! Reason: " + e.Message);
|
|
if (e.StackTrace != null)
|
|
{
|
|
LogInfo(e.StackTrace);
|
|
}
|
|
var otherException = e.InnerException;
|
|
while (otherException != null)
|
|
{
|
|
LogInfo(">> Inner exception: " + otherException.Message);
|
|
if (otherException.StackTrace != null)
|
|
{
|
|
LogInfo(otherException.StackTrace);
|
|
}
|
|
otherException = otherException.InnerException;
|
|
}
|
|
LogInfo("Please report this error to a programmer or fix the issue listed above.");
|
|
IsCreatingPDF = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
public async Task SaveInterimReportInfo()
|
|
{
|
|
var report = new PDFReport()
|
|
{
|
|
Title = ReportTitle,
|
|
Files = ReportFiles.ToList(),
|
|
BaseFolder = WorkingFolder,
|
|
LastSaved = DateTime.Now,
|
|
LastGenerated = _lastGeneratedTime,
|
|
};
|
|
await SavePDFReportDataToDisk(report);
|
|
}
|
|
|
|
private async Task SavePDFReportDataToDisk(PDFReport report)
|
|
{
|
|
var jsonContext = new SourceGenerationContext(Utilities.GetSerializerOptions());
|
|
using var memoryStream = new MemoryStream();
|
|
await JsonSerializer.SerializeAsync(memoryStream, report, jsonContext.PDFReport);
|
|
memoryStream.Position = 0;
|
|
using var reader = new StreamReader(memoryStream);
|
|
var json = await reader.ReadToEndAsync();
|
|
var savePath = GetReportSavedDataPath(WorkingFolder);
|
|
await File.WriteAllTextAsync(savePath, json);
|
|
LogInfo("Saved report information to {0}", savePath);
|
|
HasUnsavedWork = false;
|
|
}
|
|
|
|
private async Task CreateAndSaveReportObjectAfterReportCreation()
|
|
{
|
|
var report = new PDFReport()
|
|
{
|
|
Title = ReportTitle,
|
|
Files = ReportFiles.ToList(),
|
|
BaseFolder = WorkingFolder,
|
|
LastSaved = DateTime.Now,
|
|
LastGenerated = DateTime.Now,
|
|
};
|
|
_lastGeneratedTime = DateTime.Now;
|
|
await SavePDFReportDataToDisk(report);
|
|
}
|
|
|
|
public async Task CopyLogToClipboard()
|
|
{
|
|
var clipboard = TopLevelGrabber?.GetTopLevel().Clipboard;
|
|
if (clipboard != null)
|
|
{
|
|
await clipboard.SetTextAsync(ProgramLog);
|
|
LogInfo("Program log has been copied to the clipboard!");
|
|
}
|
|
}
|
|
|
|
public byte[]? GetFont(string faceName)
|
|
{
|
|
LogInfo(string.Format("Loading font {0}", faceName));
|
|
if (faceName == "Noto Sans")
|
|
{
|
|
var path = Path.Combine(_processDir, "Assets/Fonts/Noto_Sans/static/NotoSans-Regular.ttf");
|
|
if (!File.Exists(path))
|
|
{
|
|
path = Path.Combine(_processDir, "../Resources/Assets/Fonts/Noto_Sans/static/NotoSans-Regular.ttf");
|
|
}
|
|
return File.ReadAllBytes(path);
|
|
}
|
|
if (faceName == "Noto Sans Bold")
|
|
{
|
|
var path = Path.Combine(_processDir, "Assets/Fonts/Noto_Sans/static/NotoSans-Bold.ttf");
|
|
if (!File.Exists(path))
|
|
{
|
|
path = Path.Combine(_processDir, "../Resources/Assets/Fonts/Noto_Sans/static/NotoSans-Bold.ttf");
|
|
}
|
|
return File.ReadAllBytes(path);
|
|
}
|
|
if (faceName == "Noto Sans JP")
|
|
{
|
|
var path = Path.Combine(_processDir, "Assets/Fonts/Noto_Sans_JP/static/NotoSansJP-Regular.ttf");
|
|
if (!File.Exists(path))
|
|
{
|
|
path = Path.Combine(_processDir, "../Resources/Assets/Fonts/Noto_Sans_JP/static/NotoSansJP-Regular.ttf");
|
|
}
|
|
return File.ReadAllBytes(path);
|
|
}
|
|
if (faceName == "Noto Sans JP Bold")
|
|
{
|
|
var path = Path.Combine(_processDir, "Assets/Fonts/Noto_Sans_JP/static/NotoSansJP-SemiBold.ttf");
|
|
if (!File.Exists(path))
|
|
{
|
|
path = Path.Combine(_processDir, "../Resources/Assets/Fonts/Noto_Sans_JP/static/NotoSansJP-SemiBold.ttf");
|
|
}
|
|
return File.ReadAllBytes(path);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public FontResolverInfo? ResolveTypeface(string familyName, bool bold, bool italic)
|
|
{
|
|
// LogInfo(string.Format("Resolving font name {0}", familyName));
|
|
if (familyName == "Noto Sans")
|
|
{
|
|
if (bold)
|
|
{
|
|
return new FontResolverInfo(familyName + " Bold");
|
|
}
|
|
return new FontResolverInfo(familyName);
|
|
}
|
|
if (familyName == "Noto Sans JP")
|
|
{
|
|
if (bold)
|
|
{
|
|
return new FontResolverInfo(familyName + " Bold");
|
|
}
|
|
return new FontResolverInfo(familyName);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private Paragraph GetFooterParagraph()
|
|
{
|
|
var footerPar = new Paragraph();
|
|
footerPar.Format.Alignment = ParagraphAlignment.Center;
|
|
footerPar.Format.Font.Size = 10;
|
|
footerPar.AddText("--Page ");
|
|
footerPar.AddPageField();
|
|
footerPar.AddText(" of ");
|
|
footerPar.AddNumPagesField();
|
|
footerPar.AddText("--");
|
|
footerPar.AddLineBreak();
|
|
footerPar.AddText("Report generated on " + DateTime.Now.ToString("f"));
|
|
footerPar.Tag = "FooterPar";
|
|
footerPar.Format.Font.Name = "Noto Sans";
|
|
return footerPar;
|
|
}
|
|
|
|
private decimal GetExistingPageItemHeight(PdfDocumentRenderer pdfRenderer, decimal footerParagraphHeight)
|
|
{
|
|
pdfRenderer.DocumentRenderer.PrepareDocument();
|
|
var currPageCount = pdfRenderer.DocumentRenderer.FormattedDocument?.PageCount;
|
|
var heightForExistingItemsOnPage = footerParagraphHeight;
|
|
if (currPageCount.HasValue)
|
|
{
|
|
var renderInfo = pdfRenderer.DocumentRenderer.GetRenderInfoFromPage(currPageCount.Value);
|
|
if (renderInfo != null)
|
|
{
|
|
// Console.WriteLine("Got render info for page: {0}", currPageCount);
|
|
foreach (var item in renderInfo)
|
|
{
|
|
heightForExistingItemsOnPage += (decimal)item.LayoutInfo.ContentArea.Height.Inch;
|
|
}
|
|
}
|
|
}
|
|
return heightForExistingItemsOnPage;
|
|
}
|
|
|
|
// https://forum.pdfsharp.net/viewtopic.php?f=2&t=1025
|
|
private async Task CreatePDF(string folderPath)
|
|
{
|
|
// TODO: calculate needed width for images based on page width and margins and all that?
|
|
// safety checks
|
|
var outputDir = _settings.SaveOutputPdfInWorkingDir ? folderPath : _settings.OutputPdfDir;
|
|
if (!Directory.Exists(outputDir))
|
|
{
|
|
await DialogHost.Show(new WarningViewModel("Output directory not found! Please adjust your application Settings before continuing. Output directory: " + outputDir));
|
|
return;
|
|
}
|
|
// setup globals and consts...
|
|
GlobalFontSettings.FontResolver = this;
|
|
GlobalFontSettings.FallbackFontResolver = new FailsafeFontResolver();
|
|
const decimal pageWidth = 8.5m;
|
|
const decimal pageHeight = 11.0m;
|
|
const decimal margin = 0.5m;
|
|
const int imageResolution = 72;
|
|
const int imageInsertMarginPixels = 30; // we calculate max available; use max - this # for max image size
|
|
var maxItemPxWidth = ((pageWidth - (2 * margin)) * imageResolution) - imageInsertMarginPixels;
|
|
// start making PDF!
|
|
IsCreatingPDF = true;
|
|
var pdfDoc = new Document();
|
|
var outputFileName = ReportTitle + ".pdf";
|
|
var folderName = new DirectoryInfo(folderPath).Name;
|
|
const int maxImageWidth = 425;
|
|
var imageLineFormat = new MigraDoc.DocumentObjectModel.Shapes.LineFormat()
|
|
{
|
|
Color = Colors.Black,
|
|
Width = Unit.FromPoint(2),
|
|
};;
|
|
if (folderName.Contains('-'))
|
|
{
|
|
// see if year/month format
|
|
var parts = folderName.Split('-');
|
|
if (parts[0].Length == 4 &&
|
|
parts[1].Length <= 2 &&
|
|
int.TryParse(parts[0], out int year) && int.TryParse(parts[1], out int month))
|
|
{
|
|
outputFileName = string.Format("{0} {1} Receipts.pdf",
|
|
CultureInfo.CurrentCulture.DateTimeFormat.GetMonthName(month),
|
|
year);
|
|
LogInfo("Auto-changed output file name to " + outputFileName);
|
|
}
|
|
}
|
|
// setup initial section (for page characteristics)
|
|
var section = pdfDoc.AddSection();
|
|
section.PageSetup.PageFormat = PageFormat.Letter;
|
|
section.PageSetup.PageWidth = pageWidth + "in";
|
|
section.PageSetup.PageHeight = pageHeight + "in";
|
|
section.PageSetup.TopMargin = margin + "in";
|
|
section.PageSetup.RightMargin = margin + "in";
|
|
section.PageSetup.BottomMargin = margin + "in";
|
|
section.PageSetup.LeftMargin = margin + "in";
|
|
// setup footer for page number
|
|
var footerPar = GetFooterParagraph();
|
|
section.Footers.Primary.Add(footerPar);
|
|
// create a quick PDF doc renderer to measure footer paragraph height
|
|
var footerParagraphHeight = 0.4m; // estimate
|
|
var footerOnlyPdfDoc = new Document();
|
|
var sectionClone = section.Clone();
|
|
footerOnlyPdfDoc.Add(sectionClone);
|
|
sectionClone.Add(GetFooterParagraph());
|
|
var footerPdfRenderer = new PdfDocumentRenderer
|
|
{
|
|
Document = footerOnlyPdfDoc
|
|
};
|
|
footerPdfRenderer.DocumentRenderer.PrepareDocument();
|
|
var footerRenderInfo = footerPdfRenderer.DocumentRenderer.GetRenderInfoFromPage(1);
|
|
if (footerRenderInfo != null)
|
|
{
|
|
foreach (var item in footerRenderInfo)
|
|
{
|
|
if (item.DocumentObject.Tag?.ToString() == "FooterPar")
|
|
{
|
|
Console.WriteLine("Got footer paragraph height!");
|
|
footerParagraphHeight = (decimal)item.LayoutInfo.ContentArea.Height.Inch;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
// continue setting up document
|
|
// First page only: add report title
|
|
var reportTitlePar = section.AddParagraph();
|
|
reportTitlePar.Format.Alignment = ParagraphAlignment.Center;
|
|
reportTitlePar.Format.Font.Size = 16;
|
|
reportTitlePar.Format.Font.Bold = true;
|
|
reportTitlePar.Format.Font.Name = "Noto Sans JP"; // has english letters in it, too
|
|
reportTitlePar.AddText(ReportTitle);
|
|
reportTitlePar.Tag = "TitlePar";
|
|
// get converted files directory path and create it if necessary
|
|
var convertedDir = Path.Combine(Utilities.GetInternalDataPath(), "converted");
|
|
if (!Directory.Exists(convertedDir))
|
|
{
|
|
Directory.CreateDirectory(convertedDir);
|
|
}
|
|
//
|
|
var pdfRenderer = new PdfDocumentRenderer
|
|
{
|
|
Document = pdfDoc,
|
|
WorkingDirectory = folderPath
|
|
};
|
|
var hasAddedData = false;
|
|
for (var i = 0; i < ReportFiles.Count; i++)
|
|
{
|
|
var file = ReportFiles[i];
|
|
var fileName = file.FileName;
|
|
var filePath = file.FilePath;
|
|
if (!File.Exists(filePath))
|
|
{
|
|
LogInfo("ERROR: File \"{0}\" does not exist at path \"{1}\". Please remove it from the report or re-add it using the Add Item button if you still want it to be in this report.", file.Title, file.FilePath);
|
|
IsCreatingPDF = false;
|
|
return;
|
|
}
|
|
if (fileName == ".DS_Store" || fileName == outputFileName)
|
|
{
|
|
continue;
|
|
}
|
|
if (i > 0 && hasAddedData)
|
|
{
|
|
section.AddPageBreak();
|
|
}
|
|
var imageTitlePar = section.AddParagraph();
|
|
imageTitlePar.Format.Alignment = ParagraphAlignment.Center;
|
|
imageTitlePar.Format.Font.Size = 12;
|
|
imageTitlePar.Format.Font.Bold = true;
|
|
imageTitlePar.Format.Font.Name = "Noto Sans JP"; // has english letters in it, too
|
|
imageTitlePar.AddText(string.IsNullOrWhiteSpace(file.Title) ? file.FileName : file.Title);
|
|
imageTitlePar.Tag = "ReceiptTitlePar";
|
|
var receiptDatePar = section.AddParagraph();
|
|
receiptDatePar.Format.Alignment = ParagraphAlignment.Center;
|
|
receiptDatePar.Format.Font.Size = 12;
|
|
receiptDatePar.Format.Font.Bold = true;
|
|
receiptDatePar.Format.Font.Name = "Noto Sans JP"; // has english letters in it, too
|
|
receiptDatePar.AddText(file.ReceiptDate.ToString(_settings.ReportDateFormat));
|
|
receiptDatePar.Tag = "ReceiptDatePar";
|
|
if (!string.IsNullOrWhiteSpace(file.Notes))
|
|
{
|
|
var imageNotesPar = section.AddParagraph();
|
|
imageNotesPar.Format.Alignment = ParagraphAlignment.Center;
|
|
imageNotesPar.Format.Font.Size = 10;
|
|
imageNotesPar.Format.Font.Bold = false;
|
|
imageNotesPar.Format.Font.Name = "Noto Sans JP";
|
|
imageNotesPar.AddText(file.Notes);
|
|
imageNotesPar.Tag = "ReceiptNotesPar";
|
|
}
|
|
var emptyPar = section.AddParagraph(); // add empty line for spacing
|
|
emptyPar.Tag = "EmptyParagraph";
|
|
// now add the image
|
|
var lowerName = fileName.ToLower();
|
|
var isPDF = lowerName.EndsWith(".pdf");
|
|
// convert heic, webp, or png to JPEG for size and ease of use
|
|
// (and probably compat reasons too, though I haven't tested that...)
|
|
var isHEIC = lowerName.EndsWith(".heic");
|
|
var isWebp = lowerName.EndsWith(".webp");
|
|
var isPNG = lowerName.EndsWith(".png");
|
|
var info = new FileInfo(file.FilePath);
|
|
uint loadedImageWidth = 0;
|
|
uint loadedImageHeight = 0;
|
|
// get max pixel height remaining for items on this page
|
|
// (For multi-page PDFs, showing page 2 and on will have more height since they have no title,
|
|
// but to keep things consistent we will use the same height for all PDF pages.)
|
|
// render up to now on this page and get height remaining in inches
|
|
var currPageCount = pdfRenderer.DocumentRenderer.FormattedDocument?.PageCount;
|
|
var heightForExistingItemsOnPage = GetExistingPageItemHeight(pdfRenderer, footerParagraphHeight);
|
|
var remainingHeightInches = pageHeight - (2 * margin) - heightForExistingItemsOnPage;
|
|
var remainingHeightPixels = (remainingHeightInches * imageResolution) - imageInsertMarginPixels;
|
|
if (!isPDF)
|
|
{
|
|
using var mImage = new MagickImage(info.FullName);
|
|
loadedImageWidth = mImage.Width;
|
|
loadedImageHeight = mImage.Height;
|
|
var convertedOutputPath = Path.Combine(convertedDir, info.Name + ".jpg");
|
|
var didAdjust = false;
|
|
LogInfo("Image orientation of {0} is {1}", fileName, mImage.Orientation);
|
|
if (mImage.Orientation != OrientationType.TopLeft)
|
|
{
|
|
LogInfo("Auto-adjusted image orientation of {0}", fileName);
|
|
mImage.AutoOrient();
|
|
didAdjust = true;
|
|
}
|
|
// perform needed image manipulations
|
|
if (isHEIC || isWebp || isPNG || (!isPDF && info.Length > _settings.ImageResizeThreshold * 1024 * 1024))
|
|
{
|
|
// Save image as jpg
|
|
mImage.Quality = 80;
|
|
if (mImage.Width >= 400 || mImage.Height >= 400)
|
|
{
|
|
loadedImageWidth = (uint)Math.Floor(mImage.Width * 0.5);
|
|
loadedImageHeight = (uint)Math.Floor(mImage.Height * 0.5);
|
|
mImage.Scale(loadedImageWidth, loadedImageHeight);
|
|
LogInfo("Image {2} scaled to {0}x{1}", loadedImageWidth, loadedImageHeight, fileName);
|
|
}
|
|
didAdjust = true;
|
|
LogInfo("Converted image {0} to JPEG", fileName);
|
|
}
|
|
else
|
|
{
|
|
// load height/width
|
|
loadedImageWidth = mImage.Width;
|
|
loadedImageHeight = mImage.Height;
|
|
}
|
|
if (didAdjust)
|
|
{
|
|
await mImage.WriteAsync(convertedOutputPath);
|
|
filePath = convertedOutputPath;
|
|
LogInfo(string.Format("Saved adjusted image to JPEG; file path is now {0}", filePath));
|
|
}
|
|
// write to PDF
|
|
var paragraph = section.AddParagraph();
|
|
paragraph.Format.Alignment = ParagraphAlignment.Center;
|
|
var image = paragraph.AddImage(filePath);
|
|
image.Resolution = imageResolution; // dots per inch
|
|
image.Tag = "ReceiptImageTag";
|
|
paragraph.Tag = "ReceiptImageParagraphTag";
|
|
image.LineFormat = imageLineFormat.Clone();
|
|
// resize down until it will fit on the page
|
|
while (loadedImageHeight > remainingHeightPixels || loadedImageWidth > maxItemPxWidth)
|
|
{
|
|
// Console.WriteLine("Image height = {0}, width = {1}; decreasing size by 5% to h={2}, w={3}", loadedImageHeight, loadedImageWidth, (uint)Math.Floor(loadedImageHeight * 0.95), (uint)Math.Floor(loadedImageWidth * 0.95));
|
|
// keep reducing size by 5% (little by little) until it fits on the page
|
|
// ...might skew ever so slightly but should not be noticable...
|
|
loadedImageHeight = (uint)Math.Floor(loadedImageHeight * 0.95);
|
|
loadedImageWidth = (uint)Math.Floor(loadedImageWidth * 0.95);
|
|
}
|
|
image.Height = loadedImageHeight;
|
|
image.Width = loadedImageWidth;
|
|
}
|
|
else // isPDF
|
|
{
|
|
// need to render PDF to images
|
|
if (_settings.UseDocnetPDFImageRendering)
|
|
{
|
|
// render using Docnet library (which utilizes pdfium, the chrome renderer)
|
|
string RenderPdfPageToImage(IDocReader docReader, int pgNum)
|
|
{
|
|
Console.WriteLine("Rendering pg " + pgNum);
|
|
using var pageReader = docReader.GetPageReader(pgNum);
|
|
Console.WriteLine("Getting image for page " + pgNum);
|
|
var rawBytes = pageReader.GetImage(RenderFlags.RenderAnnotations);
|
|
Console.WriteLine("Getting width & height for page " + pgNum);
|
|
var width = pageReader.GetPageWidth();
|
|
var height = pageReader.GetPageHeight();
|
|
Console.WriteLine("Loading pixel data for page " + pgNum);
|
|
using var img = Image.LoadPixelData<Bgra32>(rawBytes, width, height);
|
|
// you are likely going to want this as well otherwise you might end up with transparent parts.
|
|
img.Mutate(x => x.BackgroundColor(SixLabors.ImageSharp.Color.White));
|
|
var pdfPageImageOutputPath = Path.Combine(convertedDir, info.Name + "-Page-"
|
|
+ (pgNum + 1).ToString().PadLeft(3, '0') + ".jpg");
|
|
img.Save(pdfPageImageOutputPath);
|
|
Console.WriteLine("Done rendering pg " + pgNum);
|
|
return pdfPageImageOutputPath;
|
|
}
|
|
// render all pages to images
|
|
var docReader = DocLib.Instance.GetDocReader(
|
|
filePath,
|
|
new PageDimensions(1080, 1920)); // TODO: are these dims right?
|
|
// add to document
|
|
var pgCount = docReader.GetPageCount();
|
|
if (pgCount > 0)
|
|
{
|
|
var convertedPdfImagePath = RenderPdfPageToImage(docReader, 0);
|
|
imageTitlePar.AddText(string.Format(" (PDF with {0} page{1}) ",
|
|
pgCount,
|
|
pgCount == 1 ? "" : "s"));
|
|
var paragraph = section.AddParagraph();
|
|
paragraph.Format.Alignment = ParagraphAlignment.Center;
|
|
// get image height/width off of disk so we can resize down if needed
|
|
var image = paragraph.AddImage(convertedPdfImagePath);
|
|
image.LockAspectRatio = true;
|
|
image.LineFormat = imageLineFormat.Clone();
|
|
using (var firstPdfPageImage = new MagickImage(convertedPdfImagePath))
|
|
{
|
|
var pdfPageImageWidth = firstPdfPageImage.Width;
|
|
var pdfPageImageHeight = firstPdfPageImage.Height;
|
|
// resize down until it will fit on the page
|
|
while (pdfPageImageHeight > remainingHeightPixels || pdfPageImageWidth > maxItemPxWidth)
|
|
{
|
|
pdfPageImageHeight = (uint)Math.Floor(pdfPageImageHeight * 0.95);
|
|
pdfPageImageWidth = (uint)Math.Floor(pdfPageImageWidth * 0.95);
|
|
}
|
|
image.Height = pdfPageImageHeight;
|
|
image.Width = pdfPageImageWidth;
|
|
}
|
|
for (var j = 1; j < pgCount; j++)
|
|
{
|
|
section.AddPageBreak();
|
|
paragraph = section.AddParagraph();
|
|
paragraph.Format.Alignment = ParagraphAlignment.Center;
|
|
convertedPdfImagePath = RenderPdfPageToImage(docReader, j);
|
|
image = paragraph.AddImage(convertedPdfImagePath);
|
|
image.LockAspectRatio = true;
|
|
image.Width = maxImageWidth;
|
|
image.LineFormat = imageLineFormat.Clone();
|
|
using (var otherPdfPageImage = new MagickImage(convertedPdfImagePath))
|
|
{
|
|
var pdfPageImageWidth = otherPdfPageImage.Width;
|
|
var pdfPageImageHeight = otherPdfPageImage.Height;
|
|
// resize down until it will fit on the page
|
|
while (pdfPageImageHeight > remainingHeightPixels || pdfPageImageWidth > maxItemPxWidth)
|
|
{
|
|
pdfPageImageHeight = (uint)Math.Floor(pdfPageImageHeight * 0.95);
|
|
pdfPageImageWidth = (uint)Math.Floor(pdfPageImageWidth * 0.95);
|
|
}
|
|
image.Height = pdfPageImageHeight;
|
|
image.Width = pdfPageImageWidth;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// use older, not-docnet rendering method.
|
|
// uses MigraDoc rendering. Does not work with annotations, and since Migradoc
|
|
// doesn't let us know how big the image is, we can't do the image resizing, so
|
|
// we just do our best.
|
|
// render first page (eventually need to improve code to just do everything in a loop)
|
|
var paragraph = section.AddParagraph();
|
|
paragraph.Format.Alignment = ParagraphAlignment.Center;
|
|
var image = paragraph.AddImage(filePath);
|
|
image.LockAspectRatio = true;
|
|
image.Width = maxImageWidth; // can't be too wide now...not sure why...maybe due to margins...
|
|
image.LineFormat = imageLineFormat.Clone();
|
|
// render other PDF pages, if any
|
|
// see: https://stackoverflow.com/a/65091204/3938401
|
|
var pdfFileToAdd = PdfReader.Open(filePath, PdfDocumentOpenMode.Import);
|
|
var pgCount = pdfFileToAdd.PageCount;
|
|
imageTitlePar.AddText(string.Format(" (PDF with {0} page{1}) ",
|
|
pgCount,
|
|
pgCount == 1 ? "" : "s"));
|
|
for (var j = 2; j <= pgCount; j++)
|
|
{
|
|
section.AddPageBreak();
|
|
paragraph = section.AddParagraph();
|
|
paragraph.Format.Alignment = ParagraphAlignment.Center;
|
|
image = paragraph.AddImage(filePath + "#" + j);
|
|
image.LockAspectRatio = true;
|
|
image.Width = maxImageWidth;
|
|
image.LineFormat = imageLineFormat.Clone();
|
|
}
|
|
}
|
|
}
|
|
LogInfo(string.Format("Added image: {0} ({1})", file.Title, filePath));
|
|
hasAddedData = true;
|
|
}
|
|
LogInfo("Rendering document to PDF file...");
|
|
pdfRenderer.DocumentRenderer.PrepareDocument(); // needed if you make edits after first PrepareDocument() is called
|
|
pdfRenderer.RenderDocument();
|
|
// actually save to disk now
|
|
string outputPDFFilePath = Path.Join(outputDir, outputFileName);
|
|
LogInfo("Saving PDF document to disk...");
|
|
pdfRenderer.PdfDocument.Save(outputPDFFilePath);
|
|
LogInfo("Finished saving PDF output to: " + outputPDFFilePath);
|
|
await CreateAndSaveReportObjectAfterReportCreation();
|
|
// clean up data dir
|
|
Directory.Delete(convertedDir, true);
|
|
// show output folder to user
|
|
OpenFolderForFileInFileViewer(outputPDFFilePath);
|
|
IsCreatingPDF = false;
|
|
}
|
|
|
|
public async Task<bool> CheckIsSafeToShutdown()
|
|
{
|
|
if (!HasUnsavedWork || string.IsNullOrWhiteSpace(WorkingFolder))
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
var result = await DialogHost.Show(new ShutdownCheckViewModel());
|
|
if (result != null && result is ShutdownCheckOptions opt)
|
|
{
|
|
if (opt == ShutdownCheckOptions.SaveAndShutdown)
|
|
{
|
|
await SaveInterimReportInfo();
|
|
return true;
|
|
}
|
|
else if (opt == ShutdownCheckOptions.NoSaveShutdown)
|
|
{
|
|
return true;
|
|
}
|
|
else if (opt == ShutdownCheckOptions.CancelShutdown)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
} |