From 8bf99c3b99a7cc2bbbb4ab1a9b9b644c072d96ff Mon Sep 17 00:00:00 2001
From: L4B0MB4 <metalfan65@gmail.com>
Date: Sat, 30 Nov 2024 16:36:59 +0100
Subject: [PATCH 1/2] Refactor event polling logic to improve readability and
 modularity by extracting PollEvent method

---
 pkg/eventpolling/polling.go | 61 ++++++++++++++++++-------------------
 1 file changed, 29 insertions(+), 32 deletions(-)

diff --git a/pkg/eventpolling/polling.go b/pkg/eventpolling/polling.go
index 8ae2580..484319f 100644
--- a/pkg/eventpolling/polling.go
+++ b/pkg/eventpolling/polling.go
@@ -23,44 +23,41 @@ func NewEventPolling(client *client.EventSourcingHttpClient, eventRepo *reposito
 
 func (ep *EventPolling) PollEvents() {
 
-	hadMoreThenZeroEvents := true
 	for {
-		if hadMoreThenZeroEvents {
-			time.Sleep(100 * time.Millisecond)
-		} else {
-			time.Sleep(500 * time.Millisecond)
-		}
-		eId, err := ep.eventRepo.GetLastEvent()
-		if err != nil {
-			log.Err(err).Msg("Error while getting last events")
-			continue
-		}
-		events, err := ep.client.GetEventsSince(eId, 2)
-		if err != nil {
-			log.Err(err).Msg("Error while polling events")
-			continue
-		}
+		time.Sleep(100 * time.Millisecond)
+		ep.PollEvent()
+	}
 
-		for _, event := range events {
+}
 
-			err := ep.eventHandler.HandleEvent(event)
-			if err != nil {
-				log.Err(err).Msg("Error while processing event")
-				break
-			}
-		}
-		if len(events) == 0 {
-			hadMoreThenZeroEvents = true
-			continue
-		}
-		hadMoreThenZeroEvents = false
-		//will this break the db consistency if there are going to be multiple instances of this service?
-		// probably but if we dont a volume (that both instances use as a db file) this should be fine
-		err = ep.eventRepo.ReplaceEvent(events[len(events)-1].Id)
+func (ep *EventPolling) PollEvent() {
+	eId, err := ep.eventRepo.GetLastEvent()
+	if err != nil {
+		log.Err(err).Msg("Error while getting last events")
+		return
+	}
+	events, err := ep.client.GetEventsSince(eId, 2)
+	if err != nil {
+		log.Err(err).Msg("Error while polling events")
+		return
+	}
+
+	for _, event := range events {
+
+		err := ep.eventHandler.HandleEvent(event)
 		if err != nil {
-			log.Err(err).Msg("Error while replacing event")
+			log.Err(err).Msg("Error while processing event")
 			break
 		}
 	}
+	if len(events) == 0 {
+		return
+	}
+	//will this break the db consistency if there are going to be multiple instances of this service?
+	// probably but if we dont a volume (that both instances use as a db file) this should be fine
+	err = ep.eventRepo.ReplaceEvent(events[len(events)-1].Id)
+	if err != nil {
+		log.Err(err).Msg("Error while replacing event")
 
+	}
 }

From b1a9137b40cb4bbd6a8e61a566b972fc057983ef Mon Sep 17 00:00:00 2001
From: L4B0MB4 <metalfan65@gmail.com>
Date: Sat, 30 Nov 2024 16:40:14 +0100
Subject: [PATCH 2/2] Refactor event polling to handle events until empty,
 improving error handling and flow control

---
 pkg/eventpolling/polling.go | 54 +++++++++++++++++++------------------
 1 file changed, 28 insertions(+), 26 deletions(-)

diff --git a/pkg/eventpolling/polling.go b/pkg/eventpolling/polling.go
index 484319f..e92b404 100644
--- a/pkg/eventpolling/polling.go
+++ b/pkg/eventpolling/polling.go
@@ -25,39 +25,41 @@ func (ep *EventPolling) PollEvents() {
 
 	for {
 		time.Sleep(100 * time.Millisecond)
-		ep.PollEvent()
+		ep.PollEventsUntilEmpty()
 	}
 
 }
 
-func (ep *EventPolling) PollEvent() {
-	eId, err := ep.eventRepo.GetLastEvent()
-	if err != nil {
-		log.Err(err).Msg("Error while getting last events")
-		return
-	}
-	events, err := ep.client.GetEventsSince(eId, 2)
-	if err != nil {
-		log.Err(err).Msg("Error while polling events")
-		return
-	}
+func (ep *EventPolling) PollEventsUntilEmpty() {
+	for {
+		eId, err := ep.eventRepo.GetLastEvent()
+		if err != nil {
+			log.Err(err).Msg("Error while getting last events")
+			continue
+		}
+		events, err := ep.client.GetEventsSince(eId, 2)
+		if err != nil {
+			log.Err(err).Msg("Error while polling events")
+			continue
+		}
 
-	for _, event := range events {
+		for _, event := range events {
 
-		err := ep.eventHandler.HandleEvent(event)
-		if err != nil {
-			log.Err(err).Msg("Error while processing event")
-			break
+			err := ep.eventHandler.HandleEvent(event)
+			if err != nil {
+				log.Err(err).Msg("Error while processing event")
+				break
+			}
 		}
-	}
-	if len(events) == 0 {
-		return
-	}
-	//will this break the db consistency if there are going to be multiple instances of this service?
-	// probably but if we dont a volume (that both instances use as a db file) this should be fine
-	err = ep.eventRepo.ReplaceEvent(events[len(events)-1].Id)
-	if err != nil {
-		log.Err(err).Msg("Error while replacing event")
+		if len(events) == 0 {
+			return
+		}
+		//will this break the db consistency if there are going to be multiple instances of this service?
+		// probably but if we dont a volume (that both instances use as a db file) this should be fine
+		err = ep.eventRepo.ReplaceEvent(events[len(events)-1].Id)
+		if err != nil {
+			log.Err(err).Msg("Error while replacing event")
 
+		}
 	}
 }