716 lines
21 KiB
Go
716 lines
21 KiB
Go
package handlers
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"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 redirects to the default tab (overview)
|
|
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
|
|
}
|
|
|
|
http.Redirect(w, r, fmt.Sprintf("/fixtures/%d/overview", fixtureID), http.StatusSeeOther)
|
|
})
|
|
}
|
|
|
|
// FixtureDetailOverviewPage renders the overview tab of the fixture detail page
|
|
func FixtureDetailOverviewPage(
|
|
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
|
|
}
|
|
|
|
var fixture *db.Fixture
|
|
var currentSchedule *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")
|
|
}
|
|
user := db.CurrentUser(ctx)
|
|
canSchedule, userTeamID, err = fixture.CanSchedule(ctx, tx, user)
|
|
if err != nil {
|
|
return false, errors.Wrap(err, "fixture.CanSchedule")
|
|
}
|
|
result, err = db.GetFixtureResult(ctx, tx, fixtureID)
|
|
if err != nil {
|
|
return false, errors.Wrap(err, "db.GetFixtureResult")
|
|
}
|
|
rosters, err = db.GetFixtureTeamRosters(ctx, tx, fixture, result)
|
|
if err != nil {
|
|
return false, errors.Wrap(err, "db.GetFixtureTeamRosters")
|
|
}
|
|
nominatedFreeAgents, err = db.GetNominatedFreeAgents(ctx, tx, fixtureID)
|
|
if err != nil {
|
|
return false, errors.Wrap(err, "db.GetNominatedFreeAgents")
|
|
}
|
|
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
|
|
}
|
|
|
|
if r.Method == "GET" {
|
|
renderSafely(seasonsview.FixtureDetailOverviewPage(
|
|
fixture, currentSchedule, canSchedule, userTeamID,
|
|
result, rosters, nominatedFreeAgents, availableFreeAgents,
|
|
), s, r, w)
|
|
} else {
|
|
renderSafely(seasonsview.FixtureDetailOverviewContent(
|
|
fixture, currentSchedule, canSchedule, userTeamID,
|
|
result, rosters, nominatedFreeAgents, availableFreeAgents,
|
|
), s, r, w)
|
|
}
|
|
})
|
|
}
|
|
|
|
// FixtureDetailPreviewPage renders the match preview tab of the fixture detail page
|
|
func FixtureDetailPreviewPage(
|
|
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
|
|
}
|
|
|
|
var fixture *db.Fixture
|
|
var result *db.FixtureResult
|
|
var rosters map[string][]*db.PlayerWithPlayStatus
|
|
var previewData *db.MatchPreviewData
|
|
|
|
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")
|
|
}
|
|
result, err = db.GetFixtureResult(ctx, tx, fixtureID)
|
|
if err != nil {
|
|
return false, errors.Wrap(err, "db.GetFixtureResult")
|
|
}
|
|
rosters, err = db.GetFixtureTeamRosters(ctx, tx, fixture, result)
|
|
if err != nil {
|
|
return false, errors.Wrap(err, "db.GetFixtureTeamRosters")
|
|
}
|
|
previewData, err = db.ComputeMatchPreview(ctx, tx, fixture)
|
|
if err != nil {
|
|
return false, errors.Wrap(err, "db.ComputeMatchPreview")
|
|
}
|
|
return true, nil
|
|
}); !ok {
|
|
return
|
|
}
|
|
|
|
// If finalized, redirect to analysis instead
|
|
if result != nil && result.Finalized {
|
|
if r.Method == "GET" {
|
|
http.Redirect(w, r, fmt.Sprintf("/fixtures/%d/analysis", fixtureID), http.StatusSeeOther)
|
|
} else {
|
|
respond.HXRedirect(w, "/fixtures/%d/analysis", fixtureID)
|
|
}
|
|
return
|
|
}
|
|
|
|
if r.Method == "GET" {
|
|
renderSafely(seasonsview.FixtureDetailPreviewPage(
|
|
fixture, result, rosters, previewData,
|
|
), s, r, w)
|
|
} else {
|
|
renderSafely(seasonsview.FixtureDetailPreviewContent(
|
|
fixture, rosters, previewData,
|
|
), s, r, w)
|
|
}
|
|
})
|
|
}
|
|
|
|
// FixtureDetailAnalysisPage renders the match analysis tab of the fixture detail page
|
|
func FixtureDetailAnalysisPage(
|
|
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
|
|
}
|
|
|
|
var fixture *db.Fixture
|
|
var result *db.FixtureResult
|
|
var rosters map[string][]*db.PlayerWithPlayStatus
|
|
var previewData *db.MatchPreviewData
|
|
|
|
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")
|
|
}
|
|
result, err = db.GetFixtureResult(ctx, tx, fixtureID)
|
|
if err != nil {
|
|
return false, errors.Wrap(err, "db.GetFixtureResult")
|
|
}
|
|
rosters, err = db.GetFixtureTeamRosters(ctx, tx, fixture, result)
|
|
if err != nil {
|
|
return false, errors.Wrap(err, "db.GetFixtureTeamRosters")
|
|
}
|
|
previewData, err = db.ComputeMatchPreview(ctx, tx, fixture)
|
|
if err != nil {
|
|
return false, errors.Wrap(err, "db.ComputeMatchPreview")
|
|
}
|
|
return true, nil
|
|
}); !ok {
|
|
return
|
|
}
|
|
|
|
// If not finalized, redirect to preview instead
|
|
if result == nil || !result.Finalized {
|
|
if r.Method == "GET" {
|
|
http.Redirect(w, r, fmt.Sprintf("/fixtures/%d/preview", fixtureID), http.StatusSeeOther)
|
|
} else {
|
|
respond.HXRedirect(w, "/fixtures/%d/preview", fixtureID)
|
|
}
|
|
return
|
|
}
|
|
|
|
if r.Method == "GET" {
|
|
renderSafely(seasonsview.FixtureDetailAnalysisPage(
|
|
fixture, result, rosters, previewData,
|
|
), s, r, w)
|
|
} else {
|
|
renderSafely(seasonsview.FixtureDetailAnalysisContent(
|
|
fixture, result, rosters, previewData,
|
|
), s, r, w)
|
|
}
|
|
})
|
|
}
|
|
|
|
// FixtureDetailSchedulePage renders the schedule tab of the fixture detail page
|
|
func FixtureDetailSchedulePage(
|
|
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
|
|
}
|
|
|
|
var fixture *db.Fixture
|
|
var currentSchedule *db.FixtureSchedule
|
|
var history []*db.FixtureSchedule
|
|
var canSchedule bool
|
|
var userTeamID int
|
|
var result *db.FixtureResult
|
|
|
|
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")
|
|
}
|
|
result, err = db.GetFixtureResult(ctx, tx, fixtureID)
|
|
if err != nil {
|
|
return false, errors.Wrap(err, "db.GetFixtureResult")
|
|
}
|
|
return true, nil
|
|
}); !ok {
|
|
return
|
|
}
|
|
|
|
// If finalized, redirect to overview (scheduling tab is hidden)
|
|
if result != nil && result.Finalized {
|
|
if r.Method == "GET" {
|
|
http.Redirect(w, r, fmt.Sprintf("/fixtures/%d/overview", fixtureID), http.StatusSeeOther)
|
|
} else {
|
|
respond.HXRedirect(w, "/fixtures/%d/overview", fixtureID)
|
|
}
|
|
return
|
|
}
|
|
|
|
if r.Method == "GET" {
|
|
renderSafely(seasonsview.FixtureDetailSchedulePage(
|
|
fixture, currentSchedule, history, canSchedule, userTeamID,
|
|
), s, r, w)
|
|
} else {
|
|
renderSafely(seasonsview.FixtureDetailScheduleContent(
|
|
fixture, currentSchedule, history, canSchedule, userTeamID,
|
|
), 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)
|
|
})
|
|
}
|