303 lines
9.2 KiB
Go
303 lines
9.2 KiB
Go
package repository
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"math"
|
|
|
|
dbgen "github.com/SamuelTariku/FortuneBet-Backend/gen/db"
|
|
"github.com/SamuelTariku/FortuneBet-Backend/internal/domain"
|
|
|
|
// "github.com/SamuelTariku/FortuneBet-Backend/internal/services/event"
|
|
"github.com/jackc/pgx/v5/pgtype"
|
|
)
|
|
|
|
func (s *Store) SaveEvent(ctx context.Context, e domain.CreateEvent) error {
|
|
return s.queries.InsertEvent(ctx, domain.ConvertCreateEvent(e))
|
|
}
|
|
|
|
func (s *Store) GetLiveEventIDs(ctx context.Context) ([]string, error) {
|
|
return s.queries.ListLiveEvents(ctx)
|
|
}
|
|
|
|
func (s *Store) GetAllUpcomingEvents(ctx context.Context) ([]domain.BaseEvent, error) {
|
|
events, err := s.queries.GetAllUpcomingEvents(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return domain.ConvertDBEvents(events), nil
|
|
}
|
|
|
|
func (s *Store) GetExpiredUpcomingEvents(ctx context.Context, filter domain.EventFilter) ([]domain.BaseEvent, error) {
|
|
events, err := s.queries.GetExpiredEvents(ctx, pgtype.Text{
|
|
String: filter.MatchStatus.Value,
|
|
Valid: filter.MatchStatus.Valid,
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return domain.ConvertDBEvents(events), nil
|
|
}
|
|
|
|
func (s *Store) GetPaginatedUpcomingEvents(ctx context.Context, filter domain.EventFilter) ([]domain.BaseEvent, int64, error) {
|
|
|
|
events, err := s.queries.GetPaginatedUpcomingEvents(ctx, dbgen.GetPaginatedUpcomingEventsParams{
|
|
LeagueID: filter.LeagueID.ToPG(),
|
|
SportID: filter.SportID.ToPG(),
|
|
Query: filter.Query.ToPG(),
|
|
Limit: filter.Limit.ToPG(),
|
|
Offset: filter.Offset.ToPG(),
|
|
FirstStartTime: filter.FirstStartTime.ToPG(),
|
|
LastStartTime: filter.LastStartTime.ToPG(),
|
|
CountryCode: filter.CountryCode.ToPG(),
|
|
})
|
|
|
|
if err != nil {
|
|
return nil, 0, err
|
|
}
|
|
|
|
totalCount, err := s.queries.GetTotalEvents(ctx, dbgen.GetTotalEventsParams{
|
|
LeagueID: filter.LeagueID.ToPG(),
|
|
SportID: filter.SportID.ToPG(),
|
|
Query: filter.Query.ToPG(),
|
|
FirstStartTime: filter.FirstStartTime.ToPG(),
|
|
LastStartTime: filter.LastStartTime.ToPG(),
|
|
CountryCode: filter.CountryCode.ToPG(),
|
|
})
|
|
if err != nil {
|
|
return nil, 0, err
|
|
}
|
|
|
|
numberOfPages := math.Ceil(float64(totalCount) / float64(filter.Limit.Value))
|
|
return domain.ConvertDBEvents(events), int64(numberOfPages), nil
|
|
}
|
|
|
|
func (s *Store) GetEventsWithSettings(ctx context.Context, companyID int64, filter domain.EventFilter) ([]domain.EventWithSettings, int64, error) {
|
|
events, err := s.queries.GetEventsWithSettings(ctx, dbgen.GetEventsWithSettingsParams{
|
|
CompanyID: companyID,
|
|
LeagueID: filter.LeagueID.ToPG(),
|
|
SportID: filter.SportID.ToPG(),
|
|
Query: filter.Query.ToPG(),
|
|
Limit: filter.Limit.ToPG(),
|
|
Offset: filter.Offset.ToPG(),
|
|
FirstStartTime: filter.FirstStartTime.ToPG(),
|
|
LastStartTime: filter.LastStartTime.ToPG(),
|
|
CountryCode: filter.CountryCode.ToPG(),
|
|
IsFeatured: filter.Featured.ToPG(),
|
|
IsActive: filter.Active.ToPG(),
|
|
})
|
|
|
|
if err != nil {
|
|
return nil, 0, err
|
|
}
|
|
|
|
totalCount, err := s.queries.GetTotalCompanyEvents(ctx, dbgen.GetTotalCompanyEventsParams{
|
|
CompanyID: companyID,
|
|
LeagueID: filter.LeagueID.ToPG(),
|
|
SportID: filter.SportID.ToPG(),
|
|
Query: filter.Query.ToPG(),
|
|
FirstStartTime: filter.FirstStartTime.ToPG(),
|
|
LastStartTime: filter.LastStartTime.ToPG(),
|
|
CountryCode: filter.CountryCode.ToPG(),
|
|
IsFeatured: filter.Featured.ToPG(),
|
|
IsActive: filter.Active.ToPG(),
|
|
})
|
|
if err != nil {
|
|
return nil, 0, err
|
|
}
|
|
|
|
numberOfPages := math.Ceil(float64(totalCount) / float64(filter.Limit.Value))
|
|
|
|
result := make([]domain.EventWithSettings, len(events))
|
|
|
|
for i, event := range events {
|
|
result[i] = domain.EventWithSettings{
|
|
ID: event.ID,
|
|
SportID: event.SportID,
|
|
MatchName: event.MatchName,
|
|
HomeTeam: event.HomeTeam,
|
|
AwayTeam: event.AwayTeam,
|
|
HomeTeamID: event.HomeTeamID,
|
|
AwayTeamID: event.AwayTeamID,
|
|
HomeTeamImage: event.HomeKitImage,
|
|
AwayTeamImage: event.AwayKitImage,
|
|
LeagueID: event.LeagueID,
|
|
LeagueName: event.LeagueName,
|
|
LeagueCC: domain.ValidString{
|
|
Value: event.LeagueCc.String,
|
|
Valid: event.LeagueCc.Valid,
|
|
},
|
|
StartTime: event.StartTime.Time.UTC(),
|
|
Source: domain.EventSource(event.Source),
|
|
Status: domain.EventStatus(event.Status),
|
|
IsFeatured: event.IsFeatured,
|
|
IsMonitored: event.IsMonitored,
|
|
IsActive: event.IsActive,
|
|
DefaultIsFeatured: event.DefaultIsFeatured,
|
|
DefaultIsActive: event.DefaultIsActive,
|
|
DefaultWinningUpperLimit: event.DefaultWinningUpperLimit,
|
|
Score: domain.ValidString{
|
|
Value: event.Score.String,
|
|
Valid: event.Score.Valid,
|
|
},
|
|
MatchMinute: domain.ValidInt{
|
|
Value: int(event.MatchMinute.Int32),
|
|
Valid: event.MatchMinute.Valid,
|
|
},
|
|
TimerStatus: domain.ValidString{
|
|
Value: event.TimerStatus.String,
|
|
Valid: event.TimerStatus.Valid,
|
|
},
|
|
AddedTime: domain.ValidInt{
|
|
Value: int(event.AddedTime.Int32),
|
|
Valid: event.AddedTime.Valid,
|
|
},
|
|
MatchPeriod: domain.ValidInt{
|
|
Value: int(event.MatchPeriod.Int32),
|
|
Valid: event.MatchPeriod.Valid,
|
|
},
|
|
IsLive: event.IsLive,
|
|
UpdatedAt: event.UpdatedAt.Time,
|
|
FetchedAt: event.FetchedAt.Time,
|
|
}
|
|
}
|
|
|
|
return result, int64(numberOfPages), nil
|
|
}
|
|
func (s *Store) GetUpcomingEventByID(ctx context.Context, ID string) (domain.BaseEvent, error) {
|
|
event, err := s.queries.GetUpcomingByID(ctx, ID)
|
|
if err != nil {
|
|
return domain.BaseEvent{}, err
|
|
}
|
|
|
|
return domain.ConvertDBEvent(event), nil
|
|
}
|
|
func (s *Store) GetEventWithSettingByID(ctx context.Context, ID string, companyID int64) (domain.EventWithSettings, error) {
|
|
event, err := s.queries.GetEventWithSettingByID(ctx, dbgen.GetEventWithSettingByIDParams{
|
|
ID: ID,
|
|
CompanyID: companyID,
|
|
})
|
|
if err != nil {
|
|
return domain.EventWithSettings{}, err
|
|
}
|
|
|
|
res := domain.EventWithSettings{
|
|
ID: event.ID,
|
|
SportID: event.SportID,
|
|
MatchName: event.MatchName,
|
|
HomeTeam: event.HomeTeam,
|
|
AwayTeam: event.AwayTeam,
|
|
HomeTeamID: event.HomeTeamID,
|
|
AwayTeamID: event.AwayTeamID,
|
|
HomeTeamImage: event.HomeKitImage,
|
|
AwayTeamImage: event.AwayKitImage,
|
|
LeagueID: event.LeagueID,
|
|
LeagueName: event.LeagueName,
|
|
LeagueCC: domain.ValidString{
|
|
Value: event.LeagueCc.String,
|
|
Valid: event.LeagueCc.Valid,
|
|
},
|
|
StartTime: event.StartTime.Time.UTC(),
|
|
Source: domain.EventSource(event.Source),
|
|
Status: domain.EventStatus(event.Status),
|
|
IsFeatured: event.IsFeatured,
|
|
IsMonitored: event.IsMonitored,
|
|
IsActive: event.IsActive,
|
|
DefaultIsFeatured: event.DefaultIsFeatured,
|
|
DefaultIsActive: event.DefaultIsActive,
|
|
DefaultWinningUpperLimit: event.DefaultWinningUpperLimit,
|
|
Score: domain.ValidString{
|
|
Value: event.Score.String,
|
|
Valid: event.Score.Valid,
|
|
},
|
|
MatchMinute: domain.ValidInt{
|
|
Value: int(event.MatchMinute.Int32),
|
|
Valid: event.MatchMinute.Valid,
|
|
},
|
|
TimerStatus: domain.ValidString{
|
|
Value: event.TimerStatus.String,
|
|
Valid: event.TimerStatus.Valid,
|
|
},
|
|
AddedTime: domain.ValidInt{
|
|
Value: int(event.AddedTime.Int32),
|
|
Valid: event.AddedTime.Valid,
|
|
},
|
|
MatchPeriod: domain.ValidInt{
|
|
Value: int(event.MatchPeriod.Int32),
|
|
Valid: event.MatchPeriod.Valid,
|
|
},
|
|
IsLive: event.IsLive,
|
|
UpdatedAt: event.UpdatedAt.Time,
|
|
FetchedAt: event.FetchedAt.Time,
|
|
}
|
|
return res, nil
|
|
}
|
|
func (s *Store) UpdateFinalScore(ctx context.Context, eventID, fullScore string, status domain.EventStatus) error {
|
|
params := dbgen.UpdateMatchResultParams{
|
|
Score: pgtype.Text{String: fullScore, Valid: true},
|
|
Status: string(status),
|
|
ID: eventID,
|
|
}
|
|
|
|
err := s.queries.UpdateMatchResult(ctx, params)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to update final score for event %s: %w", eventID, err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *Store) UpdateEventStatus(ctx context.Context, eventID string, status domain.EventStatus) error {
|
|
params := dbgen.UpdateMatchResultParams{
|
|
Status: string(status),
|
|
ID: eventID,
|
|
}
|
|
|
|
err := s.queries.UpdateMatchResult(ctx, params)
|
|
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
|
|
}
|
|
|
|
func (s *Store) IsEventMonitored(ctx context.Context, eventID string) (bool, error) {
|
|
isMonitored, err := s.queries.IsEventMonitored(ctx, eventID)
|
|
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
return isMonitored, err
|
|
}
|
|
func (s *Store) UpdateEventMonitored(ctx context.Context, eventID string, IsMonitored bool) error {
|
|
return s.queries.UpdateEventMonitored(ctx, dbgen.UpdateEventMonitoredParams{
|
|
ID: eventID,
|
|
IsMonitored: IsMonitored,
|
|
})
|
|
}
|
|
|
|
func (s *Store) UpdateEventSettings(ctx context.Context, event domain.CreateEventSettings) error {
|
|
return s.queries.SaveEventSettings(ctx, domain.ConvertUpdateEventSettings(event))
|
|
}
|
|
|
|
func (s *Store) DeleteEvent(ctx context.Context, eventID string) error {
|
|
err := s.queries.DeleteEvent(ctx, eventID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *Store) GetSportAndLeagueIDs(ctx context.Context, eventID string) ([]int64, error) {
|
|
sportAndLeagueIDs, err := s.queries.GetSportAndLeagueIDs(ctx, eventID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
res := []int64{int64(sportAndLeagueIDs.SportID), sportAndLeagueIDs.LeagueID}
|
|
return res, err
|
|
}
|