Projekt końcowy: aplikacja „Moje Zadania”

<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="MojaAplikacja.MainPage">
    <VerticalStackLayout Padding="24" Spacing="14">
        <Label Text="Moje zadania" FontSize="24" />
        <Entry Placeholder="Nowe zadanie" />
        <DatePicker />
        <Label Text="Najpierw ekran. Za chwilę walidacja i zapis." />
    </VerticalStackLayout>
</ContentPage>

MojeZadaniaApp/
├── Modele/Zadanie.cs
├── Logika/WalidatorZadania.cs
├── Data/ZadaniaDatabase.cs
├── App.xaml.cs                 (inicjalizacja bazy, App.Database)
├── MainPage.xaml(.cs)          (lista zadań, CollectionView)
├── DodajZadaniePage.xaml(.cs)  (formularz z walidacją)
└── UstawieniaPage.xaml(.cs)    (Preferences)

using SQLite;

namespace MojaAplikacja.Modele;

public class Zadanie
{
    [PrimaryKey, AutoIncrement]
    public int Id { get; set; }

    [MaxLength(100)]
    public string Nazwa { get; set; } = "";

    public DateTime Termin { get; set; }

    public bool Wykonane { get; set; }

    [Ignore]
    public string TerminOpis => Termin.ToString("dd.MM.yyyy HH:mm");

    [Ignore]
    public string Status => Wykonane ? "Wykonane" : "Do zrobienia";
}

using MojaAplikacja.Modele;

namespace MojaAplikacja.Logika;

public static class WalidatorZadania
{
    public static (bool ok, List<string> bledy, Zadanie? model) Waliduj(string? nazwa, DateTime termin)
    {
        var bledy = new List<string>();

        if (string.IsNullOrWhiteSpace(nazwa))
            bledy.Add("Podaj nazwę zadania.");
        else if (nazwa.Trim().Length > 100)
            bledy.Add("Nazwa może mieć najwyżej 100 znaków.");

        if (termin < DateTime.Now)
            bledy.Add("Termin nie może być z przeszłości.");

        if (bledy.Count > 0)
            return (false, bledy, null);

        return (true, bledy, new Zadanie { Nazwa = nazwa!.Trim(), Termin = termin });
    }
}

using SQLite;
using MojaAplikacja.Modele;

namespace MojaAplikacja.Data;

public class ZadaniaDatabase
{
    private readonly SQLiteAsyncConnection _database;
    private readonly Task _inicjalizacja;

    public ZadaniaDatabase(string dbPath)
    {
        _database = new SQLiteAsyncConnection(dbPath);
        _inicjalizacja = _database.CreateTableAsync<Zadanie>();
    }

    private Task InitAsync() => _inicjalizacja;

    public async Task<List<Zadanie>> PobierzAsync()
    {
        await InitAsync();
        return await _database.Table<Zadanie>().ToListAsync();
    }

    public async Task<int> DodajAsync(Zadanie zadanie)
    {
        await InitAsync();
        return await _database.InsertAsync(zadanie);
    }

    public async Task<int> AktualizujAsync(Zadanie zadanie)
    {
        await InitAsync();
        return await _database.UpdateAsync(zadanie);
    }

    public async Task<int> UsunAsync(Zadanie zadanie)
    {
        await InitAsync();
        return await _database.DeleteAsync(zadanie);
    }
}

using MojaAplikacja.Data;

namespace MojaAplikacja;

public partial class App : Application
{
    public static ZadaniaDatabase Database { get; private set; } = null!;

    public App()
    {
        InitializeComponent();

        string dbPath = Path.Combine(FileSystem.AppDataDirectory, "zadania.db3");
        Database = new ZadaniaDatabase(dbPath);
    }

    protected override Window CreateWindow(IActivationState? activationState)
    {
        return new Window(new NavigationPage(new MainPage()));
    }
}

<?xml version="1.0" encoding="utf-8" ?>
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             xmlns:modele="clr-namespace:MojaAplikacja.Modele"
             x:Class="MojaAplikacja.MainPage"
             Title="Moje Zadania">

    <Grid Padding="16" RowDefinitions="Auto,*" RowSpacing="12">

        <HorizontalStackLayout Spacing="12">
            <Button Text="Nowe zadanie" Clicked="Dodaj_Clicked" />
            <Button Text="Ustawienia" Clicked="Ustawienia_Clicked" />
        </HorizontalStackLayout>

        <CollectionView Grid.Row="1" x:Name="ListaZadan" EmptyView="Brak zadań.">
            <CollectionView.ItemTemplate>
                <DataTemplate x:DataType="modele:Zadanie">
                    <Grid Padding="8" ColumnDefinitions="*,Auto,Auto" ColumnSpacing="8">
                        <VerticalStackLayout>
                            <Label Text="{Binding Nazwa}" FontAttributes="Bold" />
                            <Label Text="{Binding TerminOpis}" FontSize="12" />
                        </VerticalStackLayout>
                        <Button Grid.Column="1" Text="{Binding Status}" Clicked="Status_Clicked" />
                        <Button Grid.Column="2" Text="Usuń" Clicked="Usun_Clicked" />
                    </Grid>
                </DataTemplate>
            </CollectionView.ItemTemplate>
        </CollectionView>
    </Grid>
</ContentPage>

using MojaAplikacja.Modele;

namespace MojaAplikacja;

public partial class MainPage : ContentPage
{
    public MainPage()
    {
        InitializeComponent();
    }

    protected override async void OnAppearing()
    {
        base.OnAppearing();
        await BezpiecznieAsync(OdswiezAsync);
    }

    private async Task OdswiezAsync()
    {
        List<Zadanie> zadania = await App.Database.PobierzAsync();

        if (!Preferences.Default.Get("pokazuj_wykonane", true))
            zadania = zadania.Where(z => !z.Wykonane).ToList();

        zadania = Preferences.Default.Get("sortowanie", 0) == 0
            ? zadania.OrderBy(z => z.Termin).ToList()
            : zadania.OrderBy(z => z.Nazwa).ToList();

        ListaZadan.ItemsSource = zadania;
    }

    private async void Dodaj_Clicked(object sender, EventArgs e)
        => await Navigation.PushAsync(new DodajZadaniePage());

    private async void Ustawienia_Clicked(object sender, EventArgs e)
        => await Navigation.PushAsync(new UstawieniaPage());

    private async void Status_Clicked(object sender, EventArgs e)
    {
        if ((sender as BindableObject)?.BindingContext is Zadanie zadanie)
        {
            zadanie.Wykonane = !zadanie.Wykonane;
            await BezpiecznieAsync(() => App.Database.AktualizujAsync(zadanie));
            await BezpiecznieAsync(OdswiezAsync);
        }
    }

    private async void Usun_Clicked(object sender, EventArgs e)
    {
        if ((sender as BindableObject)?.BindingContext is Zadanie zadanie)
        {
            await BezpiecznieAsync(() => App.Database.UsunAsync(zadanie));
            await BezpiecznieAsync(OdswiezAsync);
        }
    }
    private async Task BezpiecznieAsync(Func<Task> operacja)
    {
        try { await operacja(); }
        catch (Exception)
        {
            await DisplayAlertAsync("Baza", "Operacja się nie powiodła. Odśwież listę i spróbuj ponownie.", "OK");
        }
    }
}

<?xml version="1.0" encoding="utf-8" ?>
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="MojaAplikacja.DodajZadaniePage"
             Title="Nowe zadanie">

    <VerticalStackLayout Padding="16" Spacing="12">
        <Entry x:Name="NazwaEntry" Placeholder="Nazwa zadania" />
        <DatePicker x:Name="DataPicker" />
        <TimePicker x:Name="CzasPicker" />
        <Button Text="Zapisz" Clicked="Zapisz_Clicked" />
    </VerticalStackLayout>
</ContentPage>

using MojaAplikacja.Logika;

namespace MojaAplikacja;

public partial class DodajZadaniePage : ContentPage
{
    public DodajZadaniePage()
    {
        InitializeComponent();
        DataPicker.Date = DateTime.Today.AddDays(1);
    }

    private async void Zapisz_Clicked(object sender, EventArgs e)
    {
        if (DataPicker.Date is not DateTime data || CzasPicker.Time is not TimeSpan czas)
        {
            await DisplayAlertAsync("Termin", "Wybierz datę i godzinę.", "OK");
            return;
        }
        DateTime termin = data.Date + czas;
        var (ok, bledy, zadanie) = WalidatorZadania.Waliduj(NazwaEntry.Text, termin);

        if (!ok)
        {
            await DisplayAlertAsync("Popraw dane", string.Join("\n", bledy), "OK");
            return;
        }

        try
        {
            await App.Database.DodajAsync(zadanie!);
            await Navigation.PopAsync();
        }
        catch (Exception)
        {
            await DisplayAlertAsync("Baza", "Nie udało się zapisać zadania. Formularz zachował dane.", "OK");
        }
    }
}

<?xml version="1.0" encoding="utf-8" ?>
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="MojaAplikacja.UstawieniaPage"
             Title="Ustawienia">

    <VerticalStackLayout Padding="16" Spacing="14">
        <HorizontalStackLayout Spacing="10">
            <Label Text="Pokazuj wykonane" VerticalOptions="Center" />
            <Switch x:Name="WykonaneSwitch" Toggled="Zmiana" />
        </HorizontalStackLayout>

        <Picker x:Name="SortPicker" Title="Sortowanie" SelectedIndexChanged="Zmiana">
            <Picker.Items>
                <x:String>Po terminie</x:String>
                <x:String>Alfabetycznie</x:String>
            </Picker.Items>
        </Picker>
    </VerticalStackLayout>
</ContentPage>

namespace MojaAplikacja;

public partial class UstawieniaPage : ContentPage
{
    private readonly bool _wczytano;

    public UstawieniaPage()
    {
        InitializeComponent();
        WykonaneSwitch.IsToggled = Preferences.Default.Get("pokazuj_wykonane", true);
        SortPicker.SelectedIndex = Preferences.Default.Get("sortowanie", 0);
        _wczytano = true;
    }

    private void Zmiana(object? sender, EventArgs e)
    {
        if (!_wczytano) return;

        Preferences.Default.Set("pokazuj_wykonane", WykonaneSwitch.IsToggled);
        Preferences.Default.Set("sortowanie", SortPicker.SelectedIndex);
    }
}

Dodaj priorytet zadania jako nową właściwość modelu i element formularza.
Dotychczasowe działanie ma pozostać poprawne.