1005 lines
30 KiB
TypeScript
Executable File
1005 lines
30 KiB
TypeScript
Executable File
import { Injectable, Logger } from "@nestjs/common";
|
|
import * as fs from "fs";
|
|
import * as path from "path";
|
|
import { PrismaService } from "../../database/prisma.service";
|
|
import {
|
|
Sport,
|
|
MatchQueryDto,
|
|
LeagueWithMatchesDto,
|
|
ActiveLeagueDto,
|
|
} from "./dto";
|
|
import { Prisma } from "@prisma/client";
|
|
import {
|
|
FINISHED_STATE_VALUES_FOR_DB,
|
|
FINISHED_STATUS_VALUES_FOR_DB,
|
|
LIVE_STATE_VALUES_FOR_DB,
|
|
LIVE_STATUS_VALUES_FOR_DB,
|
|
getDisplayMatchStatus,
|
|
} from "../../common/utils/match-status.util";
|
|
|
|
@Injectable()
|
|
export class MatchesService {
|
|
private readonly logger = new Logger(MatchesService.name);
|
|
private topLeagueIds: string[] = [];
|
|
|
|
constructor(private readonly prisma: PrismaService) {
|
|
this.loadTopLeagues();
|
|
}
|
|
|
|
private loadTopLeagues() {
|
|
try {
|
|
const topLeaguesPath = path.join(process.cwd(), "top_leagues.json");
|
|
if (fs.existsSync(topLeaguesPath)) {
|
|
this.topLeagueIds = JSON.parse(fs.readFileSync(topLeaguesPath, "utf8"));
|
|
this.logger.log(
|
|
`Loaded ${this.topLeagueIds.length} top leagues for filtering.`,
|
|
);
|
|
}
|
|
} catch (e) {
|
|
this.logger.warn(`Failed to load top_leagues.json: ${e.message}`);
|
|
}
|
|
}
|
|
|
|
private getLiveFilter(): Prisma.LiveMatchWhereInput {
|
|
return {
|
|
OR: [
|
|
{
|
|
status: {
|
|
in: LIVE_STATUS_VALUES_FOR_DB,
|
|
},
|
|
},
|
|
{
|
|
state: {
|
|
in: LIVE_STATE_VALUES_FOR_DB,
|
|
},
|
|
},
|
|
],
|
|
};
|
|
}
|
|
|
|
private getFinishedFilter(): Prisma.LiveMatchWhereInput {
|
|
return {
|
|
OR: [
|
|
{
|
|
status: {
|
|
in: FINISHED_STATUS_VALUES_FOR_DB,
|
|
},
|
|
},
|
|
{
|
|
state: {
|
|
in: FINISHED_STATE_VALUES_FOR_DB,
|
|
},
|
|
},
|
|
{
|
|
AND: [
|
|
{ scoreHome: { not: null } },
|
|
{ scoreAway: { not: null } },
|
|
{
|
|
NOT: this.getLiveFilter(),
|
|
},
|
|
],
|
|
},
|
|
],
|
|
};
|
|
}
|
|
|
|
private getUpcomingFilter(
|
|
fromTimestampMs: number,
|
|
): Prisma.LiveMatchWhereInput {
|
|
return {
|
|
AND: [
|
|
{
|
|
mstUtc: {
|
|
gte: BigInt(fromTimestampMs),
|
|
},
|
|
},
|
|
{
|
|
NOT: {
|
|
OR: [this.getLiveFilter(), this.getFinishedFilter()],
|
|
},
|
|
},
|
|
],
|
|
};
|
|
}
|
|
|
|
private getBrowseFilter(fromTimestampMs: number): Prisma.LiveMatchWhereInput {
|
|
return {
|
|
AND: [
|
|
{
|
|
mstUtc: {
|
|
gte: BigInt(fromTimestampMs),
|
|
},
|
|
},
|
|
{
|
|
NOT: this.getFinishedFilter(),
|
|
},
|
|
],
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Find matches by query criteria
|
|
*/
|
|
async findMatches(options: MatchQueryDto): Promise<string[]> {
|
|
const {
|
|
sport,
|
|
limit = 50,
|
|
leagueId,
|
|
status,
|
|
date,
|
|
team,
|
|
dateRange,
|
|
} = options;
|
|
|
|
// Build where conditions
|
|
const where: Prisma.LiveMatchWhereInput = {
|
|
sport: sport as any,
|
|
};
|
|
const andConditions: Prisma.LiveMatchWhereInput[] = [];
|
|
|
|
if (leagueId) {
|
|
where.leagueId = leagueId;
|
|
} else if (status === "LIVE" && this.topLeagueIds.length > 0) {
|
|
// Filter live matches by top leagues by default if no leagueId is provided
|
|
where.leagueId = { in: this.topLeagueIds };
|
|
}
|
|
|
|
if (status === "LIVE") {
|
|
andConditions.push(this.getLiveFilter());
|
|
} else if (status === "UPCOMING" || status === "NOT_STARTED") {
|
|
andConditions.push(this.getUpcomingFilter(Date.now()));
|
|
} else if (status === "FINISHED") {
|
|
andConditions.push(this.getFinishedFilter());
|
|
} else if (status) {
|
|
where.status = status;
|
|
}
|
|
|
|
// Date filter
|
|
if (date) {
|
|
const d = new Date(date);
|
|
const startOfDay = new Date(d);
|
|
startOfDay.setUTCHours(0, 0, 0, 0);
|
|
const endOfDay = new Date(d);
|
|
endOfDay.setUTCHours(23, 59, 59, 999);
|
|
|
|
where.mstUtc = {
|
|
gte: BigInt(startOfDay.getTime()),
|
|
lte: BigInt(endOfDay.getTime()),
|
|
};
|
|
} else if (dateRange) {
|
|
where.mstUtc = {
|
|
gte: BigInt(new Date(dateRange.from).getTime()),
|
|
lte: BigInt(new Date(dateRange.to).getTime()),
|
|
};
|
|
}
|
|
|
|
// Team filter
|
|
if (team) {
|
|
if (team.role === "home") {
|
|
where.homeTeamId = team.id;
|
|
} else if (team.role === "away") {
|
|
where.awayTeamId = team.id;
|
|
} else {
|
|
andConditions.push({
|
|
OR: [{ homeTeamId: team.id }, { awayTeamId: team.id }],
|
|
});
|
|
}
|
|
}
|
|
|
|
// Default date filter: From today onwards if no specific filter
|
|
if (!date && !dateRange && !status) {
|
|
const today = new Date();
|
|
today.setUTCHours(0, 0, 0, 0); // Start of today in UTC
|
|
|
|
andConditions.push(this.getBrowseFilter(today.getTime()));
|
|
}
|
|
|
|
if (andConditions.length > 0) {
|
|
where.AND = andConditions;
|
|
}
|
|
|
|
// Switch to live_matches table
|
|
const matches = await this.prisma.liveMatch.findMany({
|
|
where,
|
|
select: { id: true },
|
|
orderBy: { mstUtc: "asc" }, // Sort by nearest match first
|
|
take: limit,
|
|
});
|
|
|
|
return matches.map((m) => m.id);
|
|
}
|
|
|
|
/**
|
|
* Find upcoming matches from the live matches table
|
|
* Used for Coupon Generator when no specific matches are selected
|
|
*/
|
|
async findUpcomingMatches(
|
|
sport: Sport,
|
|
limit: number = 50,
|
|
): Promise<string[]> {
|
|
console.log(`[MatchesService] Finding upcoming matches for ${sport}`);
|
|
|
|
const matches = await this.prisma.liveMatch.findMany({
|
|
where: {
|
|
sport: sport as any,
|
|
AND: [this.getUpcomingFilter(Date.now())],
|
|
},
|
|
select: { id: true },
|
|
orderBy: { mstUtc: "asc" },
|
|
take: limit,
|
|
});
|
|
console.log(
|
|
`[MatchesService] Found ${matches.length} upcoming matches from live_matches`,
|
|
);
|
|
|
|
return matches.map((m) => m.id);
|
|
}
|
|
|
|
async filterUpcomingMatchIds(
|
|
matchIds: string[],
|
|
sport: Sport,
|
|
): Promise<string[]> {
|
|
const uniqueIds = [...new Set(matchIds.filter((id) => !!id))];
|
|
|
|
if (uniqueIds.length === 0) {
|
|
return [];
|
|
}
|
|
|
|
const matches = await this.prisma.liveMatch.findMany({
|
|
where: {
|
|
id: { in: uniqueIds },
|
|
sport: sport as any,
|
|
AND: [this.getUpcomingFilter(Date.now())],
|
|
},
|
|
select: { id: true },
|
|
});
|
|
|
|
return matches.map((match) => match.id);
|
|
}
|
|
|
|
/**
|
|
* Get matches structured by league (from live_matches table)
|
|
*/
|
|
async getMatchesAndStructureByIds(
|
|
matchIds: string[],
|
|
sport: Sport,
|
|
): Promise<LeagueWithMatchesDto[]> {
|
|
if (!matchIds.length) return [];
|
|
|
|
const matches = await this.prisma.liveMatch.findMany({
|
|
where: { id: { in: matchIds } },
|
|
include: {
|
|
league: {
|
|
include: {
|
|
country: true,
|
|
},
|
|
},
|
|
homeTeam: true,
|
|
awayTeam: true,
|
|
},
|
|
});
|
|
|
|
// Sort matches by time (ASC) before grouping to ensure correct order
|
|
matches.sort((a, b) =>
|
|
Number(BigInt(a.mstUtc || 0) - BigInt(b.mstUtc || 0)),
|
|
);
|
|
|
|
// Group by league
|
|
const leaguesMap = new Map<string, LeagueWithMatchesDto>();
|
|
|
|
for (const match of matches) {
|
|
const leagueId = match.leagueId || "unknown";
|
|
|
|
if (!leaguesMap.has(leagueId)) {
|
|
leaguesMap.set(leagueId, {
|
|
id: leagueId,
|
|
name: match.league?.name || "Unknown League",
|
|
code: match.league?.code || undefined,
|
|
country: {
|
|
id: match.league?.country?.id || "",
|
|
name: match.league?.country?.name || "",
|
|
flagUrl: match.league?.country?.flagUrl || undefined,
|
|
},
|
|
sport: sport,
|
|
matches: [],
|
|
});
|
|
}
|
|
|
|
const league = leaguesMap.get(leagueId)!;
|
|
|
|
// Structure odds from JSON
|
|
const structuredOdds: any[] = [];
|
|
if (
|
|
match.odds &&
|
|
typeof match.odds === "object" &&
|
|
!Array.isArray(match.odds)
|
|
) {
|
|
const oddsObj = match.odds as Record<string, Record<string, number>>;
|
|
for (const [marketName, selections] of Object.entries(oddsObj)) {
|
|
const structuredSelections: Record<string, { odd: string }> = {};
|
|
if (selections && typeof selections === "object") {
|
|
for (const [selName, selOdd] of Object.entries(selections)) {
|
|
structuredSelections[selName] = { odd: String(selOdd) };
|
|
}
|
|
structuredOdds.push({
|
|
category_name: marketName,
|
|
selections: structuredSelections,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
// Map status for frontend
|
|
const displayStatus = getDisplayMatchStatus({
|
|
state: match.state,
|
|
status: match.status,
|
|
substate: match.substate,
|
|
scoreHome: match.scoreHome,
|
|
scoreAway: match.scoreAway,
|
|
});
|
|
|
|
league.matches.push({
|
|
id: match.id,
|
|
matchName:
|
|
match.matchName ||
|
|
`${match.homeTeam?.name} vs ${match.awayTeam?.name}`,
|
|
matchSlug: match.matchSlug || undefined,
|
|
mstUtc: Number(match.mstUtc),
|
|
status: displayStatus,
|
|
state: match.state || undefined,
|
|
scoreHome: match.scoreHome ?? undefined,
|
|
scoreAway: match.scoreAway ?? undefined,
|
|
htScoreHome: undefined, // LiveMatch table doesn't have HT scores separately usually
|
|
htScoreAway: undefined,
|
|
homeTeamName: match.homeTeam?.name || "Unknown",
|
|
homeTeamLogo: match.homeTeamId
|
|
? `https://file.mackolikfeeds.com/teams/${match.homeTeamId}`
|
|
: undefined,
|
|
awayTeamName: match.awayTeam?.name || "Unknown",
|
|
awayTeamLogo: match.awayTeamId
|
|
? `https://file.mackolikfeeds.com/teams/${match.awayTeamId}`
|
|
: undefined,
|
|
leagueName: match.league?.name,
|
|
countryName: match.league?.country?.name,
|
|
odds: structuredOdds,
|
|
});
|
|
}
|
|
|
|
return Array.from(leaguesMap.values());
|
|
}
|
|
|
|
/**
|
|
* Get active leagues with match counts
|
|
*/
|
|
async getActiveLeagues(sport: Sport): Promise<ActiveLeagueDto[]> {
|
|
// Use raw query for complex aggregation
|
|
const leagues = await this.prisma.$queryRaw<any[]>`
|
|
SELECT
|
|
l.id, l.name, l.code,
|
|
c.name as country_name,
|
|
c.flag_url as country_flag,
|
|
COUNT(lm.id)::int as match_count,
|
|
COUNT(CASE WHEN lm.status IN ('LIVE', '1H', '2H', 'HT', '1Q', '2Q', '3Q', '4Q', 'Playing', 'Half Time')
|
|
OR lm.state IN ('live', 'firsthalf', 'secondhalf') THEN 1 END)::int as live_count
|
|
FROM live_matches lm
|
|
JOIN leagues l ON lm.league_id = l.id
|
|
LEFT JOIN countries c ON l.country_id = c.id
|
|
WHERE lm.sport = ${sport}
|
|
${this.topLeagueIds.length > 0 ? Prisma.sql`AND l.id IN (${Prisma.join(this.topLeagueIds)})` : Prisma.empty}
|
|
GROUP BY l.id, l.name, l.code, c.name, c.flag_url
|
|
ORDER BY l.name ASC
|
|
`;
|
|
|
|
// Priority sorting (Mackolik style)
|
|
const PRIORITY = [
|
|
"Trendyol Süper Lig",
|
|
"Süper Lig",
|
|
"Trendyol 1. Lig",
|
|
"1. Lig",
|
|
"Premier Lig",
|
|
"LaLiga",
|
|
"Serie A",
|
|
"Bundesliga",
|
|
"Ligue 1",
|
|
];
|
|
|
|
return leagues
|
|
.sort((a, b) => {
|
|
const aIdx = PRIORITY.findIndex((p) => a.name?.includes(p));
|
|
const bIdx = PRIORITY.findIndex((p) => b.name?.includes(p));
|
|
|
|
const aPriority = aIdx === -1 ? 999 : aIdx;
|
|
const bPriority = bIdx === -1 ? 999 : bIdx;
|
|
|
|
if (aPriority !== bPriority) return aPriority - bPriority;
|
|
return (a.name || "").localeCompare(b.name || "");
|
|
})
|
|
.map((l) => ({
|
|
id: l.id,
|
|
name: l.name,
|
|
code: l.code,
|
|
countryName: l.country_name,
|
|
countryFlag: l.country_flag,
|
|
matchCount: l.match_count,
|
|
liveCount: l.live_count,
|
|
}));
|
|
}
|
|
|
|
/**
|
|
* List matches with pagination
|
|
*/
|
|
async listMatches(sport: Sport, page: number = 1, limit: number = 20) {
|
|
const skip = (page - 1) * limit;
|
|
|
|
const [matches, total] = await Promise.all([
|
|
this.prisma.match.findMany({
|
|
where: { sport: sport as any },
|
|
include: {
|
|
homeTeam: true,
|
|
awayTeam: true,
|
|
league: {
|
|
include: { country: true },
|
|
},
|
|
},
|
|
orderBy: { mstUtc: "desc" },
|
|
skip,
|
|
take: limit,
|
|
}),
|
|
this.prisma.match.count({ where: { sport: sport as any } }),
|
|
]);
|
|
|
|
return {
|
|
matches: matches.map((m) => ({
|
|
id: m.id,
|
|
matchName: m.matchName,
|
|
matchSlug: m.matchSlug,
|
|
mstUtc: Number(m.mstUtc),
|
|
scoreHome: m.scoreHome,
|
|
scoreAway: m.scoreAway,
|
|
status: m.status,
|
|
homeTeamName: m.homeTeam?.name,
|
|
homeTeamLogo: m.homeTeamId
|
|
? `https://file.mackolikfeeds.com/teams/${m.homeTeamId}`
|
|
: null,
|
|
awayTeamName: m.awayTeam?.name,
|
|
awayTeamLogo: m.awayTeamId
|
|
? `https://file.mackolikfeeds.com/teams/${m.awayTeamId}`
|
|
: null,
|
|
leagueName: m.league?.name,
|
|
countryName: m.league?.country?.name,
|
|
})),
|
|
total,
|
|
page,
|
|
totalPages: Math.ceil(total / limit),
|
|
};
|
|
}
|
|
|
|
private normalizeTeamStat(stat: any, sport?: string) {
|
|
if (!stat) return null;
|
|
|
|
const base = {
|
|
id: stat.id,
|
|
matchId: stat.matchId,
|
|
teamId: stat.teamId,
|
|
createdAt: stat.createdAt,
|
|
};
|
|
|
|
if ((sport || "").toLowerCase() === "basketball") {
|
|
return {
|
|
...base,
|
|
points: stat.points,
|
|
rebounds: stat.rebounds,
|
|
assists: stat.assists,
|
|
fgMade: stat.fgMade,
|
|
fgAttempted: stat.fgAttempted,
|
|
threePtMade: stat.threePtMade,
|
|
threePtAttempted: stat.threePtAttempted,
|
|
ftMade: stat.ftMade,
|
|
ftAttempted: stat.ftAttempted,
|
|
steals: stat.steals,
|
|
blocks: stat.blocks,
|
|
turnovers: stat.turnovers,
|
|
q1Score: stat.q1Score,
|
|
q2Score: stat.q2Score,
|
|
q3Score: stat.q3Score,
|
|
q4Score: stat.q4Score,
|
|
otScore: stat.otScore,
|
|
};
|
|
}
|
|
|
|
return {
|
|
...base,
|
|
possessionPercentage: stat.possessionPercentage,
|
|
shotsOnTarget: stat.shotsOnTarget,
|
|
shotsOffTarget: stat.shotsOffTarget,
|
|
totalShots: stat.totalShots,
|
|
totalPasses: stat.totalPasses,
|
|
corners: stat.corners,
|
|
fouls: stat.fouls,
|
|
offsides: stat.offsides,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Get full match details by ID
|
|
*/
|
|
async getMatchDetailsById(matchId: string) {
|
|
let match: any = await this.prisma.match.findUnique({
|
|
where: { id: matchId },
|
|
include: {
|
|
league: { include: { country: true } },
|
|
homeTeam: true,
|
|
awayTeam: true,
|
|
footballTeamStats: true,
|
|
basketballTeamStats: true,
|
|
playerParticipations: {
|
|
include: { player: true },
|
|
orderBy: [{ isStarting: "desc" }, { position: "asc" }],
|
|
},
|
|
playerEvents: {
|
|
include: {
|
|
player: true,
|
|
assistPlayer: true,
|
|
substitutedOut: true,
|
|
},
|
|
orderBy: [{ periodId: "asc" }, { timeMinute: "asc" }],
|
|
},
|
|
oddCategories: {
|
|
include: { selections: true },
|
|
},
|
|
officials: true,
|
|
},
|
|
});
|
|
|
|
if (!match) {
|
|
// Try to find in LiveMatch table
|
|
const liveMatch = await this.prisma.liveMatch.findUnique({
|
|
where: { id: matchId },
|
|
include: {
|
|
league: { include: { country: true } },
|
|
homeTeam: true,
|
|
awayTeam: true,
|
|
},
|
|
});
|
|
|
|
if (liveMatch) {
|
|
// Map liveMatch status
|
|
const displayStatus = getDisplayMatchStatus({
|
|
state: liveMatch.state,
|
|
status: liveMatch.status,
|
|
substate: liveMatch.substate,
|
|
scoreHome: liveMatch.scoreHome,
|
|
scoreAway: liveMatch.scoreAway,
|
|
});
|
|
|
|
match = {
|
|
...liveMatch,
|
|
matchName:
|
|
liveMatch.matchName ||
|
|
`${liveMatch.homeTeam?.name} vs ${liveMatch.awayTeam?.name}`,
|
|
status: displayStatus,
|
|
mstUtc: liveMatch.mstUtc,
|
|
score: {
|
|
home: liveMatch.scoreHome,
|
|
away: liveMatch.scoreAway,
|
|
},
|
|
date: new Date(Number(liveMatch.mstUtc)),
|
|
// Fill missing relations with empty arrays
|
|
teamStats: [],
|
|
playerParticipations: (() => {
|
|
const parsed: Array<{ teamId: string; isStarting: boolean; shirtNumber: string | number | null; position: string | null; player: { id: string; name: string } }> = [];
|
|
const canTrustFeedLineups = displayStatus === "LIVE" || displayStatus === "Finished";
|
|
if (!canTrustFeedLineups) {
|
|
return parsed;
|
|
}
|
|
if (liveMatch.lineups && typeof liveMatch.lineups === 'object') {
|
|
const lu = liveMatch.lineups as Record<string, any>;
|
|
const addPlayers = (teamLu: any, teamId: string | null) => {
|
|
if (!teamLu || !teamId) return;
|
|
if (teamLu.xi && Array.isArray(teamLu.xi)) {
|
|
teamLu.xi.forEach((p: any) => {
|
|
parsed.push({
|
|
teamId,
|
|
isStarting: true,
|
|
shirtNumber: p.shirtNumber || p.number,
|
|
position: p.position || p.pos,
|
|
player: { id: p.personId || p.id || p.playerId || 'unknown', name: p.matchName || p.name || p.playerName || 'Bilinmiyor' }
|
|
});
|
|
});
|
|
}
|
|
if (teamLu.subs && Array.isArray(teamLu.subs)) {
|
|
teamLu.subs.forEach((p: any) => {
|
|
parsed.push({
|
|
teamId,
|
|
isStarting: false,
|
|
shirtNumber: p.shirtNumber || p.number,
|
|
position: p.position || p.pos,
|
|
player: { id: p.personId || p.id || p.playerId || 'unknown', name: p.matchName || p.name || p.playerName || 'Bilinmiyor' }
|
|
});
|
|
});
|
|
}
|
|
};
|
|
addPlayers(lu.home, liveMatch.homeTeamId);
|
|
addPlayers(lu.away, liveMatch.awayTeamId);
|
|
}
|
|
return parsed;
|
|
})(),
|
|
playerEvents: [],
|
|
oddCategories: [], // Will handle odds parsing below
|
|
officials: [],
|
|
isLiveSource: true, // Flag to indicate source
|
|
};
|
|
}
|
|
}
|
|
|
|
if (!match) return null;
|
|
|
|
const detailDisplayStatus = getDisplayMatchStatus({
|
|
state: match.state,
|
|
status: match.status,
|
|
substate: match.substate,
|
|
scoreHome: match.scoreHome,
|
|
scoreAway: match.scoreAway,
|
|
});
|
|
const canTrustStoredLineups = this.canTrustStoredLineups(detailDisplayStatus);
|
|
|
|
if (Array.isArray(match.playerParticipations)) {
|
|
if (!canTrustStoredLineups) {
|
|
match.playerParticipations = [];
|
|
}
|
|
|
|
const hasHomeLineup = match.playerParticipations.some(
|
|
(p: any) => p.teamId === match.homeTeamId && p.isStarting,
|
|
);
|
|
const hasAwayLineup = match.playerParticipations.some(
|
|
(p: any) => p.teamId === match.awayTeamId && p.isStarting,
|
|
);
|
|
|
|
if (!hasHomeLineup || !hasAwayLineup) {
|
|
const sidelined =
|
|
match.sidelined && typeof match.sidelined === "object"
|
|
? (match.sidelined as Record<string, any>)
|
|
: {};
|
|
const matchDateMs = Number(match.mstUtc || Date.now());
|
|
const probableLineups: any[] = [];
|
|
|
|
if (!hasHomeLineup && match.homeTeamId) {
|
|
probableLineups.push(
|
|
...(await this.buildProbableLineupForTeam({
|
|
teamId: match.homeTeamId,
|
|
beforeDateMs: matchDateMs,
|
|
sidelinedTeamData: sidelined.homeTeam,
|
|
})),
|
|
);
|
|
}
|
|
|
|
if (!hasAwayLineup && match.awayTeamId) {
|
|
probableLineups.push(
|
|
...(await this.buildProbableLineupForTeam({
|
|
teamId: match.awayTeamId,
|
|
beforeDateMs: matchDateMs,
|
|
sidelinedTeamData: sidelined.awayTeam,
|
|
})),
|
|
);
|
|
}
|
|
|
|
if (probableLineups.length > 0) {
|
|
match.playerParticipations = canTrustStoredLineups
|
|
? [...match.playerParticipations, ...probableLineups]
|
|
: probableLineups;
|
|
match.lineupSource = "probable_xi";
|
|
}
|
|
}
|
|
}
|
|
|
|
// Structure odds
|
|
const odds: Record<
|
|
string,
|
|
Record<string, { odd: string; sov?: number }>
|
|
> = {};
|
|
|
|
if (
|
|
match.isLiveSource &&
|
|
match.odds &&
|
|
typeof match.odds === "object" &&
|
|
!Array.isArray(match.odds)
|
|
) {
|
|
// Parse JSON odds from LiveMatch
|
|
const oddsObj = match.odds as Record<string, Record<string, number>>;
|
|
for (const [marketName, selections] of Object.entries(oddsObj)) {
|
|
odds[marketName] = {};
|
|
if (selections && typeof selections === "object") {
|
|
for (const [selName, selOdd] of Object.entries(selections)) {
|
|
odds[marketName][selName] = { odd: String(selOdd) };
|
|
}
|
|
}
|
|
}
|
|
} else if (match.oddCategories) {
|
|
// Parse relation odds from Match
|
|
for (const cat of match.oddCategories) {
|
|
if (!cat.name) continue;
|
|
odds[cat.name] = {};
|
|
for (const sel of cat.selections) {
|
|
if (sel.name) {
|
|
odds[cat.name][sel.name] = {
|
|
odd: sel.oddValue || "",
|
|
sov: sel.sov ?? undefined,
|
|
};
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
const sportStats =
|
|
match.sport === "basketball"
|
|
? match.basketballTeamStats || []
|
|
: match.footballTeamStats || [];
|
|
const normalizedTeamStats = sportStats.map((s: any) =>
|
|
this.normalizeTeamStat(s, match.sport),
|
|
);
|
|
const homeStat = sportStats.find((s: any) => s.teamId === match.homeTeamId);
|
|
const awayStat = sportStats.find((s: any) => s.teamId === match.awayTeamId);
|
|
|
|
return {
|
|
...match,
|
|
teamStats: normalizedTeamStats,
|
|
mstUtc: Number(match.mstUtc),
|
|
date: match.date || new Date(Number(match.mstUtc)),
|
|
// Ensure score is in expected format (nested object for frontend if needed, but frontend seems to use match.score.home in some places and match.scoreHome in others.
|
|
// The match-detail-content uses match.score.home. Match entity has scoreHome/scoreAway fields.
|
|
// Let's ensure compatibility.
|
|
score: match.score || { home: match.scoreHome, away: match.scoreAway },
|
|
stats: {
|
|
home: this.normalizeTeamStat(homeStat, match.sport),
|
|
away: this.normalizeTeamStat(awayStat, match.sport),
|
|
},
|
|
lineups: {
|
|
home: match.playerParticipations.filter(
|
|
(p: any) => p.teamId === match.homeTeamId,
|
|
),
|
|
away: match.playerParticipations.filter(
|
|
(p: any) => p.teamId === match.awayTeamId,
|
|
),
|
|
},
|
|
events: match.playerEvents,
|
|
odds,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Get team ID by name (for legacy compatibility)
|
|
*/
|
|
async getTeamIdByName(
|
|
teamName: string,
|
|
sport: Sport,
|
|
): Promise<string | null> {
|
|
const trimmedName = teamName.trim();
|
|
|
|
// Exact match first
|
|
let team = await this.prisma.team.findFirst({
|
|
where: { name: trimmedName, sport: sport as any },
|
|
select: { id: true },
|
|
});
|
|
|
|
if (team) return team.id;
|
|
|
|
// Fuzzy search
|
|
team = await this.prisma.team.findFirst({
|
|
where: {
|
|
name: { contains: trimmedName, mode: "insensitive" },
|
|
sport: sport as any,
|
|
},
|
|
select: { id: true },
|
|
});
|
|
|
|
return team?.id || null;
|
|
}
|
|
|
|
private async buildProbableLineupForTeam(params: {
|
|
teamId: string;
|
|
beforeDateMs: number;
|
|
sidelinedTeamData?: any;
|
|
matchLimit?: number;
|
|
lookbackDays?: number;
|
|
maxStalenessDays?: number;
|
|
}) {
|
|
const matchLimit = params.matchLimit ?? 5;
|
|
const lookbackDays = params.lookbackDays ?? 370;
|
|
const maxStalenessDays = params.maxStalenessDays ?? 120;
|
|
const beforeDateMs = params.beforeDateMs || Date.now();
|
|
const minDateMs = Math.max(
|
|
0,
|
|
beforeDateMs - lookbackDays * 24 * 60 * 60 * 1000,
|
|
);
|
|
const excluded = this.extractSidelinedPlayerIds(params.sidelinedTeamData);
|
|
|
|
const rows = await this.prisma.$queryRaw<any[]>`
|
|
SELECT
|
|
mpp.player_id AS "playerId",
|
|
p.name AS "playerName",
|
|
mpp.position AS "position",
|
|
mpp.shirt_number AS "shirtNumber",
|
|
m.id AS "matchId",
|
|
m.mst_utc AS "mstUtc"
|
|
FROM match_player_participation mpp
|
|
JOIN matches m ON m.id = mpp.match_id
|
|
JOIN players p ON p.id = mpp.player_id
|
|
WHERE mpp.team_id = ${params.teamId}
|
|
AND mpp.is_starting = true
|
|
AND NOT EXISTS (
|
|
SELECT 1
|
|
FROM match_player_participation later_mpp
|
|
JOIN matches later_m ON later_m.id = later_mpp.match_id
|
|
WHERE later_mpp.player_id = mpp.player_id
|
|
AND later_mpp.team_id <> ${params.teamId}
|
|
AND later_m.mst_utc > m.mst_utc
|
|
AND later_m.mst_utc < ${BigInt(beforeDateMs)}
|
|
AND (
|
|
later_m.status = 'FT'
|
|
OR later_m.state = 'postGame'
|
|
OR (later_m.score_home IS NOT NULL AND later_m.score_away IS NOT NULL)
|
|
)
|
|
)
|
|
AND m.id IN (
|
|
SELECT m2.id
|
|
FROM matches m2
|
|
JOIN match_player_participation recent_mpp
|
|
ON recent_mpp.match_id = m2.id
|
|
AND recent_mpp.team_id = ${params.teamId}
|
|
AND recent_mpp.is_starting = true
|
|
WHERE (m2.home_team_id = ${params.teamId} OR m2.away_team_id = ${params.teamId})
|
|
AND (
|
|
m2.status = 'FT'
|
|
OR m2.state = 'postGame'
|
|
OR (m2.score_home IS NOT NULL AND m2.score_away IS NOT NULL)
|
|
)
|
|
AND m2.mst_utc < ${BigInt(beforeDateMs)}
|
|
AND m2.mst_utc >= ${BigInt(minDateMs)}
|
|
GROUP BY m2.id
|
|
HAVING COUNT(recent_mpp.*) >= 9
|
|
ORDER BY MAX(m2.mst_utc) DESC
|
|
LIMIT ${matchLimit}
|
|
)
|
|
ORDER BY m.mst_utc DESC
|
|
`;
|
|
|
|
if (!rows.length) return [];
|
|
|
|
const latestMst = Math.max(
|
|
...rows.map((row) => Number(row.mstUtc || 0)),
|
|
);
|
|
const ageDays =
|
|
latestMst > 0
|
|
? (beforeDateMs - latestMst) / (24 * 60 * 60 * 1000)
|
|
: Number.POSITIVE_INFINITY;
|
|
const staleProjection = ageDays > maxStalenessDays;
|
|
|
|
const matchOrder = new Map<string, number>();
|
|
for (const row of rows) {
|
|
const matchId = String(row.matchId);
|
|
if (!matchOrder.has(matchId)) {
|
|
matchOrder.set(matchId, matchOrder.size);
|
|
}
|
|
}
|
|
|
|
const playerMap = new Map<
|
|
string,
|
|
{
|
|
playerId: string;
|
|
playerName: string;
|
|
position: string | null;
|
|
shirtNumber: number | null;
|
|
score: number;
|
|
starts: number;
|
|
lastSeenRank: number;
|
|
}
|
|
>();
|
|
|
|
for (const row of rows) {
|
|
const playerId = String(row.playerId);
|
|
if (excluded.has(playerId)) continue;
|
|
|
|
const rank = matchOrder.get(String(row.matchId)) ?? matchLimit;
|
|
const recencyWeight = Math.max(1, matchLimit - rank);
|
|
const score =
|
|
recencyWeight + (rank === 0 ? 3 : rank === 1 ? 1.5 : 0);
|
|
const existing = playerMap.get(playerId);
|
|
|
|
if (!existing) {
|
|
playerMap.set(playerId, {
|
|
playerId,
|
|
playerName: row.playerName || "Bilinmiyor",
|
|
position: row.position ?? null,
|
|
shirtNumber:
|
|
row.shirtNumber === null || row.shirtNumber === undefined
|
|
? null
|
|
: Number(row.shirtNumber),
|
|
score,
|
|
starts: 1,
|
|
lastSeenRank: rank,
|
|
});
|
|
} else {
|
|
existing.score += score;
|
|
existing.starts += 1;
|
|
existing.lastSeenRank = Math.min(existing.lastSeenRank, rank);
|
|
existing.position = existing.position || row.position || null;
|
|
existing.shirtNumber =
|
|
existing.shirtNumber ??
|
|
(row.shirtNumber === null || row.shirtNumber === undefined
|
|
? null
|
|
: Number(row.shirtNumber));
|
|
}
|
|
}
|
|
|
|
const ranked = [...playerMap.values()]
|
|
.sort((a, b) => {
|
|
if (b.score !== a.score) return b.score - a.score;
|
|
if (b.starts !== a.starts) return b.starts - a.starts;
|
|
return a.lastSeenRank - b.lastSeenRank;
|
|
})
|
|
.slice(0, 11);
|
|
|
|
const coverage = Math.min(1, ranked.length / 11);
|
|
const historyScore = Math.min(1, matchOrder.size / matchLimit);
|
|
const stableCore = ranked.filter((p) => p.starts >= 2).length / 11;
|
|
const stalenessFactor = Math.max(
|
|
0.35,
|
|
Math.min(1, maxStalenessDays / Math.max(ageDays, 1)),
|
|
);
|
|
const confidence = Math.max(
|
|
0,
|
|
Math.min(
|
|
staleProjection ? 0.58 : 0.88,
|
|
(coverage * 0.45 + historyScore * 0.25 + stableCore * 0.3) *
|
|
stalenessFactor,
|
|
),
|
|
);
|
|
|
|
return ranked.map((p) => ({
|
|
teamId: params.teamId,
|
|
isStarting: true,
|
|
shirtNumber: p.shirtNumber,
|
|
position: p.position,
|
|
isProbable: true,
|
|
lineupSource: "probable_xi",
|
|
projectionConfidence: Number(confidence.toFixed(3)),
|
|
projectionAgeDays: Number(ageDays.toFixed(1)),
|
|
projectionStale: staleProjection,
|
|
projectionMatchLimit: matchLimit,
|
|
projectionLookbackDays: lookbackDays,
|
|
projectionMaxStalenessDays: maxStalenessDays,
|
|
player: {
|
|
id: p.playerId,
|
|
name: p.playerName,
|
|
},
|
|
}));
|
|
}
|
|
|
|
private extractSidelinedPlayerIds(teamData: any): Set<string> {
|
|
if (!teamData || typeof teamData !== "object") return new Set();
|
|
const players = Array.isArray(teamData.players) ? teamData.players : [];
|
|
return new Set(
|
|
players
|
|
.map((player: any) =>
|
|
String(
|
|
player?.playerId ??
|
|
player?.player_id ??
|
|
player?.id ??
|
|
player?.personId ??
|
|
"",
|
|
),
|
|
)
|
|
.filter(Boolean),
|
|
);
|
|
}
|
|
|
|
private canTrustStoredLineups(displayStatus?: string): boolean {
|
|
const normalized = String(displayStatus || "").toLowerCase();
|
|
return (
|
|
normalized === "live" ||
|
|
normalized === "finished" ||
|
|
normalized === "ft"
|
|
);
|
|
}
|
|
}
|