Étapes de Conception

Stratégie Git

Patterns de Conception Utilisés

Prérequis

Compilation

Pour générer un exécutable autonome (self-contained), utilisez la commande correspondant à votre plateforme :

dotnet publish EasySave.Avalonia/EasySave.Avalonia.csproj -c Release -r win-x64 --self-contained true -o ./publish/windows

dotnet publish EasySave.Avalonia/EasySave.Avalonia.csproj -c Release -r osx-arm64 --self-contained true -o ./publish/macos

dotnet publish EasySave.Avalonia/EasySave.Avalonia.csproj -c Release -r osx-x64 --self-contained true -o ./publish/macos_intel

dotnet publish EasySave.Avalonia/EasySave.Avalonia.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux

Lancement rapide (développement)

dotnet run --project EasySave.Avalonia

Fenêtre Principale

Au lancement sans arguments, EasySave ouvre une interface graphique (Avalonia UI) composée d'une fenêtre principale affichant la liste des travaux de sauvegarde.

Créer un Travail

Exécuter des Travaux

Vous pouvez lancer un travail unique, une sélection, ou tous les travaux. En v3.0, les travaux s'exécutent en parallèle. La progression s'affiche en temps réel par travail avec des contrôles Pause / Reprise / Stop individuels. En ligne de commande, la syntaxe reste identique aux v1.0 et v1.1 (EasySave.Avalonia.exe 1-3, 1;3;5).

Paramètres (Paramètres généraux)

Notes Importantes

Syntaxe

EasySave.Avalonia.exe <sélecteur_travaux>

Formats de sélection

Exemples d'utilisation

./EasySave.Avalonia.exe 2

./EasySave.Avalonia.exe 1-3

./EasySave.Avalonia.exe 1;3;5

EasySave v3.0 est une application de sauvegarde avec interface graphique (GUI). Elle permet de créer un nombre illimité de travaux de sauvegarde, de les exécuter en parallèle avec contrôles Pause/Reprise/Stop par travail, de chiffrer des fichiers sensibles et de centraliser les logs via Docker.

Comparaison des versions

Interface principale

Au démarrage, le tableau de bord affiche tous les travaux de sauvegarde. Créer (Ajouter), Exécuter (sélectionner puis Lancer), Supprimer, Paramètres (langue, chiffrement, logs).

Paramètres

• Général : Langue (FR/EN), Format des logs (JSON ou XML).
• Logiciel métier : Nom du processus (ex. Calculatrice). S'il est en cours, EasySave bloque les nouvelles sauvegardes et arrête les en cours.
• Chiffrement (CryptoSoft) : Extensions à chiffrer (ex. .pdf, .docx). Seuls les fichiers avec ces extensions sont chiffrés. Le module CryptoSoft est intégré directement dans l'application.

Créer un travail

Cliquer sur Ajouter un travail, renseigner le nom, la source, la destination, le type (Complète ou Différentielle), puis Enregistrer. Aucune limite de nombre de travaux.

Exécuter des sauvegardes

Sélectionner un ou plusieurs travaux, cliquer sur Lancer. La fenêtre de progression affiche l'état. Si un logiciel métier est détecté, la sauvegarde s'arrête automatiquement.

Logs

Stockés dans Data/Logs/ : format YYYY-MM-DD.json ou YYYY-MM-DD.xml. Contenu : horodatage, source, destination, taille, temps de transfert, temps de chiffrement.

Cas d'Utilisation

Diagramme de Classes

Diagramme d'Activité

Diagrammes de Séquence

Créer un travail

Modifier un travail

Supprimer un travail

Exécuter un travail

Lister les travaux

Changer les paramètres

Chiffrer un fichier (CryptoSoft)

Play / Stop / Pause un travail

Détecter le logiciel métier

Gérer la persistance

Qu'est-ce que le Pattern MVVM ?

Pourquoi ce choix architectural ?

Flux de Données dans EasySave (v3.0)

Lors d'une action utilisateur dans l'interface graphique :

Diagramme MVVM Simplifié

EasySave v3.0 : couche Services avec exécution parallèle, contrôles temps réel, ViewModels pour la GUI.

Structure des fichiers (v3.0)

Rôle des Modèles dans l'Architecture

BackupJob

Représente un travail de sauvegarde configuré par l'utilisateur. Cette classe est persistée dans jobs.json et chargée au démarrage de l'application.

JobState

Représente l'état temps réel d'une sauvegarde en cours d'exécution. Cette classe est mise à jour à chaque fichier copié et persistée dans state.json pour permettre un suivi externe (ex: application de monitoring).

BackupType (Enum)

Définit le type de sauvegarde à effectuer. Le choix du type impacte directement le comportement de BackupExecutor lors de la copie des fichiers.

Emplacement des fichiers

Tous les fichiers de configuration sont stockés dans un dossier Data/ situé à côté de l'exécutable :

EasySave.Avalonia.exe
Data/
├── jobs.json        # Liste des travaux de sauvegarde
├── settings.json    # Paramètres (langue, format log, extensions chiffrement, logiciel métier)
├── state.json       # État temps réel des sauvegardes
└── Logs/
    ├── 2026-02-03.json   # Logs journaliers (JSON ou XML selon paramètre)
    └── 2026-02-03.xml

Fichier jobs.json

Contient la liste des travaux de sauvegarde configurés. Ce fichier est créé automatiquement au premier lancement.

[
  {
    "id": 1,
    "name": "Sauvegarde Documents",
    "sourceDirectory": "C:\\Users\\Documents",
    "targetDirectory": "D:\\Backup\\Documents",
    "type": 0
  },
  {
    "id": 2,
    "name": "Sauvegarde Photos",
    "sourceDirectory": "C:\\Users\\Pictures",
    "targetDirectory": "D:\\Backup\\Pictures",
    "type": 1
  }
]

Fichier settings.json

Contient les paramètres globaux : langue, format des logs, extensions à chiffrer (CryptoSoft), logiciel métier, extensions prioritaires, taille max fichier volumineux, mode de log et URL du serveur de log (v3.0).

{
  "language": "fr-FR",
  "logFormat": "JSON",
  "businessSoftwareProcessName": "Calculator",
  "encryptedExtensions": [ ".docx", ".pdf", ".xlsx" ],
  "priorityExtensions": [ ".docx", ".pdf" ],
  "maxLargeFileTransferSizeKB": 10240,
  "logMode": "Local",
  "logServerUrl": "http://localhost:5000"
}

Structure du Projet

EasySave/
├── EasySave/                # Bibliothèque métier (Models, Services, ViewModels)
│   └── EasySave.csproj      # Référence EasyLog + CryptoSoft
│
├── EasySave.Avalonia/       # Interface graphique (Views Avalonia)
│   └── EasySave.Avalonia.csproj  # Point d'entrée (WinExe), référence EasySave
│
├── EasyLog/                 # Projet DLL de logging
│   ├── EasyLog.csproj       # Compile en DLL
│   └── Logger.cs            # Classe principale
│
├── CryptoSoft/              # Module de chiffrement (DLL)
│   └── CryptoSoft.csproj
│
├── EasySave.Tests/          # Tests unitaires et d'intégration (xUnit)
│   └── EasySave.Tests.csproj
│
└── EasySave.sln             # Solution regroupant les 5 projets

API de la Classe Logger

Structure d'une Entrée de Log

Formats de log (JSON / XML)

Depuis la v1.1, l'utilisateur peut choisir le format des fichiers log journaliers : YYYY-MM-DD.json ou YYYY-MM-DD.xml. Le paramètre est stocké dans settings.json (logFormat).

Conversion UNC

Tous les chemins sont automatiquement convertis au format UNC (Universal Naming Convention) pour compatibilité avec les serveurs et lecteurs réseaux :

Chemin local    : C:\Users\Documents\file.txt
Chemin UNC      : \\?\C:\Users\Documents\file.txt

Chemin réseau   : \\server\share\file.txt
Chemin UNC      : \\server\share\file.txt (inchangé)

Fichier Log Journalier

Les logs sont enregistrés dans des fichiers journaliers au format YYYY-MM-DD.json :

[
  {
    "Name": "Sauvegarde Documents",
    "Timestamp": "2026-02-05T14:30:45",
    "SourcePath": "\\\\?\\C:\\Users\\Documents\\rapport.docx",
    "DestinationPath": "\\\\?\\D:\\Backup\\Documents\\rapport.docx",
    "FileSize": 245760,
    "TransferTimeMs": 45
  },
  {
    "Name": "Sauvegarde Documents",
    "Timestamp": "2026-02-05T14:30:46",
    "SourcePath": "\\\\?\\C:\\Users\\Documents\\image.png",
    "DestinationPath": "\\\\?\\D:\\Backup\\Documents\\image.png",
    "FileSize": 1048576,
    "TransferTimeMs": 120
  },
  {
    "Name": "[CREATED] Sauvegarde Photos",
    "Timestamp": "2026-02-05T15:00:00",
    "SourcePath": "",
    "DestinationPath": "",
    "FileSize": 0,
    "TransferTimeMs": 0
  }
]

Fichiers de log journaliers

Chaque transfert est enregistré dans un fichier par jour (YYYY-MM-DD.json ou YYYY-MM-DD.xml selon les paramètres), dans Data/Logs/. En v3.0, chaque entrée peut inclure le temps de cryptage (EncryptionTimeMs) : 0 = pas de cryptage, >0 = temps en ms, <0 = code erreur.

{
  "timestamp": "2026-02-03T15:30:45",
  "jobName": "Sauvegarde Documents",
  "sourceFile": "C:\\Users\\Documents\\rapport.docx",
  "targetFile": "D:\\Backup\\Documents\\rapport.docx",
  "fileSize": 245760,
  "transferTimeMs": 45
}

Fichier d'État (state.json)

L'état temps réel des sauvegardes est maintenu dans un fichier JSON actualisé en continu.

{
  "jobName": "Sauvegarde Documents",
  "timestamp": "2026-02-03T15:30:50",
  "state": "Active",
  "totalFiles": 150,
  "totalSize": 52428800,
  "filesRemaining": 75,
  "sizeRemaining": 26214400,
  "currentSourceFile": "C:\\Users\\Documents\\images\\photo.jpg",
  "currentTargetFile": "D:\\Backup\\Documents\\images\\photo.jpg",
  "progression": 50.0
}

États possibles

Bibliothèque EasyLog

Le module EasyLog est une DLL séparée qui gère l'écriture des logs. Elle offre les fonctionnalités suivantes :

Fonctionnement

• L'utilisateur configure dans Paramètres la liste des extensions à chiffrer (ex: .docx, .pdf, .xlsx).
• Lors d'une sauvegarde, pour chaque fichier dont l'extension est dans cette liste, EasySave appelle CryptoSoft pour chiffrer le fichier (XOR ou algorithme implémenté) avant la copie.
• Le temps de cryptage (en ms) est enregistré dans le fichier log journalier (EncryptionTimeMs). Valeur 0 = pas de cryptage, >0 = temps, <0 = code erreur.

Paramètres

La liste des extensions est stockée dans settings.json sous la clé encryptedExtensions (tableau de chaînes). Elle est modifiable via la fenêtre Paramètres de l'interface.

Architecture

Déploiement avec Docker Compose

Depuis la racine du dépôt :

docker compose up -d

Le service écoute sur http://localhost:5050. Les logs centralisés sont stockés dans le volume Docker logcentralization_data (répertoire /app/Data/Logs dans le conteneur).

Build manuel de l'image

docker build -f LogCentralization/Dockerfile -t easysave-logcentralization .
docker run -d -p 5050:5050 -v logcentralization_data:/app/Data --name easysave-logcentralization easysave-logcentralization

Exécution locale (sans Docker)

cd LogCentralization
dotnet run

Configuration du client EasySave

Dans les paramètres généraux (ou dans settings.json) :

Endpoint API

{
  "machineId": "PC-BUREAU-01",
  "userName": "jean.dupont",
  "name": "Sauvegarde Documents",
  "timestamp": "2026-02-24T14:30:45",
  "sourcePath": "C:\\Users\\Documents\\rapport.docx",
  "destinationPath": "D:\\Backup\\Documents\\rapport.docx",
  "fileSize": 245760,
  "transferTimeMs": 45,
  "encryptionTimeMs": 12
}

docker-compose.yml

services:
  logcentralization:
    build:
      context: .
      dockerfile: LogCentralization/Dockerfile
    container_name: easysave-logcentralization
    ports:
      - "5050:5050"
    volumes:
      - logcentralization_data:/app/Data
    environment:
      - LogStorage__Directory=/app/Data/Logs
    restart: unless-stopped

volumes:
  logcentralization_data:

Langues supportées

EasySave supporte actuellement deux langues :

Changement de langue

En v3.0, la langue se change via Paramètres (fenêtre Paramètres). Le choix est sauvegardé dans settings.json et persiste entre les sessions.

Fichiers de traduction

Les traductions sont stockées dans des fichiers JSON situés dans le dossier Resources/ :

{
  "MenuOption1": "1. Lister les travaux",
  "MenuOption2": "2. Créer un travail",
  "MenuOption3": "3. Modifier un travail",
  "JobCreated": "Travail créé avec succès !",
  "JobDeleted": "Travail supprimé avec succès !",
  "MaxJobsReached": "Erreur : Limite de 5 travaux atteinte."
}

Architecture du LanguageManager

Le gestionnaire de langues utilise le pattern Singleton pour garantir une instance unique dans toute l'application.

Configuration minimale

Installation

Exécutable autonome : Aucune installation requise. Le module CryptoSoft est intégré directement dans l'application (DLL incluse).

Compilation depuis les sources :

dotnet publish EasySave.Avalonia/EasySave.Avalonia.csproj -c Release -r <RID> --self-contained true -o ./publish

RID (Runtime Identifier) : Windows win-x64, macOS ARM osx-arm64, Linux linux-x64.

Emplacements des fichiers

Tous les fichiers de configuration et de log sont dans le dossier Data/, à côté de l'exécutable :

EasySave/
├── EasySave.Avalonia.exe   (application principale)
├── CryptoSoft.dll          (module de chiffrement, intégré)
└── Data/
    ├── jobs.json           # Définition des travaux
    ├── settings.json       # Paramètres (langue, format log, extensions, logiciel métier)
    ├── state.json          # État d'exécution en temps réel
    └── Logs/
        └── YYYY-MM-DD.json  # Logs journaliers des transferts

Formats des fichiers de configuration

settings.json (v3.0) — Champs : language, logFormat, businessSoftwareProcessName, encryptedExtensions, priorityExtensions, maxLargeFileTransferSizeKB, logMode, logServerUrl.

state.json — Champs : JobId, JobName, SourceFilePath, TargetFilePath, State, TotalFiles, FilesToCopy, TotalSize, BytesToCopy, Progression.

Log journalier (YYYY-MM-DD.json) — Chaque entrée : Name, SourceFilePath, TargetFilePath, FileSize, TransferTime, EncryptionTime, Time. EncryptionTime en ms (0 si non chiffré). TransferTime < 0 = erreur.

Dépannage

Contact

Pour le support, contacter l'équipe technique ProSoft.

Cette section décrit l'architecture du projet de tests, les technologies utilisées, comment lancer les tests et le détail de chaque suite de tests.

1. Architecture du projet de tests

Le projet de tests se trouve dans le dossier EasySave.Tests/ et suit la structure suivante :

EasySave.Tests/
├── EasySave.Tests.csproj          # Fichier projet (dépendances, références)
├── Mocks/
│   ├── TestData.cs                # Données de test réutilisables (jobs, settings, fichiers temporaires)
│   └── MockDialogService.cs       # Mock du service de dialogues pour les ViewModels
├── Services/
│   ├── BackupServiceTests.cs      # Tests de la façade BackupService (CRUD, exécution, settings)
│   ├── BackupExecutorV3Tests.cs   # v3.0 : parallélisme, priorités, fichiers volumineux, logiciel métier
│   ├── JobControllerTests.cs      # v3.0 : pause/resume/stop, WaitIfPaused
│   ├── CryptoSoftEngineTests.cs   # Tests du moteur de chiffrement XOR
│   └── CryptoSoftServiceTests.cs  # Tests du wrapper de chiffrement avec timing
├── ViewModels/
│   ├── JobEditViewModelTests.cs   # Tests du ViewModel d'édition de job
│   ├── JobProgressViewModelTests.cs # v3.0 : progression par travail, commandes
│   ├── MainViewModelTests.cs      # Tests du ViewModel principal
│   ├── RelayCommandTests.cs       # Tests de l'implémentation ICommand
│   └── SettingsViewModelTests.cs  # Tests du ViewModel de paramètres
└── RegressionTests.cs             # Tests de régression (compatibilité v1.0/v1.1 → v2.0/v3.0)

L'organisation miroir la structure du projet principal (Services/, ViewModels/) pour faciliter la navigation.

2. Technologies et dépendances

Framework cible : .NET 10.0

Références de projet : EasySave.csproj (projet principal), CryptoSoft.csproj (module de chiffrement).

3. Types de tests utilisés

3.1 Tests unitaires (Unit Tests)

La majorité des tests sont des tests unitaires. Ils testent des unités de code isolées, sans dépendances externes réelles.

Fichiers concernés : RelayCommandTests.cs, JobEditViewModelTests.cs, SettingsViewModelTests.cs, CryptoSoftEngineTests.cs, CryptoSoftServiceTests.cs.

• Utilisation de mocks (MockDialogService) pour isoler les ViewModels de l'UI
• Données de test centralisées (TestData)
• Chaque test vérifie un seul comportement (Arrange-Act-Assert)

3.2 Tests d'intégration (Integration Tests)

Ils vérifient l'interaction entre plusieurs composants réels.

Fichiers concernés : BackupServiceTests.cs, MainViewModelTests.cs.

• Création de vrais fichiers et dossiers temporaires ; nettoyage via IDisposable
• Collection xUnit [Collection("BackupService")] pour éviter les conflits de parallélisme

3.3 Tests de régression (Regression Tests)

Ils garantissent que les fonctionnalités v1.0/v1.1 continuent de fonctionner dans la v2.0/v3.0.

Fichier : RegressionTests.cs. Catégories : sauvegarde complète et différentielle, StateManager, journalisation JSON/XML, CRUD jobs, parsing arguments CLI.

4. Comment lancer les tests

5. Verbosité des tests

Option --verbosity (ou -v) : quiet, minimal, normal (défaut), detailed, diagnostic.

Génération d'un rapport TRX (CI) :

dotnet test --logger "trx;LogFileName=results.trx"

6. CI/CD

Les tests sont exécutés automatiquement via GitHub Actions à chaque push ou pull request sur les branches v1.0, v1.1, v2.0, v3.0, develop et main.

Points clés : build et tests multi-plateforme (Windows, Ubuntu, macOS) ; sur les branches version (v*), publish self-contained et création/mise à jour d’une Release GitHub avec les archives par OS.

7. Infrastructure de test — Mocks

TestData : données réutilisables (jobs valides/invalides, paramètres, structures de fichiers temporaires, nettoyage).

MockDialogService : implémentation mock de IDialogService pour tester les ViewModels sans UI (résultats prédéfinis pour dialogues et confirmations, compteurs d'appels, Reset()).

8. Détail de chaque suite de tests

RegressionTests — Tests de régression

But : Vérifier que les fonctionnalités v1.0/v1.1 fonctionnent toujours en v2.0/v3.0.

Catégories : Backup (complète, différentielle), StateManager, Logger (JSON, XML, EncryptionTimeMs), Job CRUD, parsing CLI (plage, liste, entrée unique, entrée invalide, HasJobArguments).

BackupServiceTests — Façade BackupService

But : Tester l'API publique (CRUD jobs, exécution, paramètres).

Catégories : création (valide, chemins invalides, doublon, pas de limite en v2.0), récupération (liste vide, index valide/invalide), JobNameExists, suppression, modification, exécution (valide, copie réelle, ExecuteAllJobs, source vide), paramètres (GetSettings, UpdateSettings, ChangeLanguage), événement Progress.

CryptoSoftEngineTests — Moteur de chiffrement XOR

But : Tester le chiffrement/déchiffrement symétrique.

Tests : contenu changé après chiffrement, double chiffrement restaure l'original, FileNotFoundException si source absente, fichier vide, création du répertoire de destination, fichier volumineux (1 Mo), contenu binaire (taille préservée).

CryptoSoftServiceTests — Wrapper avec timing

But : Tester RunWithTiming() (chiffrement + mesure du temps).

Tests : succès (true, temps ≥ 0), source introuvable (false, temps -1), fichier chiffré valide.

JobEditViewModelTests — ViewModel d'édition

But : Validation, constructeurs, conversion ToBackupJob().

Catégories : constructeur (nouveau job champs vides, job existant pré-rempli), IsValid (champs remplis, nom vide/espaces, source/dest vides, caractères spéciaux, nom long), ToBackupJob (valeurs, préservation ID, ID 0 pour nouveau), PropertyChanged (Name, IsValid, SourceDirectory), AvailableTypes (Complete et Differential).

MainViewModelTests — ViewModel principal

But : Commandes, état, interactions avec MockDialogService.

Catégories : état initial (JobsList, SelectedJob, IsExecuting, ProgressValue), CanExecute des commandes, sélection (HasSelection, PropertyChanged), CreateJob (annulation, ajout), DeleteJob (confirmation/refus), IsExecuting/StatusMessage/ProgressValue (PropertyChanged), OpenSettings (annulation, sauvegarde).

RelayCommandTests — ICommand

But : Tester l'implémentation du pattern ICommand (Execute, CanExecute, RaiseCanExecuteChanged, constructeurs, ArgumentNullException si execute null).

SettingsViewModelTests — ViewModel paramètres

But : Propriétés, extensions chiffrées, conversion ToAppSettings().

Catégories : constructeur (paramètres par défaut, v2.0 complets, anglais+XML), gestion des extensions (Add avec/sans point, pas de doublons, Remove, nombreuses extensions), ToAppSettings (valeurs correctes, copie indépendante), AvailableLanguages (fr-FR, en-US), AvailableLogFormats (JSON, XML), PropertyChanged (Language, LogFormat).

BackupExecutorV3Tests — Exécuteur v3.0 (23 tests)

But : Tester l'exécution parallèle, les fichiers prioritaires, les fichiers volumineux, le logiciel métier, et les contrôles Pause/Resume/Stop.

Catégories : exécution parallèle (3 travaux, 5 travaux concurrents, sélection spécifique, travail unique async), Pause/Resume/Stop (pause, stop avec fichiers partiels, resume après pause), contrôles globaux (PauseAll, StopAll), fichiers prioritaires (traités en premier, barrière inter-travaux, fonctionnement normal sans priorité), fichiers volumineux (sémaphore actif, petits fichiers libres), logiciel métier (processus absent, nom vide, parsing .exe), événements de progression (émis par travail, informations correctes), cas limites (liste vide, sources vides, nettoyage des contrôleurs).

JobControllerTests — Contrôleur de travail v3.0 (17 tests)

But : Tester le cycle de vie du contrôleur : état initial, transitions Pause/Resume/Stop, WaitIfPaused, CancellationToken.

Catégories : état initial (Pending, IsStopped false), Start (→ Running), Pause (depuis Running, Pending, Finished), Resume (depuis Paused, Running), Stop (→ Stopped, IsStopped true, annule le token, depuis Paused), Finish (→ Finished), WaitIfPaused (pas de blocage si Running, bloque jusqu'au Resume, débloque et annule si Stopped), cycles complets (Pending→Finished, avec pause/resume, 5 cycles consécutifs).

JobProgressViewModelTests — Progression par travail v3.0 (20 tests)

But : Tester le ViewModel de progression temps réel par travail : constructeur, mise à jour depuis JobState, commandes Pause/Resume/Stop, PropertyChanged.

Catégories : constructeur (nom, status Pending, progression 0, IsRunning), UpdateFromState (progression, compteur fichiers, Finished, Stopped), commandes (Pause, Resume, Stop existent, Resume désactivé si pas en pause, Stop activé/désactivé selon état), PropertyChanged (Progression, Status, IsPaused + IsRunning, FilesProgress).

9. Résumé des tests (176 au total)

Pipeline

Étapes du workflow

Artifacts / Release

Télécharger les exécutables

.github/workflows/ci.yml

Exigences Fonctionnelles (v3.0)

Exigences Techniques - Stockage

Exigences Techniques - Logging & État

v1.0 — Détail complémentaire

Gestion des sauvegardes : Jusqu'à 5 travaux ; sauvegarde complète (tous les fichiers) et différentielle (fichiers modifiés) ; récursive (sous-répertoires) ; disques locaux, externes et réseau.

Modes d'exécution : Mode interactif (menu) ; ligne de commande EasySave 1-3 ou EasySave 1;3 ; exécution séquentielle.

Multilingue : Français (par défaut), Anglais.

Journalisation : Fichiers log journaliers (YYYY-MM-DD.json), état temps réel (state.json), chemins au format UNC.

Limitations connues (v1.0)

• Maximum 5 travaux de sauvegarde
• Exécution séquentielle uniquement (parallèle prévu en v3.0)
• Format de log JSON uniquement (XML ajouté en v1.1)

Évolutions livrées en v2.0 (par rapport à la v1.1)

• Interface graphique (Avalonia)
• Travaux de sauvegarde illimités
• Chiffrement des fichiers (CryptoSoft)
• Détection du logiciel métier

Ces évolutions sont livrées dans la version 2.0.