Sync AppData

Datenaustausch Lokale Daten - Server Daten Im Schritt1 werden nur HashWerte/Stamp verglichen. Da im neuen System wirlich nur Änderungen weggespeichert werden wird das Speicherdatum = changed verwendet. Dieser Zeitstamp ist immer UTC. ;-)

Schritte in Sync Tools.

public class SyncTrans {
    /// <summary>
    /// Data Hash for Sync
    /// </summary>
    public string Hash { get; set; } = "";
    /// <summary>
    /// ID Filename => DataID
    /// </summary>
    public string ID { get; set; } = "";
    /// <summary>
    /// Base64 emdj File ReadAll
    /// </summary>
    public string Blob { get; set; } = "";
    /// <summary>
    /// Helper If copy This Data to Lokal (1) 
    /// (0) no copy
    /// </summary>
    public int Copy { get; set; } = 0;
    /// <summary>
    /// TimeStamp last Wrote
    /// </summary>
    public DateTime? Stamp { get; set; }
}

public async Task<string?> SyncWorkflow(bool force) {
    WebApiWorker wc = new WebApiWorker(WebApi);
    _LokalProcess.Invoke("start", new SyncEventArgs("Start"));
    // 1) get all Lokal Data 2 HashList
    IEnumerable<SyncTrans> LokalHashData = IOAccess.GetLokalDataPool();
    _LokalProcess.Invoke("lokal Data", new SyncEventArgs(LokalHashData.Count()));
    // 2) Push Hash List 2 Server
    // 3) Get Difference List from Server
    IEnumerable<SyncTrans>? ServerHashDataList = await wc.PushLokalHashData(LokalHashData,Lizenz);
    _LokalProcess.Invoke("Server Data", new SyncEventArgs(ServerHashDataList.Count()));
    // 4) Get Server Newer Data 
    IEnumerable<SyncTrans>? SyncResultSet = IOAccess.PushServerDataToLokal(ServerHashDataList, Lizenz);
    _LokalProcess.Invoke("Lokale Daten", new SyncEventArgs(ServerHashDataList.Count()));
    // 5) Server 2 Lokal && Lokal Newer as Pool 2 Server
    var ServerUpdateList = IOAccess.GetLokalDataPoolSet(SyncResultSet);
    _LokalProcess.Invoke("Server Data", new SyncEventArgs("Done"));
    // 6) Done....
    await Task.Delay(10);
    return null;
}

Hole alle Lokalen Daten und erstelle eine SyncTrans List. ID und Hash.

public IEnumerable<SyncTrans> GetLokalDataPool() {
    if (new DirectoryInfo(IODataPath) is DirectoryInfo di && di.Exists) {
        var Res = new List<SyncTrans>();
        if (di.GetFiles("*.emdj", new EnumerationOptions { RecurseSubdirectories = true }) is IEnumerable<FileInfo> files) {
            foreach (var file in files) {
                SyncTrans trans = new SyncTrans();
                trans.ID = Path.GetFileNameWithoutExtension(file.Name);
                trans.Hash = file.FullName?.GetMD5Hash() ?? string.Empty;
                trans.Copy = 0;
                trans.Stamp = file.LastWriteTimeUtc;
                Res.Add(trans);
            }
            return Res;
        }
    }
    return Array.Empty<SyncTrans>();
}

Sendet diese Liste zum Server.

Der Server prüft die "lokalen" SyncTrans mit den Server Daten.

• Lokal neuer copy =-1.
• Server neuer copy =1 => Blob ServerData.
• Identisch copy=0
• Nur auf dem Server existierende Daten werden hinzu, mit Blob & copy =1

Gib Liste zurück.

• Neuere Lokale Daten => copy= -1,
• Neuere Server Daten und exklusiv auf Server => copy =1
• keine Änderung copy =0

Client empfängt Daten

Client verarbeitet gefüllte SyncTransListe

• Copy =1 mit Blob auf Client.
• Copy =-1 Sind die neueren Lokalen.
• Copy =0 Skip (same)
• Client nimmt alle copy 1 mit Blob und speichert sie Lokal.
• Client nimmt nur noch -1, fügt Blob hinzu und zum Server (insert New or Changed Lokals)

Client Sendet

sendet diese als letzten Schritt zum Server, dort werden diese auf den Server kopiert. nur copy =-1 und Blob => LizenzKey Pool Ablage

Info als Feedback => Client Result

Result

Damit sollte der Vorgang abgeschlossen sein.