435 lines
14 KiB
TypeScript
435 lines
14 KiB
TypeScript
// /app/api/matches/[id]/mapvote/route.ts
|
||
import { NextResponse, NextRequest } from 'next/server'
|
||
import { getServerSession } from 'next-auth'
|
||
import { authOptions } from '@/app/lib/auth'
|
||
import { prisma } from '@/app/lib/prisma'
|
||
import { MapVetoAction } from '@/generated/prisma'
|
||
import { sendServerSSEMessage } from '@/app/lib/sse-server-client'
|
||
|
||
/* -------------------- Konstanten -------------------- */
|
||
|
||
const ACTIVE_DUTY: string[] = [
|
||
'de_inferno','de_mirage','de_nuke','de_overpass','de_vertigo','de_ancient','de_anubis',
|
||
]
|
||
|
||
const ACTION_MAP: Record<MapVetoAction, 'ban'|'pick'|'decider'> = {
|
||
BAN: 'ban', PICK: 'pick', DECIDER: 'decider',
|
||
}
|
||
|
||
/* -------------------- Helper -------------------- */
|
||
|
||
function vetoOpensAt(match: { matchDate: Date | null, demoDate: Date | null }) {
|
||
const base = match.matchDate ?? match.demoDate ?? new Date()
|
||
return new Date(base.getTime() - 60 * 60 * 1000) // 1h vorher
|
||
}
|
||
|
||
function mapActionToApi(a: MapVetoAction): 'ban'|'pick'|'decider' {
|
||
return ACTION_MAP[a]
|
||
}
|
||
|
||
function buildSteps(bestOf: number, teamAId: string, teamBId: string) {
|
||
if (bestOf === 3) {
|
||
// 2x Ban, 2x Pick, 2x Ban, Decider
|
||
return [
|
||
{ order: 0, action: 'BAN', teamId: teamAId },
|
||
{ order: 1, action: 'BAN', teamId: teamBId },
|
||
{ order: 2, action: 'PICK', teamId: teamAId },
|
||
{ order: 3, action: 'PICK', teamId: teamBId },
|
||
{ order: 4, action: 'BAN', teamId: teamAId },
|
||
{ order: 5, action: 'BAN', teamId: teamBId },
|
||
{ order: 6, action: 'DECIDER', teamId: null },
|
||
] as const
|
||
}
|
||
// BO5: 2x Ban, dann 5 Picks (kein Decider)
|
||
return [
|
||
{ order: 0, action: 'BAN', teamId: teamAId },
|
||
{ order: 1, action: 'BAN', teamId: teamBId },
|
||
{ order: 2, action: 'PICK', teamId: teamAId },
|
||
{ order: 3, action: 'PICK', teamId: teamBId },
|
||
{ order: 4, action: 'PICK', teamId: teamAId },
|
||
{ order: 5, action: 'PICK', teamId: teamBId },
|
||
{ order: 6, action: 'PICK', teamId: teamAId },
|
||
] as const
|
||
}
|
||
|
||
function shapeState(veto: any) {
|
||
const steps = [...veto.steps]
|
||
.sort((a, b) => a.order - b.order)
|
||
.map((s: any) => ({
|
||
order : s.order,
|
||
action : mapActionToApi(s.action),
|
||
teamId : s.teamId,
|
||
map : s.map,
|
||
chosenAt: s.chosenAt ? s.chosenAt.toISOString() : null,
|
||
chosenBy: s.chosenBy ?? null,
|
||
}))
|
||
|
||
return {
|
||
bestOf : veto.bestOf,
|
||
mapPool : veto.mapPool as string[],
|
||
currentIndex: veto.currentIdx,
|
||
locked : veto.locked as boolean,
|
||
opensAt : veto.opensAt ? new Date(veto.opensAt).toISOString() : null,
|
||
steps,
|
||
}
|
||
}
|
||
|
||
// Leader -> Player-Shape fürs Frontend
|
||
function shapeLeader(leader: any | null) {
|
||
if (!leader) return null
|
||
return {
|
||
steamId : leader.steamId,
|
||
name : leader.name ?? '',
|
||
avatar : leader.avatar ?? '',
|
||
location : leader.location ?? undefined,
|
||
premierRank: leader.premierRank ?? undefined,
|
||
isAdmin : leader.isAdmin ?? undefined,
|
||
}
|
||
}
|
||
|
||
// Player -> Player-Shape (falls wir aus Team-API übernehmen)
|
||
function shapePlayer(p: any) {
|
||
if (!p) return null
|
||
return {
|
||
steamId : p.steamId,
|
||
name : p.name ?? '',
|
||
avatar : p.avatar ?? '',
|
||
location : p.location ?? undefined,
|
||
premierRank: p.premierRank ?? undefined,
|
||
isAdmin : p.isAdmin ?? undefined,
|
||
}
|
||
}
|
||
|
||
// Base-URL aus Request ableiten (lokal/proxy-fähig)
|
||
function getBaseUrl(req: NextRequest | NextResponse) {
|
||
// NextRequest hat headers; bei internen Aufrufen ggf. NextResponse, hier aber nur Request relevant
|
||
const proto = (req.headers.get('x-forwarded-proto') || 'http').split(',')[0].trim()
|
||
const host = (req.headers.get('x-forwarded-host') || req.headers.get('host') || '').split(',')[0].trim()
|
||
return `${proto}://${host}`
|
||
}
|
||
|
||
async function fetchTeamApi(teamId: string | null | undefined, req: NextRequest) {
|
||
if (!teamId) return null
|
||
const base = getBaseUrl(req)
|
||
const url = `${base}/api/team/${teamId}`
|
||
|
||
try {
|
||
const r = await fetch(url, {
|
||
// interne Server-Fetches dürfen nicht gecacht werden
|
||
cache: 'no-store',
|
||
headers: {
|
||
// Forward auth/proxy headers, falls nötig (nicht zwingend)
|
||
'x-forwarded-proto': req.headers.get('x-forwarded-proto') || '',
|
||
'x-forwarded-host' : req.headers.get('x-forwarded-host') || '',
|
||
}
|
||
})
|
||
if (!r.ok) return null
|
||
const json = await r.json()
|
||
return json as {
|
||
id: string
|
||
name?: string | null
|
||
logo?: string | null
|
||
leader?: string | null // LeaderId
|
||
activePlayers: any[]
|
||
inactivePlayers: any[]
|
||
invitedPlayers: any[]
|
||
}
|
||
} catch {
|
||
return null
|
||
}
|
||
}
|
||
|
||
// Leader bevorzugt aus Match-Relation; Fallback über Team-API (LeaderId -> Player aus Listen)
|
||
function resolveLeaderPlayer(matchTeam: any | null | undefined, teamApi: any | null) {
|
||
const leaderFromMatch = shapeLeader(matchTeam?.leader ?? null)
|
||
if (leaderFromMatch) return leaderFromMatch
|
||
|
||
const leaderId: string | null = teamApi?.leader ?? null
|
||
if (!leaderId) return null
|
||
|
||
const pool: any[] = [
|
||
...(teamApi?.activePlayers ?? []),
|
||
...(teamApi?.inactivePlayers ?? []),
|
||
...(teamApi?.invitedPlayers ?? []),
|
||
]
|
||
const found = pool.find(p => p?.steamId === leaderId)
|
||
return shapePlayer(found) ?? { steamId: leaderId, name: '', avatar: '' }
|
||
}
|
||
|
||
async function ensureVeto(matchId: string) {
|
||
const match = await prisma.match.findUnique({
|
||
where: { id: matchId },
|
||
include: {
|
||
teamA : {
|
||
include: {
|
||
// Leader-Relation als Objekt laden
|
||
leader: {
|
||
select: {
|
||
steamId: true,
|
||
name: true,
|
||
avatar: true,
|
||
location: true,
|
||
premierRank: true,
|
||
isAdmin: true,
|
||
}
|
||
}
|
||
}
|
||
},
|
||
teamB : {
|
||
include: {
|
||
leader: {
|
||
select: {
|
||
steamId: true,
|
||
name: true,
|
||
avatar: true,
|
||
location: true,
|
||
premierRank: true,
|
||
isAdmin: true,
|
||
}
|
||
}
|
||
}
|
||
},
|
||
mapVeto: { include: { steps: true } },
|
||
},
|
||
})
|
||
if (!match) return { match: null, veto: null }
|
||
|
||
// Bereits vorhanden?
|
||
if (match.mapVeto) return { match, veto: match.mapVeto }
|
||
|
||
// Neu anlegen
|
||
const bestOf = match.bestOf ?? 3
|
||
const mapPool = ACTIVE_DUTY
|
||
const opensAt = vetoOpensAt({ matchDate: match.matchDate ?? null, demoDate: match.demoDate ?? null })
|
||
const stepsDef = buildSteps(bestOf, match.teamA!.id, match.teamB!.id)
|
||
|
||
const created = await prisma.mapVeto.create({
|
||
data: {
|
||
matchId : match.id,
|
||
bestOf,
|
||
mapPool,
|
||
currentIdx: 0,
|
||
locked : false,
|
||
opensAt,
|
||
steps : {
|
||
create: stepsDef.map(s => ({
|
||
order : s.order,
|
||
action: s.action as MapVetoAction,
|
||
teamId: s.teamId,
|
||
})),
|
||
},
|
||
},
|
||
include: { steps: true },
|
||
})
|
||
|
||
return { match, veto: created }
|
||
}
|
||
|
||
function computeAvailableMaps(mapPool: string[], steps: Array<{ map: string | null }>) {
|
||
const used = new Set(steps.map(s => s.map).filter(Boolean) as string[])
|
||
return mapPool.filter(m => !used.has(m))
|
||
}
|
||
|
||
// Teams-Payload (mit Spielern) zusammenbauen
|
||
async function buildTeamsPayload(match: any, req: NextRequest) {
|
||
const [teamAApi, teamBApi] = await Promise.all([
|
||
fetchTeamApi(match.teamA?.id, req),
|
||
fetchTeamApi(match.teamB?.id, req),
|
||
])
|
||
|
||
const teamAPlayers = (teamAApi?.activePlayers ?? []).map(shapePlayer).filter(Boolean)
|
||
const teamBPlayers = (teamBApi?.activePlayers ?? []).map(shapePlayer).filter(Boolean)
|
||
|
||
return {
|
||
teamA: {
|
||
id : match.teamA?.id ?? null,
|
||
name : match.teamA?.name ?? null,
|
||
logo : match.teamA?.logo ?? null,
|
||
leader: resolveLeaderPlayer(match.teamA, teamAApi),
|
||
players: teamAPlayers,
|
||
},
|
||
teamB: {
|
||
id : match.teamB?.id ?? null,
|
||
name : match.teamB?.name ?? null,
|
||
logo : match.teamB?.logo ?? null,
|
||
leader: resolveLeaderPlayer(match.teamB, teamBApi),
|
||
players: teamBPlayers,
|
||
},
|
||
}
|
||
}
|
||
|
||
/* -------------------- GET -------------------- */
|
||
|
||
export async function GET(req: NextRequest, { params }: { params: { matchId: string } }) {
|
||
try {
|
||
const matchId = params.matchId
|
||
if (!matchId) return NextResponse.json({ message: 'Missing id' }, { status: 400 })
|
||
|
||
const { match, veto } = await ensureVeto(matchId)
|
||
if (!match || !veto) return NextResponse.json({ message: 'Match nicht gefunden' }, { status: 404 })
|
||
|
||
const teams = await buildTeamsPayload(match, req)
|
||
|
||
return NextResponse.json(
|
||
{ ...shapeState(veto), teams },
|
||
{ headers: { 'Cache-Control': 'no-store' } },
|
||
)
|
||
} catch (e) {
|
||
console.error('[map-vote][GET] error', e)
|
||
return NextResponse.json({ message: 'Fehler beim Laden' }, { status: 500 })
|
||
}
|
||
}
|
||
|
||
/* -------------------- POST ------------------- */
|
||
|
||
export async function POST(req: NextRequest, { params }: { params: { matchId: string } }) {
|
||
const session = await getServerSession(authOptions(req))
|
||
const me = session?.user as { steamId: string; isAdmin?: boolean } | undefined
|
||
if (!me?.steamId) return NextResponse.json({ message: 'Nicht eingeloggt' }, { status: 401 })
|
||
|
||
const matchId = params.matchId
|
||
if (!matchId) return NextResponse.json({ message: 'Missing id' }, { status: 400 })
|
||
|
||
let body: { map?: string } = {}
|
||
try { body = await req.json() } catch {}
|
||
|
||
try {
|
||
const { match, veto } = await ensureVeto(matchId)
|
||
if (!match || !veto) return NextResponse.json({ message: 'Match nicht gefunden' }, { status: 404 })
|
||
|
||
// Öffnungsfenster (1h vor Match-/Demo-Beginn)
|
||
const opensAt = veto.opensAt ?? vetoOpensAt({ matchDate: match.matchDate ?? null, demoDate: match.demoDate ?? null })
|
||
const isOpen = new Date() >= new Date(opensAt)
|
||
if (!isOpen && !me.isAdmin) return NextResponse.json({ message: 'Veto ist noch nicht offen' }, { status: 403 })
|
||
|
||
// Schon abgeschlossen?
|
||
if (veto.locked) return NextResponse.json({ message: 'Veto bereits abgeschlossen' }, { status: 409 })
|
||
|
||
// Aktuellen Schritt bestimmen
|
||
const stepsSorted = [...veto.steps].sort((a: any, b: any) => a.order - b.order)
|
||
const current = stepsSorted.find((s: any) => s.order === veto.currentIdx)
|
||
|
||
if (!current) {
|
||
// Kein Schritt mehr -> Veto abschließen
|
||
await prisma.mapVeto.update({ where: { id: veto.id }, data: { locked: true } })
|
||
|
||
const updated = await prisma.mapVeto.findUnique({
|
||
where: { id: veto.id },
|
||
include: { steps: true },
|
||
})
|
||
|
||
// 🔔 Broadcast (flat)
|
||
await sendServerSSEMessage({ type: 'map-vote-updated', matchId })
|
||
|
||
const teams = await buildTeamsPayload(match, req)
|
||
|
||
return NextResponse.json({ ...shapeState(updated), teams })
|
||
}
|
||
|
||
const available = computeAvailableMaps(veto.mapPool, stepsSorted)
|
||
|
||
// DECIDER automatisch setzen, wenn nur noch 1 Map übrig
|
||
if (current.action === 'DECIDER') {
|
||
if (available.length !== 1) {
|
||
return NextResponse.json({ message: 'DECIDER noch nicht bestimmbar' }, { status: 400 })
|
||
}
|
||
const lastMap = available[0]
|
||
await prisma.$transaction(async (tx) => {
|
||
await tx.mapVetoStep.update({
|
||
where: { id: current.id },
|
||
data : { map: lastMap, chosenAt: new Date(), chosenBy: me.steamId },
|
||
})
|
||
await tx.mapVeto.update({
|
||
where: { id: veto.id },
|
||
data : { currentIdx: veto.currentIdx + 1, locked: true },
|
||
})
|
||
})
|
||
|
||
const updated = await prisma.mapVeto.findUnique({
|
||
where: { id: veto.id },
|
||
include: { steps: true },
|
||
})
|
||
|
||
// 🔔 Broadcast (flat)
|
||
await sendServerSSEMessage({ type: 'map-vote-updated', matchId })
|
||
|
||
const teams = await buildTeamsPayload(match, req)
|
||
|
||
return NextResponse.json({ ...shapeState(updated), teams })
|
||
}
|
||
|
||
// Rechte prüfen (Admin oder Leader des Teams am Zug) – weiterhin via leaderId
|
||
const isLeaderA = !!(match as any).teamA?.leaderId && (match as any).teamA.leaderId === me.steamId
|
||
const isLeaderB = !!(match as any).teamB?.leaderId && (match as any).teamB.leaderId === me.steamId
|
||
const allowed = me.isAdmin || (current.teamId && (
|
||
(current.teamId === match.teamA?.id && isLeaderA) ||
|
||
(current.teamId === match.teamB?.id && isLeaderB)
|
||
))
|
||
if (!allowed) return NextResponse.json({ message: 'Keine Berechtigung für diesen Schritt' }, { status: 403 })
|
||
|
||
// Payload validieren
|
||
const map = body.map?.trim()
|
||
if (!map) return NextResponse.json({ message: 'map fehlt' }, { status: 400 })
|
||
if (!veto.mapPool.includes(map)) return NextResponse.json({ message: 'Map nicht im Pool' }, { status: 400 })
|
||
if (!available.includes(map)) return NextResponse.json({ message: 'Map bereits vergeben' }, { status: 409 })
|
||
|
||
// Schritt setzen & ggf. weiterdrehen (+ Decider evtl. auto)
|
||
await prisma.$transaction(async (tx) => {
|
||
// aktuellen Schritt setzen
|
||
await tx.mapVetoStep.update({
|
||
where: { id: current.id },
|
||
data : { map, chosenAt: new Date(), chosenBy: me.steamId },
|
||
})
|
||
|
||
// neuen Zustand ermitteln
|
||
const after = await tx.mapVeto.findUnique({
|
||
where : { id: veto.id },
|
||
include: { steps: true },
|
||
})
|
||
if (!after) return
|
||
|
||
const stepsAfter = [...after.steps].sort((a: any, b: any) => a.order - b.order)
|
||
let idx = after.currentIdx + 1
|
||
let locked = false
|
||
|
||
// Falls nächster Schritt DECIDER und genau 1 Map übrig -> auto setzen & locken
|
||
const next = stepsAfter.find(s => s.order === idx)
|
||
if (next?.action === 'DECIDER') {
|
||
const avail = computeAvailableMaps(after.mapPool, stepsAfter)
|
||
if (avail.length === 1) {
|
||
await tx.mapVetoStep.update({
|
||
where: { id: next.id },
|
||
data : { map: avail[0], chosenAt: new Date(), chosenBy: me.steamId },
|
||
})
|
||
idx += 1
|
||
locked = true
|
||
}
|
||
}
|
||
|
||
// Ende erreicht?
|
||
const maxOrder = Math.max(...stepsAfter.map(s => s.order))
|
||
if (idx > maxOrder) locked = true
|
||
|
||
await tx.mapVeto.update({
|
||
where: { id: after.id },
|
||
data : { currentIdx: idx, locked },
|
||
})
|
||
})
|
||
|
||
const updated = await prisma.mapVeto.findUnique({
|
||
where : { id: veto.id },
|
||
include: { steps: true },
|
||
})
|
||
|
||
// 🔔 Broadcast (flat)
|
||
await sendServerSSEMessage({ type: 'map-vote-updated', matchId })
|
||
|
||
const teams = await buildTeamsPayload(match, req)
|
||
|
||
return NextResponse.json({ ...shapeState(updated), teams })
|
||
} catch (e) {
|
||
console.error('[map-vote][POST] error', e)
|
||
return NextResponse.json({ message: 'Aktion fehlgeschlagen' }, { status: 500 })
|
||
}
|
||
}
|