Initial Python rewrite

src.bak/main/java/com/example/service/base/DataPurgeService.java

@@ -0,0 +1,214 @@
+
+package com.example.service.base;
+
+
+
+import com.example.repository.FirestoreBaseRepository;
+
+import com.google.cloud.firestore.CollectionReference;
+
+import com.google.cloud.firestore.Firestore;
+
+import com.google.cloud.firestore.QueryDocumentSnapshot;
+
+import java.util.List;
+
+import org.slf4j.Logger;
+
+import org.slf4j.LoggerFactory;
+
+import org.springframework.beans.factory.annotation.Autowired;
+
+import org.springframework.beans.factory.annotation.Qualifier;
+
+import org.springframework.data.redis.core.ReactiveRedisTemplate;
+
+import org.springframework.stereotype.Service;
+
+import reactor.core.publisher.Mono;
+
+import reactor.core.scheduler.Schedulers;
+
+
+
+@Service
+
+public class DataPurgeService {
+
+
+
+    private static final Logger logger = LoggerFactory.getLogger(DataPurgeService.class);
+
+
+
+    private final ReactiveRedisTemplate<String, ?> redisTemplate;
+
+    private final FirestoreBaseRepository firestoreBaseRepository;
+
+
+
+    private final Firestore firestore;
+
+
+
+    @Autowired
+
+    public DataPurgeService(
+
+            @Qualifier("reactiveRedisTemplate") ReactiveRedisTemplate<String, ?> redisTemplate,
+
+            FirestoreBaseRepository firestoreBaseRepository, Firestore firestore) {
+
+        this.redisTemplate = redisTemplate;
+
+        this.firestoreBaseRepository = firestoreBaseRepository;
+
+        this.firestore = firestore;
+
+    }
+
+
+
+    public Mono<Void> purgeAllData() {
+
+        return purgeRedis()
+
+                .then(purgeFirestore());
+
+    }
+
+
+
+    private Mono<Void> purgeRedis() {
+
+        logger.info("Starting Redis data purge.");
+
+        return redisTemplate.getConnectionFactory().getReactiveConnection().serverCommands().flushAll()
+
+                .doOnSuccess(v -> logger.info("Successfully purged all data from Redis."))
+
+                .doOnError(e -> logger.error("Error purging data from Redis.", e))
+
+                .then();
+
+    }
+
+
+
+    private Mono<Void> purgeFirestore() {
+
+        logger.info("Starting Firestore data purge.");
+
+        return Mono.fromRunnable(() -> {
+
+            try {
+
+                String appId = firestoreBaseRepository.getAppId();
+
+                String conversationsCollectionPath = String.format("artifacts/%s/conversations", appId);
+
+                String notificationsCollectionPath = String.format("artifacts/%s/notifications", appId);
+
+
+
+                // Delete 'mensajes' sub-collections in 'conversations'
+
+                logger.info("Deleting 'mensajes' sub-collections from '{}'", conversationsCollectionPath);
+
+                try {
+
+                    List<QueryDocumentSnapshot> conversationDocuments = firestore.collection(conversationsCollectionPath).get().get().getDocuments();
+
+                    for (QueryDocumentSnapshot document : conversationDocuments) {
+
+                        String messagesCollectionPath = document.getReference().getPath() + "/mensajes";
+
+                        logger.info("Deleting sub-collection: {}", messagesCollectionPath);
+
+                        firestoreBaseRepository.deleteCollection(messagesCollectionPath, 50);
+
+                    }
+
+                } catch (Exception e) {
+
+                    if (e.getMessage().contains("NOT_FOUND")) {
+
+                        logger.warn("Collection '{}' not found, skipping.", conversationsCollectionPath);
+
+                    } else {
+
+                        throw e;
+
+                    }
+
+                }
+
+
+
+                // Delete the 'conversations' collection
+
+                logger.info("Deleting collection: {}", conversationsCollectionPath);
+
+                try {
+
+                    firestoreBaseRepository.deleteCollection(conversationsCollectionPath, 50);
+
+                } catch (Exception e) {
+
+                    if (e.getMessage().contains("NOT_FOUND")) {
+
+                        logger.warn("Collection '{}' not found, skipping.", conversationsCollectionPath);
+
+                    }
+
+                    else {
+
+                        throw e;
+
+                    }
+
+                }
+
+
+
+                // Delete the 'notifications' collection
+
+                logger.info("Deleting collection: {}", notificationsCollectionPath);
+
+                try {
+
+                    firestoreBaseRepository.deleteCollection(notificationsCollectionPath, 50);
+
+                } catch (Exception e) {
+
+                    if (e.getMessage().contains("NOT_FOUND")) {
+
+                        logger.warn("Collection '{}' not found, skipping.", notificationsCollectionPath);
+
+                    } else {
+
+                        throw e;
+
+                    }
+
+                }
+
+
+
+                logger.info("Successfully purged Firestore collections.");
+
+            } catch (Exception e) {
+
+                logger.error("Error purging Firestore collections.", e);
+
+                throw new RuntimeException("Failed to purge Firestore collections.", e);
+
+            }
+
+        }).subscribeOn(Schedulers.boundedElastic()).then();
+
+    }
+
+}
+
+