fixed event purging

config/Whitelist.go

@@ -21,7 +21,7 @@ func CheckWhitelist(evt nostr.Event) (bool, string) {
 	}
 
 	// Check if the event's pubkey is whitelisted
-    if whitelistCfg.PubkeyWhitelist.Enabled && !IsPubKeyWhitelisted(evt.PubKey) {
+	if whitelistCfg.PubkeyWhitelist.Enabled && !IsPubKeyWhitelisted(evt.PubKey, false) {
 		return false, "not allowed: pubkey or npub is not whitelisted"
 	}
 
@@ -29,10 +29,16 @@ func CheckWhitelist(evt nostr.Event) (bool, string) {
 }
 
 // IsPubKeyWhitelisted checks if a pubkey or npub is whitelisted, considering pubkeys from domains.
-func IsPubKeyWhitelisted(pubKey string) bool {
+// The `forPurge` flag indicates if the check is for purging purposes.
+func IsPubKeyWhitelisted(pubKey string, forPurge bool) bool {
 	cfg := GetWhitelistConfig()
-    if cfg == nil || !cfg.PubkeyWhitelist.Enabled {
+	if cfg == nil {
-        return true // Whitelisting is not enforced if the configuration is missing or disabled
+		return false // No configuration means no whitelisting.
+	}
+
+	// If the whitelist is disabled but this check is for purging, we still evaluate it.
+	if !cfg.PubkeyWhitelist.Enabled && !forPurge {
+		return true // Whitelisting is not enforced for posting if disabled.
 	}
 
 	// Check statically defined pubkeys
@@ -60,7 +66,7 @@ func IsPubKeyWhitelisted(pubKey string) bool {
 		pubkeys, err := utils.FetchPubkeysFromDomains(domains)
 		if err != nil {
 			log.Printf("Error fetching pubkeys from domains: %v", err)
-            return false // Consider returning true or handling based on your application's needs
+			return false // Consider errors as non-whitelisted for purging
 		}
 
 		for _, domainPubKey := range pubkeys {
@@ -70,7 +76,7 @@ func IsPubKeyWhitelisted(pubKey string) bool {
 		}
 	}
 
-    return false
+	return false // Not whitelisted
 }
 
 // Check if a kind is whitelisted

server/db/mongo/purgeEvents.go

@@ -21,8 +21,14 @@ func PurgeOldEvents(cfg *types.EventPurgeConfig) {
 	}
 
 	client := GetClient()
-	cutoff := time.Now().Add(-time.Duration(cfg.KeepIntervalHours) * time.Hour).Unix()
+
+	// Calculate the cutoff time
+	currentTime := time.Now().Unix()
+	cutoff := currentTime - int64(cfg.KeepIntervalHours*3600) // Convert hours to seconds
+
 	var collectionsToPurge []string
+	totalPurged := 0
+	totalKept := 0
 
 	// Determine collections to purge
 	if cfg.PurgeByKindEnabled {
@@ -30,7 +36,6 @@ func PurgeOldEvents(cfg *types.EventPurgeConfig) {
 			collectionsToPurge = append(collectionsToPurge, "event-kind"+strconv.Itoa(kind))
 		}
 	} else {
-		// If `purge_by_kind_enabled` is false, add all potential event kinds or find dynamically
 		collectionsToPurge = getAllEventCollections(client)
 	}
 
@@ -49,27 +54,45 @@ func PurgeOldEvents(cfg *types.EventPurgeConfig) {
 			var evt nostr.Event
 			if err := cursor.Decode(&evt); err != nil {
 				log.Printf("Error decoding event from %s: %v", collectionName, err)
+				totalKept++
 				continue
 			}
 
-			// Skip if the pubkey is whitelisted
+			// Debug log to check created_at and cutoff
-			if cfg.ExcludeWhitelisted && config.IsPubKeyWhitelisted(evt.PubKey) {
+			//log.Printf("Processing event ID: %s, pubkey: %s, created_at: %d, cutoff: %d", evt.ID, evt.PubKey, evt.CreatedAt, cutoff)
-				log.Printf("Skipping purging for whitelisted event ID: %s, pubkey: %s", evt.ID, evt.PubKey)
+
+			// If the event is not older than the cutoff, mark it as kept
+			if evt.CreatedAt >= cutoff {
+				totalKept++
 				continue
 			}
 
-			// Check if purging by category is enabled and if the event matches the allowed category
+			// Skip purging if the pubkey is whitelisted
+			if cfg.ExcludeWhitelisted && config.IsPubKeyWhitelisted(evt.PubKey, true) {
+				//log.Printf("Event ID: %s is kept because the pubkey is whitelisted.", evt.ID)
+				totalKept++
+				continue
+			}
+
+			// Check if purging by category is enabled and matches the event's category
 			category := utils.DetermineEventCategory(evt.Kind)
-			if purge, exists := cfg.PurgeByCategory[category]; exists && purge {
+			if purge, exists := cfg.PurgeByCategory[category]; !exists || !purge {
-				_, err := collection.DeleteOne(context.TODO(), bson.M{"id": evt.ID})
+				totalKept++
+				continue
+			}
+
+			// Proceed to delete the event
+			_, err = collection.DeleteOne(context.TODO(), bson.M{"id": evt.ID})
 			if err != nil {
 				log.Printf("Error purging event ID %s from %s: %v", evt.ID, collectionName, err)
+				totalKept++
 			} else {
-					log.Printf("Purged event ID: %s from %s", evt.ID, collectionName)
+				totalPurged++
-				}
 			}
 		}
 	}
+
+	log.Printf("Purging completed: Total events purged = %d, Total events kept = %d", totalPurged, totalKept)
 }
 
 // getAllEventCollections returns a list of all event collections if purging all kinds.
@@ -97,6 +120,6 @@ func ScheduleEventPurging(cfg *types.ServerConfig) {
 
 	for range ticker.C {
 		PurgeOldEvents(&cfg.EventPurge)
-		log.Println("Scheduled purging completed.")
+		//log.Println("Scheduled purging completed.")
 	}
 }