Add processors list and details pages.

Marechai.App/Presentation/ViewModels/MachineViewViewModel.cs

@@ -181,6 +181,20 @@ public partial class MachineViewViewModel : ObservableObject
             return;
         }
 
+        // If we came from ProcessorDetailViewModel, navigate back to processor details
+        if(_navigationSource is ProcessorDetailViewModel processorDetailVm)
+        {
+            var navParam = new ProcessorDetailNavigationParameter
+            {
+                ProcessorId      = processorDetailVm.ProcessorId,
+                NavigationSource = this
+            };
+
+            await _navigator.NavigateViewModelAsync<ProcessorDetailViewModel>(this, data: navParam);
+
+            return;
+        }
+
         // Otherwise, try to go back in the navigation stack
         await _navigator.GoBack(this);
     }

Marechai.App/Presentation/ViewModels/ProcessorDetailViewModel.cs

@@ -0,0 +1,294 @@
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Windows.Input;
+using Marechai.App.Presentation.Models;
+using Marechai.App.Services;
+using Uno.Extensions.Navigation;
+
+namespace Marechai.App.Presentation.ViewModels;
+
+public partial class ProcessorDetailViewModel : ObservableObject
+{
+    private readonly CompaniesService                  _companiesService;
+    private readonly IStringLocalizer                  _localizer;
+    private readonly ILogger<ProcessorDetailViewModel> _logger;
+    private readonly INavigator                        _navigator;
+    private readonly ProcessorsService                 _processorsService;
+
+    [ObservableProperty]
+    private ObservableCollection<MachineItem> _computers = [];
+
+    [ObservableProperty]
+    private string _computersFilterText = string.Empty;
+
+    [ObservableProperty]
+    private string _consoelsFilterText = string.Empty;
+
+    [ObservableProperty]
+    private ObservableCollection<MachineItem> _consoles = [];
+
+    [ObservableProperty]
+    private string _errorMessage = string.Empty;
+
+    [ObservableProperty]
+    private ObservableCollection<MachineItem> _filteredComputers = [];
+
+    [ObservableProperty]
+    private ObservableCollection<MachineItem> _filteredConsoles = [];
+
+    [ObservableProperty]
+    private bool _hasComputers;
+
+    [ObservableProperty]
+    private bool _hasConsoles;
+
+    [ObservableProperty]
+    private bool _hasError;
+
+    [ObservableProperty]
+    private bool _isDataLoaded;
+
+    [ObservableProperty]
+    private bool _isLoading;
+
+    [ObservableProperty]
+    private string _manufacturerName = string.Empty;
+
+    private object? _navigationSource;
+
+    [ObservableProperty]
+    private ProcessorDto? _processor;
+
+    [ObservableProperty]
+    private int _processorId;
+
+    public ProcessorDetailViewModel(ProcessorsService processorsService, CompaniesService companiesService,
+                                    IStringLocalizer  localizer,         ILogger<ProcessorDetailViewModel> logger,
+                                    INavigator        navigator)
+    {
+        _processorsService     = processorsService;
+        _companiesService      = companiesService;
+        _localizer             = localizer;
+        _logger                = logger;
+        _navigator             = navigator;
+        LoadData               = new AsyncRelayCommand(LoadDataAsync);
+        GoBackCommand          = new AsyncRelayCommand(GoBackAsync);
+        SelectMachineCommand   = new AsyncRelayCommand<int>(SelectMachineAsync);
+        ComputersFilterCommand = new RelayCommand(() => FilterComputers());
+        ConsolesFilterCommand  = new RelayCommand(() => FilterConsoles());
+    }
+
+    public IAsyncRelayCommand LoadData               { get; }
+    public ICommand           GoBackCommand          { get; }
+    public IAsyncRelayCommand SelectMachineCommand   { get; }
+    public ICommand           ComputersFilterCommand { get; }
+    public ICommand           ConsolesFilterCommand  { get; }
+
+    public string Title { get; } = "Processor Details";
+
+    /// <summary>
+    ///     Loads Processor details
+    /// </summary>
+    private async Task LoadDataAsync()
+    {
+        try
+        {
+            IsLoading    = true;
+            ErrorMessage = string.Empty;
+            HasError     = false;
+            IsDataLoaded = false;
+            Computers.Clear();
+            Consoles.Clear();
+
+            if(ProcessorId <= 0)
+            {
+                ErrorMessage = _localizer["Invalid Processor ID"].Value;
+                HasError     = true;
+
+                return;
+            }
+
+            _logger.LogInformation("Loading Processor details for ID: {ProcessorId}", ProcessorId);
+
+            // Load Processor details
+            Processor = await _processorsService.GetProcessorByIdAsync(ProcessorId);
+
+            if(Processor is null)
+            {
+                ErrorMessage = _localizer["Processor not found"].Value;
+                HasError     = true;
+
+                return;
+            }
+
+            // Set manufacturer name (from Company field or fetch by CompanyId if empty)
+            ManufacturerName = Processor.Company ?? string.Empty;
+
+            if(string.IsNullOrEmpty(ManufacturerName) && Processor.CompanyId.HasValue)
+            {
+                try
+                {
+                    CompanyDto? company = await _companiesService.GetCompanyByIdAsync(Processor.CompanyId.Value);
+                    if(company != null) ManufacturerName = company.Name ?? string.Empty;
+                }
+                catch(Exception ex)
+                {
+                    _logger.LogWarning(ex, "Failed to load company for Processor {ProcessorId}", ProcessorId);
+                }
+            }
+
+            _logger.LogInformation("Processor loaded: {Name}, Company: {Company}", Processor.Name, ManufacturerName);
+
+            // Load machines and separate into computers and consoles
+            try
+            {
+                List<MachineDto>? machines = await _processorsService.GetMachinesByProcessorAsync(ProcessorId);
+
+                if(machines != null && machines.Count > 0)
+                {
+                    Computers.Clear();
+                    Consoles.Clear();
+
+                    foreach(MachineDto machine in machines)
+                    {
+                        var machineItem = new MachineItem
+                        {
+                            Id           = machine.Id               ?? 0,
+                            Name         = machine.Name             ?? string.Empty,
+                            Manufacturer = machine.Company          ?? string.Empty,
+                            Year         = machine.Introduced?.Year ?? 0
+                        };
+
+                        // Distinguish between computers and consoles based on Type
+                        if(machine.Type == 2) // MachineType.Console
+                            Consoles.Add(machineItem);
+                        else // MachineType.Computer or Unknown
+                            Computers.Add(machineItem);
+                    }
+
+                    HasComputers = Computers.Count > 0;
+                    HasConsoles  = Consoles.Count  > 0;
+
+                    // Initialize filtered collections
+                    FilterComputers();
+                    FilterConsoles();
+
+                    _logger.LogInformation("Loaded {ComputerCount} computers and {ConsoleCount} consoles for Processor {ProcessorId}",
+                                           Computers.Count,
+                                           Consoles.Count,
+                                           ProcessorId);
+                }
+                else
+                {
+                    HasComputers = false;
+                    HasConsoles  = false;
+                }
+            }
+            catch(Exception ex)
+            {
+                _logger.LogWarning(ex, "Failed to load machines for Processor {ProcessorId}", ProcessorId);
+                HasComputers = false;
+                HasConsoles  = false;
+            }
+
+            IsDataLoaded = true;
+        }
+        catch(Exception ex)
+        {
+            _logger.LogError(ex, "Error loading Processor details: {Exception}", ex.Message);
+            ErrorMessage = _localizer["Failed to load processor details. Please try again later."].Value;
+            HasError     = true;
+        }
+        finally
+        {
+            IsLoading = false;
+        }
+    }
+
+    /// <summary>
+    ///     Navigates back to the Processor list
+    /// </summary>
+    private async Task GoBackAsync()
+    {
+        // If we came from a machine view, go back to machine view
+        if(_navigationSource is MachineViewViewModel machineVm)
+        {
+            await _navigator.NavigateViewModelAsync<MachineViewViewModel>(this);
+
+            return;
+        }
+
+        // Default: go back to Processor list
+        await _navigator.NavigateViewModelAsync<ProcessorsListViewModel>(this);
+    }
+
+    /// <summary>
+    ///     Filters computers based on search text
+    /// </summary>
+    private void FilterComputers()
+    {
+        if(string.IsNullOrWhiteSpace(ComputersFilterText))
+        {
+            FilteredComputers.Clear();
+            foreach(MachineItem computer in Computers) FilteredComputers.Add(computer);
+        }
+        else
+        {
+            var filtered = Computers
+                          .Where(c => c.Name.Contains(ComputersFilterText, StringComparison.OrdinalIgnoreCase))
+                          .ToList();
+
+            FilteredComputers.Clear();
+            foreach(MachineItem computer in filtered) FilteredComputers.Add(computer);
+        }
+    }
+
+    /// <summary>
+    ///     Filters consoles based on search text
+    /// </summary>
+    private void FilterConsoles()
+    {
+        if(string.IsNullOrWhiteSpace(ConsoelsFilterText))
+        {
+            FilteredConsoles.Clear();
+            foreach(MachineItem console in Consoles) FilteredConsoles.Add(console);
+        }
+        else
+        {
+            var filtered = Consoles.Where(c => c.Name.Contains(ConsoelsFilterText, StringComparison.OrdinalIgnoreCase))
+                                   .ToList();
+
+            FilteredConsoles.Clear();
+            foreach(MachineItem console in filtered) FilteredConsoles.Add(console);
+        }
+    }
+
+    /// <summary>
+    ///     Navigates to machine detail view
+    /// </summary>
+    private async Task SelectMachineAsync(int machineId)
+    {
+        if(machineId <= 0) return;
+
+        var navParam = new MachineViewNavigationParameter
+        {
+            MachineId        = machineId,
+            NavigationSource = this
+        };
+
+        await _navigator.NavigateViewModelAsync<MachineViewViewModel>(this, data: navParam);
+    }
+
+    /// <summary>
+    ///     Sets the navigation source (where we came from).
+    /// </summary>
+    public void SetNavigationSource(object? source)
+    {
+        _navigationSource = source;
+    }
+}

Marechai.App/Presentation/ViewModels/ProcessorsListViewModel.cs

@@ -0,0 +1,177 @@
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Threading.Tasks;
+using Marechai.App.Presentation.Models;
+using Marechai.App.Services;
+using Uno.Extensions.Navigation;
+
+namespace Marechai.App.Presentation.ViewModels;
+
+/// <summary>
+///     ViewModel for displaying a list of Processors
+/// </summary>
+public partial class ProcessorsListViewModel : ObservableObject
+{
+    private readonly IStringLocalizer                 _localizer;
+    private readonly ILogger<ProcessorsListViewModel> _logger;
+    private readonly INavigator                       _navigator;
+    private readonly ProcessorsService                _processorsService;
+
+    [ObservableProperty]
+    private string _errorMessage = string.Empty;
+
+    [ObservableProperty]
+    private bool _hasError;
+
+    [ObservableProperty]
+    private bool _isDataLoaded;
+
+    [ObservableProperty]
+    private bool _isLoading;
+
+    [ObservableProperty]
+    private string _pageTitle = string.Empty;
+
+    [ObservableProperty]
+    private ObservableCollection<ProcessorListItem> _processorsList = [];
+
+    public ProcessorsListViewModel(ProcessorsService                processorsService, IStringLocalizer localizer,
+                                   ILogger<ProcessorsListViewModel> logger,            INavigator       navigator)
+    {
+        _processorsService         = processorsService;
+        _localizer                 = localizer;
+        _logger                    = logger;
+        _navigator                 = navigator;
+        LoadData                   = new AsyncRelayCommand(LoadDataAsync);
+        NavigateToProcessorCommand = new AsyncRelayCommand<ProcessorListItem>(NavigateToProcessorAsync);
+    }
+
+    public IAsyncRelayCommand                    LoadData                   { get; }
+    public IAsyncRelayCommand<ProcessorListItem> NavigateToProcessorCommand { get; }
+
+    /// <summary>
+    ///     Loads all Processors and sorts them alphabetically
+    /// </summary>
+    private async Task LoadDataAsync()
+    {
+        try
+        {
+            IsLoading    = true;
+            ErrorMessage = string.Empty;
+            HasError     = false;
+            IsDataLoaded = false;
+            ProcessorsList.Clear();
+
+            _logger.LogInformation("LoadDataAsync called for Processors");
+
+            PageTitle = _localizer["Processors"];
+
+            // Load Processors from the API
+            await LoadProcessorsFromApiAsync();
+
+            _logger.LogInformation("LoadProcessorsFromApiAsync completed. ProcessorsList.Count={Count}",
+                                   ProcessorsList.Count);
+
+            if(ProcessorsList.Count == 0)
+            {
+                ErrorMessage = _localizer["No processors found"].Value;
+                HasError     = true;
+
+                _logger.LogWarning("No Processors found");
+            }
+            else
+                IsDataLoaded = true;
+        }
+        catch(Exception ex)
+        {
+            _logger.LogError(ex, "Error loading Processors: {Exception}", ex.Message);
+            ErrorMessage = _localizer["Failed to load processors. Please try again later."].Value;
+            HasError     = true;
+        }
+        finally
+        {
+            IsLoading = false;
+        }
+    }
+
+    /// <summary>
+    ///     Loads Processors from the API and sorts them alphabetically
+    /// </summary>
+    private async Task LoadProcessorsFromApiAsync()
+    {
+        try
+        {
+            List<ProcessorDto> processors = await _processorsService.GetAllProcessorsAsync();
+
+            if(processors == null || processors.Count == 0)
+            {
+                _logger.LogInformation("No Processors returned from API");
+
+                return;
+            }
+
+            var processorItems = new List<ProcessorListItem>();
+
+            foreach(ProcessorDto processor in processors)
+            {
+                var processorItem = new ProcessorListItem
+                {
+                    Id      = processor.Id      ?? 0,
+                    Name    = processor.Name    ?? string.Empty,
+                    Company = processor.Company ?? string.Empty
+                };
+
+                processorItems.Add(processorItem);
+
+                _logger.LogInformation("Processor: {Name}, Company: {Company}, ID: {Id}",
+                                       processor.Name,
+                                       processor.Company,
+                                       processor.Id);
+            }
+
+            // Sort processors alphabetically
+            processorItems.Sort((a, b) => string.Compare(a.Name, b.Name, StringComparison.OrdinalIgnoreCase));
+
+            // Add all processors to the list
+            foreach(ProcessorListItem processor in processorItems) ProcessorsList.Add(processor);
+        }
+        catch(Exception ex)
+        {
+            _logger.LogError(ex, "Error loading Processors from API");
+        }
+    }
+
+    /// <summary>
+    ///     Navigates to the Processor detail view
+    /// </summary>
+    private async Task NavigateToProcessorAsync(ProcessorListItem? processor)
+    {
+        if(processor is null) return;
+
+        _logger.LogInformation("Navigating to Processor detail: {ProcessorName} (ID: {ProcessorId})",
+                               processor.Name,
+                               processor.Id);
+
+        // Navigate to Processor detail view with navigation parameter
+        var navParam = new ProcessorDetailNavigationParameter
+        {
+            ProcessorId      = processor.Id,
+            NavigationSource = this
+        };
+
+        await _navigator.NavigateViewModelAsync<ProcessorDetailViewModel>(this, data: navParam);
+    }
+}
+
+/// <summary>
+///     Data model for a Processor in the list
+/// </summary>
+public class ProcessorListItem
+{
+    public int    Id      { get; set; }
+    public string Name    { get; set; } = string.Empty;
+    public string Company { get; set; } = string.Empty;
+}