502 lines
15 KiB
Go
502 lines
15 KiB
Go
package handlers
|
|
|
|
import (
|
|
"context"
|
|
"net/http"
|
|
"strconv"
|
|
"time"
|
|
|
|
"git.haelnorr.com/h/golib/hws"
|
|
"git.haelnorr.com/h/oslstats/internal/contexts"
|
|
"git.haelnorr.com/h/oslstats/internal/db"
|
|
"git.haelnorr.com/h/oslstats/internal/notify"
|
|
"git.haelnorr.com/h/oslstats/internal/permissions"
|
|
"git.haelnorr.com/h/oslstats/internal/respond"
|
|
"git.haelnorr.com/h/oslstats/internal/throw"
|
|
"git.haelnorr.com/h/oslstats/internal/validation"
|
|
"git.haelnorr.com/h/oslstats/internal/view/seasonsview"
|
|
"git.haelnorr.com/h/timefmt"
|
|
"github.com/pkg/errors"
|
|
"github.com/uptrace/bun"
|
|
)
|
|
|
|
// FixtureDetailPage renders the fixture detail page with scheduling UI, history,
|
|
// result display, and team rosters
|
|
func FixtureDetailPage(
|
|
s *hws.Server,
|
|
conn *db.DB,
|
|
) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
fixtureID, err := strconv.Atoi(r.PathValue("fixture_id"))
|
|
if err != nil {
|
|
throw.BadRequest(s, w, r, "Invalid fixture ID", err)
|
|
return
|
|
}
|
|
|
|
activeTab := r.URL.Query().Get("tab")
|
|
if activeTab == "" {
|
|
activeTab = "overview"
|
|
}
|
|
|
|
var fixture *db.Fixture
|
|
var currentSchedule *db.FixtureSchedule
|
|
var history []*db.FixtureSchedule
|
|
var canSchedule bool
|
|
var userTeamID int
|
|
var result *db.FixtureResult
|
|
var rosters map[string][]*db.PlayerWithPlayStatus
|
|
var nominatedFreeAgents []*db.FixtureFreeAgent
|
|
var availableFreeAgents []*db.SeasonLeagueFreeAgent
|
|
|
|
if ok := conn.WithReadTx(s, w, r, func(ctx context.Context, tx bun.Tx) (bool, error) {
|
|
var err error
|
|
fixture, err = db.GetFixture(ctx, tx, fixtureID)
|
|
if err != nil {
|
|
if db.IsBadRequest(err) {
|
|
throw.NotFound(s, w, r, r.URL.Path)
|
|
return false, nil
|
|
}
|
|
return false, errors.Wrap(err, "db.GetFixture")
|
|
}
|
|
currentSchedule, err = db.GetCurrentFixtureSchedule(ctx, tx, fixtureID)
|
|
if err != nil {
|
|
return false, errors.Wrap(err, "db.GetCurrentFixtureSchedule")
|
|
}
|
|
history, err = db.GetFixtureScheduleHistory(ctx, tx, fixtureID)
|
|
if err != nil {
|
|
return false, errors.Wrap(err, "db.GetFixtureScheduleHistory")
|
|
}
|
|
user := db.CurrentUser(ctx)
|
|
canSchedule, userTeamID, err = fixture.CanSchedule(ctx, tx, user)
|
|
if err != nil {
|
|
return false, errors.Wrap(err, "fixture.CanSchedule")
|
|
}
|
|
// Fetch fixture result if it exists
|
|
result, err = db.GetFixtureResult(ctx, tx, fixtureID)
|
|
if err != nil {
|
|
return false, errors.Wrap(err, "db.GetFixtureResult")
|
|
}
|
|
// Fetch team rosters with play status
|
|
rosters, err = db.GetFixtureTeamRosters(ctx, tx, fixture, result)
|
|
if err != nil {
|
|
return false, errors.Wrap(err, "db.GetFixtureTeamRosters")
|
|
}
|
|
// Fetch free agent nominations for this fixture
|
|
nominatedFreeAgents, err = db.GetNominatedFreeAgents(ctx, tx, fixtureID)
|
|
if err != nil {
|
|
return false, errors.Wrap(err, "db.GetNominatedFreeAgents")
|
|
}
|
|
// Fetch available free agents for nomination (if user can schedule or manage fixtures)
|
|
canManage := contexts.Permissions(ctx).HasPermission(permissions.FixturesManage)
|
|
if canSchedule || canManage {
|
|
availableFreeAgents, err = db.GetFreeAgentsForSeasonLeague(ctx, tx, fixture.SeasonID, fixture.LeagueID)
|
|
if err != nil {
|
|
return false, errors.Wrap(err, "db.GetFreeAgentsForSeasonLeague")
|
|
}
|
|
}
|
|
return true, nil
|
|
}); !ok {
|
|
return
|
|
}
|
|
|
|
renderSafely(seasonsview.FixtureDetailPage(
|
|
fixture, currentSchedule, history, canSchedule, userTeamID,
|
|
result, rosters, activeTab, nominatedFreeAgents, availableFreeAgents,
|
|
), s, r, w)
|
|
})
|
|
}
|
|
|
|
// ProposeSchedule handles POST /fixtures/{fixture_id}/schedule
|
|
func ProposeSchedule(
|
|
s *hws.Server,
|
|
conn *db.DB,
|
|
) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
fixtureID, err := strconv.Atoi(r.PathValue("fixture_id"))
|
|
if err != nil {
|
|
throw.BadRequest(s, w, r, "Invalid fixture ID", err)
|
|
return
|
|
}
|
|
|
|
getter, ok := validation.ParseFormOrNotify(s, w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
format := timefmt.NewBuilder().Year4().Dash().MonthNumeric2().Dash().
|
|
DayNumeric2().T().Hour24().Colon().Minute().Build()
|
|
aest, _ := time.LoadLocation("Australia/Sydney")
|
|
// scheduledTime := getter.TimeInLocation("scheduled_time", format, aest).After(time.Now()).Value
|
|
scheduledTime := getter.TimeInLocation("scheduled_time", format, aest).Value
|
|
|
|
if !getter.ValidateAndNotify(s, w, r) {
|
|
return
|
|
}
|
|
|
|
if ok := conn.WithNotifyTx(s, w, r, func(ctx context.Context, tx bun.Tx) (bool, error) {
|
|
fixture, err := db.GetFixture(ctx, tx, fixtureID)
|
|
if err != nil {
|
|
if db.IsBadRequest(err) {
|
|
respond.NotFound(w, errors.Wrap(err, "db.GetFixture"))
|
|
return false, nil
|
|
}
|
|
return false, errors.Wrap(err, "db.GetFixture")
|
|
}
|
|
|
|
user := db.CurrentUser(ctx)
|
|
canSchedule, userTeamID, err := fixture.CanSchedule(ctx, tx, user)
|
|
if err != nil {
|
|
return false, errors.Wrap(err, "fixture.CanSchedule")
|
|
}
|
|
if !canSchedule {
|
|
throw.Forbidden(s, w, r, "You must be a team manager to propose a schedule", nil)
|
|
return false, nil
|
|
}
|
|
|
|
_, err = db.ProposeFixtureSchedule(ctx, tx, fixtureID, userTeamID, scheduledTime, db.NewAuditFromRequest(r))
|
|
if err != nil {
|
|
if db.IsBadRequest(err) {
|
|
notify.Warn(s, w, r, "Cannot Propose", err.Error(), nil)
|
|
return false, nil
|
|
}
|
|
return false, errors.Wrap(err, "db.ProposeFixtureSchedule")
|
|
}
|
|
return true, nil
|
|
}); !ok {
|
|
return
|
|
}
|
|
|
|
notify.SuccessWithDelay(s, w, r, "Time Proposed", "Your proposed time has been submitted.", nil)
|
|
respond.HXRedirect(w, "/fixtures/%d", fixtureID)
|
|
})
|
|
}
|
|
|
|
// AcceptSchedule handles POST /fixtures/{fixture_id}/schedule/{schedule_id}/accept
|
|
func AcceptSchedule(
|
|
s *hws.Server,
|
|
conn *db.DB,
|
|
) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
fixtureID, err := strconv.Atoi(r.PathValue("fixture_id"))
|
|
if err != nil {
|
|
throw.BadRequest(s, w, r, "Invalid fixture ID", err)
|
|
return
|
|
}
|
|
scheduleID, err := strconv.Atoi(r.PathValue("schedule_id"))
|
|
if err != nil {
|
|
throw.BadRequest(s, w, r, "Invalid schedule ID", err)
|
|
return
|
|
}
|
|
|
|
if ok := conn.WithNotifyTx(s, w, r, func(ctx context.Context, tx bun.Tx) (bool, error) {
|
|
fixture, err := db.GetFixture(ctx, tx, fixtureID)
|
|
if err != nil {
|
|
if db.IsBadRequest(err) {
|
|
respond.NotFound(w, errors.Wrap(err, "db.GetFixture"))
|
|
return false, nil
|
|
}
|
|
return false, errors.Wrap(err, "db.GetFixture")
|
|
}
|
|
|
|
user := db.CurrentUser(ctx)
|
|
canSchedule, userTeamID, err := fixture.CanSchedule(ctx, tx, user)
|
|
if err != nil {
|
|
return false, errors.Wrap(err, "fixture.CanSchedule")
|
|
}
|
|
if !canSchedule {
|
|
throw.Forbidden(s, w, r, "You must be a team manager to accept a schedule", nil)
|
|
return false, nil
|
|
}
|
|
|
|
err = db.AcceptFixtureSchedule(ctx, tx, scheduleID, userTeamID, db.NewAuditFromRequest(r))
|
|
if err != nil {
|
|
if db.IsBadRequest(err) {
|
|
notify.Warn(s, w, r, "Cannot Accept", err.Error(), nil)
|
|
return false, nil
|
|
}
|
|
return false, errors.Wrap(err, "db.AcceptFixtureSchedule")
|
|
}
|
|
return true, nil
|
|
}); !ok {
|
|
return
|
|
}
|
|
|
|
notify.Success(s, w, r, "Schedule Accepted", "The fixture time has been confirmed.", nil)
|
|
respond.HXRedirect(w, "/fixtures/%d", fixtureID)
|
|
})
|
|
}
|
|
|
|
// RejectSchedule handles POST /fixtures/{fixture_id}/schedule/{schedule_id}/reject
|
|
func RejectSchedule(
|
|
s *hws.Server,
|
|
conn *db.DB,
|
|
) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
fixtureID, err := strconv.Atoi(r.PathValue("fixture_id"))
|
|
if err != nil {
|
|
throw.BadRequest(s, w, r, "Invalid fixture ID", err)
|
|
return
|
|
}
|
|
scheduleID, err := strconv.Atoi(r.PathValue("schedule_id"))
|
|
if err != nil {
|
|
throw.BadRequest(s, w, r, "Invalid schedule ID", err)
|
|
return
|
|
}
|
|
|
|
if ok := conn.WithNotifyTx(s, w, r, func(ctx context.Context, tx bun.Tx) (bool, error) {
|
|
fixture, err := db.GetFixture(ctx, tx, fixtureID)
|
|
if err != nil {
|
|
if db.IsBadRequest(err) {
|
|
respond.NotFound(w, errors.Wrap(err, "db.GetFixture"))
|
|
return false, nil
|
|
}
|
|
return false, errors.Wrap(err, "db.GetFixture")
|
|
}
|
|
|
|
user := db.CurrentUser(ctx)
|
|
canSchedule, _, err := fixture.CanSchedule(ctx, tx, user)
|
|
if err != nil {
|
|
return false, errors.Wrap(err, "fixture.CanSchedule")
|
|
}
|
|
if !canSchedule {
|
|
throw.Forbidden(s, w, r, "You must be a team manager to reject a schedule", nil)
|
|
return false, nil
|
|
}
|
|
|
|
err = db.RejectFixtureSchedule(ctx, tx, scheduleID, db.NewAuditFromRequest(r))
|
|
if err != nil {
|
|
if db.IsBadRequest(err) {
|
|
notify.Warn(s, w, r, "Cannot Reject", err.Error(), nil)
|
|
return false, nil
|
|
}
|
|
return false, errors.Wrap(err, "db.RejectFixtureSchedule")
|
|
}
|
|
return true, nil
|
|
}); !ok {
|
|
return
|
|
}
|
|
|
|
notify.Success(s, w, r, "Schedule Rejected", "The proposed time has been rejected.", nil)
|
|
respond.HXRedirect(w, "/fixtures/%d", fixtureID)
|
|
})
|
|
}
|
|
|
|
// PostponeSchedule handles POST /fixtures/{fixture_id}/schedule/postpone
|
|
func PostponeSchedule(
|
|
s *hws.Server,
|
|
conn *db.DB,
|
|
) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
fixtureID, err := strconv.Atoi(r.PathValue("fixture_id"))
|
|
if err != nil {
|
|
throw.BadRequest(s, w, r, "Invalid fixture ID", err)
|
|
return
|
|
}
|
|
|
|
getter, ok := validation.ParseFormOrNotify(s, w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
reason := getter.String("reschedule_reason").TrimSpace().Required().Value
|
|
if !getter.ValidateAndNotify(s, w, r) {
|
|
return
|
|
}
|
|
|
|
if ok := conn.WithNotifyTx(s, w, r, func(ctx context.Context, tx bun.Tx) (bool, error) {
|
|
fixture, err := db.GetFixture(ctx, tx, fixtureID)
|
|
if err != nil {
|
|
if db.IsBadRequest(err) {
|
|
respond.NotFound(w, errors.Wrap(err, "db.GetFixture"))
|
|
return false, nil
|
|
}
|
|
return false, errors.Wrap(err, "db.GetFixture")
|
|
}
|
|
|
|
user := db.CurrentUser(ctx)
|
|
canSchedule, _, err := fixture.CanSchedule(ctx, tx, user)
|
|
if err != nil {
|
|
return false, errors.Wrap(err, "fixture.CanSchedule")
|
|
}
|
|
if !canSchedule {
|
|
throw.Forbidden(s, w, r, "You must be a team manager to postpone a fixture", nil)
|
|
return false, nil
|
|
}
|
|
|
|
err = db.PostponeFixtureSchedule(ctx, tx, fixtureID, reason, db.NewAuditFromRequest(r))
|
|
if err != nil {
|
|
if db.IsBadRequest(err) {
|
|
notify.Warn(s, w, r, "Cannot Postpone", err.Error(), nil)
|
|
return false, nil
|
|
}
|
|
return false, errors.Wrap(err, "db.PostponeFixtureSchedule")
|
|
}
|
|
return true, nil
|
|
}); !ok {
|
|
return
|
|
}
|
|
|
|
notify.Success(s, w, r, "Fixture Postponed", "The fixture has been postponed.", nil)
|
|
respond.HXRedirect(w, "/fixtures/%d", fixtureID)
|
|
})
|
|
}
|
|
|
|
// RescheduleFixture handles POST /fixtures/{fixture_id}/schedule/reschedule
|
|
func RescheduleFixture(
|
|
s *hws.Server,
|
|
conn *db.DB,
|
|
) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
fixtureID, err := strconv.Atoi(r.PathValue("fixture_id"))
|
|
if err != nil {
|
|
throw.BadRequest(s, w, r, "Invalid fixture ID", err)
|
|
return
|
|
}
|
|
|
|
getter, ok := validation.ParseFormOrNotify(s, w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
format := timefmt.NewBuilder().Year4().Dash().MonthNumeric2().Dash().
|
|
DayNumeric2().T().Hour24().Colon().Minute().Build()
|
|
aest, _ := time.LoadLocation("Australia/Sydney")
|
|
scheduledTime := getter.TimeInLocation("scheduled_time", format, aest).After(time.Now()).Value
|
|
reason := getter.String("reschedule_reason").TrimSpace().Required().Value
|
|
|
|
if !getter.ValidateAndNotify(s, w, r) {
|
|
return
|
|
}
|
|
|
|
if ok := conn.WithNotifyTx(s, w, r, func(ctx context.Context, tx bun.Tx) (bool, error) {
|
|
fixture, err := db.GetFixture(ctx, tx, fixtureID)
|
|
if err != nil {
|
|
if db.IsBadRequest(err) {
|
|
respond.NotFound(w, errors.Wrap(err, "db.GetFixture"))
|
|
return false, nil
|
|
}
|
|
return false, errors.Wrap(err, "db.GetFixture")
|
|
}
|
|
|
|
user := db.CurrentUser(ctx)
|
|
canSchedule, userTeamID, err := fixture.CanSchedule(ctx, tx, user)
|
|
if err != nil {
|
|
return false, errors.Wrap(err, "fixture.CanSchedule")
|
|
}
|
|
if !canSchedule {
|
|
throw.Forbidden(s, w, r, "You must be a team manager to reschedule a fixture", nil)
|
|
return false, nil
|
|
}
|
|
|
|
_, err = db.RescheduleFixtureSchedule(ctx, tx, fixtureID, userTeamID, scheduledTime, reason, db.NewAuditFromRequest(r))
|
|
if err != nil {
|
|
if db.IsBadRequest(err) {
|
|
notify.Warn(s, w, r, "Cannot Reschedule", err.Error(), nil)
|
|
return false, nil
|
|
}
|
|
return false, errors.Wrap(err, "db.RescheduleFixtureSchedule")
|
|
}
|
|
return true, nil
|
|
}); !ok {
|
|
return
|
|
}
|
|
|
|
notify.Success(s, w, r, "Fixture Rescheduled", "The new proposed time has been submitted.", nil)
|
|
respond.HXRedirect(w, "/fixtures/%d", fixtureID)
|
|
})
|
|
}
|
|
|
|
// WithdrawSchedule handles POST /fixtures/{fixture_id}/schedule/{schedule_id}/withdraw
|
|
// Only the proposing team manager can withdraw their own pending proposal.
|
|
func WithdrawSchedule(
|
|
s *hws.Server,
|
|
conn *db.DB,
|
|
) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
fixtureID, err := strconv.Atoi(r.PathValue("fixture_id"))
|
|
if err != nil {
|
|
throw.BadRequest(s, w, r, "Invalid fixture ID", err)
|
|
return
|
|
}
|
|
scheduleID, err := strconv.Atoi(r.PathValue("schedule_id"))
|
|
if err != nil {
|
|
throw.BadRequest(s, w, r, "Invalid schedule ID", err)
|
|
return
|
|
}
|
|
|
|
if ok := conn.WithNotifyTx(s, w, r, func(ctx context.Context, tx bun.Tx) (bool, error) {
|
|
fixture, err := db.GetFixture(ctx, tx, fixtureID)
|
|
if err != nil {
|
|
if db.IsBadRequest(err) {
|
|
respond.NotFound(w, errors.Wrap(err, "db.GetFixture"))
|
|
return false, nil
|
|
}
|
|
return false, errors.Wrap(err, "db.GetFixture")
|
|
}
|
|
|
|
user := db.CurrentUser(ctx)
|
|
canSchedule, userTeamID, err := fixture.CanSchedule(ctx, tx, user)
|
|
if err != nil {
|
|
return false, errors.Wrap(err, "fixture.CanSchedule")
|
|
}
|
|
if !canSchedule {
|
|
throw.Forbidden(s, w, r, "You must be a team manager to withdraw a proposal", nil)
|
|
return false, nil
|
|
}
|
|
|
|
err = db.WithdrawFixtureSchedule(ctx, tx, scheduleID, userTeamID, db.NewAuditFromRequest(r))
|
|
if err != nil {
|
|
if db.IsBadRequest(err) {
|
|
notify.Warn(s, w, r, "Cannot Withdraw", err.Error(), nil)
|
|
return false, nil
|
|
}
|
|
return false, errors.Wrap(err, "db.WithdrawFixtureSchedule")
|
|
}
|
|
return true, nil
|
|
}); !ok {
|
|
return
|
|
}
|
|
|
|
notify.Success(s, w, r, "Proposal Withdrawn", "Your proposed time has been withdrawn.", nil)
|
|
respond.HXRedirect(w, "/fixtures/%d", fixtureID)
|
|
})
|
|
}
|
|
|
|
// CancelSchedule handles POST /fixtures/{fixture_id}/schedule/cancel
|
|
// This is a moderator-only action that requires fixtures.manage permission.
|
|
func CancelSchedule(
|
|
s *hws.Server,
|
|
conn *db.DB,
|
|
) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
fixtureID, err := strconv.Atoi(r.PathValue("fixture_id"))
|
|
if err != nil {
|
|
throw.BadRequest(s, w, r, "Invalid fixture ID", err)
|
|
return
|
|
}
|
|
|
|
getter, ok := validation.ParseFormOrNotify(s, w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
reason := getter.String("reschedule_reason").TrimSpace().Required().Value
|
|
if !getter.ValidateAndNotify(s, w, r) {
|
|
return
|
|
}
|
|
|
|
if ok := conn.WithNotifyTx(s, w, r, func(ctx context.Context, tx bun.Tx) (bool, error) {
|
|
err := db.CancelFixtureSchedule(ctx, tx, fixtureID, reason, db.NewAuditFromRequest(r))
|
|
if err != nil {
|
|
if db.IsBadRequest(err) {
|
|
notify.Warn(s, w, r, "Cannot Cancel", err.Error(), nil)
|
|
return false, nil
|
|
}
|
|
return false, errors.Wrap(err, "db.CancelFixtureSchedule")
|
|
}
|
|
return true, nil
|
|
}); !ok {
|
|
return
|
|
}
|
|
|
|
notify.Success(s, w, r, "Forfeit Declared", "The fixture has been declared a forfeit.", nil)
|
|
respond.HXRedirect(w, "/fixtures/%d", fixtureID)
|
|
})
|
|
}
|