CreateDocumentsViewModel.cs

using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using MahApps.Metro.Controls.Dialogs;
using Microsoft.Win32;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.IO;
using System.Reflection;
using System.Resources;
using System.Windows.Data;
using System.Windows.Input;
using Vereinsmeisterschaften.Contracts.ViewModels;
using Vereinsmeisterschaften.Core.Contracts.Services;
using Vereinsmeisterschaften.Core.Documents;
using Vereinsmeisterschaften.Core.Documents.DocumentStrategies;
using Vereinsmeisterschaften.Core.Helpers;
using Vereinsmeisterschaften.Core.Models;
using Vereinsmeisterschaften.Core.Settings;
using Vereinsmeisterschaften.Models;
using Vereinsmeisterschaften.Properties;
 
namespace Vereinsmeisterschaften.ViewModels;

public partial class CreateDocumentsViewModel : ObservableObject, INavigationAware
{
    public Dictionary<DocumentCreationTypes, DocumentCreationConfig> DocumentCreationConfigPerType { get; } = new Dictionary<DocumentCreationTypes, DocumentCreationConfig>();

    public Dictionary<DocumentCreationTypes, DocumentCreationStatus> DocumentCreationStatusPerType { get; } = new Dictionary<DocumentCreationTypes, DocumentCreationStatus>();

    public bool IsAnyDocumentCreationRunning => DocumentCreationStatusPerType.Any(kv => kv.Value.IsDocumentCreationRunning == true);
 
    // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
    private void changeDocumentCreationRunningState(DocumentCreationTypes documentType, bool isRunning)
        => setDictionaryValue(documentType, isRunning, nameof(DocumentCreationStatus.IsDocumentCreationRunning));
    
    private void changeDocumentCreationSuccessfulState(DocumentCreationTypes documentType, bool isSuccessful)
        => setDictionaryValue(documentType, isSuccessful, nameof(DocumentCreationStatus.IsDocumentCreationSuccessful));
 
    private void changeDocumentDataAvailableState(DocumentCreationTypes documentType, bool isDataAvailable)
        => setDictionaryValue(documentType, isDataAvailable, nameof(DocumentCreationStatus.IsDocumentDataAvailable));
 
    private void changeDocumentTemplateAvailableState(DocumentCreationTypes documentType, bool isTemplateAvailable)
        => setDictionaryValue(documentType, isTemplateAvailable, nameof(DocumentCreationStatus.IsDocumentTemplateAvailable));
 
    private void changeLastDocumentFilePath(DocumentCreationTypes documentType, string lastDocumentFilePath)
        => setDictionaryValue(documentType, lastDocumentFilePath, nameof(DocumentCreationStatus.LastDocumentFilePath));
 
    private void setDictionaryValue<T>(DocumentCreationTypes documentType, T value, string propertyName)
    {
        if (DocumentCreationStatusPerType.ContainsKey(documentType))
        {
            PropertyInfo propInfo = typeof(DocumentCreationStatus).GetProperty(propertyName);
            propInfo?.SetValue(DocumentCreationStatusPerType[documentType], value);
            OnPropertyChanged(nameof(DocumentCreationStatusPerType));
            ((RelayCommand<DocumentCreationTypes>)CreateDocumentCommand).NotifyCanExecuteChanged();
        }
    }
 
    // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
    #region Create Certificates Properties
 
    
    [ObservableProperty]
    private int _numberCreatedCertificates = -1;
    
    // ----------------------------------------------------------------------------------------------------------------------------------------------

    public List<Person> AvailablePersons => _personService?.GetPersons().OrderBy(p => p.Name).ToList();
 
    // ----------------------------------------------------------------------------------------------------------------------------------------------
 
    private List<SwimmingStyles> _availableSwimmingStyles = Enum.GetValues(typeof(SwimmingStyles)).Cast<SwimmingStyles>().Where(s => s != SwimmingStyles.Unknown).ToList();
    public List<SwimmingStyles> AvailableSwimmingStyles => _availableSwimmingStyles;
 
    #endregion
 
    // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
    #region Create Time Forms Properties

    [ObservableProperty]
    private int _numberCreatedTimeForms = -1;
 
    #endregion
 
    // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
    #region Placeholders
 
    private ObservableCollection<DocumentPlaceholderViewConfig> _placeholderViewConfigs = new ObservableCollection<DocumentPlaceholderViewConfig>();
    public ObservableCollection<DocumentPlaceholderViewConfig> PlaceholderViewConfigs
    {
        get => _placeholderViewConfigs;
        private set => SetProperty(ref _placeholderViewConfigs, value);
    }

    public ICollectionView PlaceholderViewConfigsView { get; private set; }

    private void initPlaceholderViewConfigs()
    {
        PlaceholderViewConfigs.Clear();
        foreach(KeyValuePair<string, (string groupName, List<string> placeholders)> placeholderEntry in Placeholders.PlaceholderDict)
        {
            string placeholderKey = placeholderEntry.Key;
            ResourceManager rm = new ResourceManager(typeof(Properties.PlaceholderResources));
            string resourceStringName = rm.GetString($"PlaceholderName{placeholderKey}") ?? "?";
            string resourceStringInfo = rm.GetString($"PlaceholderInfo{placeholderKey}") ?? "?";
            string resourceStringGroup = rm.GetString($"PlaceholderGroup{placeholderEntry.Value.groupName}") ?? "?";
 
            Dictionary<DocumentCreationTypes, bool> isSupportedForDocumentType = new Dictionary<DocumentCreationTypes, bool>();
            Dictionary<DocumentCreationTypes, bool> isSupportedForTextPlaceholders = new Dictionary<DocumentCreationTypes, bool>();
            Dictionary<DocumentCreationTypes, bool> isSupportedForTablePlaceholders = new Dictionary<DocumentCreationTypes, bool>();
            Dictionary<DocumentCreationTypes, string> postfixNumbersSupportedForDocumentType = new Dictionary<DocumentCreationTypes, string>();
            foreach (IDocumentStrategy strategy in _documentStrategies)
            {
                DocumentCreationTypes documentCreationType = strategy.DocumentType;
                List<string> supportedPlaceholderKeys = strategy.SupportedPlaceholderKeys;
                bool isCurrentPlaceholderSupportedForStrategy = supportedPlaceholderKeys.Contains(placeholderKey);
                bool isCurrentPlaceholderSupportedForText = strategy.SupportTextPlaceholders || strategy.AlwaysSupportedPlaceholderKeys.Contains(placeholderKey);
                bool isCurrentPlaceholderSupportedForTable = strategy.SupportTablePlaceholders || strategy.AlwaysSupportedPlaceholderKeys.Contains(placeholderKey);
 
                int indexOfKey = supportedPlaceholderKeys.IndexOf(placeholderKey);
                int postfixNumbersSupported = (indexOfKey >= 0 && indexOfKey < strategy.PostfixNumbersSupported.Count) ? strategy.PostfixNumbersSupported[indexOfKey] : 0;
                string postfixNumbersSupportedStr = postfixNumbersSupported > 0 ? postfixNumbersSupported.ToString() : string.Empty;
 
                if (!isSupportedForDocumentType.ContainsKey(documentCreationType))
                {
                    isSupportedForDocumentType.Add(documentCreationType, isCurrentPlaceholderSupportedForStrategy);
                    isSupportedForTextPlaceholders.Add(documentCreationType, isCurrentPlaceholderSupportedForText);
                    isSupportedForTablePlaceholders.Add(documentCreationType, isCurrentPlaceholderSupportedForTable);
                    postfixNumbersSupportedForDocumentType.Add(documentCreationType, postfixNumbersSupportedStr);
                }
                else
                {
                    isSupportedForDocumentType[documentCreationType] = isCurrentPlaceholderSupportedForStrategy;
                    isSupportedForTextPlaceholders[documentCreationType] = isCurrentPlaceholderSupportedForText;
                    isSupportedForTablePlaceholders[documentCreationType] = isCurrentPlaceholderSupportedForTable;
                    postfixNumbersSupportedForDocumentType[documentCreationType] = postfixNumbersSupportedStr;
                }
            }
 
            DocumentPlaceholderViewConfig placeholderViewConfig = new DocumentPlaceholderViewConfig()
            {
                Group = resourceStringGroup,
                Key = placeholderKey,
                Name = resourceStringName,
                Info = resourceStringInfo,
                Placeholders = string.Join(Environment.NewLine, placeholderEntry.Value.placeholders.Select(p => $"{_documentService.PlaceholderMarker}{p}{_documentService.PlaceholderMarker}")),
                IsSupportedForDocumentType = isSupportedForDocumentType,
                IsSupportedForTextPlaceholders = isSupportedForTextPlaceholders,
                IsSupportedForTablePlaceholders = isSupportedForTablePlaceholders,
                PostfixNumbersSupportedForDocumentType = postfixNumbersSupportedForDocumentType
            };
            PlaceholderViewConfigs.Add(placeholderViewConfig);
        }
        OnPropertyChanged(nameof(PlaceholderViewConfigs));
    }
 
    #endregion
 
    // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
    private IDocumentService _documentService;
    private IPersonService _personService;
    private IWorkspaceService _workspaceService;
    private IDialogCoordinator _dialogCoordinator;
    private ShellViewModel _shellVM;
    private IEnumerable<IDocumentStrategy> _documentStrategies;

    public CreateDocumentsViewModel(IDocumentService documentService, IPersonService personService, IWorkspaceService workspaceService, IDialogCoordinator dialogCoordinator, ShellViewModel shellVM, IEnumerable<IDocumentStrategy> documentStrategies)
    {
        _documentService = documentService;
        _personService = personService;
        _workspaceService = workspaceService;
        _dialogCoordinator = dialogCoordinator;
        _shellVM = shellVM;
        _documentStrategies = documentStrategies;
 
        List<DocumentCreationTypes> availableDocumentCreationTypes = Enum.GetValues(typeof(DocumentCreationTypes)).Cast<DocumentCreationTypes>().ToList();
        DocumentCreationStatusPerType.Clear();
        DocumentCreationConfigPerType.Clear();     
        foreach (DocumentCreationTypes type in availableDocumentCreationTypes)
        {
            IDocumentStrategy strategy = _documentStrategies.FirstOrDefault(d => d.DocumentType == type);
 
            DocumentCreationStatusPerType.Add(type, new DocumentCreationStatus());
            DocumentCreationConfigPerType.Add(type, new DocumentCreationConfig()
            {
                DocumentStrategy = strategy,
                AvailableItemOrderings = strategy?.AvailableItemOrderings,
                CurrentItemOrdering = strategy?.ItemOrdering,
                AvailableItemFilters = strategy?.AvailableItemFilters,
                CurrentItemFilter = strategy?.ItemFilter,
                CurrentItemFilterParameter = strategy?.ItemFilterParameter
            });
        }
 
        PlaceholderViewConfigsView = CollectionViewSource.GetDefaultView(PlaceholderViewConfigs);
        PlaceholderViewConfigsView.GroupDescriptions.Add(new PropertyGroupDescription(nameof(DocumentPlaceholderViewConfig.Group)));
    }
 
    // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
    private ICommand _createDocumentCommand;
    public ICommand CreateDocumentCommand => _createDocumentCommand ?? (_createDocumentCommand = new RelayCommand<DocumentCreationTypes>(async (documentType) =>
    {
        int numCreatedPages = 0;
        string returnFilePath = string.Empty;
 
        // Update the item ordering and filter for all document strategies before creating the document
        List<DocumentCreationTypes> availableDocumentCreationTypes = Enum.GetValues(typeof(DocumentCreationTypes)).Cast<DocumentCreationTypes>().ToList();
        foreach (DocumentCreationTypes type in availableDocumentCreationTypes)
        {
            IDocumentStrategy strategy = _documentStrategies.FirstOrDefault(s => s.DocumentType == type);
            if (strategy != null)
            {
                strategy.ItemOrdering = DocumentCreationConfigPerType[type].CurrentItemOrdering;
                strategy.ItemFilter = DocumentCreationConfigPerType[type].CurrentItemFilter;
                strategy.ItemFilterParameter = DocumentCreationConfigPerType[type].CurrentItemFilterParameter;
            }
        }
 
        changeDocumentCreationRunningState(documentType, true);
        try
        {
            changeDocumentCreationSuccessfulState(documentType, false);
            switch (documentType)
            {
                case DocumentCreationTypes.Certificates:
                    {
                        (numCreatedPages, returnFilePath) = await _documentService.CreateDocument(DocumentCreationTypes.Certificates);
                        NumberCreatedCertificates = numCreatedPages;
                        break;
                    }
                case DocumentCreationTypes.OverviewList:
                    {
                        (numCreatedPages, returnFilePath) = await _documentService.CreateDocument(DocumentCreationTypes.OverviewList);
                        break;
                    }
                case DocumentCreationTypes.RaceStartList:
                    {
                        (numCreatedPages, returnFilePath) = await _documentService.CreateDocument(DocumentCreationTypes.RaceStartList);
                        break;
                    }
                case DocumentCreationTypes.TimeForms:
                    {
                        (numCreatedPages, returnFilePath) = await _documentService.CreateDocument(DocumentCreationTypes.TimeForms);
                        NumberCreatedTimeForms = numCreatedPages;
                        break;
                    }
                case DocumentCreationTypes.ResultList:
                    {
                        (numCreatedPages, returnFilePath) = await _documentService.CreateDocument(DocumentCreationTypes.ResultList);
                        break;
                    }
                case DocumentCreationTypes.ResultListDetail:
                    {
                        (numCreatedPages, returnFilePath) = await _documentService.CreateDocument(DocumentCreationTypes.ResultListDetail);
                        break;
                    }
                case DocumentCreationTypes.Analytics:
                    {
                        (numCreatedPages, returnFilePath) = await _documentService.CreateDocument(DocumentCreationTypes.Analytics);
                        break;
                    }
                default: throw new ArgumentOutOfRangeException(nameof(documentType), documentType, "Unknown document type for creation command.");
            }
            changeLastDocumentFilePath(documentType, returnFilePath);
            changeDocumentCreationSuccessfulState(documentType, true);
        }
        catch (Exception ex)
        {
            await _dialogCoordinator.ShowMessageAsync(_shellVM, Resources.ErrorString, ex.Message);
        }
        changeDocumentCreationRunningState(documentType, false);
    }, (documentType) => !IsAnyDocumentCreationRunning));
 

    public void OnNavigatedTo(object parameter)
    {
        foreach(IDocumentStrategy strategy in _documentStrategies)
        {
            object[] items = strategy.GetItems();
            bool isDataAvailable = items != null;
            changeDocumentDataAvailableState(strategy.DocumentType, isDataAvailable);
 
            bool isTemplateAvailable = !string.IsNullOrEmpty(strategy.TemplatePath) && 
                                       File.Exists(strategy.TemplatePath) &&
                                       Path.GetExtension(strategy.TemplatePath) == ".docx";
            changeDocumentTemplateAvailableState(strategy.DocumentType, isTemplateAvailable);
 
            if (!isDataAvailable || !isTemplateAvailable)
            {
                changeDocumentCreationRunningState(strategy.DocumentType, false);
                changeDocumentCreationSuccessfulState(strategy.DocumentType, false);
            }
 
            // Find existing documents
            string templateFileNamePostfix = _workspaceService?.Settings?.GetSettingValue<string>(WorkspaceSettings.GROUP_DOCUMENT_CREATION, WorkspaceSettings.SETTING_DOCUMENT_CREATION_TEMPLATE_FILENAME_POSTFIX) ?? string.Empty;
            string documentOutputFolder = _workspaceService?.Settings?.GetSettingValue<string>(WorkspaceSettings.GROUP_DOCUMENT_CREATION, WorkspaceSettings.SETTING_DOCUMENT_CREATION_OUTPUT_FOLDER) ?? string.Empty;
            documentOutputFolder = FilePathHelper.MakePathAbsolute(documentOutputFolder, _workspaceService?.PersistentPath);
 
            string outputFileNameDocx = Path.GetFileNameWithoutExtension(strategy.TemplatePath);
            outputFileNameDocx = outputFileNameDocx.Replace(templateFileNamePostfix, "") + ".docx";
            string outputFilePathDocx = Path.Combine(documentOutputFolder, outputFileNameDocx);
            string outputFilePathPdf = outputFilePathDocx.Replace(".docx", ".pdf", StringComparison.InvariantCultureIgnoreCase);
            if(File.Exists(outputFilePathPdf))
            {
                changeLastDocumentFilePath(strategy.DocumentType, outputFilePathPdf);
                changeDocumentCreationSuccessfulState(strategy.DocumentType, true);     // necessary to show the path
            }
            else if(File.Exists(outputFilePathDocx))
            {
                changeLastDocumentFilePath(strategy.DocumentType, outputFilePathDocx);
                changeDocumentCreationSuccessfulState(strategy.DocumentType, true);     // necessary to show the path
            }
        }
 
        initPlaceholderViewConfigs();
    }

    public void OnNavigatedFrom()
    {
    }
}