merge alertsDataRepo into DataRepository

As Todd pointed out in code review, there's no need for this to be
separate from the existing DataRepository, as it only queries the
deviceData collection.

BACK-2559

Author: ewollesen

data/service/service/standard.go

@@ -495,7 +495,7 @@ func (s *Standard) initializeAlertsEventsHandler() error {
 	}
 
 	alertsRepo := s.dataStore.NewAlertsRepository()
-	dataRepo := s.dataStore.NewAlertsDataRepository()
+	dataRepo := s.dataStore.NewDataRepository()
 	lastCommunicationsRepo := s.dataStore.NewLastCommunicationsRepository()
 
 	alertsEvaluator := alerts.NewEvaluator(alertsRepo, dataRepo, s.PermissionClient(),

data/store/mongo/mongo.go

@@ -76,8 +76,3 @@ func (s *Store) NewLastCommunicationsRepository() alerts.LastCommunicationsRepos
 	r := lastCommunicationsRepo(*s.Store.GetRepository("lastCommunications"))
 	return &r
 }
-
-func (s *Store) NewAlertsDataRepository() alerts.DataRepository {
-	r := alertsDataRepo(*s.Store.GetRepository("deviceData"))
-	return &r
-}

data/store/mongo/mongo_alerts.go

@@ -3,16 +3,12 @@ package mongo
 import (
 	"context"
 	"fmt"
-	"time"
 
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/mongo"
 	"go.mongodb.org/mongo-driver/mongo/options"
 
 	"github.com/tidepool-org/platform/alerts"
-	"github.com/tidepool-org/platform/data/types/blood/glucose"
-	"github.com/tidepool-org/platform/data/types/blood/glucose/continuous"
-	"github.com/tidepool-org/platform/data/types/dosingdecision"
 	"github.com/tidepool-org/platform/errors"
 	structuredmongo "github.com/tidepool-org/platform/store/structured/mongo"
 )
@@ -24,7 +20,7 @@ type alertsRepo structuredmongo.Repository
 //
 // Once set, UploadID, UserID, and FollowedUserID cannot be changed. This is to prevent a
 // user from granting themselves access to another data set.
-func (r *alertsRepo) Upsert(ctx context.Context, conf *alerts.Config) error {
+func (a *alertsRepo) Upsert(ctx context.Context, conf *alerts.Config) error {
 	opts := options.Update().SetUpsert(true)
 	filter := bson.D{
 		{Key: "userId", Value: conf.UserID},
@@ -35,28 +31,28 @@ func (r *alertsRepo) Upsert(ctx context.Context, conf *alerts.Config) error {
 		"$set":         bson.M{"alerts": conf.Alerts, "activity": conf.Activity},
 		"$setOnInsert": filter,
 	}
-	_, err := r.UpdateOne(ctx, filter, doc, opts)
+	_, err := a.UpdateOne(ctx, filter, doc, opts)
 	if err != nil {
 		return fmt.Errorf("upserting alerts.Config: %w", err)
 	}
 	return nil
 }
 
 // Delete will delete the given Config.
-func (r *alertsRepo) Delete(ctx context.Context, cfg *alerts.Config) error {
-	_, err := r.DeleteMany(ctx, r.filter(cfg), nil)
+func (a *alertsRepo) Delete(ctx context.Context, cfg *alerts.Config) error {
+	_, err := a.DeleteMany(ctx, a.filter(cfg), nil)
 	if err != nil {
 		return fmt.Errorf("upserting alerts.Config: %w", err)
 	}
 	return nil
 }
 
 // List will retrieve any Configs that are defined by followers of the given user.
-func (r *alertsRepo) List(ctx context.Context, followedUserID string) ([]*alerts.Config, error) {
+func (a *alertsRepo) List(ctx context.Context, followedUserID string) ([]*alerts.Config, error) {
 	filter := bson.D{
 		{Key: "followedUserId", Value: followedUserID},
 	}
-	cursor, err := r.Find(ctx, filter, nil)
+	cursor, err := a.Find(ctx, filter, nil)
 	if err != nil {
 		return nil, errors.Wrapf(err, "Unable to list alerts.Config(s) for followed user %s", followedUserID)
 	}
@@ -72,8 +68,8 @@ func (r *alertsRepo) List(ctx context.Context, followedUserID string) ([]*alerts
 }
 
 // Get will retrieve the given Config.
-func (r *alertsRepo) Get(ctx context.Context, cfg *alerts.Config) (*alerts.Config, error) {
-	res := r.FindOne(ctx, r.filter(cfg), nil)
+func (a *alertsRepo) Get(ctx context.Context, cfg *alerts.Config) (*alerts.Config, error) {
+	res := a.FindOne(ctx, a.filter(cfg), nil)
 	if res.Err() != nil {
 		return nil, fmt.Errorf("getting alerts.Config: %w", res.Err())
 	}
@@ -85,8 +81,8 @@ func (r *alertsRepo) Get(ctx context.Context, cfg *alerts.Config) (*alerts.Confi
 }
 
 // EnsureIndexes to maintain index constraints.
-func (r *alertsRepo) EnsureIndexes() error {
-	repo := structuredmongo.Repository(*r)
+func (a *alertsRepo) EnsureIndexes() error {
+	repo := structuredmongo.Repository(*a)
 	return (&repo).CreateAllIndexes(context.Background(), []mongo.IndexModel{
 		{
 			Keys: bson.D{
@@ -100,61 +96,9 @@ func (r *alertsRepo) EnsureIndexes() error {
 	})
 }
 
-func (r *alertsRepo) filter(cfg *alerts.Config) interface{} {
+func (a *alertsRepo) filter(cfg *alerts.Config) interface{} {
 	return bson.D{
 		{Key: "userId", Value: cfg.UserID},
 		{Key: "followedUserId", Value: cfg.FollowedUserID},
 	}
 }
-
-type alertsDataRepo structuredmongo.Repository
-
-func (d *alertsDataRepo) GetAlertableData(ctx context.Context,
-	params alerts.GetAlertableDataParams) (*alerts.GetAlertableDataResponse, error) {
-
-	if params.End.IsZero() {
-		params.End = time.Now()
-	}
-
-	cursor, err := d.getAlertableData(ctx, params, dosingdecision.Type)
-	if err != nil {
-		return nil, err
-	}
-	dosingDecisions := []*dosingdecision.DosingDecision{}
-	if err := cursor.All(ctx, &dosingDecisions); err != nil {
-		return nil, errors.Wrap(err, "Unable to load alertable dosing documents")
-	}
-	cursor, err = d.getAlertableData(ctx, params, continuous.Type)
-	if err != nil {
-		return nil, err
-	}
-	glucoseData := []*glucose.Glucose{}
-	if err := cursor.All(ctx, &glucoseData); err != nil {
-		return nil, errors.Wrap(err, "Unable to load alertable glucose documents")
-	}
-	response := &alerts.GetAlertableDataResponse{
-		DosingDecisions: dosingDecisions,
-		Glucose:         glucoseData,
-	}
-
-	return response, nil
-}
-
-func (d *alertsDataRepo) getAlertableData(ctx context.Context,
-	params alerts.GetAlertableDataParams, typ string) (*mongo.Cursor, error) {
-
-	selector := bson.M{
-		"_active":  true,
-		"uploadId": params.UploadID,
-		"type":     typ,
-		"_userId":  params.UserID,
-		"time":     bson.M{"$gte": params.Start, "$lte": params.End},
-	}
-	findOptions := options.Find().SetSort(bson.D{{Key: "time", Value: -1}})
-	cursor, err := d.Find(ctx, selector, findOptions)
-	if err != nil {
-		format := "Unable to find alertable %s data in dataset %s"
-		return nil, errors.Wrapf(err, format, typ, params.UploadID)
-	}
-	return cursor, nil
-}

data/store/mongo/mongo_data.go

@@ -8,9 +8,14 @@ import (
 
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
 
+	"github.com/tidepool-org/platform/alerts"
 	"github.com/tidepool-org/platform/data"
 	"github.com/tidepool-org/platform/data/store"
+	"github.com/tidepool-org/platform/data/types/blood/glucose"
+	"github.com/tidepool-org/platform/data/types/blood/glucose/continuous"
+	"github.com/tidepool-org/platform/data/types/dosingdecision"
 	"github.com/tidepool-org/platform/data/types/upload"
 	"github.com/tidepool-org/platform/errors"
 	"github.com/tidepool-org/platform/log"
@@ -198,3 +203,53 @@ func (d *DataRepository) DestroyDataForUserByID(ctx context.Context, userID stri
 func isTypeUpload(typ []string) bool {
 	return slices.Contains(typ, strings.ToLower(upload.Type))
 }
+
+func (d *DataRepository) GetAlertableData(ctx context.Context,
+	params alerts.GetAlertableDataParams) (*alerts.GetAlertableDataResponse, error) {
+
+	if params.End.IsZero() {
+		params.End = time.Now()
+	}
+
+	cursor, err := d.getAlertableData(ctx, params, dosingdecision.Type)
+	if err != nil {
+		return nil, err
+	}
+	dosingDecisions := []*dosingdecision.DosingDecision{}
+	if err := cursor.All(ctx, &dosingDecisions); err != nil {
+		return nil, errors.Wrap(err, "Unable to load alertable dosing documents")
+	}
+	cursor, err = d.getAlertableData(ctx, params, continuous.Type)
+	if err != nil {
+		return nil, err
+	}
+	glucoseData := []*glucose.Glucose{}
+	if err := cursor.All(ctx, &glucoseData); err != nil {
+		return nil, errors.Wrap(err, "Unable to load alertable glucose documents")
+	}
+	response := &alerts.GetAlertableDataResponse{
+		DosingDecisions: dosingDecisions,
+		Glucose:         glucoseData,
+	}
+
+	return response, nil
+}
+
+func (d *DataRepository) getAlertableData(ctx context.Context,
+	params alerts.GetAlertableDataParams, typ string) (*mongo.Cursor, error) {
+
+	selector := bson.M{
+		"_active":  true,
+		"uploadId": params.UploadID,
+		"type":     typ,
+		"_userId":  params.UserID,
+		"time":     bson.M{"$gte": params.Start, "$lte": params.End},
+	}
+	findOptions := options.Find().SetSort(bson.D{{Key: "time", Value: -1}})
+	cursor, err := d.DatumRepository.Find(ctx, selector, findOptions)
+	if err != nil {
+		format := "Unable to find alertable %s data in dataset %s"
+		return nil, errors.Wrapf(err, format, typ, params.UploadID)
+	}
+	return cursor, nil
+}

data/store/mongo/mongo_test.go

@@ -465,7 +465,7 @@ var _ = Describe("Mongo", Label("mongodb", "slow", "integration"), func() {
 				repository = store.NewDataRepository()
 				summaryRepository = store.NewSummaryRepository()
 				alertsRepository = store.NewAlertsRepository()
-				alertsDataRepository = store.NewAlertsDataRepository()
+				alertsDataRepository = store.NewDataRepository()
 				lastCommunicationsRepository = store.NewLastCommunicationsRepository()
 				Expect(repository).ToNot(BeNil())
 				Expect(summaryRepository).ToNot(BeNil())
@@ -2427,7 +2427,7 @@ var _ = Describe("Mongo", Label("mongodb", "slow", "integration"), func() {
 				Expect(repository.CreateDataSet(ctx, testSet)).To(Succeed())
 				testSetData := testDataSetData(testSet)
 				Expect(repository.CreateDataSetData(ctx, testSet, testSetData)).To(Succeed())
-				alertsDataRepository = store.NewAlertsDataRepository()
+				alertsDataRepository = store.NewDataRepository()
 				Expect(alertsDataRepository).ToNot(BeNil())
 
 				params := alerts.GetAlertableDataParams{

data/store/store.go

@@ -65,11 +65,12 @@ type DatumRepository interface {
 	DistinctUserIDs(ctx context.Context, typ []string) ([]string, error)
 }
 
-// DataRepository is the combined interface of DataSetRepository and
-// DatumRepository.
+// DataRepository is the combined interface of DataSetRepository,
+// DatumRepository, and [alerts.DataRepository].
 type DataRepository interface {
 	DataSetRepository
 	DatumRepository
+	alerts.DataRepository
 }
 
 type Filter struct {