Sync: code local unifié
Synchronisation du code source local (fait foi). Signed-off-by: lions dev Team
This commit is contained in:
dahoud
@@ -0,0 +1,294 @@
|
||||
package dev.lions.unionflow.server.service;
|
||||
|
||||
import dev.lions.unionflow.server.api.dto.backup.request.CreateBackupRequest;
|
||||
import dev.lions.unionflow.server.api.dto.backup.request.RestoreBackupRequest;
|
||||
import dev.lions.unionflow.server.api.dto.backup.request.UpdateBackupConfigRequest;
|
||||
import dev.lions.unionflow.server.api.dto.backup.response.BackupConfigResponse;
|
||||
import dev.lions.unionflow.server.api.dto.backup.response.BackupResponse;
|
||||
import io.quarkus.security.identity.SecurityIdentity;
|
||||
import jakarta.enterprise.context.ApplicationScoped;
|
||||
import jakarta.inject.Inject;
|
||||
import lombok.extern.slf4j.Slf4j;
|
||||
|
||||
import java.time.LocalDateTime;
|
||||
import java.time.LocalTime;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.UUID;
|
||||
import java.util.concurrent.ThreadLocalRandom;
|
||||
|
||||
/**
|
||||
* Service de gestion des sauvegardes système
|
||||
*/
|
||||
@Slf4j
|
||||
@ApplicationScoped
|
||||
public class BackupService {
|
||||
|
||||
@Inject
|
||||
SecurityIdentity securityIdentity;
|
||||
|
||||
/**
|
||||
* Lister toutes les sauvegardes disponibles
|
||||
*/
|
||||
public List<BackupResponse> getAllBackups() {
|
||||
log.debug("Récupération de toutes les sauvegardes");
|
||||
|
||||
// Dans une vraie implémentation, on lirait depuis le système de fichiers ou DB
|
||||
// Pour l'instant, on retourne des données de test
|
||||
List<BackupResponse> backups = new ArrayList<>();
|
||||
|
||||
backups.add(BackupResponse.builder()
|
||||
.id(UUID.randomUUID())
|
||||
.name("Sauvegarde automatique")
|
||||
.description("Sauvegarde quotidienne programmée")
|
||||
.type("AUTO")
|
||||
.sizeBytes(2_300_000_000L) // 2.3 GB
|
||||
.sizeFormatted("2.3 GB")
|
||||
.status("COMPLETED")
|
||||
.createdAt(LocalDateTime.now().minusHours(2))
|
||||
.completedAt(LocalDateTime.now().minusHours(2).plusMinutes(45))
|
||||
.createdBy("system")
|
||||
.includesDatabase(true)
|
||||
.includesFiles(true)
|
||||
.includesConfiguration(true)
|
||||
.filePath("/backups/auto-2024-12-15-02-00.zip")
|
||||
.build()
|
||||
);
|
||||
|
||||
backups.add(BackupResponse.builder()
|
||||
.id(UUID.randomUUID())
|
||||
.name("Sauvegarde manuelle")
|
||||
.description("Sauvegarde avant mise à jour")
|
||||
.type("MANUAL")
|
||||
.sizeBytes(2_100_000_000L) // 2.1 GB
|
||||
.sizeFormatted("2.1 GB")
|
||||
.status("COMPLETED")
|
||||
.createdAt(LocalDateTime.now().minusDays(1).withHour(14).withMinute(30))
|
||||
.completedAt(LocalDateTime.now().minusDays(1).withHour(14).withMinute(55))
|
||||
.createdBy("admin@unionflow.test")
|
||||
.includesDatabase(true)
|
||||
.includesFiles(false)
|
||||
.includesConfiguration(true)
|
||||
.filePath("/backups/manual-2024-12-14-14-30.zip")
|
||||
.build()
|
||||
);
|
||||
|
||||
backups.add(BackupResponse.builder()
|
||||
.id(UUID.randomUUID())
|
||||
.name("Sauvegarde automatique")
|
||||
.description("Sauvegarde quotidienne programmée")
|
||||
.type("AUTO")
|
||||
.sizeBytes(2_200_000_000L) // 2.2 GB
|
||||
.sizeFormatted("2.2 GB")
|
||||
.status("COMPLETED")
|
||||
.createdAt(LocalDateTime.now().minusDays(1).withHour(2).withMinute(0))
|
||||
.completedAt(LocalDateTime.now().minusDays(1).withHour(2).withMinute(43))
|
||||
.createdBy("system")
|
||||
.includesDatabase(true)
|
||||
.includesFiles(true)
|
||||
.includesConfiguration(true)
|
||||
.filePath("/backups/auto-2024-12-14-02-00.zip")
|
||||
.build()
|
||||
);
|
||||
|
||||
return backups;
|
||||
}
|
||||
|
||||
/**
|
||||
* Récupérer une sauvegarde par ID
|
||||
*/
|
||||
public BackupResponse getBackupById(UUID id) {
|
||||
log.debug("Récupération de la sauvegarde: {}", id);
|
||||
|
||||
// Dans une vraie implémentation, on chercherait dans la DB
|
||||
return getAllBackups().stream()
|
||||
.filter(b -> b.getId().equals(id))
|
||||
.findFirst()
|
||||
.orElseThrow(() -> new RuntimeException("Sauvegarde non trouvée: " + id));
|
||||
}
|
||||
|
||||
/**
|
||||
* Créer une nouvelle sauvegarde
|
||||
*/
|
||||
public BackupResponse createBackup(CreateBackupRequest request) {
|
||||
log.info("Création d'une nouvelle sauvegarde: {}", request.getName());
|
||||
|
||||
String createdBy = securityIdentity.getPrincipal() != null
|
||||
? securityIdentity.getPrincipal().getName()
|
||||
: "system";
|
||||
|
||||
// Dans une vraie implémentation, on lancerait le processus de backup
|
||||
// Pour l'instant, on simule la création
|
||||
BackupResponse backup = BackupResponse.builder()
|
||||
.id(UUID.randomUUID())
|
||||
.name(request.getName())
|
||||
.description(request.getDescription())
|
||||
.type(request.getType() != null ? request.getType() : "MANUAL")
|
||||
.sizeBytes(2_000_000_000L + ThreadLocalRandom.current().nextLong(500_000_000L))
|
||||
.sizeFormatted("2.0 GB")
|
||||
.status("IN_PROGRESS")
|
||||
.createdAt(LocalDateTime.now())
|
||||
.createdBy(createdBy)
|
||||
.includesDatabase(request.getIncludeDatabase() != null ? request.getIncludeDatabase() : true)
|
||||
.includesFiles(request.getIncludeFiles() != null ? request.getIncludeFiles() : true)
|
||||
.includesConfiguration(request.getIncludeConfiguration() != null ? request.getIncludeConfiguration() : true)
|
||||
.filePath("/backups/manual-" + LocalDateTime.now().toString().replace(":", "-") + ".zip")
|
||||
.build();
|
||||
|
||||
// TODO: Lancer le processus de backup en asynchrone
|
||||
log.info("Sauvegarde créée avec succès: {}", backup.getId());
|
||||
|
||||
return backup;
|
||||
}
|
||||
|
||||
/**
|
||||
* Restaurer une sauvegarde
|
||||
*/
|
||||
public void restoreBackup(RestoreBackupRequest request) {
|
||||
log.info("Restauration de la sauvegarde: {}", request.getBackupId());
|
||||
|
||||
// Vérifier que la sauvegarde existe
|
||||
BackupResponse backup = getBackupById(request.getBackupId());
|
||||
|
||||
if (!"COMPLETED".equals(backup.getStatus())) {
|
||||
throw new RuntimeException("La sauvegarde doit être complétée pour être restaurée");
|
||||
}
|
||||
|
||||
// Créer un point de restauration si demandé
|
||||
if (Boolean.TRUE.equals(request.getCreateRestorePoint())) {
|
||||
log.info("Création d'un point de restauration avant la restauration");
|
||||
CreateBackupRequest restorePoint = CreateBackupRequest.builder()
|
||||
.name("Point de restauration")
|
||||
.description("Avant restauration de: " + backup.getName())
|
||||
.type("RESTORE_POINT")
|
||||
.includeDatabase(true)
|
||||
.includeFiles(true)
|
||||
.includeConfiguration(true)
|
||||
.build();
|
||||
createBackup(restorePoint);
|
||||
}
|
||||
|
||||
// Dans une vraie implémentation, on restaurerait les données
|
||||
// Pour l'instant, on log juste l'action
|
||||
log.info("Restauration en cours...");
|
||||
log.info("- Database: {}", request.getRestoreDatabase());
|
||||
log.info("- Files: {}", request.getRestoreFiles());
|
||||
log.info("- Configuration: {}", request.getRestoreConfiguration());
|
||||
|
||||
// TODO: Implémenter la logique de restauration réelle
|
||||
log.info("Restauration complétée avec succès");
|
||||
}
|
||||
|
||||
/**
|
||||
* Supprimer une sauvegarde
|
||||
*/
|
||||
public void deleteBackup(UUID id) {
|
||||
log.info("Suppression de la sauvegarde: {}", id);
|
||||
|
||||
// Vérifier que la sauvegarde existe
|
||||
BackupResponse backup = getBackupById(id);
|
||||
|
||||
// Dans une vraie implémentation, on supprimerait le fichier
|
||||
log.info("Fichier supprimé: {}", backup.getFilePath());
|
||||
|
||||
// TODO: Supprimer le fichier physique et l'entrée en DB
|
||||
log.info("Sauvegarde supprimée avec succès");
|
||||
}
|
||||
|
||||
/**
|
||||
* Récupérer la configuration des sauvegardes automatiques
|
||||
*/
|
||||
public BackupConfigResponse getBackupConfig() {
|
||||
log.debug("Récupération de la configuration des sauvegardes");
|
||||
|
||||
// Dans une vraie implémentation, on lirait depuis la DB
|
||||
return BackupConfigResponse.builder()
|
||||
.autoBackupEnabled(true)
|
||||
.frequency("DAILY")
|
||||
.retention("30 jours")
|
||||
.retentionDays(30)
|
||||
.backupTime("02:00")
|
||||
.includeDatabase(true)
|
||||
.includeFiles(true)
|
||||
.includeConfiguration(true)
|
||||
.lastBackup(LocalDateTime.now().minusHours(2))
|
||||
.nextScheduledBackup(LocalDateTime.now().plusDays(1).withHour(2).withMinute(0))
|
||||
.totalBackups(15)
|
||||
.totalSizeBytes(35_000_000_000L) // 35 GB
|
||||
.totalSizeFormatted("35 GB")
|
||||
.build();
|
||||
}
|
||||
|
||||
/**
|
||||
* Mettre à jour la configuration des sauvegardes automatiques
|
||||
*/
|
||||
public BackupConfigResponse updateBackupConfig(UpdateBackupConfigRequest request) {
|
||||
log.info("Mise à jour de la configuration des sauvegardes");
|
||||
|
||||
// Dans une vraie implémentation, on persisterait en DB
|
||||
// Pour l'instant, on retourne juste la config avec les nouvelles valeurs
|
||||
|
||||
// TODO: Persister la configuration en DB
|
||||
|
||||
return BackupConfigResponse.builder()
|
||||
.autoBackupEnabled(request.getAutoBackupEnabled() != null ? request.getAutoBackupEnabled() : true)
|
||||
.frequency(request.getFrequency() != null ? request.getFrequency() : "DAILY")
|
||||
.retention(request.getRetention() != null ? request.getRetention() : "30 jours")
|
||||
.retentionDays(request.getRetentionDays() != null ? request.getRetentionDays() : 30)
|
||||
.backupTime(request.getBackupTime() != null ? request.getBackupTime() : "02:00")
|
||||
.includeDatabase(request.getIncludeDatabase() != null ? request.getIncludeDatabase() : true)
|
||||
.includeFiles(request.getIncludeFiles() != null ? request.getIncludeFiles() : true)
|
||||
.includeConfiguration(request.getIncludeConfiguration() != null ? request.getIncludeConfiguration() : true)
|
||||
.lastBackup(LocalDateTime.now().minusHours(2))
|
||||
.nextScheduledBackup(calculateNextBackup(request.getFrequency(), request.getBackupTime()))
|
||||
.totalBackups(15)
|
||||
.totalSizeBytes(35_000_000_000L)
|
||||
.totalSizeFormatted("35 GB")
|
||||
.build();
|
||||
}
|
||||
|
||||
/**
|
||||
* Créer un point de restauration
|
||||
*/
|
||||
public BackupResponse createRestorePoint() {
|
||||
log.info("Création d'un point de restauration");
|
||||
|
||||
CreateBackupRequest request = CreateBackupRequest.builder()
|
||||
.name("Point de restauration")
|
||||
.description("Point de restauration créé le " + LocalDateTime.now())
|
||||
.type("RESTORE_POINT")
|
||||
.includeDatabase(true)
|
||||
.includeFiles(true)
|
||||
.includeConfiguration(true)
|
||||
.build();
|
||||
|
||||
return createBackup(request);
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculer la prochaine date de sauvegarde programmée
|
||||
*/
|
||||
private LocalDateTime calculateNextBackup(String frequency, String backupTime) {
|
||||
LocalTime time = backupTime != null ? LocalTime.parse(backupTime) : LocalTime.of(2, 0);
|
||||
LocalDateTime next = LocalDateTime.now().with(time);
|
||||
|
||||
if (frequency == null) frequency = "DAILY";
|
||||
|
||||
switch (frequency) {
|
||||
case "HOURLY":
|
||||
return next.plusHours(1);
|
||||
case "DAILY":
|
||||
if (next.isBefore(LocalDateTime.now())) {
|
||||
next = next.plusDays(1);
|
||||
}
|
||||
return next;
|
||||
case "WEEKLY":
|
||||
if (next.isBefore(LocalDateTime.now())) {
|
||||
next = next.plusWeeks(1);
|
||||
}
|
||||
return next;
|
||||
default:
|
||||
return next;
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user