feat: added date range filter to pegout reports

Author: gsoares85

internal/adapters/dataproviders/database/mongo/pegout.go

@@ -350,3 +350,96 @@ func (repo *pegoutMongoRepository) UpsertPegoutDeposits(ctx context.Context, dep
 	}
 	return err
 }
+
+func (repo *pegoutMongoRepository) GetQuotesByState(ctx context.Context, filter quote.GetPegoutQuotesByStateFilter) ([]quote.PegoutQuote, error) {
+	dbCtx, cancel := context.WithTimeout(ctx, repo.conn.timeout)
+	defer cancel()
+
+	quoteHashes, err := repo.getRetainedQuoteHashes(dbCtx, filter.States)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(quoteHashes) == 0 {
+		return []quote.PegoutQuote{}, nil
+	}
+
+	pegoutQuotes, err := repo.getPegoutQuotesByHashesAndDate(dbCtx, quoteHashes, filter.StartDate, filter.EndDate)
+	if err != nil {
+		return nil, err
+	}
+
+	logDbInteraction(Read, pegoutQuotes)
+	return pegoutQuotes, nil
+}
+
+func (repo *pegoutMongoRepository) getRetainedQuoteHashes(ctx context.Context, states []quote.PegoutState) ([]string, error) {
+	retainedCollection := repo.conn.Collection(RetainedPegoutQuoteCollection)
+	retainedFilter := bson.D{
+		primitive.E{
+			Key:   "state",
+			Value: bson.D{primitive.E{Key: "$in", Value: states}},
+		},
+	}
+
+	projection := bson.D{
+		primitive.E{Key: "quote_hash", Value: 1},
+		primitive.E{Key: "_id", Value: 0},
+	}
+
+	retainedCursor, err := retainedCollection.Find(ctx, retainedFilter, options.Find().SetProjection(projection))
+	if err != nil {
+		return nil, err
+	}
+	defer retainedCursor.Close(ctx)
+
+	var retainedResults []struct {
+		QuoteHash string `bson:"quote_hash"`
+	}
+
+	if err = retainedCursor.All(ctx, &retainedResults); err != nil {
+		return nil, err
+	}
+
+	quoteHashes := make([]string, len(retainedResults))
+	for i, result := range retainedResults {
+		quoteHashes[i] = result.QuoteHash
+	}
+
+	return quoteHashes, nil
+}
+
+func (repo *pegoutMongoRepository) getPegoutQuotesByHashesAndDate(
+	ctx context.Context,
+	quoteHashes []string,
+	startDate, endDate uint32) ([]quote.PegoutQuote, error) {
+
+	pegoutCollection := repo.conn.Collection(PegoutQuoteCollection)
+	pegoutFilter := bson.D{
+		primitive.E{
+			Key:   "hash",
+			Value: bson.D{primitive.E{Key: "$in", Value: quoteHashes}},
+		},
+		primitive.E{
+			Key: "agreement_timestamp",
+			Value: bson.D{
+				primitive.E{Key: "$gte", Value: startDate},
+				primitive.E{Key: "$lte", Value: endDate},
+			},
+		},
+	}
+
+	sortOptions := options.Find().SetSort(bson.D{primitive.E{Key: "agreement_timestamp", Value: -1}})
+	pegoutCursor, err := pegoutCollection.Find(ctx, pegoutFilter, sortOptions)
+	if err != nil {
+		return nil, err
+	}
+	defer pegoutCursor.Close(ctx)
+
+	var pegoutQuotes []quote.PegoutQuote
+	if err = pegoutCursor.All(ctx, &pegoutQuotes); err != nil {
+		return nil, err
+	}
+
+	return pegoutQuotes, nil
+}

internal/adapters/dataproviders/database/mongo/pegout_test.go

@@ -2,6 +2,7 @@ package mongo_test
 
 import (
 	"context"
+	"errors"
 	"github.com/btcsuite/btcd/btcjson"
 	"github.com/rsksmart/liquidity-provider-server/internal/adapters/dataproviders/database/mongo"
 	"github.com/rsksmart/liquidity-provider-server/internal/entities"
@@ -720,3 +721,115 @@ func TestPegoutMongoRepository_GetQuotes(t *testing.T) {
 		assert.Nil(t, quotes)
 	})
 }
+
+// nolint:funlen
+func TestPegoutMongoRepository_GetQuotesByStates(t *testing.T) {
+	t.Run("Successfully retrieves quotes", func(t *testing.T) {
+		client, db := getClientAndDatabaseMocks()
+		retainedCollection := &mocks.CollectionBindingMock{}
+		pegoutCollection := &mocks.CollectionBindingMock{}
+
+		db.EXPECT().Collection(mongo.RetainedPegoutQuoteCollection).Return(retainedCollection)
+		db.EXPECT().Collection(mongo.PegoutQuoteCollection).Return(pegoutCollection)
+
+		states := []quote.PegoutState{quote.PegoutStateRefundPegOutSucceeded}
+		startDate := uint32(1727000000)
+		endDate := uint32(1728000000)
+
+		expectedQuotes := []quote.PegoutQuote{testPegoutQuote}
+
+		retainedCollection.On("Find", mock.Anything, mock.MatchedBy(func(filter bson.D) bool {
+			return true
+		}), mock.Anything).Return(mongoDb.NewCursorFromDocuments([]any{testRetainedPegoutQuote}, nil, nil))
+
+		pegoutCollection.On("Find", mock.Anything, mock.MatchedBy(func(filter bson.D) bool {
+			return true
+		}), mock.Anything).Return(mongoDb.NewCursorFromDocuments([]any{testPegoutQuote}, nil, nil))
+
+		conn := mongo.NewConnection(client, time.Duration(1))
+		repo := mongo.NewPegoutMongoRepository(conn)
+
+		filter := quote.GetPegoutQuotesByStateFilter{
+			States:    states,
+			StartDate: startDate,
+			EndDate:   endDate,
+		}
+		result, err := repo.GetQuotesByState(context.Background(), filter)
+
+		require.NoError(t, err)
+		assert.Equal(t, expectedQuotes, result)
+
+		retainedCollection.AssertExpectations(t)
+		pegoutCollection.AssertExpectations(t)
+	})
+
+	t.Run("Fails when retainedCollection.Find returns an error", func(t *testing.T) {
+		client, db := getClientAndDatabaseMocks()
+		retainedCollection := &mocks.CollectionBindingMock{}
+
+		db.EXPECT().Collection(mongo.RetainedPegoutQuoteCollection).Return(retainedCollection)
+
+		states := []quote.PegoutState{quote.PegoutStateRefundPegOutSucceeded}
+		startDate := uint32(1727000000)
+		endDate := uint32(1728000000)
+
+		expectedError := errors.New("database connection error")
+		retainedCollection.On("Find", mock.Anything, mock.MatchedBy(func(filter bson.D) bool {
+			return true
+		}), mock.Anything).Return(nil, expectedError)
+
+		conn := mongo.NewConnection(client, time.Duration(1))
+		repo := mongo.NewPegoutMongoRepository(conn)
+
+		filter := quote.GetPegoutQuotesByStateFilter{
+			States:    states,
+			StartDate: startDate,
+			EndDate:   endDate,
+		}
+		result, err := repo.GetQuotesByState(context.Background(), filter)
+
+		require.Error(t, err)
+		assert.Equal(t, expectedError, err)
+		assert.Nil(t, result)
+
+		retainedCollection.AssertExpectations(t)
+	})
+	t.Run("Fails when pegoutCollection.Find returns an error", func(t *testing.T) {
+		client, db := getClientAndDatabaseMocks()
+		retainedCollection := &mocks.CollectionBindingMock{}
+		pegoutCollection := &mocks.CollectionBindingMock{}
+
+		db.EXPECT().Collection(mongo.RetainedPegoutQuoteCollection).Return(retainedCollection)
+		db.EXPECT().Collection(mongo.PegoutQuoteCollection).Return(pegoutCollection)
+
+		states := []quote.PegoutState{quote.PegoutStateRefundPegOutSucceeded}
+		startDate := uint32(1727000000)
+		endDate := uint32(1728000000)
+
+		retainedCollection.On("Find", mock.Anything, mock.MatchedBy(func(filter bson.D) bool {
+			return true
+		}), mock.Anything).Return(mongoDb.NewCursorFromDocuments([]any{testRetainedPegoutQuote}, nil, nil))
+
+		expectedError := errors.New("pegout collection query error")
+		pegoutCollection.On("Find", mock.Anything, mock.MatchedBy(func(filter bson.D) bool {
+			return true
+		}), mock.Anything).Return(nil, expectedError)
+
+		conn := mongo.NewConnection(client, time.Duration(1))
+		repo := mongo.NewPegoutMongoRepository(conn)
+
+		filter := quote.GetPegoutQuotesByStateFilter{
+			States:    states,
+			StartDate: startDate,
+			EndDate:   endDate,
+		}
+		result, err := repo.GetQuotesByState(context.Background(), filter)
+
+		require.Error(t, err)
+		assert.Equal(t, expectedError, err)
+		assert.Nil(t, result)
+
+		retainedCollection.AssertExpectations(t)
+		pegoutCollection.AssertExpectations(t)
+	})
+}

internal/adapters/entrypoints/rest/handlers/get_reports_pegin.go

@@ -11,20 +11,20 @@ import (
 // NewGetReportsPeginHandler
 // @Title Get Pegin Reports
 // @Description Get the last pegins on the API. Included in the management API.
-// @Param GetReportsPeginRequest body pkg.GetReportsPeginRequest true "Date range for the report with startDate and endDate"
+// @Param GetReportsPeginRequest body pkg.GetReportsPeginPegoutRequest true "Date range for the report with startDate and endDate"
 // @Success 200 pkg.GetPeginReportResponse
 // @Route /reports/pegin [get]
 func NewGetReportsPeginHandler(useCase *pegin.GetPeginReportUseCase) http.HandlerFunc {
 	return func(w http.ResponseWriter, req *http.Request) {
-		var requestBody pkg.GetReportsPeginRequest
+		var requestBody pkg.GetReportsPeginPegoutRequest
 		var err error
 		if err = json.NewDecoder(req.Body).Decode(&requestBody); err != nil {
 			jsonErr := rest.NewErrorResponseWithDetails("Invalid request body", rest.DetailsFromError(err), false)
 			rest.JsonErrorResponse(w, http.StatusBadRequest, jsonErr)
 			return
 		}
 
-		if err = requestBody.ValidateGetReportsPeginRequest(); err != nil {
+		if err = requestBody.ValidateGetReportsPeginPegoutRequest(); err != nil {
 			jsonErr := rest.NewErrorResponseWithDetails("Validation error", rest.DetailsFromError(err), false)
 			rest.JsonErrorResponse(w, http.StatusBadRequest, jsonErr)
 			return

internal/adapters/entrypoints/rest/handlers/get_reports_pegout.go

@@ -1,6 +1,7 @@
 package handlers
 
 import (
+	"encoding/json"
 	"github.com/rsksmart/liquidity-provider-server/internal/adapters/entrypoints/rest"
 	"github.com/rsksmart/liquidity-provider-server/internal/usecases/pegout"
 	"github.com/rsksmart/liquidity-provider-server/pkg"
@@ -10,13 +11,33 @@ import (
 // NewGetReportsPegoutHandler
 // @Title Get Pegout Reports
 // @Description Get the last pegouts on the API. Included in the management API.
+// @Param GetReportsPeginRequest body pkg.GetReportsPeginPegoutRequest true "Date range for the report with startDate and endDate"
 // @Success 200 pkg.GetPegoutReportResponse
 // @Route /reports/pegout [get]
 func NewGetReportsPegoutHandler(useCase *pegout.GetPegoutReportUseCase) http.HandlerFunc {
 	return func(w http.ResponseWriter, req *http.Request) {
+		var requestBody pkg.GetReportsPeginPegoutRequest
 		var err error
+		if err = json.NewDecoder(req.Body).Decode(&requestBody); err != nil {
+			jsonErr := rest.NewErrorResponseWithDetails("Invalid request body", rest.DetailsFromError(err), false)
+			rest.JsonErrorResponse(w, http.StatusBadRequest, jsonErr)
+			return
+		}
+
+		if err = requestBody.ValidateGetReportsPeginPegoutRequest(); err != nil {
+			jsonErr := rest.NewErrorResponseWithDetails("Validation error", rest.DetailsFromError(err), false)
+			rest.JsonErrorResponse(w, http.StatusBadRequest, jsonErr)
+			return
+		}
+
+		startTime, endTime, err := requestBody.GetTimestamps()
+		if err != nil {
+			jsonErr := rest.NewErrorResponseWithDetails("Date conversion error", rest.DetailsFromError(err), false)
+			rest.JsonErrorResponse(w, http.StatusBadRequest, jsonErr)
+			return
+		}
 
-		pegoutReport, err := useCase.Run(req.Context())
+		pegoutReport, err := useCase.Run(req.Context(), startTime, endTime)
 		if err != nil {
 			jsonErr := rest.NewErrorResponseWithDetails(UnknownErrorMessage, rest.DetailsFromError(err), false)
 			rest.JsonErrorResponse(w, http.StatusInternalServerError, jsonErr)

internal/entities/quote/pegout_quote.go

@@ -40,12 +40,19 @@ type PegoutQuoteRepository interface {
 	UpdateRetainedQuote(ctx context.Context, quote RetainedPegoutQuote) error
 	UpdateRetainedQuotes(ctx context.Context, quotes []RetainedPegoutQuote) error
 	GetRetainedQuoteByState(ctx context.Context, states ...PegoutState) ([]RetainedPegoutQuote, error)
+	GetQuotesByState(ctx context.Context, filter GetPegoutQuotesByStateFilter) ([]PegoutQuote, error)
 	// DeleteQuotes deletes both regular and retained quotes
 	DeleteQuotes(ctx context.Context, quotes []string) (uint, error)
 	UpsertPegoutDeposit(ctx context.Context, deposit PegoutDeposit) error
 	UpsertPegoutDeposits(ctx context.Context, deposits []PegoutDeposit) error
 }
 
+type GetPegoutQuotesByStateFilter struct {
+	States    []PegoutState
+	StartDate uint32
+	EndDate   uint32
+}
+
 type CreatedPegoutQuote struct {
 	Hash         string
 	Quote        PegoutQuote

internal/usecases/pegout/get_pegout_report.go

@@ -5,6 +5,7 @@ import (
 	"github.com/rsksmart/liquidity-provider-server/internal/entities"
 	"github.com/rsksmart/liquidity-provider-server/internal/entities/quote"
 	"github.com/rsksmart/liquidity-provider-server/internal/usecases"
+	"time"
 )
 
 type GetPegoutReportUseCase struct {
@@ -28,21 +29,29 @@ type GetPegoutReportResult struct {
 	AverageFeePerQuote *entities.Wei
 }
 
-func (useCase *GetPegoutReportUseCase) Run(ctx context.Context) (GetPegoutReportResult, error) {
+func (useCase *GetPegoutReportUseCase) Run(
+	ctx context.Context,
+	startDate time.Time,
+	endDate time.Time,
+) (GetPegoutReportResult, error) {
 	var err error
-	var retained []quote.RetainedPegoutQuote
+	var quotes []quote.PegoutQuote
 	var minimumQuoteValue *entities.Wei
 	var maximumQuoteValue *entities.Wei
 	var averageQuoteValue *entities.Wei
 	var totalFeesCollected *entities.Wei
 	var averageFeePerQuote *entities.Wei
 
-	retained, err = useCase.pegoutQuoteRepository.GetRetainedQuoteByState(ctx, quote.PegoutStateRefundPegOutSucceeded)
-
+	filter := quote.GetPegoutQuotesByStateFilter{
+		States:    []quote.PegoutState{quote.PegoutStateRefundPegOutSucceeded},
+		StartDate: uint32(startDate.Unix()),
+		EndDate:   uint32(endDate.Unix()),
+	}
+	quotes, err = useCase.pegoutQuoteRepository.GetQuotesByState(ctx, filter)
 	if err != nil {
 		return GetPegoutReportResult{}, usecases.WrapUseCaseError(usecases.GetPegoutReportId, err)
 	}
-	if len(retained) == 0 {
+	if len(quotes) == 0 {
 		return GetPegoutReportResult{
 			NumberOfQuotes:     0,
 			MinimumQuoteValue:  entities.NewWei(0),
@@ -53,16 +62,6 @@ func (useCase *GetPegoutReportUseCase) Run(ctx context.Context) (GetPegoutReport
 		}, nil
 	}
 
-	quoteHashes := make([]string, 0)
-	for _, q := range retained {
-		quoteHashes = append(quoteHashes, q.QuoteHash)
-	}
-
-	quotes, err := useCase.pegoutQuoteRepository.GetQuotes(ctx, quoteHashes)
-	if err != nil {
-		return GetPegoutReportResult{}, usecases.WrapUseCaseError(usecases.GetPegoutReportId, err)
-	}
-
 	minimumQuoteValue = useCase.calculateMinimumQuoteValue(quotes)
 	maximumQuoteValue = useCase.calculateMaximumQuoteValue(quotes)
 	averageQuoteValue, err = useCase.calculateAverageQuoteValue(quotes)