package adapter import ( "context" "database/sql" "errors" "fmt" "time" "gitea.dwysokinski.me/twhelp/corev3/internal/adapter/internal/bunmodel" "gitea.dwysokinski.me/twhelp/corev3/internal/domain" "github.com/uptrace/bun" "github.com/uptrace/bun/dialect" ) type PlayerBunRepository struct { db bun.IDB } func NewPlayerBunRepository(db bun.IDB) *PlayerBunRepository { return &PlayerBunRepository{db: db} } func (repo *PlayerBunRepository) CreateOrUpdate(ctx context.Context, params ...domain.CreatePlayerParams) error { if len(params) == 0 { return nil } now := time.Now() players := make(bunmodel.Players, 0, len(params)) for _, p := range params { base := p.Base() players = append(players, bunmodel.Player{ ID: base.ID(), ServerKey: p.ServerKey(), Name: base.Name(), NumVillages: base.NumVillages(), Points: base.Points(), Rank: base.Rank(), TribeID: base.TribeID(), ProfileURL: base.ProfileURL().String(), BestRank: p.BestRank(), BestRankAt: p.BestRankAt(), MostPoints: p.MostPoints(), MostPointsAt: p.MostPointsAt(), MostVillages: p.MostVillages(), MostVillagesAt: p.MostVillagesAt(), LastActivityAt: p.LastActivityAt(), CreatedAt: now, OpponentsDefeated: bunmodel.NewOpponentsDefeated(base.OD()), }) } q := repo.db.NewInsert(). Model(&players) //nolint:exhaustive switch q.Dialect().Name() { case dialect.PG: q = q.On("CONFLICT ON CONSTRAINT players_pkey DO UPDATE") case dialect.SQLite: q = q.On("CONFLICT(id, server_key) DO UPDATE") default: q = q.Err(errors.New("unsupported dialect")) } if _, err := q. Set("name = EXCLUDED.name"). Set("num_villages = EXCLUDED.num_villages"). Set("points = EXCLUDED.points"). Set("rank = EXCLUDED.rank"). Set("tribe_id = EXCLUDED.tribe_id"). Set("profile_url = EXCLUDED.profile_url"). Set("best_rank = EXCLUDED.best_rank"). Set("best_rank_at = EXCLUDED.best_rank_at"). Set("most_villages = EXCLUDED.most_villages"). Set("most_villages_at = EXCLUDED.most_villages_at"). Set("most_points = EXCLUDED.most_points"). Set("most_points_at = EXCLUDED.most_points_at"). Set("last_activity_at = EXCLUDED.last_activity_at"). Set("deleted_at = EXCLUDED.deleted_at"). Apply(appendODSetClauses). Returning(""). Exec(ctx); err != nil { return fmt.Errorf("something went wrong while inserting players into the db: %w", err) } return nil } func (repo *PlayerBunRepository) List(ctx context.Context, params domain.ListPlayersParams) (domain.Players, error) { var players bunmodel.Players if err := repo.db.NewSelect(). Model(&players). Apply(listPlayersParamsApplier{params: params}.apply). Scan(ctx); err != nil && !errors.Is(err, sql.ErrNoRows) { return nil, fmt.Errorf("couldn't select players from the db: %w", err) } return players.ToDomain() } func (repo *PlayerBunRepository) Delete(ctx context.Context, serverKey string, ids ...int) error { if len(ids) == 0 { return nil } if _, err := repo.db.NewUpdate(). Model((*bunmodel.Player)(nil)). Where("deleted_at IS NULL"). Where("id IN (?)", bun.In(ids)). Where("server_key = ?", serverKey). Set("deleted_at = ?", time.Now()). Set("tribe_id = NULL"). Returning(""). Exec(ctx); err != nil { return fmt.Errorf("couldn't delete players: %w", err) } return nil } type listPlayersParamsApplier struct { params domain.ListPlayersParams } //nolint:gocyclo func (a listPlayersParamsApplier) apply(q *bun.SelectQuery) *bun.SelectQuery { if ids := a.params.IDs(); len(ids) > 0 { q = q.Where("player.id IN (?)", bun.In(ids)) } if idGT := a.params.IDGT(); idGT.Valid { q = q.Where("player.id > ?", idGT.Value) } if serverKeys := a.params.ServerKeys(); len(serverKeys) > 0 { q = q.Where("player.server_key IN (?)", bun.In(serverKeys)) } if deleted := a.params.Deleted(); deleted.Valid { if deleted.Value { q = q.Where("player.deleted_at IS NOT NULL") } else { q = q.Where("player.deleted_at IS NULL") } } for _, s := range a.params.Sort() { switch s { case domain.PlayerSortIDASC: q = q.Order("player.id ASC") case domain.PlayerSortIDDESC: q = q.Order("player.id DESC") case domain.PlayerSortServerKeyASC: q = q.Order("player.server_key ASC") case domain.PlayerSortServerKeyDESC: q = q.Order("player.server_key DESC") default: return q.Err(errors.New("unsupported sort value")) } } return q.Limit(a.params.Limit()).Offset(a.params.Offset()) }