public static async Task AllPhotoMetadataToHtml(FileInfo selectedFile, StatusControlContext statusContext)
        {
            await ThreadSwitcher.ResumeBackgroundAsync();

            if (selectedFile == null)
            {
                statusContext.ToastError("No photo...");
                return;
            }

            selectedFile.Refresh();

            if (!selectedFile.Exists)
            {
                statusContext.ToastError($"File {selectedFile.FullName} doesn't exist?");
                return;
            }

            var photoMetaTags = ImageMetadataReader.ReadMetadata(selectedFile.FullName);

            var tagHtml = photoMetaTags.SelectMany(x => x.Tags).OrderBy(x => x.DirectoryName).ThenBy(x => x.Name)
                          .ToList().Select(x => new
            {
                DataType = x.Type.ToString(),
                x.DirectoryName,
                Tag      = x.Name,
                TagValue = ObjectDumper.Dump(x.Description)
            }).ToHtmlTable(new { @class = "pure-table pure-table-striped" });

            var xmpDirectory = ImageMetadataReader.ReadMetadata(selectedFile.FullName).OfType <XmpDirectory>()
                               .FirstOrDefault();

            var xmpMetadata = xmpDirectory?.GetXmpProperties().Select(x => new { XmpKey = x.Key, XmpValue = x.Value })
                              .ToHtmlTable(new { @class = "pure-table pure-table-striped" });

            await ThreadSwitcher.ResumeForegroundAsync();

            var file = new FileInfo(Path.Combine(UserSettingsUtilities.TempStorageDirectory().FullName,
                                                 $"PhotoMetadata-{Path.GetFileNameWithoutExtension(selectedFile.Name)}-{DateTime.Now:yyyy-MM-dd---HH-mm-ss}.htm"));

            var htmlString =
                ($"<h1>Metadata Report:</h1><h1>{HttpUtility.HtmlEncode(selectedFile.FullName)}</h1><br><h1>Metadata - Part 1</h1><br>" +
                 tagHtml + "<br><br><h1>XMP - Part 2</h1><br>" + xmpMetadata)
                .ToHtmlDocumentWithPureCss("Photo Metadata", "body {margin: 12px;}");

            await File.WriteAllTextAsync(file.FullName, htmlString);

            var ps = new ProcessStartInfo(file.FullName)
            {
                UseShellExecute = true, Verb = "open"
            };

            Process.Start(ps);
        }
Пример #2
0
        public static async Task SelectedToExcel(List <dynamic> selected, StatusControlContext statusContext)
        {
            await ThreadSwitcher.ThreadSwitcher.ResumeBackgroundAsync();

            if (selected == null || !selected.Any())
            {
                statusContext?.ToastError("Nothing to send to Excel?");
                return;
            }

            ContentToExcelFileAsTable(selected.Select(x => x.DbEntry).Cast <object>().ToList(), "SelectedItems",
                                      progress: statusContext?.ProgressTracker());
        }
        public WindowScreenShotControl()
        {
            InitializeComponent();

            WindowScreenShotCommand = new Command <Window>(async x =>
            {
                if (x == null)
                {
                    return;
                }

                StatusControlContext statusContext = null;

                try
                {
                    statusContext = (StatusControlContext)((dynamic)x.DataContext).StatusContext;
                }
                catch (Exception e)
                {
                    Console.WriteLine(e);
                }

                var result = await FrameworkElementScreenShot.TryScreenShotToClipboardAsync(x);

                if (statusContext != null)
                {
                    if (result)
                    {
                        statusContext.ToastSuccess("Window copied to Clipboard");
                    }
                    else
                    {
                        statusContext.ToastError("Problem Copying Window to Clipboard");
                    }
                }
            });

            DataContext = this;
        }
Пример #4
0
        public static async Task PdfPageToImageWithPdfToCairo(StatusControlContext statusContext,
                                                              List <FileContent> selected, int pageNumber)
        {
            await ThreadSwitcher.ThreadSwitcher.ResumeBackgroundAsync();


            var pdfToCairoDirectoryString = UserSettingsSingleton.CurrentSettings().PdfToCairoExeDirectory;

            if (string.IsNullOrWhiteSpace(pdfToCairoDirectoryString))
            {
                statusContext.ToastError(
                    "Sorry - this function requires that pdftocairo.exe be on the system - please set the directory... ");
                return;
            }

            var pdfToCairoDirectory = new DirectoryInfo(pdfToCairoDirectoryString);

            if (!pdfToCairoDirectory.Exists)
            {
                statusContext.ToastError(
                    $"{pdfToCairoDirectory.FullName} doesn't exist? Check your pdftocairo bin directory setting.");
                return;
            }

            var pdfToCairoExe = new FileInfo(Path.Combine(pdfToCairoDirectory.FullName, "pdftocairo.exe"));

            if (!pdfToCairoExe.Exists)
            {
                statusContext.ToastError(
                    $"{pdfToCairoExe.FullName} doesn't exist? Check your pdftocairo bin directory setting.");
                return;
            }

            var toProcess = new List <(FileInfo targetFile, FileInfo destinationFile, FileContent content)>();

            foreach (var loopSelected in selected)
            {
                var targetFile = new FileInfo(Path.Combine(
                                                  UserSettingsSingleton.CurrentSettings().LocalSiteFileContentDirectory(loopSelected).FullName,
                                                  loopSelected.OriginalFileName));

                if (!targetFile.Exists)
                {
                    continue;
                }

                if (!targetFile.Extension.ToLower().Contains("pdf"))
                {
                    continue;
                }

                FileInfo destinationFile;
                if (pageNumber == 1)
                {
                    destinationFile = new FileInfo(Path.Combine(UserSettingsUtilities.TempStorageDirectory().FullName,
                                                                $"{Path.GetFileNameWithoutExtension(targetFile.Name)}-CoverPage.jpg"));

                    if (destinationFile.Exists)
                    {
                        destinationFile.Delete();
                        destinationFile.Refresh();
                    }
                }
                else
                {
                    destinationFile = new FileInfo(Path.Combine(UserSettingsUtilities.TempStorageDirectory().FullName,
                                                                $"{Path.GetFileNameWithoutExtension(targetFile.Name)}-Page.jpg"));
                }

                toProcess.Add((targetFile, destinationFile, loopSelected));
            }

            if (!toProcess.Any())
            {
                statusContext.ToastError("No PDFs found? This process can only generate PDF previews...");
                return;
            }

            foreach (var loopSelected in toProcess)
            {
                if (loopSelected.destinationFile.Directory == null)
                {
                    statusContext.ToastError(
                        $"Problem with {loopSelected.destinationFile.FullName} - Directory is Null?");
                    continue;
                }

                var executionParameters = pageNumber == 1
                    ? $"-jpeg -singlefile \"{loopSelected.targetFile.FullName}\" \"{Path.Combine(loopSelected.destinationFile.Directory.FullName, Path.GetFileNameWithoutExtension(loopSelected.destinationFile.FullName))}\""
                    : $"-jpeg -f {pageNumber} -l {pageNumber} \"{loopSelected.targetFile.FullName}\" \"{Path.Combine(loopSelected.destinationFile.Directory.FullName, Path.GetFileNameWithoutExtension(loopSelected.destinationFile.FullName))}\"";

                var(success, _, errorOutput) = ProcessHelpers.ExecuteProcess(pdfToCairoExe.FullName,
                                                                             executionParameters, statusContext.ProgressTracker());

                if (!success)
                {
                    if (await statusContext.ShowMessage("PDF Generation Problem",
                                                        $"Execution Failed for {loopSelected.content.Title} - Continue??{Environment.NewLine}{errorOutput}",
                                                        new List <string> {
                        "Yes", "No"
                    }) == "No")
                    {
                        return;
                    }

                    continue;
                }

                FileInfo updatedDestination = null;

                if (pageNumber == 1)
                {
                    //With the singlefile option pdftocairo uses your filename directly
                    loopSelected.destinationFile.Refresh();
                    updatedDestination = loopSelected.destinationFile;
                }
                else
                {
                    var directoryToSearch = loopSelected.destinationFile.Directory;

                    var possibleFiles = directoryToSearch
                                        .EnumerateFiles($"{Path.GetFileNameWithoutExtension(loopSelected.destinationFile.Name)}-*.jpg")
                                        .ToList();

                    foreach (var loopFiles in possibleFiles)
                    {
                        var fileNamePageNumber = loopFiles.Name.Split("-Page-").ToList().Last().Replace(".jpg", "");

                        if (int.TryParse(fileNamePageNumber, out var possiblePageNumber) &&
                            possiblePageNumber == pageNumber)
                        {
                            updatedDestination = loopFiles;
                            break;
                        }
                    }
                }

                if (updatedDestination == null || !updatedDestination.Exists)
                {
                    if (await statusContext.ShowMessage("PDF Generation Problem",
                                                        $"Execution Failed for {loopSelected.content.Title} - Continue??{Environment.NewLine}{errorOutput}",
                                                        new List <string> {
                        "Yes", "No"
                    }) == "No")
                    {
                        return;
                    }

                    continue;
                }

                await ThreadSwitcher.ThreadSwitcher.ResumeForegroundAsync();

                var newImage = new ImageContent {
                    ContentId = Guid.NewGuid()
                };

                if (pageNumber == 1)
                {
                    newImage.Title   = $"{loopSelected.content.Title} Cover Page";
                    newImage.Summary = $"Cover Page from {loopSelected.content.Title}.";
                }
                else
                {
                    newImage.Title   = $"{loopSelected.content.Title} - Page {pageNumber}";
                    newImage.Summary = $"Page {pageNumber} from {loopSelected.content.Title}.";
                }

                newImage.ShowInSearch      = false;
                newImage.Folder            = loopSelected.content.Folder;
                newImage.Tags              = loopSelected.content.Tags;
                newImage.Slug              = SlugUtility.Create(true, newImage.Title);
                newImage.BodyContentFormat = ContentFormatDefaults.Content.ToString();
                newImage.BodyContent       = $"Generated by pdftocairo from {BracketCodeFiles.Create(loopSelected.content)}.";
                newImage.UpdateNotesFormat = ContentFormatDefaults.Content.ToString();

                var editor = new ImageContentEditorWindow(newImage, updatedDestination);
                editor.Show();

                await ThreadSwitcher.ThreadSwitcher.ResumeBackgroundAsync();
            }
        }
Пример #5
0
        public static async Task RenameSelectedFile(FileInfo selectedFile, StatusControlContext statusContext,
                                                    Action <FileInfo> setSelectedFile)
        {
            if (selectedFile == null || !selectedFile.Exists)
            {
                statusContext.ToastWarning("No file to rename?");
                return;
            }

            var newName = await statusContext.ShowStringEntry("Rename File",
                                                              $"Rename {Path.GetFileNameWithoutExtension(selectedFile.Name)} - " +
                                                              "File Names must be limited to A-Z a-z 0-9 - . _  :",
                                                              Path.GetFileNameWithoutExtension(selectedFile.Name));

            if (!newName.Item1)
            {
                return;
            }

            var cleanedName = newName.Item2.TrimNullToEmpty();

            if (string.IsNullOrWhiteSpace(cleanedName))
            {
                statusContext.ToastError("Can't rename the file to an empty string...");
                return;
            }

            var noExtensionCleaned = Path.GetFileNameWithoutExtension(cleanedName);

            if (string.IsNullOrWhiteSpace(noExtensionCleaned))
            {
                statusContext.ToastError("Not a valid filename...");
                return;
            }

            if (!FolderFileUtility.IsNoUrlEncodingNeeded(noExtensionCleaned))
            {
                statusContext.ToastError("File Names must be limited to A - Z a - z 0 - 9 - . _");
                return;
            }

            var moveToName = Path.Combine(selectedFile.Directory?.FullName ?? string.Empty,
                                          $"{noExtensionCleaned}{Path.GetExtension(selectedFile.Name)}");

            try
            {
                File.Copy(selectedFile.FullName, moveToName);
            }
            catch (Exception e)
            {
                await EventLogContext.TryWriteExceptionToLog(e, statusContext.StatusControlContextId.ToString(),
                                                             "Exception while trying to rename file.");

                statusContext.ToastError($"Error Copying File: {e.Message}");
                return;
            }

            var finalFile = new FileInfo(moveToName);

            if (!finalFile.Exists)
            {
                statusContext.ToastError("Unknown error renaming file - original file still selected.");
                return;
            }

            try
            {
                setSelectedFile(finalFile);
            }
            catch (Exception e)
            {
                statusContext.ToastError($"Error setting selected file - {e.Message}");
                return;
            }

            statusContext.ToastSuccess($"Selected file now {selectedFile.FullName}");
        }
Пример #6
0
        public static async Task ImportFromExcel(StatusControlContext statusContext)
        {
            await ThreadSwitcher.ThreadSwitcher.ResumeBackgroundAsync();

            statusContext.Progress("Starting excel load.");

            var dialog = new VistaOpenFileDialog();

            if (!(dialog.ShowDialog() ?? false))
            {
                return;
            }

            var newFile = new FileInfo(dialog.FileName);

            if (!newFile.Exists)
            {
                statusContext.ToastError("File doesn't exist?");
                return;
            }

            ExcelContentImports.ExcelContentTableImportResults contentTableImportResult;

            try
            {
                contentTableImportResult =
                    await ExcelContentImports.ImportFromFile(newFile.FullName, statusContext.ProgressTracker());
            }
            catch (Exception e)
            {
                await statusContext.ShowMessageWithOkButton("Import File Errors",
                                                            $"Import Stopped because of an error processing the file:{Environment.NewLine}{e.Message}");

                return;
            }

            if (contentTableImportResult.HasError)
            {
                await statusContext.ShowMessageWithOkButton("Import Errors",
                                                            $"Import Stopped because errors were reported:{Environment.NewLine}{contentTableImportResult.ErrorNotes}");

                return;
            }

            var shouldContinue = await statusContext.ShowMessage("Confirm Import",
                                                                 $"Continue?{Environment.NewLine}{Environment.NewLine}{contentTableImportResult.ToUpdate.Count} updates from {newFile.FullName} {Environment.NewLine}" +
                                                                 $"{string.Join(Environment.NewLine, contentTableImportResult.ToUpdate.Select(x => $"{Environment.NewLine}{x.Title}{Environment.NewLine}{x.DifferenceNotes}"))}",
                                                                 new List <string> {
                "Yes", "No"
            });

            if (shouldContinue == "No")
            {
                return;
            }

            var saveResult =
                await ExcelContentImports.SaveAndGenerateHtmlFromExcelImport(contentTableImportResult,
                                                                             statusContext.ProgressTracker());

            if (saveResult.hasError)
            {
                await statusContext.ShowMessageWithOkButton("Excel Import Save Errors",
                                                            $"There were error saving changes from the Excel Content:{Environment.NewLine}{saveResult.errorMessage}");

                return;
            }

            statusContext.ToastSuccess(
                $"Imported {contentTableImportResult.ToUpdate.Count} items with changes from {newFile.FullName}");
        }