950 lines
35 KiB
Go
950 lines
35 KiB
Go
package repository
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"math"
|
|
"math/big"
|
|
"strconv"
|
|
"time"
|
|
|
|
dbgen "github.com/SamuelTariku/FortuneBet-Backend/gen/db"
|
|
"github.com/SamuelTariku/FortuneBet-Backend/internal/domain"
|
|
"github.com/jackc/pgx/v5/pgtype"
|
|
)
|
|
|
|
func (s *Store) CreateEnetpulseSport(ctx context.Context, sport domain.CreateEnetpulseSport) (domain.EnetpulseSport, error) {
|
|
// Convert domain model to DB model if needed
|
|
dbSport, err := s.queries.CreateEnetpulseSport(ctx, ConvertCreateEnetpulseSport(sport))
|
|
if err != nil {
|
|
return domain.EnetpulseSport{}, err
|
|
}
|
|
return ConvertDBEnetpulseSport(dbSport), nil
|
|
}
|
|
|
|
// Fetch all sports
|
|
func (s *Store) GetAllEnetpulseSports(ctx context.Context) ([]domain.EnetpulseSport, error) {
|
|
dbSports, err := s.queries.GetAllEnetpulseSports(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var sports []domain.EnetpulseSport
|
|
for _, dbSport := range dbSports {
|
|
sports = append(sports, ConvertDBEnetpulseSport(dbSport))
|
|
}
|
|
|
|
return sports, nil
|
|
}
|
|
|
|
func (s *Store) CreateEnetpulseTournamentTemplate(
|
|
ctx context.Context,
|
|
template domain.CreateEnetpulseTournamentTemplate,
|
|
) (domain.EnetpulseTournamentTemplate, error) {
|
|
// Convert domain model to DB model if needed
|
|
dbTemplate, err := s.queries.CreateEnetpulseTournamentTemplate(
|
|
ctx,
|
|
ConvertCreateEnetpulseTournamentTemplate(template),
|
|
)
|
|
if err != nil {
|
|
return domain.EnetpulseTournamentTemplate{}, err
|
|
}
|
|
return ConvertDBEnetpulseTournamentTemplate(dbTemplate), nil
|
|
}
|
|
|
|
// Fetch all tournament templates
|
|
func (s *Store) GetAllEnetpulseTournamentTemplates(ctx context.Context) ([]domain.EnetpulseTournamentTemplate, error) {
|
|
dbTemplates, err := s.queries.GetAllEnetpulseTournamentTemplates(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var templates []domain.EnetpulseTournamentTemplate
|
|
for _, dbTemplate := range dbTemplates {
|
|
templates = append(templates, ConvertDBEnetpulseTournamentTemplate(dbTemplate))
|
|
}
|
|
|
|
return templates, nil
|
|
}
|
|
|
|
// Store.go
|
|
func (s *Store) CreateEnetpulseTournament(
|
|
ctx context.Context,
|
|
tournament domain.CreateEnetpulseTournament,
|
|
) (domain.EnetpulseTournament, error) {
|
|
// Convert domain model to DB model if needed
|
|
dbTournament, err := s.queries.CreateEnetpulseTournament(
|
|
ctx,
|
|
ConvertCreateEnetpulseTournament(tournament),
|
|
)
|
|
if err != nil {
|
|
return domain.EnetpulseTournament{}, err
|
|
}
|
|
return ConvertDBEnetpulseTournament(dbTournament), nil
|
|
}
|
|
|
|
// store.go
|
|
func (s *Store) GetAllEnetpulseTournaments(ctx context.Context) ([]domain.EnetpulseTournament, error) {
|
|
dbTournaments, err := s.queries.GetAllEnetpulseTournaments(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var tournaments []domain.EnetpulseTournament
|
|
for _, dbT := range dbTournaments {
|
|
tournaments = append(tournaments, ConvertDBEnetpulseTournament(dbT))
|
|
}
|
|
|
|
return tournaments, nil
|
|
}
|
|
|
|
func (s *Store) CreateEnetpulseTournamentStage(
|
|
ctx context.Context,
|
|
stage domain.CreateEnetpulseTournamentStage,
|
|
) (domain.EnetpulseTournamentStage, error) {
|
|
// Convert domain model to DB model if needed
|
|
dbStage, err := s.queries.CreateEnetpulseTournamentStage(
|
|
ctx,
|
|
ConvertCreateEnetpulseTournamentStage(stage),
|
|
)
|
|
if err != nil {
|
|
return domain.EnetpulseTournamentStage{}, err
|
|
}
|
|
return ConvertDBEnetpulseTournamentStage(dbStage), nil
|
|
}
|
|
|
|
// Fetch all tournament stages
|
|
func (s *Store) GetAllEnetpulseTournamentStages(ctx context.Context) ([]domain.EnetpulseTournamentStage, error) {
|
|
dbStages, err := s.queries.GetAllEnetpulseTournamentStages(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var stages []domain.EnetpulseTournamentStage
|
|
for _, dbStage := range dbStages {
|
|
stages = append(stages, ConvertDBEnetpulseTournamentStage(dbStage))
|
|
}
|
|
|
|
return stages, nil
|
|
}
|
|
|
|
// Optional: Fetch stages by TournamentFK
|
|
func (s *Store) GetTournamentStagesByTournamentFK(ctx context.Context, tournamentFK string) ([]domain.EnetpulseTournamentStage, error) {
|
|
dbStages, err := s.queries.GetTournamentStagesByTournamentFK(ctx, tournamentFK)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var stages []domain.EnetpulseTournamentStage
|
|
for _, dbStage := range dbStages {
|
|
stages = append(stages, ConvertDBEnetpulseTournamentStage(dbStage))
|
|
}
|
|
|
|
return stages, nil
|
|
}
|
|
|
|
// Create a new fixture
|
|
func (s *Store) CreateEnetpulseFixture(
|
|
ctx context.Context,
|
|
fixture domain.CreateEnetpulseFixture,
|
|
) (domain.EnetpulseFixture, error) {
|
|
// Convert domain model to DB params (sqlc-generated struct or parameters)
|
|
dbFixture, err := s.queries.CreateEnetpulseFixture(
|
|
ctx,
|
|
ConvertCreateEnetpulseFixture(fixture), // your converter
|
|
)
|
|
if err != nil {
|
|
return domain.EnetpulseFixture{}, err
|
|
}
|
|
return ConvertDBEnetpulseFixture(dbFixture), nil // convert DB row to domain
|
|
}
|
|
|
|
// Fetch all fixtures
|
|
func (s *Store) GetAllEnetpulseFixtures(ctx context.Context) ([]domain.EnetpulseFixture, error) {
|
|
dbFixtures, err := s.queries.GetAllEnetpulseFixtures(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var fixtures []domain.EnetpulseFixture
|
|
for _, dbFixture := range dbFixtures {
|
|
fixtures = append(fixtures, ConvertDBEnetpulseFixture(dbFixture))
|
|
}
|
|
|
|
return fixtures, nil
|
|
}
|
|
|
|
func (s *Store) CreateEnetpulseResult(
|
|
ctx context.Context,
|
|
result domain.CreateEnetpulseResult,
|
|
) (domain.EnetpulseResult, error) {
|
|
dbResult, err := s.queries.CreateEnetpulseResult(
|
|
ctx,
|
|
ConvertCreateEnetpulseResult(result),
|
|
)
|
|
if err != nil {
|
|
return domain.EnetpulseResult{}, err
|
|
}
|
|
|
|
return ConvertDBEnetpulseResult(dbResult), nil
|
|
}
|
|
|
|
// GetAllEnetpulseResults retrieves all Enetpulse results.
|
|
func (s *Store) GetAllEnetpulseResults(ctx context.Context) ([]domain.EnetpulseResult, error) {
|
|
dbResults, err := s.queries.GetAllEnetpulseResults(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
results := make([]domain.EnetpulseResult, 0, len(dbResults))
|
|
for _, dbR := range dbResults {
|
|
results = append(results, ConvertDBEnetpulseResult(dbR))
|
|
}
|
|
|
|
return results, nil
|
|
}
|
|
|
|
// CreateEnetpulseOutcomeType inserts or updates an EnetPulse outcome type record.
|
|
func (s *Store) CreateEnetpulseOutcomeType(
|
|
ctx context.Context,
|
|
outcomeType domain.CreateEnetpulseOutcomeType,
|
|
) (domain.EnetpulseOutcomeType, error) {
|
|
dbOutcome, err := s.queries.CreateEnetpulseOutcomeType(
|
|
ctx,
|
|
ConvertCreateEnetpulseOutcomeType(outcomeType),
|
|
)
|
|
if err != nil {
|
|
return domain.EnetpulseOutcomeType{}, err
|
|
}
|
|
|
|
return ConvertDBEnetpulseOutcomeType(dbOutcome), nil
|
|
}
|
|
|
|
// GetAllEnetpulseOutcomeTypes retrieves all outcome types.
|
|
func (s *Store) GetAllEnetpulseOutcomeTypes(ctx context.Context) ([]domain.EnetpulseOutcomeType, error) {
|
|
dbOutcomes, err := s.queries.GetAllEnetpulseOutcomeTypes(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
outcomes := make([]domain.EnetpulseOutcomeType, 0, len(dbOutcomes))
|
|
for _, dbO := range dbOutcomes {
|
|
outcomes = append(outcomes, ConvertDBEnetpulseOutcomeType(dbO))
|
|
}
|
|
|
|
return outcomes, nil
|
|
}
|
|
|
|
// CreateEnetpulsePreodds inserts or updates a preodds record.
|
|
func (s *Store) CreateEnetpulsePreodds(
|
|
ctx context.Context,
|
|
preodds domain.CreateEnetpulsePreodds,
|
|
) (domain.EnetpulsePreodds, error) {
|
|
|
|
// Convert domain to DB params
|
|
params, err := ConvertCreateEnetpulsePreodds(preodds)
|
|
if err != nil {
|
|
return domain.EnetpulsePreodds{}, err
|
|
}
|
|
|
|
// Insert into DB
|
|
dbPreodds, err := s.queries.CreateEnetpulsePreodds(ctx, params)
|
|
if err != nil {
|
|
return domain.EnetpulsePreodds{}, err
|
|
}
|
|
|
|
return ConvertDBEnetpulsePreodds(dbPreodds), nil
|
|
}
|
|
|
|
// GetAllEnetpulsePreodds retrieves all preodds records.
|
|
func (s *Store) GetAllEnetpulsePreodds(ctx context.Context) ([]domain.EnetpulsePreodds, error) {
|
|
dbPreodds, err := s.queries.GetAllEnetpulsePreodds(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
preodds := make([]domain.EnetpulsePreodds, 0, len(dbPreodds))
|
|
for _, dbP := range dbPreodds {
|
|
preodds = append(preodds, ConvertDBEnetpulsePreodds(dbP))
|
|
}
|
|
|
|
return preodds, nil
|
|
}
|
|
|
|
// CreateEnetpulsePreoddsBettingOffer inserts or updates a betting offer
|
|
func (s *Store) CreateEnetpulsePreoddsBettingOffer(
|
|
ctx context.Context,
|
|
bettingOffer domain.CreateEnetpulsePreoddsBettingOffer,
|
|
) (domain.EnetpulsePreoddsBettingOffer, error) {
|
|
|
|
params := ConvertCreateEnetpulsePreoddsBettingOffer(bettingOffer)
|
|
|
|
dbOffer, err := s.queries.CreateEnetpulsePreoddsBettingOffer(ctx, params)
|
|
if err != nil {
|
|
return domain.EnetpulsePreoddsBettingOffer{}, err
|
|
}
|
|
|
|
return ConvertDBEnetpulsePreoddsBettingOffer(dbOffer), nil
|
|
}
|
|
|
|
// GetAllEnetpulsePreoddsBettingOffers retrieves all betting offers
|
|
func (s *Store) GetAllEnetpulsePreoddsBettingOffers(ctx context.Context) ([]domain.EnetpulsePreoddsBettingOffer, error) {
|
|
dbOffers, err := s.queries.GetAllEnetpulsePreoddsBettingOffers(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
offers := make([]domain.EnetpulsePreoddsBettingOffer, 0, len(dbOffers))
|
|
for _, dbO := range dbOffers {
|
|
offers = append(offers, ConvertDBEnetpulsePreoddsBettingOffer(dbO))
|
|
}
|
|
|
|
return offers, nil
|
|
}
|
|
|
|
func (s *Store) GetFixturesWithPreodds(ctx context.Context) ([]domain.EnetpulseFixtureWithPreodds, error) {
|
|
dbRows, err := s.queries.GetFixturesWithPreodds(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Use a map to group preodds by fixture
|
|
fixtureMap := make(map[string]*domain.EnetpulseFixtureWithPreodds)
|
|
|
|
for _, row := range dbRows {
|
|
// If fixture not yet in map, add it
|
|
if _, exists := fixtureMap[row.FixtureID]; !exists {
|
|
fixtureMap[row.FixtureID] = &domain.EnetpulseFixtureWithPreodds{
|
|
FixtureID: row.FixtureID,
|
|
FixtureApiID: row.FixtureID, // same alias used in query
|
|
FixtureName: row.FixtureName,
|
|
SportFk: row.SportFk,
|
|
TournamentFk: row.TournamentFk.String,
|
|
TournamentTemplateFk: row.TournamentTemplateFk.String,
|
|
// TournamentStageFk: row.TournamentStageFk.String,
|
|
StartDate: row.StartDate.Time,
|
|
StatusType: row.StatusType.String,
|
|
StatusDescFk: row.StatusDescFk.String,
|
|
RoundTypeFk: row.RoundTypeFk.String,
|
|
UpdatesCount: row.FixtureUpdatesCount.Int32,
|
|
LastUpdatedAt: row.FixtureLastUpdatedAt.Time,
|
|
CreatedAt: row.FixtureCreatedAt.Time,
|
|
UpdatedAt: row.FixtureUpdatedAt.Time,
|
|
Preodds: []domain.EnetpulsePreodds{}, // initialize slice
|
|
}
|
|
}
|
|
|
|
// Add preodds only if it exists (avoid NULL rows)
|
|
if row.PreoddsDbID.Valid {
|
|
preodds := domain.EnetpulsePreodds{
|
|
ID: row.PreoddsDbID.Int64,
|
|
PreoddsID: row.PreoddsID.String,
|
|
EventFK: row.EventFk.Int64,
|
|
OutcomeTypeFK: row.OutcomeTypeFk.Int32,
|
|
OutcomeScopeFK: row.OutcomeScopeFk.Int32,
|
|
OutcomeSubtypeFK: row.OutcomeSubtypeFk.Int32,
|
|
EventParticipantNumber: row.EventParticipantNumber.Int32,
|
|
IParam: row.Iparam.String,
|
|
IParam2: row.Iparam2.String,
|
|
DParam: row.Dparam.String,
|
|
DParam2: row.Dparam2.String,
|
|
SParam: row.Sparam.String,
|
|
UpdatesCount: row.PreoddsUpdatesCount.Int32,
|
|
LastUpdatedAt: row.PreoddsLastUpdatedAt.Time,
|
|
CreatedAt: row.PreoddsCreatedAt.Time,
|
|
UpdatedAt: row.PreoddsUpdatedAt.Time,
|
|
}
|
|
fixtureMap[row.FixtureID].Preodds = append(fixtureMap[row.FixtureID].Preodds, preodds)
|
|
}
|
|
}
|
|
|
|
// Flatten the map into a slice
|
|
result := make([]domain.EnetpulseFixtureWithPreodds, 0, len(fixtureMap))
|
|
for _, f := range fixtureMap {
|
|
result = append(result, *f)
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// func ConvertCreateEnetpulseTournamentStage(stage domain.CreateEnetpulseTournamentStage) dbgen.EnetpulseTournamentStage {
|
|
// return dbgen.EnetpulseTournamentStage{
|
|
// StageID: stage.StageID,
|
|
// Name: stage.Name,
|
|
// TournamentFK: stage.TournamentFK,
|
|
// Gender: stage.Gender,
|
|
// CountryFK: stage.CountryFK,
|
|
// StartDate: stage.StartDate,
|
|
// EndDate: stage.EndDate,
|
|
// UpdatesCount: int32(stage.UpdatesCount),
|
|
// LastUpdatedAt: stage.LastUpdatedAt,
|
|
// CountryName: stage.CountryName,
|
|
// Status: int32(stage.Status),
|
|
// UpdatedAt: time.Now(),
|
|
// }
|
|
// }
|
|
|
|
// ConvertCreateEnetpulseFixture converts the domain model to the SQLC params struct.
|
|
func ConvertCreateEnetpulseFixture(f domain.CreateEnetpulseFixture) dbgen.CreateEnetpulseFixtureParams {
|
|
return dbgen.CreateEnetpulseFixtureParams{
|
|
FixtureID: f.FixtureID,
|
|
Name: f.Name,
|
|
SportFk: f.SportFK,
|
|
TournamentFk: pgtype.Text{String: f.TournamentFK, Valid: f.TournamentFK != ""},
|
|
TournamentTemplateFk: pgtype.Text{String: f.TournamentTemplateFK, Valid: f.TournamentTemplateFK != ""},
|
|
// TournamentStageFk: pgtype.Text{String: f.TournamentStageFK, Valid: f.TournamentStageFK != ""},
|
|
// TournamentStageName: pgtype.Text{String: f.TournamentStageName, Valid: f.TournamentStageName != ""},
|
|
TournamentName: pgtype.Text{String: f.TournamentName, Valid: f.TournamentName != ""},
|
|
TournamentTemplateName: pgtype.Text{String: f.TournamentTemplateName, Valid: f.TournamentTemplateName != ""},
|
|
SportName: pgtype.Text{String: f.SportName, Valid: f.SportName != ""},
|
|
Gender: pgtype.Text{String: f.Gender, Valid: f.Gender != ""},
|
|
StartDate: pgtype.Timestamptz{Time: f.StartDate, Valid: !f.StartDate.IsZero()},
|
|
StatusType: pgtype.Text{String: f.StatusType, Valid: f.StatusType != ""},
|
|
StatusDescFk: pgtype.Text{String: f.StatusDescFK, Valid: f.StatusDescFK != ""},
|
|
RoundTypeFk: pgtype.Text{String: f.RoundTypeFK, Valid: f.RoundTypeFK != ""},
|
|
UpdatesCount: pgtype.Int4{Int32: int32(f.UpdatesCount), Valid: true},
|
|
LastUpdatedAt: pgtype.Timestamptz{Time: f.LastUpdatedAt, Valid: !f.LastUpdatedAt.IsZero()},
|
|
}
|
|
}
|
|
|
|
// ConvertDBEnetpulseFixture converts the DB row to the domain model.
|
|
func ConvertDBEnetpulseFixture(dbF dbgen.EnetpulseFixture) domain.EnetpulseFixture {
|
|
return domain.EnetpulseFixture{
|
|
FixtureID: dbF.FixtureID,
|
|
Name: dbF.Name,
|
|
SportFK: dbF.SportFk,
|
|
TournamentFK: dbF.TournamentFk.String,
|
|
TournamentTemplateFK: dbF.TournamentTemplateFk.String,
|
|
// TournamentStageFK: dbF.TournamentStageFk.String,
|
|
// TournamentStageName: dbF.TournamentStageName.String,
|
|
TournamentName: dbF.TournamentName.String,
|
|
TournamentTemplateName: dbF.TournamentTemplateName.String,
|
|
SportName: dbF.SportName.String,
|
|
Gender: dbF.Gender.String,
|
|
StartDate: dbF.StartDate.Time.String(),
|
|
StatusType: dbF.StatusType.String,
|
|
StatusDescFK: dbF.StatusDescFk.String,
|
|
RoundTypeFK: dbF.RoundTypeFk.String,
|
|
UpdatesCount: fmt.Sprintf("%v", dbF.UpdatesCount),
|
|
LastUpdatedAt: dbF.LastUpdatedAt.Time.String(),
|
|
// CreatedAt: dbF.CreatedAt.Time,
|
|
// UpdatedAt: dbF.UpdatedAt.Time,
|
|
}
|
|
}
|
|
|
|
func ConvertCreateEnetpulseTournamentStage(stage domain.CreateEnetpulseTournamentStage) dbgen.CreateEnetpulseTournamentStageParams {
|
|
return dbgen.CreateEnetpulseTournamentStageParams{
|
|
StageID: stage.StageID,
|
|
Name: stage.Name,
|
|
TournamentFk: stage.TournamentFK,
|
|
Gender: pgtype.Text{String: stage.Gender, Valid: stage.Gender != ""},
|
|
CountryFk: pgtype.Text{String: stage.CountryFK, Valid: stage.CountryFK != ""},
|
|
StartDate: pgtype.Timestamptz{Time: stage.StartDate, Valid: !stage.StartDate.IsZero()},
|
|
EndDate: pgtype.Timestamptz{Time: stage.EndDate, Valid: !stage.EndDate.IsZero()},
|
|
UpdatesCount: pgtype.Int4{Int32: int32(stage.UpdatesCount), Valid: true},
|
|
LastUpdatedAt: pgtype.Timestamptz{Time: stage.LastUpdatedAt, Valid: !stage.LastUpdatedAt.IsZero()},
|
|
CountryName: pgtype.Text{String: stage.CountryName, Valid: stage.CountryFK != ""},
|
|
Status: pgtype.Int4{Int32: int32(stage.Status), Valid: true},
|
|
// Las: pgtype.Timestamptz{Time: time.Now(), Valid: true},
|
|
}
|
|
}
|
|
|
|
func ConvertDBEnetpulseTournamentStage(db dbgen.EnetpulseTournamentStage) domain.EnetpulseTournamentStage {
|
|
return domain.EnetpulseTournamentStage{
|
|
ID: db.ID,
|
|
StageID: db.StageID,
|
|
Name: db.Name,
|
|
TournamentFK: db.TournamentFk,
|
|
Gender: db.Gender.String,
|
|
CountryFK: db.CountryFk.String,
|
|
StartDate: db.StartDate.Time,
|
|
EndDate: db.EndDate.Time,
|
|
UpdatesCount: func() int {
|
|
if db.UpdatesCount.Valid {
|
|
return int(db.UpdatesCount.Int32)
|
|
}
|
|
return 0
|
|
}(),
|
|
LastUpdatedAt: db.LastUpdatedAt.Time,
|
|
CountryName: db.CountryName.String,
|
|
Status: func() int {
|
|
if db.Status.Valid {
|
|
return int(db.Status.Int32)
|
|
}
|
|
return 0
|
|
}(),
|
|
CreatedAt: db.CreatedAt.Time,
|
|
UpdatedAt: db.UpdatedAt.Time,
|
|
}
|
|
}
|
|
|
|
func ConvertCreateEnetpulseSport(s domain.CreateEnetpulseSport) dbgen.CreateEnetpulseSportParams {
|
|
return dbgen.CreateEnetpulseSportParams{
|
|
SportID: s.SportID,
|
|
Name: s.Name,
|
|
UpdatesCount: pgtype.Int4{Int32: int32(s.UpdatesCount), Valid: true}, // SQLC might use int32
|
|
LastUpdatedAt: pgtype.Timestamptz{Time: s.LastUpdatedAt, Valid: true},
|
|
Status: pgtype.Int4{Int32: int32(s.Status), Valid: true},
|
|
// UpdatedAt: nil, // SQLC will default NOW() if nil
|
|
}
|
|
}
|
|
|
|
func ConvertDBEnetpulseSport(db dbgen.EnetpulseSport) domain.EnetpulseSport {
|
|
return domain.EnetpulseSport{
|
|
ID: db.ID,
|
|
SportID: db.SportID,
|
|
Name: db.Name,
|
|
UpdatesCount: func() int {
|
|
if db.UpdatesCount.Valid {
|
|
return int(db.UpdatesCount.Int32)
|
|
}
|
|
return 0 // or another default value if needed
|
|
}(), // cast from int32
|
|
LastUpdatedAt: db.LastUpdatedAt.Time,
|
|
Status: func() int {
|
|
if db.Status.Valid {
|
|
return int(db.Status.Int32)
|
|
}
|
|
return 0 // or another default value if needed
|
|
}(), // cast from int32
|
|
CreatedAt: db.CreatedAt.Time,
|
|
UpdatedAt: db.UpdatedAt.Time,
|
|
}
|
|
}
|
|
|
|
func ConvertDBEnetpulseTournamentTemplate(db dbgen.EnetpulseTournamentTemplate) domain.EnetpulseTournamentTemplate {
|
|
return domain.EnetpulseTournamentTemplate{
|
|
ID: db.ID,
|
|
TemplateID: db.TemplateID,
|
|
Name: db.Name,
|
|
SportFK: db.SportFk,
|
|
Gender: func() string {
|
|
if db.Gender.Valid {
|
|
return db.Gender.String
|
|
}
|
|
return ""
|
|
}(),
|
|
UpdatesCount: func() int {
|
|
if db.UpdatesCount.Valid {
|
|
return int(db.UpdatesCount.Int32)
|
|
}
|
|
return 0
|
|
}(),
|
|
LastUpdatedAt: db.LastUpdatedAt.Time,
|
|
Status: func() int {
|
|
if db.Status.Valid {
|
|
return int(db.Status.Int32)
|
|
}
|
|
return 0
|
|
}(),
|
|
CreatedAt: db.CreatedAt.Time,
|
|
UpdatedAt: db.UpdatedAt.Time,
|
|
}
|
|
}
|
|
|
|
func ConvertCreateEnetpulseTournamentTemplate(
|
|
t domain.CreateEnetpulseTournamentTemplate,
|
|
) dbgen.CreateEnetpulseTournamentTemplateParams {
|
|
return dbgen.CreateEnetpulseTournamentTemplateParams{
|
|
TemplateID: t.TemplateID,
|
|
SportFk: fmt.Sprintf("%d", t.SportFK),
|
|
Gender: pgtype.Text{String: t.Gender, Valid: t.Gender != ""},
|
|
UpdatesCount: pgtype.Int4{Int32: int32(t.UpdatesCount), Valid: true},
|
|
LastUpdatedAt: pgtype.Timestamptz{Time: t.LastUpdatedAt, Valid: true},
|
|
Status: pgtype.Int4{Int32: int32(t.Status), Valid: true},
|
|
}
|
|
}
|
|
|
|
// Convert domain to DB insert struct for sqlc
|
|
func ConvertCreateEnetpulseTournament(t domain.CreateEnetpulseTournament) dbgen.CreateEnetpulseTournamentParams {
|
|
return dbgen.CreateEnetpulseTournamentParams{
|
|
TournamentID: t.TournamentID,
|
|
Name: t.Name,
|
|
TournamentTemplateFk: t.TournamentTemplateFK,
|
|
UpdatesCount: pgtype.Int4{Int32: int32(t.UpdatesCount), Valid: true},
|
|
LastUpdatedAt: pgtype.Timestamptz{Time: t.LastUpdatedAt, Valid: !t.LastUpdatedAt.IsZero()},
|
|
Status: pgtype.Int4{Int32: int32(t.Status), Valid: true},
|
|
}
|
|
}
|
|
|
|
// Convert DB row to domain model
|
|
func ConvertDBEnetpulseTournament(dbT dbgen.EnetpulseTournament) domain.EnetpulseTournament {
|
|
return domain.EnetpulseTournament{
|
|
ID: dbT.ID,
|
|
TournamentID: dbT.TournamentID,
|
|
Name: dbT.Name,
|
|
TournamentTemplateFK: dbT.TournamentTemplateFk,
|
|
UpdatesCount: func() int {
|
|
if dbT.UpdatesCount.Valid {
|
|
return int(dbT.UpdatesCount.Int32)
|
|
}
|
|
return 0
|
|
}(),
|
|
LastUpdatedAt: dbT.LastUpdatedAt.Time,
|
|
Status: func() int {
|
|
if dbT.Status.Valid {
|
|
return int(dbT.Status.Int32)
|
|
}
|
|
return 0
|
|
}(),
|
|
CreatedAt: dbT.CreatedAt.Time,
|
|
UpdatedAt: func() *time.Time {
|
|
if dbT.UpdatedAt.Valid {
|
|
return &dbT.UpdatedAt.Time
|
|
}
|
|
return nil
|
|
}(),
|
|
}
|
|
}
|
|
|
|
func ConvertCreateEnetpulseResult(input domain.CreateEnetpulseResult) dbgen.CreateEnetpulseResultParams {
|
|
return dbgen.CreateEnetpulseResultParams{
|
|
ResultID: input.ResultID,
|
|
Name: input.Name,
|
|
SportFk: input.SportFK,
|
|
TournamentFk: pgtype.Text{String: input.TournamentFK, Valid: input.TournamentFK != ""},
|
|
TournamentTemplateFk: pgtype.Text{String: input.TournamentTemplateFK, Valid: input.TournamentTemplateFK != ""},
|
|
// TournamentStageFk: pgtype.Text{String: input.TournamentStageFK, Valid: input.TournamentStageFK != ""},
|
|
// TournamentStageName: pgtype.Text{String: input.TournamentStageName, Valid: input.TournamentStageName != ""},
|
|
TournamentName: pgtype.Text{String: input.TournamentName, Valid: input.TournamentName != ""},
|
|
TournamentTemplateName: pgtype.Text{String: input.TournamentTemplateName, Valid: input.TournamentTemplateName != ""},
|
|
SportName: pgtype.Text{String: input.SportName, Valid: input.SportName != ""},
|
|
StartDate: pgtype.Timestamptz{Time: input.StartDate, Valid: !input.StartDate.IsZero()},
|
|
StatusType: pgtype.Text{String: input.StatusType, Valid: input.StatusType != ""},
|
|
StatusDescFk: pgtype.Text{String: input.StatusDescFK, Valid: input.StatusDescFK != ""},
|
|
RoundTypeFk: pgtype.Text{String: input.RoundTypeFK, Valid: input.RoundTypeFK != ""},
|
|
UpdatesCount: pgtype.Int4{Int32: int32(input.UpdatesCount), Valid: true},
|
|
LastUpdatedAt: pgtype.Timestamptz{Time: input.LastUpdatedAt, Valid: !input.LastUpdatedAt.IsZero()},
|
|
Round: pgtype.Text{String: input.Round, Valid: input.Round != ""},
|
|
Live: pgtype.Text{String: input.Live, Valid: input.Live != ""},
|
|
VenueName: pgtype.Text{String: input.VenueName, Valid: input.VenueName != ""},
|
|
LivestatsPlus: pgtype.Text{String: input.LivestatsPlus, Valid: input.LivestatsPlus != ""},
|
|
LivestatsType: pgtype.Text{String: input.LivestatsType, Valid: input.LivestatsType != ""},
|
|
Commentary: pgtype.Text{String: input.Commentary, Valid: input.Commentary != ""},
|
|
LineupConfirmed: pgtype.Bool{Bool: input.LineupConfirmed, Valid: true},
|
|
Verified: pgtype.Bool{Bool: input.Verified, Valid: true},
|
|
Spectators: pgtype.Int4{Int32: int32(input.Spectators), Valid: true},
|
|
GameStarted: pgtype.Timestamptz{Time: *input.GameStarted, Valid: !input.GameStarted.IsZero()},
|
|
FirstHalfEnded: pgtype.Timestamptz{Time: *input.FirstHalfEnded, Valid: !input.FirstHalfEnded.IsZero()},
|
|
SecondHalfStarted: pgtype.Timestamptz{Time: *input.SecondHalfStarted, Valid: !input.SecondHalfStarted.IsZero()},
|
|
SecondHalfEnded: pgtype.Timestamptz{Time: *input.SecondHalfEnded, Valid: !input.SecondHalfEnded.IsZero()},
|
|
GameEnded: pgtype.Timestamptz{Time: *input.GameEnded, Valid: !input.GameEnded.IsZero()},
|
|
}
|
|
}
|
|
|
|
// ConvertDBEnetpulseResult maps SQLC result → domain model
|
|
func ConvertDBEnetpulseResult(db dbgen.EnetpulseResult) domain.EnetpulseResult {
|
|
return domain.EnetpulseResult{
|
|
ID: db.ID,
|
|
ResultID: db.ResultID,
|
|
Name: db.Name,
|
|
SportFK: db.SportFk,
|
|
TournamentFK: db.TournamentFk.String,
|
|
TournamentTemplateFK: db.TournamentTemplateFk.String,
|
|
// TournamentStageFK: db.TournamentStageFk.String,
|
|
// TournamentStageName: db.TournamentStageName.String,
|
|
TournamentName: db.TournamentName.String,
|
|
TournamentTemplateName: db.TournamentTemplateName.String,
|
|
SportName: db.SportName.String,
|
|
StartDate: db.StartDate.Time,
|
|
StatusType: db.StatusType.String,
|
|
StatusDescFK: db.StatusDescFk.String,
|
|
RoundTypeFK: db.RoundTypeFk.String,
|
|
UpdatesCount: db.UpdatesCount.Int32,
|
|
LastUpdatedAt: &db.LastUpdatedAt.Time,
|
|
Round: db.Round.String,
|
|
Live: db.Live.String,
|
|
VenueName: db.VenueName.String,
|
|
LivestatsPlus: db.LivestatsPlus.String,
|
|
LivestatsType: db.LivestatsType.String,
|
|
Commentary: db.Commentary.String,
|
|
LineupConfirmed: db.LineupConfirmed.Bool,
|
|
Verified: db.Verified.Bool,
|
|
Spectators: db.Spectators.Int32,
|
|
GameStarted: &db.GameStarted.Time,
|
|
FirstHalfEnded: &db.FirstHalfEnded.Time,
|
|
SecondHalfStarted: &db.SecondHalfStarted.Time,
|
|
SecondHalfEnded: &db.SecondHalfEnded.Time,
|
|
GameEnded: &db.GameEnded.Time,
|
|
CreatedAt: db.CreatedAt.Time,
|
|
UpdatedAt: &db.UpdatedAt.Time,
|
|
}
|
|
}
|
|
|
|
// ConvertCreateEnetpulseOutcomeType converts the domain struct to SQLC params.
|
|
func ConvertCreateEnetpulseOutcomeType(o domain.CreateEnetpulseOutcomeType) dbgen.CreateEnetpulseOutcomeTypeParams {
|
|
return dbgen.CreateEnetpulseOutcomeTypeParams{
|
|
OutcomeTypeID: o.OutcomeTypeID,
|
|
Name: o.Name,
|
|
Description: pgtype.Text{String: o.Description, Valid: o.Description != ""}, // TODO: thiso.Description,
|
|
UpdatesCount: pgtype.Int4{Int32: int32(o.UpdatesCount), Valid: true},
|
|
LastUpdatedAt: pgtype.Timestamptz{Time: o.LastUpdatedAt, Valid: !o.LastUpdatedAt.IsZero()},
|
|
}
|
|
}
|
|
|
|
// ConvertDBEnetpulseOutcomeType converts SQLC DB model to domain model.
|
|
func ConvertDBEnetpulseOutcomeType(dbO dbgen.EnetpulseOutcomeType) domain.EnetpulseOutcomeType {
|
|
return domain.EnetpulseOutcomeType{
|
|
ID: dbO.ID,
|
|
OutcomeTypeID: dbO.OutcomeTypeID,
|
|
Name: dbO.Name,
|
|
Description: dbO.Description.String,
|
|
UpdatesCount: dbO.UpdatesCount.Int32,
|
|
LastUpdatedAt: dbO.LastUpdatedAt.Time,
|
|
CreatedAt: dbO.CreatedAt.Time,
|
|
UpdatedAt: dbO.UpdatedAt.Time,
|
|
}
|
|
}
|
|
|
|
func ConvertCreateEnetpulsePreodds(p domain.CreateEnetpulsePreodds) (dbgen.CreateEnetpulsePreoddsParams, error) {
|
|
eventFK, err := strconv.ParseInt(p.EventFK, 10, 64)
|
|
if err != nil {
|
|
return dbgen.CreateEnetpulsePreoddsParams{}, fmt.Errorf("invalid EventFK: %w", err)
|
|
}
|
|
|
|
outcomeTypeFK, err := strconv.ParseInt(p.OutcomeTypeFK, 10, 32)
|
|
if err != nil {
|
|
return dbgen.CreateEnetpulsePreoddsParams{}, fmt.Errorf("invalid OutcomeTypeFK: %w", err)
|
|
}
|
|
|
|
outcomeScopeFK, err := strconv.ParseInt(p.OutcomeScopeFK, 10, 32)
|
|
if err != nil {
|
|
return dbgen.CreateEnetpulsePreoddsParams{}, fmt.Errorf("invalid OutcomeScopeFK: %w", err)
|
|
}
|
|
|
|
outcomeSubtypeFK, err := strconv.ParseInt(p.OutcomeSubtypeFK, 10, 32)
|
|
if err != nil {
|
|
return dbgen.CreateEnetpulsePreoddsParams{}, fmt.Errorf("invalid OutcomeSubtypeFK: %w", err)
|
|
}
|
|
|
|
return dbgen.CreateEnetpulsePreoddsParams{
|
|
PreoddsID: p.PreoddsID,
|
|
EventFk: eventFK,
|
|
OutcomeTypeFk: pgtype.Int4{Int32: int32(outcomeTypeFK), Valid: true},
|
|
OutcomeScopeFk: pgtype.Int4{Int32: int32(outcomeScopeFK), Valid: true},
|
|
OutcomeSubtypeFk: pgtype.Int4{Int32: int32(outcomeSubtypeFK), Valid: true},
|
|
EventParticipantNumber: pgtype.Int4{Int32: int32(p.EventParticipantNumber), Valid: true},
|
|
Iparam: pgtype.Text{String: p.IParam, Valid: p.IParam != ""},
|
|
Iparam2: pgtype.Text{String: p.IParam2, Valid: p.IParam2 != ""},
|
|
Dparam: pgtype.Text{String: p.DParam, Valid: p.DParam != ""},
|
|
Dparam2: pgtype.Text{String: p.DParam2, Valid: p.DParam2 != ""},
|
|
Sparam: pgtype.Text{String: p.SParam, Valid: p.SParam != ""},
|
|
UpdatesCount: pgtype.Int4{Int32: int32(p.UpdatesCount), Valid: true},
|
|
LastUpdatedAt: pgtype.Timestamptz{Time: p.LastUpdatedAt, Valid: !p.LastUpdatedAt.IsZero()},
|
|
}, nil
|
|
}
|
|
|
|
func ConvertDBEnetpulsePreodds(dbP dbgen.EnetpulsePreodd) domain.EnetpulsePreodds {
|
|
return domain.EnetpulsePreodds{
|
|
PreoddsID: dbP.PreoddsID,
|
|
EventFK: dbP.EventFk,
|
|
OutcomeTypeFK: dbP.OutcomeTypeFk.Int32,
|
|
OutcomeScopeFK: dbP.OutcomeScopeFk.Int32,
|
|
OutcomeSubtypeFK: dbP.OutcomeSubtypeFk.Int32,
|
|
EventParticipantNumber: dbP.EventParticipantNumber.Int32,
|
|
IParam: dbP.Iparam.String,
|
|
IParam2: dbP.Iparam2.String,
|
|
DParam: dbP.Dparam.String,
|
|
DParam2: dbP.Dparam2.String,
|
|
SParam: dbP.Sparam.String,
|
|
UpdatesCount: dbP.UpdatesCount.Int32,
|
|
LastUpdatedAt: dbP.LastUpdatedAt.Time,
|
|
CreatedAt: dbP.CreatedAt.Time,
|
|
UpdatedAt: dbP.UpdatedAt.Time,
|
|
}
|
|
}
|
|
|
|
func ConvertCreateEnetpulsePreoddsBettingOffer(o domain.CreateEnetpulsePreoddsBettingOffer) dbgen.CreateEnetpulsePreoddsBettingOfferParams {
|
|
// Convert float64 to int64 with scale 2
|
|
oddsInt := big.NewInt(int64(math.Round(o.Odds * 100)))
|
|
oddsOldInt := big.NewInt(int64(math.Round(o.OddsOld * 100)))
|
|
|
|
return dbgen.CreateEnetpulsePreoddsBettingOfferParams{
|
|
BettingofferID: o.BettingOfferID,
|
|
PreoddsFk: o.PreoddsFK,
|
|
BettingofferStatusFk: pgtype.Int4{Int32: o.BettingOfferStatusFK, Valid: true},
|
|
OddsProviderFk: pgtype.Int4{Int32: o.OddsProviderFK, Valid: true},
|
|
Odds: pgtype.Numeric{
|
|
Int: oddsInt,
|
|
Exp: -2, // scale 2 decimal places
|
|
Valid: true,
|
|
},
|
|
OddsOld: pgtype.Numeric{
|
|
Int: oddsOldInt,
|
|
Exp: -2,
|
|
Valid: true,
|
|
},
|
|
Active: pgtype.Bool{Bool: o.Active == "yes", Valid: true},
|
|
CouponKey: pgtype.Text{
|
|
String: o.CouponKey,
|
|
Valid: o.CouponKey != "",
|
|
},
|
|
UpdatesCount: pgtype.Int4{Int32: int32(o.UpdatesCount), Valid: true},
|
|
LastUpdatedAt: pgtype.Timestamptz{Time: o.LastUpdatedAt, Valid: !o.LastUpdatedAt.IsZero()},
|
|
}
|
|
}
|
|
|
|
// Convert DB result to domain struct
|
|
func ConvertDBEnetpulsePreoddsBettingOffer(o dbgen.EnetpulsePreoddsBettingoffer) domain.EnetpulsePreoddsBettingOffer {
|
|
var odds, oddsOld float64
|
|
if o.Odds.Valid {
|
|
odds, _ = o.Odds.Int.Float64() // Convert pgtype.Numeric to float64
|
|
}
|
|
if o.OddsOld.Valid {
|
|
oddsOld, _ = o.OddsOld.Int.Float64()
|
|
}
|
|
|
|
active := "no"
|
|
if o.Active.Valid && o.Active.Bool {
|
|
active = "yes"
|
|
}
|
|
|
|
return domain.EnetpulsePreoddsBettingOffer{
|
|
ID: o.ID,
|
|
BettingOfferID: o.BettingofferID,
|
|
PreoddsFK: o.PreoddsFk,
|
|
BettingOfferStatusFK: o.BettingofferStatusFk.Int32,
|
|
OddsProviderFK: o.OddsProviderFk.Int32,
|
|
Odds: odds,
|
|
OddsOld: oddsOld,
|
|
Active: active,
|
|
CouponKey: o.CouponKey.String,
|
|
UpdatesCount: int(o.UpdatesCount.Int32),
|
|
LastUpdatedAt: o.LastUpdatedAt.Time,
|
|
CreatedAt: o.CreatedAt.Time,
|
|
UpdatedAt: o.UpdatedAt.Time,
|
|
}
|
|
}
|
|
|
|
func (s *Store) CreateEnetpulseResultParticipant(
|
|
ctx context.Context,
|
|
participant domain.CreateEnetpulseResultParticipant,
|
|
) (domain.EnetpulseResultParticipant, error) {
|
|
dbParticipant, err := s.queries.CreateEnetpulseResultParticipant(
|
|
ctx,
|
|
ConvertCreateEnetpulseResultParticipant(participant),
|
|
)
|
|
if err != nil {
|
|
return domain.EnetpulseResultParticipant{}, err
|
|
}
|
|
|
|
return ConvertDBEnetpulseResultParticipant(dbParticipant), nil
|
|
}
|
|
|
|
func (s *Store) GetEnetpulseResultParticipantsByResultFK(
|
|
ctx context.Context,
|
|
resultFK string,
|
|
) ([]domain.EnetpulseResultParticipant, error) {
|
|
dbParticipants, err := s.queries.GetEnetpulseResultParticipantsByResultFK(ctx, resultFK)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
participants := make([]domain.EnetpulseResultParticipant, 0, len(dbParticipants))
|
|
for _, dbp := range dbParticipants {
|
|
participants = append(participants, ConvertDBEnetpulseResultParticipant(dbp))
|
|
}
|
|
|
|
return participants, nil
|
|
}
|
|
|
|
func (s *Store) CreateEnetpulseResultReferee(
|
|
ctx context.Context,
|
|
referee domain.CreateEnetpulseResultReferee,
|
|
) (domain.EnetpulseResultReferee, error) {
|
|
dbReferee, err := s.queries.CreateEnetpulseResultReferee(
|
|
ctx,
|
|
ConvertCreateEnetpulseResultReferee(referee),
|
|
)
|
|
if err != nil {
|
|
return domain.EnetpulseResultReferee{}, err
|
|
}
|
|
|
|
return ConvertDBEnetpulseResultReferee(dbReferee), nil
|
|
}
|
|
|
|
func (s *Store) GetEnetpulseResultRefereesByResultFK(
|
|
ctx context.Context,
|
|
resultFK string,
|
|
) ([]domain.EnetpulseResultReferee, error) {
|
|
dbReferees, err := s.queries.GetEnetpulseResultRefereesByResultFK(ctx, resultFK)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
referees := make([]domain.EnetpulseResultReferee, 0, len(dbReferees))
|
|
for _, dbr := range dbReferees {
|
|
referees = append(referees, ConvertDBEnetpulseResultReferee(dbr))
|
|
}
|
|
|
|
return referees, nil
|
|
}
|
|
|
|
func ConvertCreateEnetpulseResultParticipant(p domain.CreateEnetpulseResultParticipant) dbgen.CreateEnetpulseResultParticipantParams {
|
|
return dbgen.CreateEnetpulseResultParticipantParams{
|
|
ParticipantMapID: p.ParticipantMapID,
|
|
ResultFk: p.ResultFk,
|
|
ParticipantFk: p.ParticipantFk,
|
|
Number: pgtype.Int4{Int32: p.Number},
|
|
Name: pgtype.Text{String: p.Name},
|
|
Gender: pgtype.Text{String: p.Gender},
|
|
Type: pgtype.Text{String: p.Type},
|
|
CountryFk: pgtype.Text{String: p.CountryFk},
|
|
CountryName: pgtype.Text{String: p.CountryName},
|
|
OrdinaryTime: pgtype.Text{String: p.OrdinaryTime},
|
|
RunningScore: pgtype.Text{String: p.RunningScore},
|
|
Halftime: pgtype.Text{String: p.Halftime},
|
|
FinalResult: pgtype.Text{String: p.FinalResult},
|
|
LastUpdatedAt: pgtype.Timestamptz{Time: p.LastUpdatedAt, Valid: !p.LastUpdatedAt.IsZero()},
|
|
}
|
|
}
|
|
|
|
func ConvertDBEnetpulseResultParticipant(p dbgen.EnetpulseResultParticipant) domain.EnetpulseResultParticipant {
|
|
return domain.EnetpulseResultParticipant{
|
|
ID: p.ID,
|
|
ParticipantMapID: p.ParticipantMapID,
|
|
ResultFk: p.ResultFk,
|
|
ParticipantFk: p.ParticipantFk,
|
|
Number: p.Number.Int32,
|
|
Name: p.Name.String,
|
|
Gender: p.Gender.String,
|
|
Type: p.Type.String,
|
|
CountryFk: p.CountryFk.String,
|
|
CountryName: p.CountryName.String,
|
|
OrdinaryTime: p.OrdinaryTime.String,
|
|
RunningScore: p.RunningScore.String,
|
|
Halftime: p.Halftime.String,
|
|
FinalResult: p.FinalResult.String,
|
|
LastUpdatedAt: p.LastUpdatedAt.Time,
|
|
CreatedAt: p.CreatedAt.Time,
|
|
}
|
|
}
|
|
|
|
func ConvertCreateEnetpulseResultReferee(r domain.CreateEnetpulseResultReferee) dbgen.CreateEnetpulseResultRefereeParams {
|
|
return dbgen.CreateEnetpulseResultRefereeParams{
|
|
ResultFk: r.ResultFk,
|
|
RefereeFk: pgtype.Text{String: r.RefereeFk},
|
|
Assistant1RefereeFk: pgtype.Text{String: r.Assistant1RefereeFk},
|
|
Assistant2RefereeFk: pgtype.Text{String: r.Assistant2RefereeFk},
|
|
FourthRefereeFk: pgtype.Text{String: r.FourthRefereeFk},
|
|
Var1RefereeFk: pgtype.Text{String: r.Var1RefereeFk},
|
|
Var2RefereeFk: pgtype.Text{String: r.Var2RefereeFk},
|
|
LastUpdatedAt: pgtype.Timestamptz{Time: r.LastUpdatedAt},
|
|
}
|
|
}
|
|
|
|
func ConvertDBEnetpulseResultReferee(r dbgen.EnetpulseResultReferee) domain.EnetpulseResultReferee {
|
|
return domain.EnetpulseResultReferee{
|
|
ID: r.ID,
|
|
ResultFk: r.ResultFk,
|
|
RefereeFk: r.RefereeFk.String,
|
|
Assistant1RefereeFk: r.Assistant1RefereeFk.String,
|
|
Assistant2RefereeFk: r.Assistant2RefereeFk.String,
|
|
FourthRefereeFk: r.FourthRefereeFk.String,
|
|
Var1RefereeFk: r.Var1RefereeFk.String,
|
|
Var2RefereeFk: r.Var2RefereeFk.String,
|
|
LastUpdatedAt: r.LastUpdatedAt.Time,
|
|
CreatedAt: r.CreatedAt.Time ,
|
|
}
|
|
}
|