Samuel Tariku
c00110a503
- Updated league handling to ensure valid page size checks and improved error handling for sport ID parsing. - Introduced new endpoint to update global league settings with comprehensive validation and error logging. - Refactored odds settings management, including saving, removing, and updating odds settings with enhanced validation. - Added tenant slug retrieval by token, ensuring proper user and company validation. - Improved middleware to check for active company status and adjusted route permissions for various endpoints. - Added SQL script to fix auto-increment desynchronization across multiple tables.
304 lines
9.5 KiB
Go
304 lines
9.5 KiB
Go
package repository
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
|
|
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) ([]int64, error) {
|
|
return s.queries.ListLiveEvents(ctx)
|
|
}
|
|
|
|
func (s *Store) GetAllEvents(ctx context.Context, filter domain.EventFilter) ([]domain.BaseEvent, int64, error) {
|
|
|
|
events, err := s.queries.GetAllEvents(ctx, dbgen.GetAllEventsParams{
|
|
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(),
|
|
IsLive: filter.IsLive.ToPG(),
|
|
Status: filter.Status.ToPG(),
|
|
Source: filter.Source.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(),
|
|
IsLive: filter.IsLive.ToPG(),
|
|
Status: filter.Status.ToPG(),
|
|
Source: filter.Source.ToPG(),
|
|
})
|
|
if err != nil {
|
|
return nil, 0, err
|
|
}
|
|
|
|
return domain.ConvertDBEvents(events), totalCount, 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(),
|
|
IsLive: filter.IsLive.ToPG(),
|
|
Status: filter.Status.ToPG(),
|
|
Source: filter.Source.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(),
|
|
IsLive: filter.IsLive.ToPG(),
|
|
Status: filter.Status.ToPG(),
|
|
Source: filter.Source.ToPG(),
|
|
})
|
|
if err != nil {
|
|
return nil, 0, err
|
|
}
|
|
|
|
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, totalCount, nil
|
|
}
|
|
func (s *Store) GetEventByID(ctx context.Context, ID int64) (domain.BaseEvent, error) {
|
|
event, err := s.queries.GetEventByID(ctx, ID)
|
|
if err != nil {
|
|
return domain.BaseEvent{}, err
|
|
}
|
|
|
|
return domain.ConvertDBEvent(event), nil
|
|
}
|
|
func (s *Store) GetEventBySourceID(ctx context.Context, id string, source domain.EventSource) (domain.BaseEvent, error) {
|
|
event, err := s.queries.GetEventBySourceID(ctx, dbgen.GetEventBySourceIDParams{
|
|
SourceEventID: id,
|
|
Source: string(source),
|
|
})
|
|
if err != nil {
|
|
return domain.BaseEvent{}, err
|
|
}
|
|
|
|
return domain.ConvertDBEvent(event), nil
|
|
}
|
|
func (s *Store) GetEventWithSettingByID(ctx context.Context, ID int64, 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 int64, 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 %v: %w", eventID, err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *Store) UpdateEventStatus(ctx context.Context, eventID int64, 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 int64) (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 int64, IsMonitored bool) error {
|
|
return s.queries.UpdateEventMonitored(ctx, dbgen.UpdateEventMonitoredParams{
|
|
ID: eventID,
|
|
IsMonitored: IsMonitored,
|
|
})
|
|
}
|
|
|
|
func (s *Store) UpdateTenantEventSettings(ctx context.Context, event domain.UpdateTenantEventSettings) error {
|
|
return s.queries.SaveTenantEventSettings(ctx, domain.ConvertUpdateTenantEventSettings(event))
|
|
}
|
|
|
|
func (s *Store) UpdateGlobalEventSettings(ctx context.Context, event domain.UpdateGlobalEventSettings) error {
|
|
return s.queries.UpdateGlobalEventSettings(ctx, domain.ConvertUpdateGlobalEventSettings(event))
|
|
}
|
|
func (s *Store) DeleteEvent(ctx context.Context, eventID int64) error {
|
|
err := s.queries.DeleteEvent(ctx, eventID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *Store) GetSportAndLeagueIDs(ctx context.Context, eventID int64) ([]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
|
|
}
|