452 lines
18 KiB
C#
452 lines
18 KiB
C#
using CommunityToolkit.Mvvm.ComponentModel;
|
||
using CommunityToolkit.Mvvm.Input;
|
||
using LehrerApp.Core.Interfaces;
|
||
using LehrerApp.Core.Models;
|
||
using System.Collections.ObjectModel;
|
||
|
||
namespace LehrerApp.Desktop.ViewModels.Students;
|
||
|
||
public partial class StudentListViewModel : ObservableObject
|
||
{
|
||
private readonly IStudentRepository _students;
|
||
public Action<Guid>? OnNavigateToDetail { get; set; }
|
||
|
||
[ObservableProperty] private string _searchText = "";
|
||
[ObservableProperty] private bool _showInactive;
|
||
[ObservableProperty] private StudentListItem? _selectedStudent;
|
||
|
||
public ObservableCollection<StudentListItem> Students { get; } = [];
|
||
|
||
public StudentListViewModel(IStudentRepository students)
|
||
{
|
||
_students = students;
|
||
LoadStudents();
|
||
}
|
||
|
||
partial void OnSearchTextChanged(string value) => LoadStudents();
|
||
partial void OnShowInactiveChanged(bool value) => LoadStudents();
|
||
partial void OnSelectedStudentChanged(StudentListItem? value)
|
||
{
|
||
if (value is not null) OnNavigateToDetail?.Invoke(value.Id);
|
||
}
|
||
|
||
public void LoadStudents()
|
||
{
|
||
Students.Clear();
|
||
var all = _students.GetAll(ShowInactive);
|
||
var f = string.IsNullOrWhiteSpace(SearchText) ? all
|
||
: all.Where(s => s.LastName.Contains(SearchText, StringComparison.OrdinalIgnoreCase)
|
||
|| s.FirstName.Contains(SearchText, StringComparison.OrdinalIgnoreCase));
|
||
foreach (var s in f) Students.Add(new StudentListItem(s));
|
||
}
|
||
|
||
public Func<Task>? OnAddStudent { get; set; }
|
||
|
||
[RelayCommand]
|
||
private async Task AddStudent()
|
||
{
|
||
if (OnAddStudent is null) return;
|
||
await OnAddStudent();
|
||
LoadStudents();
|
||
}
|
||
|
||
[RelayCommand] private void Refresh() => LoadStudents();
|
||
}
|
||
|
||
public class StudentListItem
|
||
{
|
||
public Guid Id { get; }
|
||
public string FullName { get; }
|
||
public string DateOfBirth { get; }
|
||
public StudentListItem(Student s)
|
||
{
|
||
Id = s.Id; FullName = s.FullName;
|
||
DateOfBirth = s.DateOfBirth?.ToString("dd.MM.yyyy") ?? "";
|
||
}
|
||
}
|
||
|
||
public partial class StudentDetailViewModel : ObservableObject
|
||
{
|
||
private readonly IStudentRepository _students;
|
||
private readonly IGroupMembershipRepository _memberships;
|
||
private readonly IGroupRepository _groups;
|
||
private readonly ISubjectRepository _subjects;
|
||
private readonly IDocumentationRepository _docs;
|
||
|
||
[ObservableProperty] private Student? _student;
|
||
[ObservableProperty] private string _studentTitle = "";
|
||
[ObservableProperty] private bool _isEditing;
|
||
[ObservableProperty] private string _editFirstName = "";
|
||
[ObservableProperty] private string _editLastName = "";
|
||
[ObservableProperty] private ContactItem? _selectedContact;
|
||
|
||
public ObservableCollection<GroupMembershipEntry> GroupMemberships { get; } = [];
|
||
public ObservableCollection<DocEntry> Documentation { get; } = [];
|
||
public ObservableCollection<ContactItem> Contacts { get; } = [];
|
||
public bool HasNoContacts => Contacts.Count == 0;
|
||
public Func<Contact?, Task<Contact?>>? OnEditContact { get; set; }
|
||
public Action<ContactItem>? OnViewAddress { get; set; }
|
||
|
||
public StudentDetailViewModel(IStudentRepository students,
|
||
IGroupMembershipRepository memberships, IGroupRepository groups, ISubjectRepository subjects,
|
||
IDocumentationRepository docs)
|
||
{
|
||
_students = students; _memberships = memberships;
|
||
_groups = groups; _subjects = subjects; _docs = docs;
|
||
}
|
||
|
||
public void LoadStudent(Guid id)
|
||
{
|
||
Student = _students.GetById(id);
|
||
if (Student is null) return;
|
||
StudentTitle = Student.FullName;
|
||
EditFirstName = Student.FirstName;
|
||
EditLastName = Student.LastName;
|
||
|
||
GroupMemberships.Clear();
|
||
foreach (var membership in _memberships.GetByStudent(Student.Id))
|
||
{
|
||
var g = _groups.GetById(membership.GroupId);
|
||
if (g is null) continue;
|
||
var subject = g.SubjectId is Guid subjectId ? _subjects.GetById(subjectId)?.Name ?? "" : "";
|
||
GroupMemberships.Add(new() { SchoolYear = g.SchoolYear, GroupName = g.Name, Subject = subject });
|
||
}
|
||
|
||
LoadContacts();
|
||
|
||
Documentation.Clear();
|
||
foreach (var d in _docs.GetByStudent(Student.Id))
|
||
Documentation.Add(new() { Date = d.Date.ToString("dd.MM.yyyy"), Title = d.Title,
|
||
TypeLabel = d.Type switch
|
||
{
|
||
DocumentationType.Conversation => "Gespräch",
|
||
DocumentationType.Incident => "Vorkommnis",
|
||
DocumentationType.SupportPlan => "Förderplan",
|
||
DocumentationType.Absence => "Fehlzeit",
|
||
_ => "",
|
||
},
|
||
IsConfidential = d.IsConfidential });
|
||
}
|
||
|
||
[RelayCommand] private void StartEdit() => IsEditing = true;
|
||
[RelayCommand] private void CancelEdit()
|
||
{
|
||
if (Student is null) return;
|
||
EditFirstName = Student.FirstName; EditLastName = Student.LastName;
|
||
IsEditing = false;
|
||
}
|
||
[RelayCommand] private void SaveEdit()
|
||
{
|
||
if (Student is null) return;
|
||
Student.FirstName = EditFirstName; Student.LastName = EditLastName;
|
||
_students.Save(Student);
|
||
StudentTitle = Student.FullName;
|
||
IsEditing = false;
|
||
}
|
||
|
||
private void LoadContacts(Guid? selectedId = null)
|
||
{
|
||
Contacts.Clear();
|
||
if (Student is null) return;
|
||
foreach (var c in Student.Contacts
|
||
.OrderBy(c => c.InvalidSince.HasValue)
|
||
.ThenBy(c => c.Name))
|
||
Contacts.Add(new ContactItem(c));
|
||
OnPropertyChanged(nameof(HasNoContacts));
|
||
SelectedContact = selectedId.HasValue
|
||
? Contacts.FirstOrDefault(c => c.Id == selectedId.Value)
|
||
: null;
|
||
}
|
||
|
||
[RelayCommand]
|
||
private async Task AddContact()
|
||
{
|
||
if (Student is null || OnEditContact is null) return;
|
||
var contact = await OnEditContact(null);
|
||
if (contact is null) return;
|
||
Student.Contacts.Add(contact);
|
||
_students.Save(Student);
|
||
LoadContacts(contact.Id);
|
||
}
|
||
|
||
[RelayCommand(CanExecute = nameof(HasSelectedContact))]
|
||
private async Task EditContact()
|
||
{
|
||
if (Student is null || SelectedContact is null || OnEditContact is null) return;
|
||
var edited = await OnEditContact(SelectedContact.Model);
|
||
if (edited is null) return;
|
||
var index = Student.Contacts.FindIndex(c => c.Id == edited.Id);
|
||
if (index >= 0) Student.Contacts[index] = edited;
|
||
_students.Save(Student);
|
||
LoadContacts(edited.Id);
|
||
}
|
||
|
||
[RelayCommand(CanExecute = nameof(CanViewSelectedAddress))]
|
||
private void ViewSelectedAddress()
|
||
{
|
||
if (SelectedContact is not null) OnViewAddress?.Invoke(SelectedContact);
|
||
}
|
||
|
||
partial void OnSelectedContactChanged(ContactItem? value)
|
||
{
|
||
EditContactCommand.NotifyCanExecuteChanged();
|
||
ViewSelectedAddressCommand.NotifyCanExecuteChanged();
|
||
}
|
||
|
||
private bool HasSelectedContact() => SelectedContact is not null;
|
||
private bool CanViewSelectedAddress() => SelectedContact?.HasAddress == true;
|
||
}
|
||
|
||
public class GroupMembershipEntry { public string SchoolYear { get; set; } = ""; public string GroupName { get; set; } = ""; public string Subject { get; set; } = ""; }
|
||
public class DocEntry { public string Date { get; set; } = ""; public string Title { get; set; } = ""; public string TypeLabel { get; set; } = ""; public bool IsConfidential { get; set; } }
|
||
|
||
public class ContactItem
|
||
{
|
||
public Contact Model { get; }
|
||
public Guid Id => Model.Id;
|
||
public string Name { get; }
|
||
public string Relation { get; }
|
||
public string? Phone { get; }
|
||
public string? Email { get; }
|
||
public string Address { get; }
|
||
public bool HasPhone => !string.IsNullOrEmpty(Phone);
|
||
public bool HasEmail => !string.IsNullOrEmpty(Email);
|
||
public bool HasAddress => !string.IsNullOrEmpty(Address);
|
||
public bool IsInvalid => Model.InvalidSince.HasValue;
|
||
public bool IsValid => !IsInvalid;
|
||
public string PhoneDisplay => Phone ?? "";
|
||
public string EmailDisplay => Email ?? "";
|
||
public string StatusText => IsInvalid
|
||
? $"Ungültig seit {Model.InvalidSince:dd.MM.yyyy} · {InvalidReasonText(Model.InvalidReason)}"
|
||
: "Aktuell";
|
||
|
||
public IRelayCommand CallCommand { get; }
|
||
public IRelayCommand MailCommand { get; }
|
||
|
||
public ContactItem(Contact c)
|
||
{
|
||
Model = c;
|
||
Name = c.Name;
|
||
Relation = c.Relation;
|
||
Phone = c.Phone;
|
||
Email = c.Email;
|
||
Address = FormatAddress(c);
|
||
CallCommand = new RelayCommand(() => OpenUri($"tel:{Phone}"), () => HasPhone);
|
||
MailCommand = new RelayCommand(() => OpenUri($"mailto:{Email}"), () => HasEmail);
|
||
}
|
||
|
||
public static string InvalidReasonText(ContactInvalidReason? reason) => reason switch
|
||
{
|
||
ContactInvalidReason.Moved => "Umzug",
|
||
ContactInvalidReason.NewPhoneNumber => "Telefonnummer neu",
|
||
ContactInvalidReason.LostCustody => "Sorgerecht verloren",
|
||
ContactInvalidReason.NewEmailAddress => "E-Mail-Adresse neu",
|
||
ContactInvalidReason.NoLongerResponsible => "Nicht mehr zuständig",
|
||
ContactInvalidReason.Other => "Sonstiges",
|
||
_ => "Kein Grund angegeben",
|
||
};
|
||
|
||
private static string FormatAddress(Contact c)
|
||
{
|
||
var cityLine = string.Join(" ", new[] { c.PostalCode, c.City }
|
||
.Where(value => !string.IsNullOrWhiteSpace(value)));
|
||
return string.Join(Environment.NewLine, new[] { c.Street, cityLine }
|
||
.Where(value => !string.IsNullOrWhiteSpace(value)));
|
||
}
|
||
|
||
private static void OpenUri(string uri) =>
|
||
System.Diagnostics.Process.Start(new System.Diagnostics.ProcessStartInfo(uri) { UseShellExecute = true });
|
||
}
|
||
|
||
// ── Dialog: Schüler anlegen ───────────────────────────────────────────────────
|
||
|
||
public partial class AddStudentDialogViewModel : ObservableObject
|
||
{
|
||
private readonly IStudentRepository _students;
|
||
|
||
[ObservableProperty] private string _firstName = "";
|
||
[ObservableProperty] private string _lastName = "";
|
||
[ObservableProperty] private string _dateOfBirthText = "";
|
||
[ObservableProperty] private string _selectedGender = "";
|
||
[ObservableProperty] private string _notes = "";
|
||
[ObservableProperty] private string _validationMessage = "";
|
||
|
||
public List<string> GenderOptions { get; } = ["", "M – männlich", "W – weiblich", "D – divers"];
|
||
public List<string> RelationPresets { get; } = ["Schüler/in", "Mutter", "Vater", "Elternteil", "Erziehungsberechtigte/r", "Sonstige"];
|
||
|
||
public ObservableCollection<ContactEntryViewModel> Contacts { get; } = [];
|
||
public Student? Result { get; private set; }
|
||
|
||
public AddStudentDialogViewModel(IStudentRepository students) => _students = students;
|
||
|
||
[RelayCommand]
|
||
private void AddContact() =>
|
||
Contacts.Add(new ContactEntryViewModel(this) { Relation = "Elternteil" });
|
||
|
||
public void RemoveContact(ContactEntryViewModel c) => Contacts.Remove(c);
|
||
|
||
[RelayCommand]
|
||
private void Save()
|
||
{
|
||
if (string.IsNullOrWhiteSpace(LastName)) { ValidationMessage = "Nachname erforderlich."; return; }
|
||
if (string.IsNullOrWhiteSpace(FirstName)) { ValidationMessage = "Vorname erforderlich."; return; }
|
||
|
||
DateOnly? dob = null;
|
||
if (!string.IsNullOrWhiteSpace(DateOfBirthText))
|
||
{
|
||
if (!DateOnly.TryParseExact(DateOfBirthText, "dd.MM.yyyy", null,
|
||
System.Globalization.DateTimeStyles.None, out var d))
|
||
{
|
||
ValidationMessage = "Geburtsdatum im Format TT.MM.JJJJ."; return;
|
||
}
|
||
dob = d;
|
||
}
|
||
|
||
Result = new Student
|
||
{
|
||
FirstName = FirstName.Trim(),
|
||
LastName = LastName.Trim(),
|
||
DateOfBirth = dob,
|
||
Gender = SelectedGender switch
|
||
{
|
||
"M – männlich" => Gender.M,
|
||
"W – weiblich" => Gender.W,
|
||
"D – divers" => Gender.D,
|
||
_ => (Gender?)null,
|
||
},
|
||
Notes = string.IsNullOrWhiteSpace(Notes) ? null : Notes.Trim(),
|
||
Contacts = Contacts.Select(c => c.ToModel()).Where(c => !string.IsNullOrWhiteSpace(c.Name)).ToList(),
|
||
};
|
||
_students.Save(Result);
|
||
}
|
||
}
|
||
|
||
public partial class ContactEntryViewModel : ObservableObject
|
||
{
|
||
private readonly AddStudentDialogViewModel _parent;
|
||
|
||
[ObservableProperty] private string _name = "";
|
||
[ObservableProperty] private string _relation = "";
|
||
[ObservableProperty] private string _phone = "";
|
||
[ObservableProperty] private string _email = "";
|
||
[ObservableProperty] private string _street = "";
|
||
[ObservableProperty] private string _postalCode = "";
|
||
[ObservableProperty] private string _city = "";
|
||
|
||
public ContactEntryViewModel(AddStudentDialogViewModel parent) => _parent = parent;
|
||
|
||
[RelayCommand] private void Remove() => _parent.RemoveContact(this);
|
||
|
||
public Contact ToModel() => new()
|
||
{
|
||
Name = Name.Trim(),
|
||
Relation = Relation.Trim(),
|
||
Phone = string.IsNullOrWhiteSpace(Phone) ? null : Phone.Trim(),
|
||
Email = string.IsNullOrWhiteSpace(Email) ? null : Email.Trim(),
|
||
Street = string.IsNullOrWhiteSpace(Street) ? null : Street.Trim(),
|
||
PostalCode = string.IsNullOrWhiteSpace(PostalCode) ? null : PostalCode.Trim(),
|
||
City = string.IsNullOrWhiteSpace(City) ? null : City.Trim(),
|
||
};
|
||
}
|
||
|
||
public partial class ContactEditDialogViewModel : ObservableObject
|
||
{
|
||
private readonly Contact? _source;
|
||
|
||
[ObservableProperty] private string _name = "";
|
||
[ObservableProperty] private string _relation = "Elternteil";
|
||
[ObservableProperty] private string _phone = "";
|
||
[ObservableProperty] private string _email = "";
|
||
[ObservableProperty] private string _street = "";
|
||
[ObservableProperty] private string _postalCode = "";
|
||
[ObservableProperty] private string _city = "";
|
||
[ObservableProperty] private bool _isInvalid;
|
||
[ObservableProperty] private string _invalidSinceText = "";
|
||
[ObservableProperty] private string _selectedInvalidReason = "";
|
||
[ObservableProperty] private string _invalidReasonDetails = "";
|
||
[ObservableProperty] private string _validationMessage = "";
|
||
|
||
public string DialogTitle => _source is null ? "Kontakt anlegen" : "Kontakt bearbeiten";
|
||
public List<string> RelationPresets { get; } =
|
||
["Schüler/in", "Mutter", "Vater", "Elternteil", "Erziehungsberechtigte/r", "Sonstige"];
|
||
public List<string> InvalidReasonOptions { get; } =
|
||
["Umzug", "Telefonnummer neu", "Sorgerecht verloren", "E-Mail-Adresse neu",
|
||
"Nicht mehr zuständig", "Sonstiges"];
|
||
public Contact? Result { get; private set; }
|
||
|
||
public ContactEditDialogViewModel(Contact? source)
|
||
{
|
||
_source = source;
|
||
if (source is null) return;
|
||
Name = source.Name;
|
||
Relation = source.Relation;
|
||
Phone = source.Phone ?? "";
|
||
Email = source.Email ?? "";
|
||
Street = source.Street ?? "";
|
||
PostalCode = source.PostalCode ?? "";
|
||
City = source.City ?? "";
|
||
IsInvalid = source.InvalidSince.HasValue;
|
||
InvalidSinceText = source.InvalidSince?.ToString("dd.MM.yyyy") ?? "";
|
||
SelectedInvalidReason = ContactItem.InvalidReasonText(source.InvalidReason);
|
||
InvalidReasonDetails = source.InvalidReasonDetails ?? "";
|
||
}
|
||
|
||
partial void OnIsInvalidChanged(bool value)
|
||
{
|
||
if (value && string.IsNullOrWhiteSpace(InvalidSinceText))
|
||
InvalidSinceText = DateTime.Today.ToString("dd.MM.yyyy");
|
||
if (value && string.IsNullOrWhiteSpace(SelectedInvalidReason))
|
||
SelectedInvalidReason = InvalidReasonOptions[0];
|
||
}
|
||
|
||
[RelayCommand]
|
||
private void Save()
|
||
{
|
||
if (string.IsNullOrWhiteSpace(Name))
|
||
{
|
||
ValidationMessage = "Name erforderlich.";
|
||
return;
|
||
}
|
||
|
||
DateOnly? invalidSince = null;
|
||
if (IsInvalid)
|
||
{
|
||
if (!DateOnly.TryParseExact(InvalidSinceText, "dd.MM.yyyy", null,
|
||
System.Globalization.DateTimeStyles.None, out var parsedDate))
|
||
{
|
||
ValidationMessage = "Ungültig seit im Format TT.MM.JJJJ angeben.";
|
||
return;
|
||
}
|
||
invalidSince = parsedDate;
|
||
}
|
||
|
||
Result = new Contact
|
||
{
|
||
Id = _source?.Id ?? Guid.NewGuid(),
|
||
Name = Name.Trim(),
|
||
Relation = Relation.Trim(),
|
||
Phone = NullIfEmpty(Phone),
|
||
Email = NullIfEmpty(Email),
|
||
Street = NullIfEmpty(Street),
|
||
PostalCode = NullIfEmpty(PostalCode),
|
||
City = NullIfEmpty(City),
|
||
InvalidSince = invalidSince,
|
||
InvalidReason = IsInvalid ? ParseInvalidReason(SelectedInvalidReason) : null,
|
||
InvalidReasonDetails = IsInvalid ? NullIfEmpty(InvalidReasonDetails) : null,
|
||
};
|
||
}
|
||
|
||
private static string? NullIfEmpty(string value) =>
|
||
string.IsNullOrWhiteSpace(value) ? null : value.Trim();
|
||
|
||
private static ContactInvalidReason ParseInvalidReason(string value) => value switch
|
||
{
|
||
"Umzug" => ContactInvalidReason.Moved,
|
||
"Telefonnummer neu" => ContactInvalidReason.NewPhoneNumber,
|
||
"Sorgerecht verloren" => ContactInvalidReason.LostCustody,
|
||
"E-Mail-Adresse neu" => ContactInvalidReason.NewEmailAddress,
|
||
"Nicht mehr zuständig" => ContactInvalidReason.NoLongerResponsible,
|
||
_ => ContactInvalidReason.Other,
|
||
};
|
||
}
|