Compare commits

...
2 Commits
Author SHA1 Message Date
adminandClaude Sonnet 5 ecf64fff88 fix: Sync-Ausfälle aktiv melden, Einstellungen-Absturz durch Connection-Konflikt beheben
CI / build-and-test (push) Canceled after 0s
Ein Sync-Ausfall (offline/Fehler) war bisher nur als blasser Text in der Statuszeile
sichtbar und konnte so stundenlang unbemerkt bleiben, bis auf einem anderen Gerät
Daten fehlten. SyncStatusViewModel meldet neue Ausfälle jetzt einmalig aktiv per Toast
(nicht bei jedem automatischen Retry erneut).

DatabaseEncryptionService.IsEncrypted/VerifyPassword öffneten die Datenbankdatei mit
einer zweiten, exklusiven (Direct) LiteDB-Verbindung, während LiteDbContext dieselbe
Datei bereits im Shared-Modus offen hält - jeder Aufruf (z.B. beim Öffnen der
Einstellungen) crashte reproduzierbar mit IOException. Beide öffnen jetzt ebenfalls im
Shared-Modus und erzwingen einen tatsächlichen Lesezugriff, da Shared-Verbindungen die
Datei lazy öffnen.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-20 00:07:33 +02:00
admin 22eceb3ac1 fix: Kompetenzkataloge im Sync nachreichen 2026-09-20 00:03:45 +02:00
11 changed files with 300 additions and 6 deletions

No files matched your search

@@ -26,6 +26,38 @@ public sealed class DatabaseEncryptionServiceTests
Assert.False(service.IsEncrypted(temp.Path)); Assert.False(service.IsEncrypted(temp.Path));
} }
/// Regression: SettingsViewModel ruft IsEncrypted/VerifyPassword mit dem Pfad der bereits
/// laufenden Datenbank auf, während LiteDbContext deren Shared-Verbindung noch offen hält
/// (z.B. bei jedem Öffnen der Einstellungen). Eine zweite Verbindung im Standard-Modus
/// (Direct) würde das mit "The process cannot access the file" quittieren.
[Fact]
public void IsEncrypted_WaehrendAndereSharedVerbindungOffenIst_WirftNicht()
{
using var temp = new TempDatabase();
using (var db = new LiteDatabase(temp.Path))
db.GetCollection<BsonDocument>("t").Insert(new BsonDocument { ["x"] = 1 });
using var open = new LiteDatabase(new ConnectionString(temp.Path) { Connection = ConnectionType.Shared });
var service = new DatabaseEncryptionService();
Assert.False(service.IsEncrypted(temp.Path));
}
[Fact]
public void VerifyPassword_WaehrendAndereSharedVerbindungOffenIst_WirftNicht()
{
using var temp = new TempDatabase();
using (var db = new LiteDatabase(temp.Path))
db.GetCollection<BsonDocument>("t").Insert(new BsonDocument { ["x"] = 1 });
var service = new DatabaseEncryptionService();
service.SetPassword(temp.Path, currentPassword: null, newPassword: "geheim123");
using var open = new LiteDatabase(new ConnectionString(temp.Path)
{ Password = "geheim123", Connection = ConnectionType.Shared });
Assert.True(service.VerifyPassword(temp.Path, "geheim123"));
Assert.False(service.VerifyPassword(temp.Path, "falsch"));
}
[Fact] [Fact]
public void SetPassword_VerschluesseltDieDatenbankUndBehaeltDieDaten() public void SetPassword_VerschluesseltDieDatenbankUndBehaeltDieDaten()
{ {
+13 -2
View File
@@ -10,12 +10,21 @@ namespace LehrerApp.Data;
/// </summary> /// </summary>
public class DatabaseEncryptionService public class DatabaseEncryptionService
{ {
// Beide Methoden werden auch gegen den Pfad der laufenden, bereits geöffneten Datenbank
// aufgerufen (z.B. bei jedem Öffnen der Einstellungen bzw. vor einer Passwort-Änderung) -
// LiteDbContext hält dafür längst eine ConnectionType.Shared-Verbindung offen. Ohne Shared
// hier ebenfalls zu setzen, würde die zweite Verbindung im Standard-Modus (Direct) einen
// exklusiven Dateizugriff verlangen und mit "The process cannot access the file" scheitern.
public bool IsEncrypted(string dbPath) public bool IsEncrypted(string dbPath)
{ {
if (!File.Exists(dbPath)) return false; if (!File.Exists(dbPath)) return false;
try try
{ {
using var db = new LiteDatabase(dbPath); // Shared-Verbindungen öffnen die Datei lazy - anders als Direct wirft der Konstruktor
// bei falschem/fehlendem Passwort noch nicht, erst ein tatsächlicher Zugriff liest den
// (ggf. verschlüsselten) Header.
using var db = new LiteDatabase(new ConnectionString(dbPath) { Connection = ConnectionType.Shared });
_ = db.GetCollectionNames().ToList();
return false; return false;
} }
catch (LiteException) catch (LiteException)
@@ -28,7 +37,9 @@ public class DatabaseEncryptionService
{ {
try try
{ {
using var db = new LiteDatabase(new ConnectionString(dbPath) { Password = password }); using var db = new LiteDatabase(new ConnectionString(dbPath)
{ Password = password, Connection = ConnectionType.Shared });
_ = db.GetCollectionNames().ToList();
return true; return true;
} }
catch (LiteException) catch (LiteException)
@@ -1,6 +1,7 @@
using System.Net; using System.Net;
using System.Net.Http.Json; using System.Net.Http.Json;
using LehrerApp.Data; using LehrerApp.Data;
using LehrerApp.Desktop.Services;
using LehrerApp.Desktop.ViewModels; using LehrerApp.Desktop.ViewModels;
using LehrerApp.Sync; using LehrerApp.Sync;
using LehrerApp.Sync.Crypto; using LehrerApp.Sync.Crypto;
@@ -80,6 +81,39 @@ public sealed class SyncStatusViewModelTests
Assert.Contains("Bitte aktualisiere die LehrerApp", SyncStatusViewModel.IncompatibleVersionMessage); Assert.Contains("Bitte aktualisiere die LehrerApp", SyncStatusViewModel.IncompatibleVersionMessage);
} }
/// Regression: ein Sync-Ausfall (z.B. Server nicht erreichbar) war früher nur an einem
/// blassen "Offline"-Text in der Statuszeile erkennbar - ein Gerät konnte so stundenlang
/// unbemerkt nicht synchronisieren. NotificationService bekommt jetzt aktiv eine Meldung,
/// sobald der Status neu auf Offline/Error wechselt.
[Fact]
public async Task SyncOffline_MeldetSichAktivUeberNotificationService()
{
using var temp = new TempSyncEngine(new OfflineStubHandler());
var notifications = new NotificationService();
var vm = new SyncStatusViewModel(temp.Engine, notifications);
await temp.Engine.SyncNowAsync();
Assert.Equal("Offline", vm.StatusText);
Assert.Single(notifications.Toasts);
Assert.Equal(SyncStatusViewModel.OfflineMessage, notifications.Toasts[0].Message);
}
/// Ein erneuter automatischer Retry im selben Offline-Zustand darf keinen weiteren Toast
/// auslösen - sonst würde der Nutzer alle paar Minuten dieselbe Meldung sehen.
[Fact]
public async Task SyncOffline_WiederholterRetry_MeldetNurEinmal()
{
using var temp = new TempSyncEngine(new OfflineStubHandler());
var notifications = new NotificationService();
var vm = new SyncStatusViewModel(temp.Engine, notifications);
await temp.Engine.SyncNowAsync();
await temp.Engine.SyncNowAsync();
Assert.Single(notifications.Toasts);
}
private sealed class PullEventStubHandler : HttpMessageHandler private sealed class PullEventStubHandler : HttpMessageHandler
{ {
protected override Task<HttpResponseMessage> SendAsync( protected override Task<HttpResponseMessage> SendAsync(
@@ -113,6 +147,13 @@ public sealed class SyncStatusViewModelTests
}); });
} }
private sealed class OfflineStubHandler : HttpMessageHandler
{
protected override Task<HttpResponseMessage> SendAsync(
HttpRequestMessage request, CancellationToken cancellationToken) =>
Task.FromResult(new HttpResponseMessage(HttpStatusCode.Unauthorized));
}
private sealed class IncompatibleVersionStubHandler : HttpMessageHandler private sealed class IncompatibleVersionStubHandler : HttpMessageHandler
{ {
protected override Task<HttpResponseMessage> SendAsync( protected override Task<HttpResponseMessage> SendAsync(
+6 -2
View File
@@ -375,8 +375,12 @@ public static class AppBootstrapper
// Sync-agnostischer Hook auf LiteDbContext (siehe LiteDbContext.OnChange) wird erst hier, // Sync-agnostischer Hook auf LiteDbContext (siehe LiteDbContext.OnChange) wird erst hier,
// außerhalb der Repository-Registrierung, mit der tatsächlichen Sync-Logik verbunden. // außerhalb der Repository-Registrierung, mit der tatsächlichen Sync-Logik verbunden.
if (!string.IsNullOrEmpty(serverUrl)) if (!string.IsNullOrEmpty(serverUrl))
provider.GetRequiredService<LiteDbContext>().OnChange = {
provider.GetRequiredService<SyncEventPublisher>().Publish; var context = provider.GetRequiredService<LiteDbContext>();
var publisher = provider.GetRequiredService<SyncEventPublisher>();
context.OnChange = publisher.Publish;
publisher.BackfillCompetencyCatalog(context);
}
return provider; return provider;
} }
@@ -100,6 +100,8 @@ public partial class MainWindowViewModel : ObservableObject
case ClassTeacherOverviewViewModel vm: vm.RefreshFromLocalDataOnly(); break; case ClassTeacherOverviewViewModel vm: vm.RefreshFromLocalDataOnly(); break;
case ExamsOverviewViewModel vm: vm.LoadCommand.Execute(null); break; case ExamsOverviewViewModel vm: vm.LoadCommand.Execute(null); break;
case GroupDetailViewModel { Group: { } group } vm: vm.LoadGroup(group.Id); break; case GroupDetailViewModel { Group: { } group } vm: vm.LoadGroup(group.Id); break;
case SettingsViewModel vm when vm.ActiveTabIndex == (int)SettingsTab.Competencies:
vm.RefreshCompetencyCatalogCommand.Execute(null); break;
// Inline-Bearbeitung (IsEditing) nicht überschreiben - anders als die Gruppenansicht // Inline-Bearbeitung (IsEditing) nicht überschreiben - anders als die Gruppenansicht
// laufen Namens-/Geschlechtsänderungen hier nicht über einen Dialog. // laufen Namens-/Geschlechtsänderungen hier nicht über einen Dialog.
case StudentDetailViewModel { Student: { } student, IsEditing: false } vm: case StudentDetailViewModel { Student: { } student, IsEditing: false } vm:
@@ -11,11 +11,16 @@ public partial class SyncStatusViewModel : ObservableObject
private readonly SyncEngine? _engine; private readonly SyncEngine? _engine;
private readonly NotificationService? _notifications; private readonly NotificationService? _notifications;
private bool _incompatibleNotificationShown; private bool _incompatibleNotificationShown;
private SyncState _lastNotifiedState = SyncState.Idle;
public const string IncompatibleVersionMessage = public const string IncompatibleVersionMessage =
"Diese App-Version ist veraltet oder nicht mit dem Sync-Server kompatibel. " + "Diese App-Version ist veraltet oder nicht mit dem Sync-Server kompatibel. " +
"Bitte aktualisiere die LehrerApp. Die Synchronisierung wurde zum Schutz deiner Daten angehalten."; "Bitte aktualisiere die LehrerApp. Die Synchronisierung wurde zum Schutz deiner Daten angehalten.";
public const string OfflineMessage =
"Synchronisierung nicht möglich - Änderungen werden lokal gespeichert und automatisch " +
"nachgeholt, sobald die Verbindung zum Server wieder da ist.";
[ObservableProperty] private string _statusText = "Kein Server konfiguriert"; [ObservableProperty] private string _statusText = "Kein Server konfiguriert";
[ObservableProperty] private string _lastSyncText = ""; [ObservableProperty] private string _lastSyncText = "";
[ObservableProperty] private bool _isSyncing; [ObservableProperty] private bool _isSyncing;
@@ -71,6 +76,27 @@ public partial class SyncStatusViewModel : ObservableObject
_incompatibleNotificationShown = true; _incompatibleNotificationShown = true;
_notifications?.ShowError(IncompatibleVersionMessage); _notifications?.ShowError(IncompatibleVersionMessage);
} }
// Offline/Error sonst nur als blasser Text in der Statuszeile sichtbar war - über Stunden
// unbemerkt, bis ein Blick auf ein zweites Gerät fehlende Daten offenbarte. Einmalig pro
// neuem Ausfall (nicht bei jedem automatischen Retry alle paar Minuten) aktiv als Toast
// melden; _lastNotifiedState wird bei Rückkehr zu Idle zurückgesetzt, damit ein späterer,
// neuer Ausfall wieder gemeldet wird.
if (s.State is SyncState.Offline or SyncState.Error && _lastNotifiedState != s.State)
{
_lastNotifiedState = s.State;
_notifications?.ShowError(s.State == SyncState.Offline
? OfflineMessage
: $"Synchronisierung fehlgeschlagen: {s.ErrorMessage}");
}
else if (s.State is SyncState.Idle)
{
// Nicht auch bei SyncState.Syncing zurücksetzen: Jeder Sync-Versuch (auch ein
// automatischer Retry im selben Ausfall) durchläuft kurz Syncing, bevor er wieder in
// Offline/Error landet - ein Reset hier würde bei jedem Retry erneut einen Toast
// auslösen, statt nur einmal pro tatsächlich neuem Ausfall.
_lastNotifiedState = SyncState.Idle;
}
} }
[RelayCommand(CanExecute = nameof(CanSync))] [RelayCommand(CanExecute = nameof(CanSync))]
+48
View File
@@ -52,6 +52,54 @@ public sealed class EventApplierTests
Assert.Equal(UntisHubJobKind.OffenePeriods, saved!.Kind); Assert.Equal(UntisHubJobKind.OffenePeriods, saved!.Kind);
} }
[Fact]
public async Task ApplyAsync_CompetencyDomainSave_UebernimmtVerschachtelteKompetenzen()
{
using var db = NewInMemoryContext();
var applier = new EventApplier(db, Key);
var domain = new CompetencyDomain
{
SubjectId = Guid.NewGuid(), GradeLevel = 10, VersionId = Guid.NewGuid(),
Name = "Erkenntnisgewinnung",
Items = [new CompetencyItem { Code = "EG1", Description = "Modelle verwenden" }],
};
await applier.ApplyAsync(MakeEvent(nameof(CompetencyDomain), domain.Id.ToString(), "Save", domain));
var saved = db.CompetencyDomains.FindById(domain.Id);
Assert.NotNull(saved);
Assert.Equal("EG1", Assert.Single(saved!.Items).Code);
}
[Fact]
public async Task ApplyAsync_CompetencyDomainSave_BereinigtDoppelteMigrierteStandardversionen()
{
using var db = NewInMemoryContext();
var applier = new EventApplier(db, Key);
var subjectId = Guid.NewGuid();
var emptyVersion = new CompetencyCatalogVersion
{
SubjectId = subjectId, Name = "Bestehender Kompetenzkatalog", IsDefault = true,
};
var catalogVersion = new CompetencyCatalogVersion
{
SubjectId = subjectId, Name = "Bestehender Kompetenzkatalog", IsDefault = true,
};
db.CompetencyCatalogVersions.Insert(emptyVersion);
db.CompetencyCatalogVersions.Insert(catalogVersion);
var domain = new CompetencyDomain
{
SubjectId = subjectId, GradeLevel = 10, VersionId = catalogVersion.Id,
Name = "Erkenntnisgewinnung",
};
await applier.ApplyAsync(MakeEvent(nameof(CompetencyDomain), domain.Id.ToString(), "Save", domain));
var versions = db.CompetencyCatalogVersions.Find(v => v.SubjectId == subjectId).ToList();
Assert.True(versions.Single(v => v.Id == catalogVersion.Id).IsDefault);
Assert.False(versions.Single(v => v.Id == emptyVersion.Id).IsDefault);
}
[Fact] [Fact]
public async Task ApplyAsync_UnbekannterEntityType_TutNichtsUndWirftNicht() public async Task ApplyAsync_UnbekannterEntityType_TutNichtsUndWirftNicht()
{ {
@@ -1,4 +1,5 @@
using LehrerApp.Core.Models; using LehrerApp.Core.Models;
using LehrerApp.Data;
using LehrerApp.Sync.Crypto; using LehrerApp.Sync.Crypto;
using Xunit; using Xunit;
@@ -49,6 +50,38 @@ public sealed class SyncEventPublisherTests
Assert.Empty(temp.Queue.GetPendingAttachmentUploads()); Assert.Empty(temp.Queue.GetPendingAttachmentUploads());
} }
[Fact]
public void BackfillCompetencyCatalog_ReihtVersionUndBereichMitItemsGenauEinmalEin()
{
using var temp = new TempEventQueue();
using var db = new LiteDbContext(new MemoryStream());
var subjectId = Guid.NewGuid();
var version = new CompetencyCatalogVersion
{
SubjectId = subjectId, Name = "Bildungsplan 2026", IsDefault = true,
};
var item = new CompetencyItem { Code = "EG1", Description = "Modelle verwenden" };
var domain = new CompetencyDomain
{
SubjectId = subjectId, GradeLevel = 10, VersionId = version.Id,
Name = "Erkenntnisgewinnung", Items = [item],
};
db.CompetencyCatalogVersions.Insert(version);
db.CompetencyDomains.Insert(domain);
var publisher = new SyncEventPublisher(temp.Queue, "desktop-1", Key);
Assert.Equal(2, publisher.BackfillCompetencyCatalog(db));
Assert.Equal(0, publisher.BackfillCompetencyCatalog(db));
var events = temp.Queue.GetPending();
Assert.Equal(2, events.Count);
Assert.Contains(events, e => e.EntityType == nameof(CompetencyCatalogVersion));
var domainEvent = Assert.Single(events, e => e.EntityType == nameof(CompetencyDomain));
var restored = SyncCrypto.DecryptObject<CompetencyDomain>(domainEvent.Payload, Key);
Assert.Equal(domain.Id, restored!.Id);
Assert.Equal("EG1", Assert.Single(restored.Items).Code);
}
private sealed class TempEventQueue : IDisposable private sealed class TempEventQueue : IDisposable
{ {
private readonly string _directory = Path.Combine( private readonly string _directory = Path.Combine(
+64 -2
View File
@@ -145,11 +145,38 @@ public class EventApplier(LiteDbContext db, byte[] syncKey, HttpClient? http = n
Simple<SchoolHoliday>(context => context.SchoolHolidays); Simple<SchoolHoliday>(context => context.SchoolHolidays);
Simple<SupervisionDuty>(context => context.SupervisionDuties); Simple<SupervisionDuty>(context => context.SupervisionDuties);
Simple<SubstitutionEntry>(context => context.SubstitutionEntries); Simple<SubstitutionEntry>(context => context.SubstitutionEntries);
Simple<CompetencyDomain>(context => context.CompetencyDomains);
Simple<CompetencyCatalogVersion>(context => context.CompetencyCatalogVersions);
Simple<Vorgang>(context => context.Vorgaenge); Simple<Vorgang>(context => context.Vorgaenge);
Simple<UntisHubJobState>(context => context.UntisHubJobStates); Simple<UntisHubJobState>(context => context.UntisHubJobStates);
handlers[nameof(CompetencyCatalogVersion)] = (context, operation, entityId, json) =>
{
if (operation == "Delete")
{
context.CompetencyCatalogVersions.Delete(new Guid(entityId));
return;
}
var version = JsonSerializer.Deserialize<CompetencyCatalogVersion>(json)!;
context.CompetencyCatalogVersions.Upsert(version);
NormalizeCompetencyDefaults(context, version.SubjectId, version.Id);
};
handlers[nameof(CompetencyDomain)] = (context, operation, entityId, json) =>
{
Guid? subjectId;
if (operation == "Delete")
{
subjectId = context.CompetencyDomains.FindById(new Guid(entityId))?.SubjectId;
context.CompetencyDomains.Delete(new Guid(entityId));
}
else
{
var domain = JsonSerializer.Deserialize<CompetencyDomain>(json)!;
subjectId = domain.SubjectId;
context.CompetencyDomains.Upsert(domain);
}
if (subjectId is Guid id) NormalizeCompetencyDefaults(context, id);
};
// Kaskaden-Fälle: dieselben internen LiteDbContext-Hilfsmethoden wie die jeweiligen // Kaskaden-Fälle: dieselben internen LiteDbContext-Hilfsmethoden wie die jeweiligen
// Repositories, damit die Kaskade nur an einer Stelle im Code existiert. // Repositories, damit die Kaskade nur an einer Stelle im Code existiert.
handlers[nameof(LearningGroup)] = (context, operation, entityId, json) => handlers[nameof(LearningGroup)] = (context, operation, entityId, json) =>
@@ -177,4 +204,39 @@ public class EventApplier(LiteDbContext db, byte[] syncKey, HttpClient? http = n
return handlers; return handlers;
} }
/// <summary>
/// Alte, auf mehreren Geräten unabhängig erzeugte Standardversionen heißen identisch
/// „Bestehender Kompetenzkatalog“, besitzen aber unterschiedliche IDs. Bei diesem speziellen
/// Migrationsfall gewinnt deterministisch die Version mit den meisten Bereichen. Bei bewusst
/// verschieden benannten Versionen gilt dagegen die zuletzt empfangene Standard-Auswahl.
/// Direkte Collection-Schreibzugriffe verhindern dabei Sync-Ping-Pong.
/// </summary>
private static void NormalizeCompetencyDefaults(LiteDbContext context, Guid subjectId,
Guid? incomingDefaultId = null)
{
var defaults = context.CompetencyCatalogVersions
.Find(v => v.SubjectId == subjectId && v.IsDefault).ToList();
if (defaults.Count <= 1) return;
CompetencyCatalogVersion winner;
if (defaults.Select(v => v.Name.Trim()).Distinct(StringComparer.OrdinalIgnoreCase).Count() == 1)
{
winner = defaults
.OrderByDescending(v => context.CompetencyDomains.Count(d => d.VersionId == v.Id))
.ThenBy(v => v.Id)
.First();
}
else
{
winner = defaults.FirstOrDefault(v => v.Id == incomingDefaultId)
?? defaults.OrderBy(v => v.Id).First();
}
foreach (var version in defaults.Where(v => v.Id != winner.Id))
{
version.IsDefault = false;
context.CompetencyCatalogVersions.Upsert(version);
}
}
} }
+6
View File
@@ -102,7 +102,13 @@ public class EventQueue : IDisposable
/// sie an, solange er sie unter der aktuellen userId selbst noch nicht kennt.</summary> /// sie an, solange er sie unter der aktuellen userId selbst noch nicht kennt.</summary>
public void ResetKnownServerSeqs() => _entityVersions.DeleteAll(); public void ResetKnownServerSeqs() => _entityVersions.DeleteAll();
internal bool IsMaintenanceCompleted(string id) => _meta.FindById(MaintenanceKey(id)) is not null;
internal void MarkMaintenanceCompleted(string id) =>
_meta.Upsert(new SyncMeta { Id = MaintenanceKey(id), Value = 1, Timestamp = DateTime.UtcNow });
private static string EntityVersionKey(string entityType, string entityId) => $"{entityType}:{entityId}"; private static string EntityVersionKey(string entityType, string entityId) => $"{entityType}:{entityId}";
private static string MaintenanceKey(string id) => $"maintenance:{id}";
// ── Anhang-Warteliste (getrennt von der JSON-Ereignis-Outbox, siehe AttachmentSyncer) ──── // ── Anhang-Warteliste (getrennt von der JSON-Ereignis-Outbox, siehe AttachmentSyncer) ────
public void QueueAttachmentUpload(string storageId) public void QueueAttachmentUpload(string storageId)
+29
View File
@@ -13,6 +13,8 @@ namespace LehrerApp.Sync;
/// </summary> /// </summary>
public class SyncEventPublisher(EventQueue queue, string deviceId, byte[] syncKey, AppLogger? logger = null) public class SyncEventPublisher(EventQueue queue, string deviceId, byte[] syncKey, AppLogger? logger = null)
{ {
private const string CompetencyCatalogBackfillId = "competency-catalog-v1";
public void Publish(string entityType, string entityId, string operation, object? payload) public void Publish(string entityType, string entityId, string operation, object? payload)
{ {
var encrypted = payload is null ? "" : SyncCrypto.EncryptObject(payload, syncKey); var encrypted = payload is null ? "" : SyncCrypto.EncryptObject(payload, syncKey);
@@ -29,4 +31,31 @@ public class SyncEventPublisher(EventQueue queue, string deviceId, byte[] syncKe
foreach (var attachment in withAttachments.Attachments) foreach (var attachment in withAttachments.Attachments)
queue.QueueAttachmentUpload(attachment.StorageId); queue.QueueAttachmentUpload(attachment.StorageId);
} }
/// <summary>
/// Veröffentlicht bestehende Kompetenzkataloge einmalig als vollständige Snapshots. Das
/// repariert Daten, die vor aktivierter Synchronisation oder während einer Migration direkt
/// in LiteDB geschrieben wurden und deshalb nie den Repository-OnChange-Hook durchlaufen
/// haben. Der Marker liegt gerätespezifisch in dessen lokaler EventQueue.
/// </summary>
public int BackfillCompetencyCatalog(LiteDbContext db)
{
if (queue.IsMaintenanceCompleted(CompetencyCatalogBackfillId)) return 0;
var count = 0;
foreach (var version in db.CompetencyCatalogVersions.FindAll())
{
Publish(nameof(CompetencyCatalogVersion), version.Id.ToString(), "Save", version);
count++;
}
foreach (var domain in db.CompetencyDomains.FindAll())
{
Publish(nameof(CompetencyDomain), domain.Id.ToString(), "Save", domain);
count++;
}
queue.MarkMaintenanceCompleted(CompetencyCatalogBackfillId);
logger?.Info($"Sync: einmaliger Kompetenzkatalog-Backfill abgeschlossen ({count} Ereignis(se)).");
return count;
}
} }