Initial QSfera import

Server/services/eventhistory/pkg/service/service.go

@@ -0,0 +1,148 @@
+package service
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"regexp"
+
+	"github.com/qsfera/server/pkg/log"
+	ehmsg "github.com/qsfera/server/protogen/gen/qsfera/messages/eventhistory/v0"
+	ehsvc "github.com/qsfera/server/protogen/gen/qsfera/services/eventhistory/v0"
+	"github.com/qsfera/server/services/eventhistory/pkg/config"
+	"github.com/opencloud-eu/reva/v2/pkg/events"
+	"go-micro.dev/v4/store"
+)
+
+// StoreEvent is data structure in the store
+type StoreEvent struct {
+	ID    string
+	Type  string
+	Event []byte
+}
+
+// EventHistoryService is the service responsible for event history
+type EventHistoryService struct {
+	ch    <-chan events.Event
+	store store.Store
+	cfg   *config.Config
+	log   log.Logger
+}
+
+// NewEventHistoryService returns an EventHistory service
+func NewEventHistoryService(cfg *config.Config, consumer events.Consumer, store store.Store, log log.Logger) (*EventHistoryService, error) {
+	if consumer == nil || store == nil {
+		return nil, fmt.Errorf("need non nil consumer (%v) and store (%v) to work properly", consumer, store)
+	}
+
+	ch, err := events.ConsumeAll(consumer, "evhistory")
+	if err != nil {
+		return nil, err
+	}
+
+	eh := &EventHistoryService{ch: ch, store: store, cfg: cfg, log: log}
+	go eh.StoreEvents()
+
+	return eh, nil
+}
+
+// StoreEvents consumes all events and stores them in the store. Will block
+func (eh *EventHistoryService) StoreEvents() {
+	for event := range eh.ch {
+		ev, err := json.Marshal(StoreEvent{
+			ID:    event.ID,
+			Type:  event.Type,
+			Event: event.Event.([]byte),
+		})
+		if err != nil {
+			eh.log.Error().Err(err).Str("eventid", event.ID).Msg("could not marshal event")
+			continue
+		}
+		if err := eh.store.Write(&store.Record{
+			Key:    event.ID,
+			Value:  ev,
+			Expiry: eh.cfg.Store.TTL,
+			Metadata: map[string]any{
+				"type": event.Type,
+			},
+		}); err != nil {
+			// we can't store. That's it for us.
+			eh.log.Error().Err(err).Str("eventid", event.ID).Msg("could not store event")
+			continue
+		}
+	}
+}
+
+// GetEvents allows retrieving events from the eventstore by id
+func (eh *EventHistoryService) GetEvents(ctx context.Context, req *ehsvc.GetEventsRequest, resp *ehsvc.GetEventsResponse) error {
+	for _, id := range req.Ids {
+		ev, err := eh.getEvent(id)
+		if err != nil {
+			continue
+		}
+
+		resp.Events = append(resp.Events, ev)
+	}
+
+	return nil
+}
+
+// GetEventsForUser allows retrieving events from the eventstore by userID
+// This function will match all events that contains the user ID between two non-word characters.
+// The reasoning behind this is that events put the userID in many different fields, which can differ
+// per event type. This function will match all events that contain the userID by using a regex.
+// This should also cover future events that might contain the userID in a different field.
+func (eh *EventHistoryService) GetEventsForUser(ctx context.Context, req *ehsvc.GetEventsForUserRequest, resp *ehsvc.GetEventsResponse) error {
+	idx, err := eh.store.List(store.ListPrefix(""))
+	if err != nil {
+		eh.log.Error().Err(err).Msg("could not list events")
+		return err
+	}
+
+	// Match all events that contains the user ID between two non-word characters.
+	userID, err := regexp.Compile(fmt.Sprintf(`\W%s\W`, req.UserID))
+	if err != nil {
+		eh.log.Error().Err(err).Str("userID", req.UserID).Msg("could not compile regex")
+		return err
+	}
+
+	for _, i := range idx {
+		e, err := eh.getEvent(i)
+		if err != nil {
+			continue
+		}
+
+		if userID.Match(e.Event) {
+			resp.Events = append(resp.Events, e)
+		}
+	}
+
+	return nil
+}
+
+func (eh *EventHistoryService) getEvent(id string) (*ehmsg.Event, error) {
+	evs, err := eh.store.Read(id)
+	if err != nil {
+		if !errors.Is(err, store.ErrNotFound) {
+			eh.log.Error().Err(err).Str("eventid", id).Msg("could not read event")
+		}
+		return nil, err
+	}
+
+	if len(evs) == 0 {
+		return nil, store.ErrNotFound
+	}
+
+	var ev StoreEvent
+	if err := json.Unmarshal(evs[0].Value, &ev); err != nil {
+		eh.log.Error().Err(err).Str("eventid", id).Msg("could not unmarshal event")
+		return nil, err
+	}
+
+	return &ehmsg.Event{
+		Id:    ev.ID,
+		Event: ev.Event,
+		Type:  ev.Type,
+	}, nil
+}