1025 lines
40 KiB
JavaScript
1025 lines
40 KiB
JavaScript
import { bindParticipantPicker, participantCopySources } from "./participant_picker.js";
|
|
import { openHouseOfRcEntryRefresh, openHouseOfRcResultsPost } from "./houseofrc_view.js";
|
|
import { mountSponsorSetup } from "./sponsor_event_view.js";
|
|
import { mountTeamRaceSetup } from "./team_race_setup_view.js";
|
|
import { orderSessionsForRunning, moveSessionInRunningOrder, applyFormatToPendingSessions, syncParticipantsToSessions } from "./event_race_logic.js";
|
|
import { setSessionGroupOpen } from "./event_manager_view.js";
|
|
let activeManageTab = "setup";
|
|
// Maps a data-target anchor id (used by the step-card overview and the race-summary
|
|
// warning links) to the tab it now lives inside, so jumping to it also switches tabs
|
|
// first - scrollIntoView on an element hidden behind an inactive tab does nothing useful.
|
|
const MANAGE_TAB_TARGETS = {
|
|
"manage-setup-participants": "setup",
|
|
"manage-setup-teams": "setup",
|
|
"manage-format": "format",
|
|
"manage-generation": "format",
|
|
"manage-live-grid": "live",
|
|
"manage-live-results": "live",
|
|
};
|
|
|
|
export function renderEventManagerView(context) {
|
|
const {
|
|
eventId,
|
|
state,
|
|
t,
|
|
escapeHtml,
|
|
normalizeEvent,
|
|
normalizeDriver,
|
|
getRaceOverview,
|
|
ensureRaceParticipantsConfigured,
|
|
getSessionsForEvent,
|
|
getSelectedTeamEditId,
|
|
setSelectedTeamEditId,
|
|
getSelectedSessionEditId,
|
|
setSelectedSessionEditId,
|
|
getSelectedGridSessionId,
|
|
setSelectedGridSessionId,
|
|
getRaceFormatAdvanced,
|
|
setRaceFormatAdvanced,
|
|
getEventDrivers,
|
|
getTeamDriverPool,
|
|
getEventTeams,
|
|
reassignTeamMembers,
|
|
moveDriversIntoQualifyingHeat,
|
|
parseQualifyingHeatName,
|
|
normalizeBrandingConfig,
|
|
getSessionTypeChoices,
|
|
getRaceFormatPresets,
|
|
getRaceSummaryItems,
|
|
getRaceSummaryWarnings,
|
|
getRaceManageStatuses,
|
|
normalizeStartMode,
|
|
renderEventManagerMarkup,
|
|
getSessionEntrants,
|
|
getSessionTypeLabel,
|
|
getStartModeLabel,
|
|
getStatusLabel,
|
|
renderManageStatusBadgeView,
|
|
getDriverDisplayById,
|
|
renderRaceFormatContextCardView,
|
|
renderRaceFormatFieldView,
|
|
renderGridEditor,
|
|
renderRaceStandingsTableView,
|
|
buildPracticeStandings,
|
|
buildQualifyingStandings,
|
|
buildFinalStandings,
|
|
renderTeamRaceStandings,
|
|
renderSessionChannelAnalysis,
|
|
renderFinalMatrix,
|
|
getModeLabel,
|
|
renderTable,
|
|
bindModalShell,
|
|
setFormError,
|
|
saveState,
|
|
purgeSessionPassings,
|
|
renderView,
|
|
rerenderEventManager,
|
|
updateHeaderState,
|
|
uid,
|
|
normalizeSession,
|
|
buildSessionHeatSheetHtml,
|
|
openPrintWindow,
|
|
exportSessionHeatSheet,
|
|
exportSessionHeatSheetPdf,
|
|
getSelectedAssignmentSessionId,
|
|
autoAssignTrackSession,
|
|
renderAssignmentList,
|
|
normalizeRaceTeam,
|
|
buildRaceFormatConfigFromForm,
|
|
applyRaceFormatPreset,
|
|
normalizeStoredRacePreset,
|
|
generateQualifyingForRace,
|
|
rebuildPracticeHeats,
|
|
clearGeneratedQualifying,
|
|
reseedUpcomingQualifying,
|
|
generateFinalsForRace,
|
|
clearGeneratedFinals,
|
|
applyBumpsForRace,
|
|
buildRacePackagePayload,
|
|
downloadJsonFile,
|
|
sanitizeFilenameSegment,
|
|
importRacePackagePayload,
|
|
buildRaceStartListsHtml,
|
|
buildRaceResultsHtml,
|
|
buildTeamRaceResultsHtml,
|
|
exportRaceStartListsPdf,
|
|
exportRaceResultsPdf,
|
|
exportTeamRaceResultsPdf,
|
|
ensureSessionDriverOrder,
|
|
reorderList,
|
|
getEventName,
|
|
buildEventSchedule,
|
|
getDayPlan = () => null,
|
|
renderCheckIn = () => {},
|
|
saveDayPlan = () => {},
|
|
} = context;
|
|
|
|
const selectedTeamEditId = getSelectedTeamEditId();
|
|
const selectedSessionEditId = getSelectedSessionEditId();
|
|
const selectedGridSessionId = getSelectedGridSessionId();
|
|
const raceFormatAdvanced = getRaceFormatAdvanced();
|
|
|
|
const event = state.events.find((e) => e.id === eventId);
|
|
if (!event) {
|
|
return;
|
|
}
|
|
const normalizedEvent = normalizeEvent(event);
|
|
if (normalizedEvent !== event) {
|
|
Object.assign(event, normalizedEvent);
|
|
}
|
|
ensureRaceParticipantsConfigured(event);
|
|
|
|
// Listed in running order; ▲▼ change it (stored on the event as sessionOrder).
|
|
const sessions = orderSessionsForRunning(getSessionsForEvent(eventId), event.sessionOrder);
|
|
const eventManageArea = document.getElementById("eventManageArea");
|
|
if (!eventManageArea) {
|
|
return;
|
|
}
|
|
|
|
const clubDrivers = state.drivers.filter((driver) => !driver.guestEventId || driver.guestEventId === event.id);
|
|
const driverOptions = clubDrivers
|
|
.map((d) => `<option value="${d.id}">${escapeHtml(d.name)}</option>`)
|
|
.join("");
|
|
const raceDrivers = event.mode === "race" ? getEventDrivers(event) : [];
|
|
// The checklist offers every driver of the class (a driver left out can be ticked again),
|
|
// the chosen ones from other classes, and the rest of the club folded away.
|
|
const chosenIds = event.raceConfig?.participantsConfigured ? (event.raceConfig.driverIds || []) : null;
|
|
const participantChoices = event.mode === "race"
|
|
? clubDrivers.filter((driver) => (!event.classId && !driver.guestEventId) || (event.classId && driver.classId === event.classId) || (chosenIds || []).includes(driver.id))
|
|
: [];
|
|
const otherClassChoices = event.mode === "race" && event.classId
|
|
? clubDrivers.filter((driver) => !driver.guestEventId && !participantChoices.includes(driver)).sort((a, b) => String(a.name || "").localeCompare(String(b.name || "")))
|
|
: [];
|
|
// Copy the drivers of an earlier race (a cup round) in one go; the series' own rounds first.
|
|
const seriesEventIds = (state.series || []).filter((series) => (series.eventIds || []).includes(event.id)).flatMap((series) => series.eventIds || []);
|
|
const copySources = event.mode === "race" ? participantCopySources(state.events, { currentEventId: event.id, seriesEventIds, getDriverIds: (item) => getEventDrivers(item).map((driver) => driver.id) }) : [];
|
|
const teamDriverPool = event.mode === "race" ? getTeamDriverPool(event) : { drivers: [], fallback: false };
|
|
const raceTeams = event.mode === "race" ? getEventTeams(event) : [];
|
|
if (selectedTeamEditId && !raceTeams.some((team) => team.id === selectedTeamEditId)) {
|
|
setSelectedTeamEditId(null);
|
|
}
|
|
const editingTeam = event.mode === "race" ? raceTeams.find((team) => team.id === selectedTeamEditId) || null : null;
|
|
const carOptions = state.cars
|
|
.map((c) => `<option value="${c.id}">${escapeHtml(c.name)} (${escapeHtml(c.transponder)})</option>`)
|
|
.join("");
|
|
const branding = normalizeBrandingConfig(event.branding);
|
|
const editingSession = sessions.find((session) => session.id === selectedSessionEditId) || null;
|
|
const sessionTypeChoices = getSessionTypeChoices(event.mode);
|
|
const sessionTypeHintKey = event.mode === "track" ? "events.session_type_hint_track" : "events.session_type_hint_race";
|
|
const racePresets = getRaceFormatPresets();
|
|
const selectedPreset = racePresets.find((preset) => preset.id === event.raceConfig.presetId) || racePresets[0];
|
|
const isEndurancePreset = event.mode === "race" && selectedPreset?.id === "endurance";
|
|
const showTeamsSection =
|
|
event.mode === "race" &&
|
|
(isEndurancePreset || sessions.some((session) => session.type === "team_race") || raceTeams.length > 0 || Boolean(selectedTeamEditId));
|
|
const showBasicQualifyingFields = raceFormatAdvanced || !isEndurancePreset;
|
|
const showBasicFinalFields = raceFormatAdvanced || !isEndurancePreset;
|
|
const selectedParticipantCount = event.mode === "race" ? (event.raceConfig.participantsConfigured ? (event.raceConfig.driverIds || []).length : raceDrivers.length) : 0;
|
|
const raceSummaryItems = event.mode === "race" ? getRaceSummaryItems(event, sessions, raceDrivers, selectedPreset, { t, getStartModeLabel }) : [];
|
|
const raceSummaryWarnings = event.mode === "race" ? getRaceSummaryWarnings(event, sessions, raceDrivers, raceTeams, selectedPreset, { t }) : [];
|
|
const manageStatuses = event.mode === "race" ? getRaceManageStatuses(event, sessions, raceDrivers, raceTeams, selectedPreset) : null;
|
|
const gridSessions = event.mode === "race" ? sessions.filter((session) => normalizeStartMode(session.startMode) === "position") : [];
|
|
if (selectedGridSessionId && !gridSessions.some((session) => session.id === selectedGridSessionId)) {
|
|
setSelectedGridSessionId("");
|
|
}
|
|
const selectedGridSession =
|
|
gridSessions.find((session) => session.id === selectedGridSessionId) || gridSessions[0] || null;
|
|
if (!selectedGridSessionId && selectedGridSession) {
|
|
setSelectedGridSessionId(selectedGridSession.id);
|
|
}
|
|
const eventSchedule = event.mode === "race" ? buildEventSchedule(event) : [];
|
|
// The start time and gap are Today's schedule's (Race Day) for the race's date - one setting.
|
|
const dayPlan = event.mode === "race" && event.date ? getDayPlan(event.date) : null;
|
|
|
|
eventManageArea.innerHTML = renderEventManagerMarkup({
|
|
event,
|
|
t,
|
|
escapeHtml,
|
|
sessions,
|
|
eventSchedule,
|
|
dayPlan,
|
|
sessionTypeChoices,
|
|
sessionTypeHintKey,
|
|
raceTeams,
|
|
getSessionEntrants,
|
|
getSessionTypeLabel,
|
|
getStartModeLabel,
|
|
getStatusLabel,
|
|
normalizeStartMode,
|
|
branding,
|
|
driverOptions,
|
|
carOptions,
|
|
manageStatuses,
|
|
renderManageStatusBadgeView,
|
|
selectedParticipantCount,
|
|
raceDrivers,
|
|
participantChoices,
|
|
otherClassChoices,
|
|
participantCopySources: copySources,
|
|
teamDriverPool,
|
|
showTeamsSection,
|
|
parseQualifyingHeatName,
|
|
state,
|
|
getDriverDisplayById,
|
|
raceFormatAdvanced,
|
|
racePresets,
|
|
selectedPreset,
|
|
isEndurancePreset,
|
|
showBasicQualifyingFields,
|
|
showBasicFinalFields,
|
|
renderRaceFormatContextCardView,
|
|
renderRaceFormatFieldView,
|
|
raceSummaryWarnings,
|
|
raceSummaryItems,
|
|
selectedGridSession,
|
|
renderGridEditor,
|
|
renderRaceStandingsTableView,
|
|
buildPracticeStandings,
|
|
buildQualifyingStandings,
|
|
buildFinalStandings,
|
|
renderTeamRaceStandings,
|
|
renderSessionChannelAnalysis,
|
|
renderFinalMatrix,
|
|
editingTeam,
|
|
editingSession,
|
|
getModeLabel,
|
|
renderTable,
|
|
});
|
|
// The optional check-in tab (check_in_view.js) is filled by app.js, which knows the decoder's sightings.
|
|
const checkInPanel = eventManageArea.querySelector("#manage-checkin");
|
|
if (checkInPanel) renderCheckIn(checkInPanel, event);
|
|
eventManageArea.querySelectorAll("details[data-session-group]").forEach((group) => {
|
|
group.addEventListener("toggle", () => setSessionGroupOpen(event.id, group.dataset.sessionGroup, group.open));
|
|
});
|
|
|
|
const manageTabButtons = Array.from(eventManageArea.querySelectorAll(".manage-tab"));
|
|
const manageTabPanels = Array.from(eventManageArea.querySelectorAll("[data-manage-panel]"));
|
|
const applyManageTab = (tabId) => {
|
|
activeManageTab = tabId;
|
|
manageTabButtons.forEach((button) => button.classList.toggle("active", button.dataset.manageTab === tabId));
|
|
manageTabPanels.forEach((panel) => { panel.hidden = panel.dataset.managePanel !== tabId; });
|
|
};
|
|
manageTabButtons.forEach((button) => {
|
|
button.addEventListener("click", () => applyManageTab(button.dataset.manageTab));
|
|
});
|
|
if (manageTabButtons.length) {
|
|
applyManageTab(manageTabButtons.some((button) => button.dataset.manageTab === activeManageTab) ? activeManageTab : "setup");
|
|
}
|
|
|
|
const bindManageJump = (node) => {
|
|
const triggerJump = () => {
|
|
const targetId = node.getAttribute("data-target") || "";
|
|
const targetTab = MANAGE_TAB_TARGETS[targetId];
|
|
if (targetTab) applyManageTab(targetTab);
|
|
const target = targetId ? document.getElementById(targetId) : null;
|
|
if (target) {
|
|
target.scrollIntoView({ behavior: "smooth", block: "start" });
|
|
}
|
|
};
|
|
node.addEventListener("click", triggerJump);
|
|
node.addEventListener("keydown", (event) => {
|
|
if (event.key === "Enter" || event.key === " ") {
|
|
event.preventDefault();
|
|
triggerJump();
|
|
}
|
|
});
|
|
};
|
|
|
|
eventManageArea.querySelectorAll(".summary-warning-link, .manage-step-card-link").forEach((node) => {
|
|
bindManageJump(node);
|
|
});
|
|
|
|
const refreshManager = () => {
|
|
renderView();
|
|
rerenderEventManager(eventId);
|
|
};
|
|
|
|
const updateEvent = (updater) => {
|
|
state.events = state.events.map((item) => {
|
|
if (item.id !== eventId) {
|
|
return item;
|
|
}
|
|
return normalizeEvent(updater(item));
|
|
});
|
|
};
|
|
|
|
document.getElementById("eventBrandingForm")?.addEventListener("submit", (e) => {
|
|
e.preventDefault();
|
|
const form = new FormData(e.currentTarget);
|
|
updateEvent((item) => ({
|
|
...item,
|
|
branding: normalizeBrandingConfig({
|
|
...item.branding,
|
|
brandName: String(form.get("brandName") || "").trim(),
|
|
brandTagline: String(form.get("brandTagline") || "").trim(),
|
|
pdfFooter: String(form.get("pdfFooter") || "").trim(),
|
|
pdfTheme: String(form.get("pdfTheme") || "").trim(),
|
|
}),
|
|
}));
|
|
saveState();
|
|
refreshManager();
|
|
});
|
|
|
|
document.getElementById("eventLogoUpload")?.addEventListener("change", (eventInput) => {
|
|
const input = eventInput.currentTarget;
|
|
const file = input instanceof HTMLInputElement ? input.files?.[0] : null;
|
|
if (!file) {
|
|
return;
|
|
}
|
|
const reader = new FileReader();
|
|
reader.onload = () => {
|
|
updateEvent((item) => ({
|
|
...item,
|
|
branding: normalizeBrandingConfig({
|
|
...item.branding,
|
|
logoDataUrl: typeof reader.result === "string" ? reader.result : "",
|
|
}),
|
|
}));
|
|
saveState();
|
|
refreshManager();
|
|
};
|
|
reader.readAsDataURL(file);
|
|
});
|
|
|
|
document.getElementById("eventLogoClear")?.addEventListener("click", () => {
|
|
event.branding = normalizeBrandingConfig({
|
|
...event.branding,
|
|
logoDataUrl: "",
|
|
});
|
|
saveState();
|
|
rerenderEventManager(eventId);
|
|
});
|
|
|
|
document.getElementById("sessionForm")?.addEventListener("submit", (e) => {
|
|
e.preventDefault();
|
|
const formNode = e.currentTarget;
|
|
if (!(formNode instanceof HTMLFormElement)) {
|
|
return;
|
|
}
|
|
const form = new FormData(formNode);
|
|
const typeField = formNode.querySelector('[name="type"]');
|
|
const selectedType = typeField instanceof HTMLSelectElement ? typeField.value : String(form.get("type") || "");
|
|
state.sessions.push(normalizeSession({
|
|
id: uid("session"),
|
|
eventId,
|
|
name: String(form.get("name")).trim(),
|
|
type: selectedType,
|
|
durationMin: Number(form.get("durationMin")),
|
|
followUpSec: Math.max(0, Number(form.get("followUpSec") || 0) || 0),
|
|
startMode: String(form.get("startMode") || "mass"),
|
|
seedBestLapCount: Math.max(0, Number(form.get("seedBestLapCount") || 0) || 0),
|
|
seedMethod: String(form.get("seedMethod") || "best_sum"),
|
|
staggerGapSec: Math.max(0, Number(form.get("staggerGapSec") || 0) || 0),
|
|
maxCars: Number(form.get("maxCars") || 0) || null,
|
|
mode: event.mode,
|
|
status: "ready",
|
|
startedAt: null,
|
|
endedAt: null,
|
|
finishedByTimer: false,
|
|
assignments: [],
|
|
}));
|
|
saveState();
|
|
refreshManager();
|
|
updateHeaderState();
|
|
});
|
|
|
|
sessions.forEach((s) => {
|
|
document.getElementById(`session-edit-${s.id}`)?.addEventListener("click", () => {
|
|
setSelectedSessionEditId(s.id);
|
|
rerenderEventManager(eventId);
|
|
});
|
|
|
|
document.getElementById(`session-active-${s.id}`)?.addEventListener("click", () => {
|
|
state.activeSessionId = s.id;
|
|
saveState();
|
|
updateHeaderState();
|
|
renderView();
|
|
});
|
|
|
|
document.querySelectorAll(`[data-session-move="${s.id}"]`).forEach((button) => button.addEventListener("click", () => {
|
|
event.sessionOrder = moveSessionInRunningOrder(sessions, event.sessionOrder, s.id, Number(button.dataset.step));
|
|
saveState();
|
|
refreshManager();
|
|
}));
|
|
|
|
document.getElementById(`session-delete-${s.id}`)?.addEventListener("click", () => {
|
|
if (!window.confirm(t("events.delete_session_confirm", { name: s.name }))) return;
|
|
state.sessions = state.sessions.filter((x) => x.id !== s.id);
|
|
delete state.resultsBySession[s.id];
|
|
if (state.activeSessionId === s.id) {
|
|
state.activeSessionId = null;
|
|
}
|
|
saveState();
|
|
void purgeSessionPassings([s.id]);
|
|
refreshManager();
|
|
updateHeaderState();
|
|
});
|
|
|
|
document.getElementById(`session-grid-${s.id}`)?.addEventListener("click", () => {
|
|
ensureSessionDriverOrder(s);
|
|
setSelectedGridSessionId(s.id);
|
|
activeManageTab = "live";
|
|
saveState();
|
|
refreshManager();
|
|
});
|
|
|
|
document.getElementById(`session-sheet-print-${s.id}`)?.addEventListener("click", () => {
|
|
openPrintWindow(`${getEventName(eventId)} - ${s.name}`, buildSessionHeatSheetHtml(s));
|
|
});
|
|
|
|
document.getElementById(`session-sheet-export-${s.id}`)?.addEventListener("click", () => {
|
|
exportSessionHeatSheet(s);
|
|
});
|
|
|
|
document.getElementById(`session-sheet-pdf-${s.id}`)?.addEventListener("click", async () => {
|
|
await exportSessionHeatSheetPdf(s);
|
|
});
|
|
});
|
|
|
|
document.getElementById("sessionEditCancel")?.addEventListener("click", () => {
|
|
setSelectedSessionEditId(null);
|
|
refreshManager();
|
|
});
|
|
|
|
document.getElementById("sessionEditCancelFooter")?.addEventListener("click", () => {
|
|
setSelectedSessionEditId(null);
|
|
refreshManager();
|
|
});
|
|
|
|
document.getElementById("sessionEditModalOverlay")?.addEventListener("click", (event) => {
|
|
if (event.target?.id === "sessionEditModalOverlay") {
|
|
setSelectedSessionEditId(null);
|
|
refreshManager();
|
|
}
|
|
});
|
|
|
|
bindModalShell("sessionEditModalOverlay", () => {
|
|
setSelectedSessionEditId(null);
|
|
refreshManager();
|
|
});
|
|
|
|
document.getElementById("sessionEditForm")?.addEventListener("submit", (event) => {
|
|
event.preventDefault();
|
|
if (!editingSession) {
|
|
return;
|
|
}
|
|
const formNode = event.currentTarget;
|
|
if (!(formNode instanceof HTMLFormElement)) {
|
|
return;
|
|
}
|
|
const form = new FormData(formNode);
|
|
const typeField = formNode.querySelector('[name="type"]');
|
|
const selectedType = typeField instanceof HTMLSelectElement ? typeField.value : String(form.get("type") || editingSession.type);
|
|
const cleanedName = String(form.get("name") || "").trim();
|
|
const cleanedDuration = Number(form.get("durationMin") || editingSession.durationMin || 5) || 0;
|
|
if (!cleanedName) {
|
|
setFormError("sessionEditError", t("validation.required_name"));
|
|
return;
|
|
}
|
|
if (cleanedDuration < 1) {
|
|
setFormError("sessionEditError", t("validation.required_duration"));
|
|
return;
|
|
}
|
|
setFormError("sessionEditError", "");
|
|
editingSession.name = cleanedName;
|
|
editingSession.type = selectedType;
|
|
editingSession.durationMin = Math.max(1, cleanedDuration);
|
|
editingSession.followUpSec = Math.max(0, Number(form.get("followUpSec") || 0) || 0);
|
|
editingSession.startMode = normalizeStartMode(String(form.get("startMode") || editingSession.startMode || "mass"));
|
|
editingSession.seedBestLapCount = Math.max(0, Number(form.get("seedBestLapCount") || 0) || 0);
|
|
editingSession.seedMethod = ["best_sum", "average", "consecutive"].includes(String(form.get("seedMethod") || "").toLowerCase())
|
|
? String(form.get("seedMethod")).toLowerCase()
|
|
: "best_sum";
|
|
editingSession.staggerGapSec = Math.max(0, Number(form.get("staggerGapSec") || 0) || 0);
|
|
editingSession.maxCars = Number(form.get("maxCars") || 0) || null;
|
|
if (selectedType === "qualification") {
|
|
const heatDriverIds = Array.from(formNode.querySelectorAll('[name="heatDriverIds"]:checked'))
|
|
.map((node) => String(node.value))
|
|
.filter(Boolean);
|
|
moveDriversIntoQualifyingHeat(editingSession.id, heatDriverIds);
|
|
editingSession.driverIds = heatDriverIds;
|
|
editingSession.manualGridIds = [...heatDriverIds];
|
|
}
|
|
setSelectedSessionEditId(null);
|
|
saveState();
|
|
refreshManager();
|
|
});
|
|
|
|
if (event.mode === "track") {
|
|
mountSponsorSetup(document.getElementById("sponsorSetup"), {
|
|
event, state, t, escapeHtml, uid, normalizeSession, saveState, refresh: refreshManager, getSessionsForEvent, getStatusLabel,
|
|
generateFinalsForRace, buildQualifyingStandings, buildPracticeStandings,
|
|
});
|
|
document.getElementById("sponsorRoundsForm")?.addEventListener("submit", (e) => {
|
|
e.preventDefault();
|
|
const form = new FormData(e.currentTarget);
|
|
const qualificationRounds = Number(form.get("qualificationRounds") || 0);
|
|
const heatRounds = Number(form.get("heatRounds") || 0);
|
|
const finalRounds = Number(form.get("finalRounds") || 0);
|
|
const durationMin = Number(form.get("roundDuration") || 5);
|
|
|
|
createSponsorRounds(eventId, {
|
|
qualificationRounds,
|
|
heatRounds,
|
|
finalRounds,
|
|
durationMin,
|
|
});
|
|
saveState();
|
|
rerenderEventManager(eventId);
|
|
});
|
|
|
|
document.getElementById("assignForm")?.addEventListener("submit", (e) => {
|
|
e.preventDefault();
|
|
const form = new FormData(e.currentTarget);
|
|
const sessionId = String(form.get("sessionId"));
|
|
const session = state.sessions.find((x) => x.id === sessionId);
|
|
if (!session) {
|
|
return;
|
|
}
|
|
|
|
const driverId = String(form.get("driverId"));
|
|
const carId = String(form.get("carId"));
|
|
const car = state.cars.find((x) => x.id === carId);
|
|
if (!car) {
|
|
return;
|
|
}
|
|
|
|
const duplicateCar = (session.assignments || []).find((a) => a.carId === carId);
|
|
if (duplicateCar) {
|
|
alert(t("events.duplicate_car"));
|
|
return;
|
|
}
|
|
|
|
const duplicateDriver = (session.assignments || []).find((a) => a.driverId === driverId);
|
|
if (duplicateDriver) {
|
|
alert(t("events.duplicate_driver"));
|
|
return;
|
|
}
|
|
|
|
const duplicateTp = (session.assignments || []).find((a) => {
|
|
const existingCar = state.cars.find((x) => x.id === a.carId);
|
|
return existingCar?.transponder && existingCar.transponder === car.transponder;
|
|
});
|
|
if (duplicateTp) {
|
|
alert(t("events.duplicate_tp"));
|
|
return;
|
|
}
|
|
|
|
session.assignments = session.assignments || [];
|
|
session.assignments.push({ id: uid("as"), driverId, carId });
|
|
saveState();
|
|
rerenderEventManager(eventId);
|
|
});
|
|
|
|
document.getElementById("autoAssignSession")?.addEventListener("click", () => {
|
|
const sessionId = getSelectedAssignmentSessionId();
|
|
if (!sessionId) {
|
|
return;
|
|
}
|
|
autoAssignTrackSession(event, sessionId);
|
|
saveState();
|
|
rerenderEventManager(eventId);
|
|
});
|
|
|
|
document.getElementById("clearAssignSession")?.addEventListener("click", () => {
|
|
const sessionId = getSelectedAssignmentSessionId();
|
|
if (!sessionId) {
|
|
return;
|
|
}
|
|
const session = state.sessions.find((x) => x.id === sessionId);
|
|
if (!session) {
|
|
return;
|
|
}
|
|
session.assignments = [];
|
|
saveState();
|
|
rerenderEventManager(eventId);
|
|
});
|
|
|
|
renderAssignmentList(eventId);
|
|
}
|
|
|
|
if (event.mode === "race") {
|
|
const persistRaceParticipants = () => {
|
|
const beforeIds = getEventDrivers(event).map((driver) => driver.id);
|
|
const checked = new Set(Array.from(document.querySelectorAll(".race-participant:checked")).map((node) => node.value));
|
|
// Keep the entry order: the ones already in stay where they were, new ones go last.
|
|
const selectedIds = [...beforeIds.filter((id) => checked.has(id)), ...[...checked].filter((id) => !beforeIds.includes(id))];
|
|
event.raceConfig.driverIds = selectedIds;
|
|
event.raceConfig.participantsConfigured = true;
|
|
syncParticipantsToSessions(state.sessions.filter((session) => session.eventId === event.id), beforeIds, selectedIds);
|
|
saveState();
|
|
refreshManager();
|
|
};
|
|
|
|
bindParticipantPicker(document.getElementById("manage-setup-participants"), {
|
|
onChange: persistRaceParticipants,
|
|
getCopyIds: (sourceId) => {
|
|
const source = state.events.find((item) => item.id === sourceId);
|
|
return source ? getEventDrivers(source).map((driver) => driver.id) : [];
|
|
},
|
|
});
|
|
|
|
// Race made from House of RC: fetch late entries and withdrawals again.
|
|
document.getElementById("houseOfRcRefreshEntries")?.addEventListener("click", () => openHouseOfRcEntryRefresh({
|
|
event, state, t, escapeHtml,
|
|
makeDriver: (fields) => normalizeDriver({ id: uid("driver"), ...fields }),
|
|
onApply: (selectedIds) => {
|
|
const beforeIds = getEventDrivers(event).map((driver) => driver.id);
|
|
event.raceConfig.driverIds = selectedIds;
|
|
event.raceConfig.participantsConfigured = true;
|
|
syncParticipantsToSessions(state.sessions.filter((session) => session.eventId === event.id), beforeIds, selectedIds);
|
|
saveState();
|
|
refreshManager();
|
|
},
|
|
}));
|
|
|
|
// Send heats and qualifying to House of RC by itself after every heat (see app.js).
|
|
document.getElementById("houseOfRcAutoSend")?.addEventListener("change", (change) => {
|
|
event.houseOfRc.autoSend = change.currentTarget.checked;
|
|
saveState();
|
|
refreshManager();
|
|
});
|
|
|
|
// Race made from House of RC: preview and send the results to its entries.
|
|
document.getElementById("houseOfRcSendResults")?.addEventListener("click", () => openHouseOfRcResultsPost({
|
|
event, overview: getRaceOverview(event), state, t, escapeHtml, saveState,
|
|
}));
|
|
|
|
if (showTeamsSection) {
|
|
mountTeamRaceSetup(document.getElementById("manage-setup-teams"), {
|
|
event, state, t, escapeHtml, uid, saveState, refresh: refreshManager, getSessionsForEvent, getEventTeams, getTeamDriverPool, normalizeSession, getStatusLabel,
|
|
});
|
|
}
|
|
|
|
document.getElementById("raceFormatBasicToggle")?.addEventListener("click", () => {
|
|
setRaceFormatAdvanced(false);
|
|
rerenderEventManager(eventId);
|
|
});
|
|
|
|
document.getElementById("raceFormatAdvancedToggle")?.addEventListener("click", () => {
|
|
setRaceFormatAdvanced(true);
|
|
rerenderEventManager(eventId);
|
|
});
|
|
|
|
document.getElementById("raceFormatForm")?.addEventListener("submit", (e) => {
|
|
e.preventDefault();
|
|
const form = new FormData(e.currentTarget);
|
|
const config = buildRaceFormatConfigFromForm(form, event);
|
|
const before = { ...(event.raceConfig || {}) };
|
|
updateEvent((item) => ({
|
|
...item,
|
|
raceConfig: {
|
|
...config,
|
|
teams: getEventTeams(item),
|
|
},
|
|
}));
|
|
applyFormatToPendingSessions(state.sessions.filter((session) => session.eventId === event.id), before, config);
|
|
// Cars per heat or the number of rounds changed: build the qualifying heats again, as
|
|
// long as none of them has run (that would delete laps). updateEvent replaced the event,
|
|
// so the new config is read from state.
|
|
let notice = "";
|
|
// Practice heats follow cars per heat too (the race's own practice only, never one that ran).
|
|
if (Number(before.carsPerHeat) !== Number(config.carsPerHeat)) {
|
|
const updated = state.events.find((item) => item.id === event.id);
|
|
if (updated && rebuildPracticeHeats(updated) < 0) notice = t("events.format_practice_not_rebuilt");
|
|
}
|
|
const heatsChanged = ["carsPerHeat", "qualifyingRounds"].some((key) => Number(before[key]) !== Number(config[key]));
|
|
if (heatsChanged && getSessionsForEvent(event.id).some((s) => s.type === "qualification" && s.generated)) {
|
|
const run = runHeatNames("qualification");
|
|
const updated = state.events.find((item) => item.id === event.id);
|
|
// A rebuild shows in the heat list at once; only a refusal needs saying.
|
|
if (run) notice = [notice, t("events.format_heats_not_rebuilt", { names: run })].filter(Boolean).join("\n");
|
|
else if (updated) generateQualifyingForRace(updated);
|
|
}
|
|
saveState();
|
|
refreshManager();
|
|
if (notice) alert(notice);
|
|
});
|
|
|
|
document.getElementById("scheduleForm")?.addEventListener("submit", (e) => {
|
|
e.preventDefault();
|
|
const form = new FormData(e.currentTarget);
|
|
if (dayPlan) {
|
|
const time = String(form.get("scheduleStartTime") || "").trim();
|
|
const startAt = time ? new Date(`${event.date}T${time}`).getTime() : NaN;
|
|
saveDayPlan({ date: event.date, startAt: Number.isFinite(startAt) ? startAt : null, gapMin: Math.max(0, Number(form.get("scheduleGapMin")) || 0) });
|
|
updateEvent((item) => ({ ...item, raceConfig: { ...item.raceConfig, scheduleStartAt: null } }));
|
|
saveState();
|
|
refreshManager();
|
|
return;
|
|
}
|
|
const startValue = String(form.get("scheduleStartAt") || "").trim();
|
|
const parsedStart = startValue ? new Date(startValue).getTime() : NaN;
|
|
const gapMin = Math.max(0, Number(form.get("scheduleGapMin")) || 0);
|
|
updateEvent((item) => ({
|
|
...item,
|
|
raceConfig: {
|
|
...item.raceConfig,
|
|
scheduleStartAt: Number.isFinite(parsedStart) ? parsedStart : null,
|
|
scheduleGapMin: gapMin,
|
|
},
|
|
}));
|
|
saveState();
|
|
refreshManager();
|
|
});
|
|
|
|
document.getElementById("scheduleClear")?.addEventListener("click", () => {
|
|
if (dayPlan) saveDayPlan({ date: event.date, startAt: null });
|
|
updateEvent((item) => ({ ...item, raceConfig: { ...item.raceConfig, scheduleStartAt: null } }));
|
|
saveState();
|
|
refreshManager();
|
|
});
|
|
|
|
document.getElementById("applyRacePreset")?.addEventListener("click", () => {
|
|
const formElement = document.getElementById("raceFormatForm");
|
|
if (!(formElement instanceof HTMLFormElement)) {
|
|
return;
|
|
}
|
|
const form = new FormData(formElement);
|
|
updateEvent((item) => {
|
|
const next = normalizeEvent(item);
|
|
applyRaceFormatPreset(next, String(form.get("presetId") || "custom"));
|
|
return next;
|
|
});
|
|
saveState();
|
|
refreshManager();
|
|
});
|
|
|
|
document.getElementById("saveRacePreset")?.addEventListener("click", () => {
|
|
const formElement = document.getElementById("raceFormatForm");
|
|
if (!(formElement instanceof HTMLFormElement)) {
|
|
return;
|
|
}
|
|
const form = new FormData(formElement);
|
|
const presetName = String(form.get("presetName") || "").trim();
|
|
if (!presetName) {
|
|
return;
|
|
}
|
|
const config = buildRaceFormatConfigFromForm(form, event);
|
|
const selectedPresetId = String(form.get("presetId") || "custom");
|
|
const existingCustomPreset = (state.settings.racePresets || []).find((preset) => preset.id === selectedPresetId);
|
|
const presetId = existingCustomPreset ? existingCustomPreset.id : uid("preset");
|
|
const storedPreset = normalizeStoredRacePreset({
|
|
id: presetId,
|
|
name: presetName,
|
|
values: {
|
|
qualifyingScoring: config.qualifyingScoring,
|
|
qualifyingRounds: config.qualifyingRounds,
|
|
carsPerHeat: config.carsPerHeat,
|
|
qualDurationMin: config.qualDurationMin,
|
|
qualStartMode: config.qualStartMode,
|
|
qualSeedLapCount: config.qualSeedLapCount,
|
|
qualSeedMethod: config.qualSeedMethod,
|
|
practiceSeedLapCount: config.practiceSeedLapCount,
|
|
practiceSeedMethod: config.practiceSeedMethod,
|
|
countedQualRounds: config.countedQualRounds,
|
|
qualifyingPointsTable: config.qualifyingPointsTable,
|
|
qualifyingTieBreak: config.qualifyingTieBreak,
|
|
carsPerFinal: config.carsPerFinal,
|
|
finalLegs: config.finalLegs,
|
|
countedFinalLegs: config.countedFinalLegs,
|
|
finalDurationMin: config.finalDurationMin,
|
|
finalStartMode: config.finalStartMode,
|
|
qualPrologueSec: config.qualPrologueSec,
|
|
finalPrologueSec: config.finalPrologueSec,
|
|
followUpSec: config.followUpSec,
|
|
minLapMs: config.minLapMs,
|
|
maxLapMs: config.maxLapMs,
|
|
bumpCount: config.bumpCount,
|
|
reserveBumpSlots: config.reserveBumpSlots,
|
|
finalsSource: config.finalsSource,
|
|
},
|
|
});
|
|
const otherPresets = (state.settings.racePresets || []).filter((preset) => preset.id !== presetId);
|
|
state.settings.racePresets = [...otherPresets, storedPreset];
|
|
updateEvent((item) => ({
|
|
...item,
|
|
raceConfig: {
|
|
...config,
|
|
presetId,
|
|
teams: getEventTeams(item),
|
|
},
|
|
}));
|
|
saveState();
|
|
refreshManager();
|
|
});
|
|
|
|
document.getElementById("deleteRacePreset")?.addEventListener("click", () => {
|
|
const formElement = document.getElementById("raceFormatForm");
|
|
if (!(formElement instanceof HTMLFormElement)) {
|
|
return;
|
|
}
|
|
const form = new FormData(formElement);
|
|
const presetId = String(form.get("presetId") || "custom");
|
|
if (!(state.settings.racePresets || []).some((preset) => preset.id === presetId)) {
|
|
return;
|
|
}
|
|
state.settings.racePresets = (state.settings.racePresets || []).filter((preset) => preset.id !== presetId);
|
|
updateEvent((item) => ({
|
|
...item,
|
|
raceConfig: {
|
|
...item.raceConfig,
|
|
presetId: "custom",
|
|
},
|
|
}));
|
|
saveState();
|
|
refreshManager();
|
|
});
|
|
|
|
// Heats that already ran: Generate refuses (it would delete their laps), Clear asks first.
|
|
const runHeatNames = (type) => getSessionsForEvent(event.id).filter((s) => s.type === type && s.generated
|
|
&& (s.status !== "ready" || Object.keys(state.resultsBySession[s.id]?.competitors || {}).length)).map((s) => s.name).join(", ");
|
|
const confirmClearRunHeats = (type) => { const run = runHeatNames(type); return !run || window.confirm(t("events.clear_run_heats_confirm", { names: run })); };
|
|
|
|
document.getElementById("generateQualifying")?.addEventListener("click", () => {
|
|
const run = runHeatNames("qualification");
|
|
if (run) { alert(t("events.qualifying_already_run", { names: run })); return; }
|
|
const created = generateQualifyingForRace(event);
|
|
saveState();
|
|
rerenderEventManager(eventId);
|
|
if (created > 0) {
|
|
alert(t("events.generated_qualifying"));
|
|
}
|
|
});
|
|
|
|
// "Qualifying starts at": stored per class on the day plan (qualStartAt); the day schedule and
|
|
// the autopilot hold every qualifier of the class until then.
|
|
document.getElementById("qualStartForm")?.addEventListener("submit", (e) => {
|
|
e.preventDefault();
|
|
const time = String(new FormData(e.currentTarget).get("qualStart") || "").trim();
|
|
const at = /^\d{2}:\d{2}$/.test(time) ? new Date(`${event.date}T${time}:00`).getTime() : NaN;
|
|
const qualStartAt = { ...(dayPlan?.qualStartAt || {}) };
|
|
if (Number.isFinite(at)) qualStartAt[event.id] = at; else delete qualStartAt[event.id];
|
|
saveDayPlan({ date: event.date, qualStartAt });
|
|
refreshManager();
|
|
});
|
|
document.getElementById("qualStartClear")?.addEventListener("click", () => {
|
|
const qualStartAt = { ...(dayPlan?.qualStartAt || {}) };
|
|
delete qualStartAt[event.id];
|
|
saveDayPlan({ date: event.date, qualStartAt });
|
|
refreshManager();
|
|
});
|
|
|
|
document.getElementById("clearGeneratedQualifying")?.addEventListener("click", () => {
|
|
if (!confirmClearRunHeats("qualification")) return;
|
|
clearGeneratedQualifying(event.id);
|
|
saveState();
|
|
rerenderEventManager(eventId);
|
|
});
|
|
|
|
document.getElementById("reseedQualifying")?.addEventListener("click", () => {
|
|
const result = reseedUpcomingQualifying(event);
|
|
saveState();
|
|
rerenderEventManager(eventId);
|
|
const messages = [];
|
|
if (result.updated > 0) {
|
|
messages.push(t("events.reseed_done"));
|
|
} else {
|
|
messages.push(t("events.no_reseed_done"));
|
|
}
|
|
if (result.locked > 0) {
|
|
messages.push(t("events.reseed_locked", { count: result.locked }));
|
|
}
|
|
if (result.mismatched > 0) {
|
|
messages.push(t("events.reseed_mismatched", { count: result.mismatched }));
|
|
}
|
|
alert(messages.join("\n"));
|
|
});
|
|
|
|
document.getElementById("generateFinals")?.addEventListener("click", () => {
|
|
const run = runHeatNames("final");
|
|
if (run) { alert(t("events.finals_already_run", { names: run })); return; }
|
|
const created = generateFinalsForRace(event);
|
|
saveState();
|
|
rerenderEventManager(eventId);
|
|
if (created > 0) {
|
|
alert(t("events.finals_generated"));
|
|
}
|
|
});
|
|
|
|
document.getElementById("clearGeneratedFinals")?.addEventListener("click", () => {
|
|
if (!confirmClearRunHeats("final")) return;
|
|
clearGeneratedFinals(event.id);
|
|
saveState();
|
|
rerenderEventManager(eventId);
|
|
});
|
|
|
|
document.getElementById("applyBumps")?.addEventListener("click", () => {
|
|
const applied = applyBumpsForRace(event);
|
|
saveState();
|
|
rerenderEventManager(eventId);
|
|
alert(t(applied > 0 ? "events.bumps_applied" : "events.no_bumps_applied"));
|
|
});
|
|
|
|
document.getElementById("exportRacePackage")?.addEventListener("click", () => {
|
|
const payload = buildRacePackagePayload(eventId);
|
|
downloadJsonFile(`${sanitizeFilenameSegment(event.name)}_race_package.json`, payload);
|
|
});
|
|
|
|
document.getElementById("importRacePackage")?.addEventListener("change", (importEvent) => {
|
|
const input = importEvent.currentTarget;
|
|
const file = input instanceof HTMLInputElement ? input.files?.[0] : null;
|
|
if (!file) {
|
|
return;
|
|
}
|
|
const reader = new FileReader();
|
|
reader.onload = () => {
|
|
try {
|
|
const parsed = JSON.parse(String(reader.result || "{}"));
|
|
importRacePackagePayload(parsed);
|
|
} catch (error) {
|
|
alert(t("settings.import_failed", { msg: error instanceof Error ? error.message : String(error) }));
|
|
}
|
|
};
|
|
reader.readAsText(file);
|
|
});
|
|
|
|
document.getElementById("printStartlists")?.addEventListener("click", () => {
|
|
openPrintWindow(`${event.name} - ${t("events.start_lists")}`, buildRaceStartListsHtml(event));
|
|
});
|
|
|
|
document.getElementById("printResults")?.addEventListener("click", () => {
|
|
openPrintWindow(`${event.name} - ${t("events.results_overview")}`, buildRaceResultsHtml(event));
|
|
});
|
|
|
|
document.getElementById("printTeamResults")?.addEventListener("click", () => {
|
|
openPrintWindow(`${event.name} - ${t("events.team_report")}`, buildTeamRaceResultsHtml(event));
|
|
});
|
|
|
|
document.getElementById("pdfStartlists")?.addEventListener("click", async () => {
|
|
await exportRaceStartListsPdf(event);
|
|
});
|
|
|
|
document.getElementById("pdfResults")?.addEventListener("click", async () => {
|
|
await exportRaceResultsPdf(event);
|
|
});
|
|
|
|
document.getElementById("pdfTeamResults")?.addEventListener("click", async () => {
|
|
await exportTeamRaceResultsPdf(event);
|
|
});
|
|
|
|
document.getElementById("gridResetOrder")?.addEventListener("click", () => {
|
|
if (!selectedGridSession) {
|
|
return;
|
|
}
|
|
selectedGridSession.driverIds = getSessionEntrants(selectedGridSession)
|
|
.map((driver) => driver.id)
|
|
.filter(Boolean);
|
|
selectedGridSession.manualGridIds = [...selectedGridSession.driverIds];
|
|
selectedGridSession.gridCustomized = false;
|
|
saveState();
|
|
rerenderEventManager(eventId);
|
|
});
|
|
|
|
document.getElementById("gridToggleLock")?.addEventListener("click", () => {
|
|
if (!selectedGridSession) {
|
|
return;
|
|
}
|
|
if (!selectedGridSession.gridCustomized) {
|
|
selectedGridSession.manualGridIds = [...ensureSessionDriverOrder(selectedGridSession)];
|
|
selectedGridSession.gridCustomized = true;
|
|
} else {
|
|
selectedGridSession.manualGridIds = [...selectedGridSession.driverIds];
|
|
selectedGridSession.gridCustomized = false;
|
|
}
|
|
saveState();
|
|
rerenderEventManager(eventId);
|
|
});
|
|
|
|
let dragIndex = null;
|
|
document.querySelectorAll("#gridDragList .drag-item").forEach((node) => {
|
|
node.addEventListener("dragstart", () => {
|
|
dragIndex = Number(node.dataset.index);
|
|
node.classList.add("drag-item-active");
|
|
});
|
|
node.addEventListener("dragend", () => {
|
|
dragIndex = null;
|
|
node.classList.remove("drag-item-active");
|
|
});
|
|
node.addEventListener("dragover", (dragEvent) => {
|
|
dragEvent.preventDefault();
|
|
node.classList.add("drag-item-over");
|
|
});
|
|
node.addEventListener("dragleave", () => {
|
|
node.classList.remove("drag-item-over");
|
|
});
|
|
node.addEventListener("drop", (dropEvent) => {
|
|
dropEvent.preventDefault();
|
|
node.classList.remove("drag-item-over");
|
|
if (!selectedGridSession || dragIndex === null) {
|
|
return;
|
|
}
|
|
const dropIndex = Number(node.dataset.index);
|
|
if (Number.isNaN(dropIndex) || dropIndex === dragIndex) {
|
|
return;
|
|
}
|
|
selectedGridSession.manualGridIds = reorderList(ensureSessionDriverOrder(selectedGridSession), dragIndex, dropIndex);
|
|
selectedGridSession.gridCustomized = true;
|
|
saveState();
|
|
rerenderEventManager(eventId);
|
|
});
|
|
});
|
|
}
|
|
|
|
}
|