lemintare
c3624376b0
This commit introduces the `DISCORD_GUILD_ID` environment variable to the configuration files, allowing for better integration with Discord for role synchronization. The event announcement functionality has been updated to include an option for the `@everyone` mention, which can be toggled during event creation. The backend logic has been modified to handle this new option, and corresponding updates have been made to the frontend to allow users to control the mention behavior. Additionally, tests have been added to ensure the correct functionality of these features.
445 lines
16 KiB
Go
445 lines
16 KiB
Go
package application
|
|
|
|
import (
|
|
"context"
|
|
"crypto/rand"
|
|
"encoding/hex"
|
|
"fmt"
|
|
"strings"
|
|
"time"
|
|
|
|
"mixmaker/backend/internal/domain"
|
|
)
|
|
|
|
type Store interface {
|
|
Ready(context.Context) error
|
|
UpsertDiscordAccount(context.Context, domain.Account, bool) (domain.Account, domain.Player, error)
|
|
AccountBySession(context.Context, string) (domain.Account, domain.Player, error)
|
|
ListAccounts(context.Context) ([]domain.Account, error)
|
|
UpdateAccountRole(context.Context, string, domain.GlobalRole) (domain.Account, error)
|
|
CreateSession(context.Context, string, string, time.Time) error
|
|
DeleteSession(context.Context, string) error
|
|
UpdatePlayer(context.Context, domain.Player) (domain.Player, error)
|
|
ListPlayers(context.Context) ([]domain.Player, error)
|
|
EnqueueDiscordRoleSync(context.Context, string, string, int64) error
|
|
CreateParticipant(context.Context, domain.Player, domain.RSVP) (domain.Player, domain.RSVP, error)
|
|
CreateEvent(context.Context, domain.Event) (domain.Event, error)
|
|
GetEvent(context.Context, string) (domain.Event, error)
|
|
UpdateEvent(context.Context, domain.Event) (domain.Event, error)
|
|
ListEvents(context.Context, time.Time) ([]domain.Event, error)
|
|
SaveEventWorkflow(context.Context, domain.Event, int) (domain.Event, error)
|
|
SaveRoster(context.Context, domain.RosterDraft, int) (domain.RosterDraft, error)
|
|
GetRoster(context.Context, string) (domain.RosterDraft, error)
|
|
ResetRoster(context.Context, string) error
|
|
SaveBracketDraft(context.Context, domain.BracketDraft, int) (domain.BracketDraft, error)
|
|
GetBracketDraft(context.Context, string) (domain.BracketDraft, error)
|
|
DeleteBracketDraft(context.Context, string) error
|
|
StartScrim(context.Context, domain.Event, int, []domain.Series, *domain.Tournament) error
|
|
DeleteEvent(context.Context, string) error
|
|
UpsertRSVP(context.Context, domain.RSVP) (domain.RSVP, error)
|
|
ListRSVPs(context.Context, string) ([]domain.RSVP, error)
|
|
DeleteRSVP(context.Context, string, string) error
|
|
SaveTeams(context.Context, string, []domain.Team) error
|
|
ListTeams(context.Context, string) ([]domain.Team, error)
|
|
GetTeam(context.Context, string) (domain.Team, error)
|
|
RenameTeam(context.Context, string, string) (domain.Team, error)
|
|
AssignCaptain(context.Context, string, string) (domain.Team, error)
|
|
SaveRuleset(context.Context, domain.Ruleset) (domain.Ruleset, error)
|
|
ListRulesets(context.Context) ([]domain.Ruleset, error)
|
|
GetRuleset(context.Context, string) (domain.Ruleset, error)
|
|
SaveSeries(context.Context, domain.Series) (domain.Series, error)
|
|
GetSeries(context.Context, string) (domain.Series, error)
|
|
SaveTournament(context.Context, domain.Tournament) (domain.Tournament, error)
|
|
GetTournament(context.Context, string) (domain.Tournament, error)
|
|
GetTournamentByEvent(context.Context, string) (domain.Tournament, error)
|
|
SaveDraft(context.Context, string, string, any, int) error
|
|
GetDraft(context.Context, string, any) (string, int, error)
|
|
AppendAudit(context.Context, string, string, string, any) error
|
|
}
|
|
|
|
type Publisher interface{ Publish(topic string, value any) }
|
|
|
|
type EventAnnouncer interface {
|
|
AnnounceEventCreated(context.Context, domain.Event, bool) error
|
|
}
|
|
|
|
type CreateEventOptions struct {
|
|
PingEveryone bool
|
|
}
|
|
|
|
func (s *Service) enqueueDiscordRoleSync(ctx context.Context, eventID, action string) {
|
|
_ = s.Store.EnqueueDiscordRoleSync(ctx, eventID, action, s.Now().UnixNano())
|
|
}
|
|
|
|
type Service struct {
|
|
Store Store
|
|
Bus Publisher
|
|
EventAnnouncer EventAnnouncer
|
|
AnnouncementTimeout time.Duration
|
|
Now func() time.Time
|
|
}
|
|
|
|
func New(store Store, bus Publisher, eventAnnouncer EventAnnouncer) *Service {
|
|
return &Service{
|
|
Store: store,
|
|
Bus: bus,
|
|
EventAnnouncer: eventAnnouncer,
|
|
AnnouncementTimeout: 3 * time.Second,
|
|
Now: func() time.Time { return time.Now().UTC() },
|
|
}
|
|
}
|
|
|
|
func NewID() string {
|
|
b := make([]byte, 16)
|
|
_, _ = rand.Read(b)
|
|
return hex.EncodeToString(b)
|
|
}
|
|
|
|
func (s *Service) Authenticate(ctx context.Context, session string) (domain.Account, domain.Player, error) {
|
|
if session == "" {
|
|
return domain.Account{}, domain.Player{}, domain.ErrUnauthorized
|
|
}
|
|
return s.Store.AccountBySession(ctx, session)
|
|
}
|
|
|
|
func (s *Service) ListAccounts(ctx context.Context, actor domain.Account) ([]domain.Account, error) {
|
|
if !actor.IsAdmin() {
|
|
return nil, domain.ErrForbidden
|
|
}
|
|
return s.Store.ListAccounts(ctx)
|
|
}
|
|
|
|
func (s *Service) SetModerator(ctx context.Context, actor domain.Account, accountID string, moderator bool) (domain.Account, error) {
|
|
if !actor.IsAdmin() {
|
|
return domain.Account{}, domain.ErrForbidden
|
|
}
|
|
role := domain.RolePlayer
|
|
if moderator {
|
|
role = domain.RoleModerator
|
|
}
|
|
account, err := s.Store.UpdateAccountRole(ctx, accountID, role)
|
|
if err == nil {
|
|
_ = s.Store.AppendAudit(ctx, actor.ID, "account.role_changed", accountID, map[string]domain.GlobalRole{"role": role})
|
|
s.Bus.Publish("accounts", account)
|
|
}
|
|
return account, err
|
|
}
|
|
|
|
func (s *Service) UpdateOwnProfile(ctx context.Context, actor domain.Account, current domain.Player, displayName string, ratings domain.Ratings, preferredRoles []domain.Role, preferredPlayerIDs, avoidedPlayerIDs []string) (domain.Player, error) {
|
|
if actor.ID != current.AccountID {
|
|
return domain.Player{}, domain.ErrForbidden
|
|
}
|
|
if err := ratings.Validate(); err != nil {
|
|
return domain.Player{}, err
|
|
}
|
|
if displayName != "" {
|
|
current.DisplayName = displayName
|
|
}
|
|
current.Ratings = ratings
|
|
current.PreferredRoles = preferredRoles
|
|
current.PreferredPlayerIDs = preferredPlayerIDs
|
|
current.AvoidedPlayerIDs = avoidedPlayerIDs
|
|
current.UpdatedAt = s.Now()
|
|
if err := current.ValidatePreferences(); err != nil {
|
|
return domain.Player{}, err
|
|
}
|
|
players, err := s.Store.ListPlayers(ctx)
|
|
if err != nil {
|
|
return domain.Player{}, err
|
|
}
|
|
knownPlayers := make(map[string]bool, len(players))
|
|
for _, player := range players {
|
|
knownPlayers[player.ID] = true
|
|
}
|
|
for _, playerID := range current.PreferredPlayerIDs {
|
|
if !knownPlayers[playerID] {
|
|
return domain.Player{}, fmt.Errorf("%w: preferred teammate does not exist", domain.ErrInvalid)
|
|
}
|
|
}
|
|
for _, playerID := range current.AvoidedPlayerIDs {
|
|
if !knownPlayers[playerID] {
|
|
return domain.Player{}, fmt.Errorf("%w: avoided teammate does not exist", domain.ErrInvalid)
|
|
}
|
|
}
|
|
out, err := s.Store.UpdatePlayer(ctx, current)
|
|
if err == nil {
|
|
s.Bus.Publish("players", out)
|
|
}
|
|
return out, err
|
|
}
|
|
|
|
func (s *Service) CreateEvent(ctx context.Context, actor domain.Account, event domain.Event, options CreateEventOptions) (domain.Event, error) {
|
|
if !actor.IsStaff() {
|
|
return domain.Event{}, domain.ErrForbidden
|
|
}
|
|
event.RegistrationDeadline = event.StartsAt
|
|
event.ID, event.CreatedBy, event.CreatedAt, event.UpdatedAt = NewID(), actor.ID, s.Now(), s.Now()
|
|
event.State, event.Version = domain.RegistrationOpen, 0
|
|
if event.RulesetID == "" {
|
|
event.RulesetID = "standard-control-hybrid-control"
|
|
}
|
|
if err := event.Validate(); err != nil {
|
|
return domain.Event{}, err
|
|
}
|
|
out, err := s.Store.CreateEvent(ctx, event)
|
|
if err == nil {
|
|
s.Bus.Publish("events", out)
|
|
if s.EventAnnouncer != nil {
|
|
announcementCtx, cancel := context.WithTimeout(ctx, s.AnnouncementTimeout)
|
|
_ = s.EventAnnouncer.AnnounceEventCreated(announcementCtx, out, options.PingEveryone)
|
|
cancel()
|
|
}
|
|
}
|
|
return out, err
|
|
}
|
|
|
|
func (s *Service) UpdateEvent(ctx context.Context, actor domain.Account, eventID string, changes domain.Event) (domain.Event, error) {
|
|
if !actor.IsStaff() {
|
|
return domain.Event{}, domain.ErrForbidden
|
|
}
|
|
current, err := s.Store.GetEvent(ctx, eventID)
|
|
if err != nil {
|
|
return domain.Event{}, err
|
|
}
|
|
changes.RegistrationDeadline = changes.StartsAt
|
|
current.Name = changes.Name
|
|
current.Description = changes.Description
|
|
current.StartsAt = changes.StartsAt
|
|
current.EndsAt = changes.EndsAt
|
|
current.RegistrationDeadline = changes.RegistrationDeadline
|
|
current.UpdatedAt = s.Now()
|
|
if err := current.Validate(); err != nil {
|
|
return domain.Event{}, err
|
|
}
|
|
out, err := s.Store.UpdateEvent(ctx, current)
|
|
if err == nil {
|
|
_ = s.Store.AppendAudit(ctx, actor.ID, "event.updated", eventID, out)
|
|
s.Bus.Publish("events", out)
|
|
}
|
|
return out, err
|
|
}
|
|
|
|
func (s *Service) SetRSVP(ctx context.Context, actor domain.Account, actorPlayer domain.Player, eventID, playerID string, status domain.RSVPStatus) (domain.RSVP, error) {
|
|
source := domain.SourcePlayer
|
|
if playerID == "" {
|
|
playerID = actorPlayer.ID
|
|
}
|
|
if playerID != actorPlayer.ID {
|
|
if !actor.IsStaff() {
|
|
return domain.RSVP{}, domain.ErrForbidden
|
|
}
|
|
source = domain.SourceAdmin
|
|
}
|
|
event, err := s.Store.GetEvent(ctx, eventID)
|
|
if err != nil {
|
|
return domain.RSVP{}, err
|
|
}
|
|
if event.State != domain.RegistrationOpen {
|
|
return domain.RSVP{}, fmt.Errorf("%w: registration is closed", domain.ErrConflict)
|
|
}
|
|
if !actor.IsStaff() && s.Now().After(event.RegistrationDeadline) {
|
|
return domain.RSVP{}, fmt.Errorf("%w: registration deadline has passed", domain.ErrConflict)
|
|
}
|
|
rsvp := domain.RSVP{EventID: eventID, PlayerID: playerID, ActorAccountID: actor.ID, Status: status, Source: source, UpdatedAt: s.Now()}
|
|
if err := rsvp.Validate(); err != nil {
|
|
return domain.RSVP{}, err
|
|
}
|
|
out, err := s.Store.UpsertRSVP(ctx, rsvp)
|
|
if err == nil {
|
|
_ = s.Store.AppendAudit(ctx, actor.ID, "rsvp.set", eventID, out)
|
|
s.Bus.Publish("event:"+eventID, out)
|
|
}
|
|
return out, err
|
|
}
|
|
|
|
func (s *Service) RemoveParticipant(ctx context.Context, actor domain.Account, eventID, playerID string) error {
|
|
if !actor.IsStaff() {
|
|
return domain.ErrForbidden
|
|
}
|
|
event, err := s.Store.GetEvent(ctx, eventID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if event.State != domain.RegistrationOpen {
|
|
return fmt.Errorf("%w: registration is closed", domain.ErrConflict)
|
|
}
|
|
if err := s.Store.DeleteRSVP(ctx, eventID, playerID); err != nil {
|
|
return err
|
|
}
|
|
_ = s.Store.AppendAudit(ctx, actor.ID, "participant.removed", eventID, map[string]string{"playerId": playerID})
|
|
s.Bus.Publish("event:"+eventID, map[string]string{"removedPlayerId": playerID})
|
|
return nil
|
|
}
|
|
|
|
func (s *Service) CreateParticipant(ctx context.Context, actor domain.Account, eventID, displayName string, ratings domain.Ratings, status domain.RSVPStatus) (domain.Player, domain.RSVP, error) {
|
|
if !actor.IsStaff() {
|
|
return domain.Player{}, domain.RSVP{}, domain.ErrForbidden
|
|
}
|
|
displayName = strings.TrimSpace(displayName)
|
|
if displayName == "" {
|
|
return domain.Player{}, domain.RSVP{}, fmt.Errorf("%w: display name is required", domain.ErrInvalid)
|
|
}
|
|
if err := ratings.Validate(); err != nil {
|
|
return domain.Player{}, domain.RSVP{}, err
|
|
}
|
|
event, err := s.Store.GetEvent(ctx, eventID)
|
|
if err != nil {
|
|
return domain.Player{}, domain.RSVP{}, err
|
|
}
|
|
if event.State != domain.RegistrationOpen {
|
|
return domain.Player{}, domain.RSVP{}, fmt.Errorf("%w: registration is closed", domain.ErrConflict)
|
|
}
|
|
now := s.Now()
|
|
player := domain.Player{
|
|
ID: NewID(),
|
|
DisplayName: displayName,
|
|
Ratings: ratings,
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
}
|
|
rsvp := domain.RSVP{
|
|
EventID: eventID,
|
|
PlayerID: player.ID,
|
|
ActorAccountID: actor.ID,
|
|
Status: status,
|
|
Source: domain.SourceAdmin,
|
|
UpdatedAt: now,
|
|
}
|
|
if err := rsvp.Validate(); err != nil {
|
|
return domain.Player{}, domain.RSVP{}, err
|
|
}
|
|
player, rsvp, err = s.Store.CreateParticipant(ctx, player, rsvp)
|
|
if err == nil {
|
|
_ = s.Store.AppendAudit(ctx, actor.ID, "participant.created", eventID, map[string]any{"player": player, "rsvp": rsvp})
|
|
s.Bus.Publish("event:"+eventID, rsvp)
|
|
s.Bus.Publish("players", player)
|
|
}
|
|
return player, rsvp, err
|
|
}
|
|
|
|
func (s *Service) Balance(ctx context.Context, actor domain.Account, eventID string) ([]domain.BalanceCandidate, error) {
|
|
if !actor.IsStaff() {
|
|
return nil, domain.ErrForbidden
|
|
}
|
|
rsvps, err := s.Store.ListRSVPs(ctx, eventID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
players, err := s.Store.ListPlayers(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
going := map[string]bool{}
|
|
for _, r := range rsvps {
|
|
going[r.PlayerID] = r.Status == domain.Going
|
|
}
|
|
eligible := players[:0]
|
|
for _, p := range players {
|
|
if going[p.ID] {
|
|
eligible = append(eligible, p)
|
|
}
|
|
}
|
|
return domain.Balance(eventID, eligible)
|
|
}
|
|
|
|
func (s *Service) SelectBalance(ctx context.Context, actor domain.Account, eventID string, candidate domain.BalanceCandidate) error {
|
|
if !actor.IsStaff() {
|
|
return domain.ErrForbidden
|
|
}
|
|
if err := s.Store.SaveTeams(ctx, eventID, candidate.Teams); err != nil {
|
|
return err
|
|
}
|
|
_ = s.Store.AppendAudit(ctx, actor.ID, "balance.selected", eventID, candidate)
|
|
s.Bus.Publish("event:"+eventID, candidate.Teams)
|
|
return nil
|
|
}
|
|
|
|
func (s *Service) AssignCaptain(ctx context.Context, actor domain.Account, teamID, playerID string) (domain.Team, error) {
|
|
if !actor.IsStaff() {
|
|
return domain.Team{}, domain.ErrForbidden
|
|
}
|
|
team, err := s.Store.AssignCaptain(ctx, teamID, playerID)
|
|
if err == nil {
|
|
_ = s.Store.AppendAudit(ctx, actor.ID, "captain.assigned", teamID, map[string]string{"playerId": playerID})
|
|
s.Bus.Publish("team:"+teamID, team)
|
|
}
|
|
return team, err
|
|
}
|
|
|
|
func (s *Service) RenameTeam(ctx context.Context, actor domain.Account, player domain.Player, teamID, name string) (domain.Team, error) {
|
|
team, err := s.Store.GetTeam(ctx, teamID)
|
|
if err != nil {
|
|
return team, err
|
|
}
|
|
event, err := s.Store.GetEvent(ctx, team.EventID)
|
|
if err != nil {
|
|
return team, err
|
|
}
|
|
if event.State != domain.Live {
|
|
return team, fmt.Errorf("%w: team names can only be changed during a live scrim", domain.ErrConflict)
|
|
}
|
|
if !CanActForTeam(actor, player, team) {
|
|
return team, domain.ErrForbidden
|
|
}
|
|
name = strings.TrimSpace(name)
|
|
if len([]rune(name)) < 2 || len([]rune(name)) > 32 {
|
|
return team, fmt.Errorf("%w: team name must contain 2 to 32 characters", domain.ErrInvalid)
|
|
}
|
|
team, err = s.Store.RenameTeam(ctx, teamID, name)
|
|
if err == nil {
|
|
_ = s.Store.AppendAudit(ctx, actor.ID, "team.renamed", teamID, map[string]string{"name": name})
|
|
s.Bus.Publish("team:"+teamID, team)
|
|
s.Bus.Publish("event:"+team.EventID, team)
|
|
s.enqueueDiscordRoleSync(ctx, team.EventID, DiscordRoleActionReconcile)
|
|
}
|
|
return team, err
|
|
}
|
|
|
|
func CanActForTeam(actor domain.Account, player domain.Player, team domain.Team) bool {
|
|
return actor.IsStaff() || (team.CaptainPlayerID != "" && team.CaptainPlayerID == player.ID)
|
|
}
|
|
|
|
func (s *Service) RecordMap(ctx context.Context, actor domain.Account, seriesID, mapName string, outcome domain.MapOutcome, expectedVersion int) (domain.Series, error) {
|
|
if !actor.IsStaff() {
|
|
return domain.Series{}, domain.ErrForbidden
|
|
}
|
|
series, err := s.Store.GetSeries(ctx, seriesID)
|
|
if err != nil {
|
|
return domain.Series{}, err
|
|
}
|
|
if series.Version != expectedVersion {
|
|
return domain.Series{}, fmt.Errorf("%w: stale series version", domain.ErrConflict)
|
|
}
|
|
if err := series.RecordResult(domain.MapResult{MapName: mapName, Outcome: outcome, ActorAccountID: actor.ID, RecordedAt: s.Now()}); err != nil {
|
|
return domain.Series{}, err
|
|
}
|
|
out, err := s.Store.SaveSeries(ctx, series)
|
|
if err == nil {
|
|
_ = s.Store.AppendAudit(ctx, actor.ID, "series.map_recorded", seriesID, out.Results[len(out.Results)-1])
|
|
s.Bus.Publish("series:"+seriesID, out)
|
|
}
|
|
return out, err
|
|
}
|
|
|
|
func (s *Service) CorrectMap(ctx context.Context, actor domain.Account, seriesID string, resultIndex int, mapName string, outcome domain.MapOutcome, expectedVersion int) (domain.Series, error) {
|
|
if !actor.IsStaff() {
|
|
return domain.Series{}, domain.ErrForbidden
|
|
}
|
|
series, err := s.Store.GetSeries(ctx, seriesID)
|
|
if err != nil {
|
|
return domain.Series{}, err
|
|
}
|
|
if series.Version != expectedVersion {
|
|
return domain.Series{}, fmt.Errorf("%w: stale series version", domain.ErrConflict)
|
|
}
|
|
if err := series.CorrectResult(resultIndex, domain.MapResult{MapName: mapName, Outcome: outcome, ActorAccountID: actor.ID, RecordedAt: s.Now()}); err != nil {
|
|
return domain.Series{}, err
|
|
}
|
|
out, err := s.Store.SaveSeries(ctx, series)
|
|
if err == nil {
|
|
_ = s.Store.AppendAudit(ctx, actor.ID, "series.map_corrected", seriesID, out.Results[len(out.Results)-1])
|
|
s.Bus.Publish("series:"+seriesID, out)
|
|
}
|
|
return out, err
|
|
}
|