@lyxa.ai/marketing 1.0.49 → 1.0.51

package/dist/lib/modules/tournament/score/score.service.d.ts

@@ -1,6 +1,13 @@
+import { UpdateMatchScoreInputDTO } from './score.validation';
+import { TournamentMatchOutputDTO } from '../match/match.validation';
 export declare class ScoreService {
     private repository;
     constructor();
+    private getMatch;
+    private resolveScore;
+    private resolveWinner;
+    private extractUpdatedMatch;
+    updateMatchScore(input: UpdateMatchScoreInputDTO): Promise<TournamentMatchOutputDTO>;
 }
 export declare const scoreService: ScoreService;
 //# sourceMappingURL=score.service.d.ts.map

package/dist/lib/modules/tournament/score/score.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"score.service.d.ts","sourceRoot":"/","sources":["modules/tournament/score/score.service.ts"],"names":[],"mappings":"AAGA,qBACa,YAAY;IACrB,OAAO,CAAC,UAAU,CAAkB;;CAKvC;AAED,eAAO,MAAM,YAAY,cAA8B,CAAC"}
+{"version":3,"file":"score.service.d.ts","sourceRoot":"/","sources":["modules/tournament/score/score.service.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAErE,qBACa,YAAY;IACrB,OAAO,CAAC,UAAU,CAAkB;;YAMtB,QAAQ;IAQtB,OAAO,CAAC,YAAY;IAuBpB,OAAO,CAAC,aAAa;IASrB,OAAO,CAAC,mBAAmB;IASd,gBAAgB,CAAC,KAAK,EAAE,wBAAwB,GAAG,OAAO,CAAC,wBAAwB,CAAC;CASpG;AAED,eAAO,MAAM,YAAY,cAA8B,CAAC"}

package/dist/lib/modules/tournament/score/score.service.js

@@ -44,12 +44,61 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.scoreService = exports.ScoreService = void 0;
 const typedi_1 = __importStar(require("typedi"));
+const typegoose_1 = require("@typegoose/typegoose");
+const error_common_1 = require("@lyxa.ai/core/dist/utilities/error-common");
 const score_repository_1 = require("./score.repository");
 let ScoreService = class ScoreService {
     repository;
     constructor() {
         this.repository = typedi_1.default.get(score_repository_1.ScoreRepository);
     }
+    async getMatch(tournamentId, matchId) {
+        const tournament = await this.repository.findMatchInTournament(tournamentId, matchId);
+        if (!tournament)
+            throw (0, error_common_1.notFoundError)('Tournament or match not found');
+        const match = tournament.matches.find(m => m._id.toString() === matchId.toString());
+        if (!match)
+            throw (0, error_common_1.notFoundError)('Match not found');
+        return { tournament, match };
+    }
+    resolveScore(match, teams) {
+        const positionByTeamId = new Map([
+            [match.team1.teamId.toString(), 'team1'],
+            [match.team2.teamId.toString(), 'team2'],
+        ]);
+        const score = {};
+        for (const { teamId, score: teamScore } of teams) {
+            const position = positionByTeamId.get(teamId.toString());
+            if (!position)
+                throw (0, error_common_1.badRequestError)(`Team ${teamId} is not part of this match`);
+            score[position] = teamScore;
+        }
+        if (score.team1 === undefined || score.team2 === undefined) {
+            throw (0, error_common_1.badRequestError)('Both teams in this match must have a score');
+        }
+        return { team1: score.team1, team2: score.team2 };
+    }
+    resolveWinner(match, score) {
+        if (score.team1 > score.team2)
+            return new typegoose_1.mongoose.Types.ObjectId(match.team1.teamId.toString());
+        if (score.team2 > score.team1)
+            return new typegoose_1.mongoose.Types.ObjectId(match.team2.teamId.toString());
+        return null;
+    }
+    extractUpdatedMatch(tournament, matchId) {
+        const updated = tournament.matches.find(m => m._id.toString() === matchId.toString());
+        if (!updated)
+            throw (0, error_common_1.notFoundError)('Match not found after update');
+        return updated;
+    }
+    async updateMatchScore(input) {
+        const { match } = await this.getMatch(input.tournamentId, input.matchId);
+        const score = this.resolveScore(match, input.teams);
+        const result = await this.repository.updateMatchScore(input.tournamentId, input.matchId, score);
+        if (!result)
+            throw (0, error_common_1.notFoundError)('Tournament not found');
+        return this.extractUpdatedMatch(result, input.matchId);
+    }
 };
 exports.ScoreService = ScoreService;
 exports.ScoreService = ScoreService = __decorate([

package/dist/lib/modules/tournament/score/score.service.js.map

@@ -1 +1 @@
-{"version":3,"file":"score.service.js","sourceRoot":"/","sources":["modules/tournament/score/score.service.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,iDAA0C;AAC1C,yDAAmD;AAG5C,IAAM,YAAY,GAAlB,MAAM,YAAY;IACb,UAAU,CAAkB;IAEpC;QACI,IAAI,CAAC,UAAU,GAAG,gBAAS,CAAC,GAAG,CAAC,kCAAe,CAAC,CAAC;IACrD,CAAC;CACJ,CAAA;AANY,oCAAY;uBAAZ,YAAY;IADxB,IAAA,gBAAO,GAAE;;GACG,YAAY,CAMxB;AAEY,QAAA,YAAY,GAAG,gBAAS,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC","sourcesContent":["import Container, {Service} from 'typedi';\nimport {ScoreRepository} from './score.repository';\n\n@Service()\nexport class ScoreService {\n    private repository: ScoreRepository;\n\n    constructor() {\n        this.repository = Container.get(ScoreRepository);\n    }\n}\n\nexport const scoreService = Container.get(ScoreService);\n"]}
+{"version":3,"file":"score.service.js","sourceRoot":"/","sources":["modules/tournament/score/score.service.ts"],"names":[],"mappings":"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","sourcesContent":["import Container, { Service } from 'typedi';\nimport { mongoose } from '@typegoose/typegoose';\nimport { badRequestError, notFoundError } from '@lyxa.ai/core/dist/utilities/error-common';\nimport { Tournament as TournamentType } from '@lyxa.ai/core/dist/libraries/mongo/models';\nimport { ScoreRepository } from './score.repository';\nimport { UpdateMatchScoreInputDTO } from './score.validation';\nimport { TournamentMatchOutputDTO } from '../match/match.validation';\n\n@Service()\nexport class ScoreService {\n    private repository: ScoreRepository;\n\n    constructor() {\n        this.repository = Container.get(ScoreRepository);\n    }\n\n    private async getMatch(tournamentId: mongoose.Types.ObjectId, matchId: mongoose.Types.ObjectId) {\n        const tournament = await this.repository.findMatchInTournament(tournamentId, matchId);\n        if (!tournament) throw notFoundError('Tournament or match not found');\n        const match = tournament.matches.find(m => m._id.toString() === matchId.toString());\n        if (!match) throw notFoundError('Match not found');\n        return { tournament, match };\n    }\n\n    private resolveScore(\n        match: TournamentType['matches'][number],\n        teams: UpdateMatchScoreInputDTO['teams']\n    ): { team1: number; team2: number } {\n        const positionByTeamId = new Map([\n            [match.team1.teamId.toString(), 'team1' as const],\n            [match.team2.teamId.toString(), 'team2' as const],\n        ]);\n\n        const score: Partial<{ team1: number; team2: number }> = {};\n        for (const { teamId, score: teamScore } of teams) {\n            const position = positionByTeamId.get(teamId.toString());\n            if (!position) throw badRequestError(`Team ${teamId} is not part of this match`);\n            score[position] = teamScore;\n        }\n\n        if (score.team1 === undefined || score.team2 === undefined) {\n            throw badRequestError('Both teams in this match must have a score');\n        }\n\n        return { team1: score.team1, team2: score.team2 };\n    }\n\n    private resolveWinner(\n        match: TournamentType['matches'][number],\n        score: { team1: number; team2: number }\n    ): mongoose.Types.ObjectId | null {\n        if (score.team1 > score.team2) return new mongoose.Types.ObjectId(match.team1.teamId.toString());\n        if (score.team2 > score.team1) return new mongoose.Types.ObjectId(match.team2.teamId.toString());\n        return null;\n    }\n\n    private extractUpdatedMatch(\n        tournament: TournamentType,\n        matchId: mongoose.Types.ObjectId\n    ): TournamentMatchOutputDTO {\n        const updated = tournament.matches.find(m => m._id.toString() === matchId.toString());\n        if (!updated) throw notFoundError('Match not found after update');\n        return updated as TournamentMatchOutputDTO;\n    }\n\n    public async updateMatchScore(input: UpdateMatchScoreInputDTO): Promise<TournamentMatchOutputDTO> {\n        const { match } = await this.getMatch(input.tournamentId, input.matchId);\n        const score = this.resolveScore(match, input.teams);\n\n        const result = await this.repository.updateMatchScore(input.tournamentId, input.matchId, score);\n        if (!result) throw notFoundError('Tournament not found');\n\n        return this.extractUpdatedMatch(result, input.matchId);\n    }\n}\n\nexport const scoreService = Container.get(ScoreService);\n"]}

package/dist/lib/modules/tournament/score/score.validation.d.ts

@@ -0,0 +1,375 @@
+import { z } from 'zod';
+import { DTO } from '@lyxa.ai/core/dist/utilities/validation/global-validation';
+export declare const UpdateMatchScoreSchema: z.ZodObject<{
+    tournamentId: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, import("mongoose").Types.ObjectId, string>, z.ZodType<import("mongoose").Types.ObjectId, z.ZodTypeDef, import("mongoose").Types.ObjectId>]>;
+    matchId: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, import("mongoose").Types.ObjectId, string>, z.ZodType<import("mongoose").Types.ObjectId, z.ZodTypeDef, import("mongoose").Types.ObjectId>]>;
+    teams: z.ZodArray<z.ZodObject<{
+        teamId: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, import("mongoose").Types.ObjectId, string>, z.ZodType<import("mongoose").Types.ObjectId, z.ZodTypeDef, import("mongoose").Types.ObjectId>]>;
+        score: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        score: number;
+        teamId: import("mongoose").Types.ObjectId;
+    }, {
+        score: number;
+        teamId: string | import("mongoose").Types.ObjectId;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    tournamentId: import("mongoose").Types.ObjectId;
+    matchId: import("mongoose").Types.ObjectId;
+    teams: {
+        score: number;
+        teamId: import("mongoose").Types.ObjectId;
+    }[];
+}, {
+    tournamentId: string | import("mongoose").Types.ObjectId;
+    matchId: string | import("mongoose").Types.ObjectId;
+    teams: {
+        score: number;
+        teamId: string | import("mongoose").Types.ObjectId;
+    }[];
+}>;
+export declare const ScoreResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    message: z.ZodString | z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    data: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+        metadata: z.ZodOptional<z.ZodObject<{
+            page: z.ZodNumber;
+            size: z.ZodNumber;
+            totalElements: z.ZodNumber;
+            totalPages: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        }, {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        }>>;
+        documents: z.ZodArray<z.ZodType<{
+            _id: string | import("mongoose").Types.ObjectId;
+            team1: {
+                name: string;
+                teamId: string | import("mongoose").Types.ObjectId;
+                picture?: string | undefined;
+            };
+            team2: {
+                name: string;
+                teamId: string | import("mongoose").Types.ObjectId;
+                picture?: string | undefined;
+            };
+            score: {
+                team1: number | null;
+                team2: number | null;
+            };
+            stage: string;
+            endDate?: Date | null | undefined;
+            additionalTag?: string | undefined;
+            winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+            startingDate?: Date | null | undefined;
+            prediction?: {
+                score: {
+                    team1: number | null;
+                    team2: number | null;
+                };
+                succeeded?: boolean | null | undefined;
+            } | null | undefined;
+        }, z.ZodTypeDef, {
+            _id: string | import("mongoose").Types.ObjectId;
+            team1: {
+                name: string;
+                teamId: string | import("mongoose").Types.ObjectId;
+                picture?: string | undefined;
+            };
+            team2: {
+                name: string;
+                teamId: string | import("mongoose").Types.ObjectId;
+                picture?: string | undefined;
+            };
+            score: {
+                team1: number | null;
+                team2: number | null;
+            };
+            stage: string;
+            endDate?: Date | null | undefined;
+            additionalTag?: string | undefined;
+            winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+            startingDate?: Date | null | undefined;
+            prediction?: {
+                score: {
+                    team1: number | null;
+                    team2: number | null;
+                };
+                succeeded?: boolean | null | undefined;
+            } | null | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        documents: {
+            _id: string | import("mongoose").Types.ObjectId;
+            team1: {
+                name: string;
+                teamId: string | import("mongoose").Types.ObjectId;
+                picture?: string | undefined;
+            };
+            team2: {
+                name: string;
+                teamId: string | import("mongoose").Types.ObjectId;
+                picture?: string | undefined;
+            };
+            score: {
+                team1: number | null;
+                team2: number | null;
+            };
+            stage: string;
+            endDate?: Date | null | undefined;
+            additionalTag?: string | undefined;
+            winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+            startingDate?: Date | null | undefined;
+            prediction?: {
+                score: {
+                    team1: number | null;
+                    team2: number | null;
+                };
+                succeeded?: boolean | null | undefined;
+            } | null | undefined;
+        }[];
+        metadata?: {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        } | undefined;
+    }, {
+        documents: {
+            _id: string | import("mongoose").Types.ObjectId;
+            team1: {
+                name: string;
+                teamId: string | import("mongoose").Types.ObjectId;
+                picture?: string | undefined;
+            };
+            team2: {
+                name: string;
+                teamId: string | import("mongoose").Types.ObjectId;
+                picture?: string | undefined;
+            };
+            score: {
+                team1: number | null;
+                team2: number | null;
+            };
+            stage: string;
+            endDate?: Date | null | undefined;
+            additionalTag?: string | undefined;
+            winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+            startingDate?: Date | null | undefined;
+            prediction?: {
+                score: {
+                    team1: number | null;
+                    team2: number | null;
+                };
+                succeeded?: boolean | null | undefined;
+            } | null | undefined;
+        }[];
+        metadata?: {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        } | undefined;
+    }>, z.ZodType<{
+        _id: string | import("mongoose").Types.ObjectId;
+        team1: {
+            name: string;
+            teamId: string | import("mongoose").Types.ObjectId;
+            picture?: string | undefined;
+        };
+        team2: {
+            name: string;
+            teamId: string | import("mongoose").Types.ObjectId;
+            picture?: string | undefined;
+        };
+        score: {
+            team1: number | null;
+            team2: number | null;
+        };
+        stage: string;
+        endDate?: Date | null | undefined;
+        additionalTag?: string | undefined;
+        winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+        startingDate?: Date | null | undefined;
+        prediction?: {
+            score: {
+                team1: number | null;
+                team2: number | null;
+            };
+            succeeded?: boolean | null | undefined;
+        } | null | undefined;
+    }, z.ZodTypeDef, {
+        _id: string | import("mongoose").Types.ObjectId;
+        team1: {
+            name: string;
+            teamId: string | import("mongoose").Types.ObjectId;
+            picture?: string | undefined;
+        };
+        team2: {
+            name: string;
+            teamId: string | import("mongoose").Types.ObjectId;
+            picture?: string | undefined;
+        };
+        score: {
+            team1: number | null;
+            team2: number | null;
+        };
+        stage: string;
+        endDate?: Date | null | undefined;
+        additionalTag?: string | undefined;
+        winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+        startingDate?: Date | null | undefined;
+        prediction?: {
+            score: {
+                team1: number | null;
+                team2: number | null;
+            };
+            succeeded?: boolean | null | undefined;
+        } | null | undefined;
+    }>]>>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    success: boolean;
+    data?: {
+        _id: string | import("mongoose").Types.ObjectId;
+        team1: {
+            name: string;
+            teamId: string | import("mongoose").Types.ObjectId;
+            picture?: string | undefined;
+        };
+        team2: {
+            name: string;
+            teamId: string | import("mongoose").Types.ObjectId;
+            picture?: string | undefined;
+        };
+        score: {
+            team1: number | null;
+            team2: number | null;
+        };
+        stage: string;
+        endDate?: Date | null | undefined;
+        additionalTag?: string | undefined;
+        winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+        startingDate?: Date | null | undefined;
+        prediction?: {
+            score: {
+                team1: number | null;
+                team2: number | null;
+            };
+            succeeded?: boolean | null | undefined;
+        } | null | undefined;
+    } | {
+        documents: {
+            _id: string | import("mongoose").Types.ObjectId;
+            team1: {
+                name: string;
+                teamId: string | import("mongoose").Types.ObjectId;
+                picture?: string | undefined;
+            };
+            team2: {
+                name: string;
+                teamId: string | import("mongoose").Types.ObjectId;
+                picture?: string | undefined;
+            };
+            score: {
+                team1: number | null;
+                team2: number | null;
+            };
+            stage: string;
+            endDate?: Date | null | undefined;
+            additionalTag?: string | undefined;
+            winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+            startingDate?: Date | null | undefined;
+            prediction?: {
+                score: {
+                    team1: number | null;
+                    team2: number | null;
+                };
+                succeeded?: boolean | null | undefined;
+            } | null | undefined;
+        }[];
+        metadata?: {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        } | undefined;
+    } | undefined;
+}, {
+    message: string;
+    success: boolean;
+    data?: {
+        _id: string | import("mongoose").Types.ObjectId;
+        team1: {
+            name: string;
+            teamId: string | import("mongoose").Types.ObjectId;
+            picture?: string | undefined;
+        };
+        team2: {
+            name: string;
+            teamId: string | import("mongoose").Types.ObjectId;
+            picture?: string | undefined;
+        };
+        score: {
+            team1: number | null;
+            team2: number | null;
+        };
+        stage: string;
+        endDate?: Date | null | undefined;
+        additionalTag?: string | undefined;
+        winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+        startingDate?: Date | null | undefined;
+        prediction?: {
+            score: {
+                team1: number | null;
+                team2: number | null;
+            };
+            succeeded?: boolean | null | undefined;
+        } | null | undefined;
+    } | {
+        documents: {
+            _id: string | import("mongoose").Types.ObjectId;
+            team1: {
+                name: string;
+                teamId: string | import("mongoose").Types.ObjectId;
+                picture?: string | undefined;
+            };
+            team2: {
+                name: string;
+                teamId: string | import("mongoose").Types.ObjectId;
+                picture?: string | undefined;
+            };
+            score: {
+                team1: number | null;
+                team2: number | null;
+            };
+            stage: string;
+            endDate?: Date | null | undefined;
+            additionalTag?: string | undefined;
+            winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+            startingDate?: Date | null | undefined;
+            prediction?: {
+                score: {
+                    team1: number | null;
+                    team2: number | null;
+                };
+                succeeded?: boolean | null | undefined;
+            } | null | undefined;
+        }[];
+        metadata?: {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        } | undefined;
+    } | undefined;
+}>;
+export type UpdateMatchScoreInputDTO = DTO<typeof UpdateMatchScoreSchema>;
+//# sourceMappingURL=score.validation.d.ts.map

package/dist/lib/modules/tournament/score/score.validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"score.validation.d.ts","sourceRoot":"/","sources":["modules/tournament/score/score.validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,GAAG,EAAiB,MAAM,2DAA2D,CAAC;AAI/F,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWjC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA8C,CAAC;AAE/E,MAAM,MAAM,wBAAwB,GAAG,GAAG,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/dist/lib/modules/tournament/score/score.validation.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScoreResponseSchema = exports.UpdateMatchScoreSchema = void 0;
+const zod_1 = require("zod");
+const global_validation_1 = require("@lyxa.ai/core/dist/utilities/validation/global-validation");
+const validation_1 = require("@lyxa.ai/core/dist/utilities/validation");
+const match_validation_1 = require("../match/match.validation");
+exports.UpdateMatchScoreSchema = zod_1.z.object({
+    tournamentId: global_validation_1.ZodValidation.objectId('Tournament id'),
+    matchId: global_validation_1.ZodValidation.objectId('Match id'),
+    teams: zod_1.z
+        .array(zod_1.z.object({
+        teamId: global_validation_1.ZodValidation.objectId('Team id'),
+        score: global_validation_1.ZodValidation.number('Score', { min: 0, isInt: true }),
+    }))
+        .length(2, 'Exactly 2 teams are required'),
+});
+exports.ScoreResponseSchema = (0, validation_1.createResponseSchema)(match_validation_1.TournamentMatchSchema);
+//# sourceMappingURL=score.validation.js.map

package/dist/lib/modules/tournament/score/score.validation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"score.validation.js","sourceRoot":"/","sources":["modules/tournament/score/score.validation.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AACxB,iGAA+F;AAC/F,wEAA+E;AAC/E,gEAAkE;AAErD,QAAA,sBAAsB,GAAG,OAAC,CAAC,MAAM,CAAC;IAC3C,YAAY,EAAE,iCAAa,CAAC,QAAQ,CAAC,eAAe,CAAC;IACrD,OAAO,EAAE,iCAAa,CAAC,QAAQ,CAAC,UAAU,CAAC;IAC3C,KAAK,EAAE,OAAC;SACH,KAAK,CACF,OAAC,CAAC,MAAM,CAAC;QACL,MAAM,EAAE,iCAAa,CAAC,QAAQ,CAAC,SAAS,CAAC;QACzC,KAAK,EAAE,iCAAa,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;KAChE,CAAC,CACL;SACA,MAAM,CAAC,CAAC,EAAE,8BAA8B,CAAC;CACjD,CAAC,CAAC;AAEU,QAAA,mBAAmB,GAAG,IAAA,iCAAoB,EAAC,wCAAqB,CAAC,CAAC","sourcesContent":["import { z } from 'zod';\nimport { DTO, ZodValidation } from '@lyxa.ai/core/dist/utilities/validation/global-validation';\nimport { createResponseSchema } from '@lyxa.ai/core/dist/utilities/validation';\nimport { TournamentMatchSchema } from '../match/match.validation';\n\nexport const UpdateMatchScoreSchema = z.object({\n    tournamentId: ZodValidation.objectId('Tournament id'),\n    matchId: ZodValidation.objectId('Match id'),\n    teams: z\n        .array(\n            z.object({\n                teamId: ZodValidation.objectId('Team id'),\n                score: ZodValidation.number('Score', { min: 0, isInt: true }),\n            })\n        )\n        .length(2, 'Exactly 2 teams are required'),\n});\n\nexport const ScoreResponseSchema = createResponseSchema(TournamentMatchSchema);\n\nexport type UpdateMatchScoreInputDTO = DTO<typeof UpdateMatchScoreSchema>;\n"]}

package/dist/lib/modules/tournament/statistics/statistics.builder.d.ts

@@ -0,0 +1,10 @@
+import { TournamentParticipant, Tournament } from '@lyxa.ai/core/dist/libraries/mongo/models';
+import { UserTournamentStatsOutputDTO } from './statistics.validation';
+export declare class StatisticsBuilder {
+    static buildUserTournamentStats(participant: TournamentParticipant & {
+        createdAt?: Date;
+    }, tournament: Tournament, couponCodeMap: Map<string, string>): UserTournamentStatsOutputDTO;
+    private static formatScore;
+    private static resolveResult;
+}
+//# sourceMappingURL=statistics.builder.d.ts.map

package/dist/lib/modules/tournament/statistics/statistics.builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"statistics.builder.d.ts","sourceRoot":"/","sources":["modules/tournament/statistics/statistics.builder.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,qBAAqB,EAAE,UAAU,EAAE,MAAM,2CAA2C,CAAC;AAC9F,OAAO,EAAE,4BAA4B,EAAE,MAAM,yBAAyB,CAAC;AAEvE,qBAAa,iBAAiB;IAC1B,MAAM,CAAC,wBAAwB,CAC3B,WAAW,EAAE,qBAAqB,GAAG;QAAE,SAAS,CAAC,EAAE,IAAI,CAAA;KAAE,EACzD,UAAU,EAAE,UAAU,EACtB,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GACnC,4BAA4B;IA0C/B,OAAO,CAAC,MAAM,CAAC,WAAW;IAK1B,OAAO,CAAC,MAAM,CAAC,aAAa;CAQ/B"}

package/dist/lib/modules/tournament/statistics/statistics.builder.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatisticsBuilder = void 0;
+class StatisticsBuilder {
+    static buildUserTournamentStats(participant, tournament, couponCodeMap) {
+        const selectedTeam = tournament.teams.find(t => t._id.toString() === participant.teamId.toString());
+        const matchViews = participant.predictions
+            .map(prediction => {
+            const match = tournament.matches.find(m => m._id.toString() === prediction.matchId.toString());
+            if (!match)
+                return null;
+            return {
+                id: match._id.toString(),
+                teams: `${match.team1.name} vs ${match.team2.name}`,
+                date: match.startingDate ? match.startingDate.toISOString() : null,
+                prediction: StatisticsBuilder.formatScore(prediction.score),
+                realScore: StatisticsBuilder.formatScore(match.score),
+                result: StatisticsBuilder.resolveResult(prediction.score, match.score),
+                coupon: prediction.coupon
+                    ? couponCodeMap.get(prediction.coupon.toString()) ?? null
+                    : null,
+            };
+        })
+            .filter((m) => m !== null);
+        return {
+            name: tournament.name,
+            joinedAt: participant.createdAt ?? null,
+            selectedTeam: {
+                name: selectedTeam?.name ?? 'Unknown',
+                flag: selectedTeam?.picture ?? null,
+            },
+            stats: {
+                predictionsMade: matchViews.length,
+                correctPredictions: matchViews.filter(m => m.result === 'won').length,
+                couponsWon: matchViews.filter(m => m.coupon != null).length,
+            },
+            matches: matchViews,
+        };
+    }
+    static formatScore(s) {
+        if (!s || s.team1 == null || s.team2 == null)
+            return null;
+        return `${s.team1} - ${s.team2}`;
+    }
+    static resolveResult(predicted, realScore) {
+        if (realScore?.team1 == null || realScore?.team2 == null)
+            return 'pending';
+        const correct = predicted?.team1 === realScore.team1 && predicted?.team2 === realScore.team2;
+        return correct ? 'won' : 'lost';
+    }
+}
+exports.StatisticsBuilder = StatisticsBuilder;
+//# sourceMappingURL=statistics.builder.js.map

package/dist/lib/modules/tournament/statistics/statistics.builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"statistics.builder.js","sourceRoot":"/","sources":["modules/tournament/statistics/statistics.builder.ts"],"names":[],"mappings":"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","sourcesContent":["import { mongoose } from '@typegoose/typegoose';\nimport { TournamentParticipant, Tournament } from '@lyxa.ai/core/dist/libraries/mongo/models';\nimport { UserTournamentStatsOutputDTO } from './statistics.validation';\n\nexport class StatisticsBuilder {\n    static buildUserTournamentStats(\n        participant: TournamentParticipant & { createdAt?: Date },\n        tournament: Tournament,\n        couponCodeMap: Map<string, string>\n    ): UserTournamentStatsOutputDTO {\n        const selectedTeam = tournament.teams.find(\n            t => t._id.toString() === (participant.teamId as mongoose.Types.ObjectId).toString()\n        );\n\n        const matchViews = participant.predictions\n            .map(prediction => {\n                const match = tournament.matches.find(\n                    m => m._id.toString() === (prediction.matchId as mongoose.Types.ObjectId).toString()\n                );\n                if (!match) return null;\n\n                return {\n                    id: (match._id as mongoose.Types.ObjectId).toString(),\n                    teams: `${match.team1.name} vs ${match.team2.name}`,\n                    date: match.startingDate ? match.startingDate.toISOString() : null,\n                    prediction: StatisticsBuilder.formatScore(prediction.score),\n                    realScore: StatisticsBuilder.formatScore(match.score),\n                    result: StatisticsBuilder.resolveResult(prediction.score, match.score),\n                    coupon: prediction.coupon\n                        ? couponCodeMap.get((prediction.coupon as mongoose.Types.ObjectId).toString()) ?? null\n                        : null,\n                };\n            })\n            .filter((m): m is NonNullable<typeof m> => m !== null);\n\n        return {\n            name: tournament.name,\n            joinedAt: participant.createdAt ?? null,\n            selectedTeam: {\n                name: selectedTeam?.name ?? 'Unknown',\n                flag: selectedTeam?.picture ?? null,\n            },\n            stats: {\n                predictionsMade: matchViews.length,\n                correctPredictions: matchViews.filter(m => m.result === 'won').length,\n                couponsWon: matchViews.filter(m => m.coupon != null).length,\n            },\n            matches: matchViews,\n        };\n    }\n\n    private static formatScore(s: { team1: number | null; team2: number | null } | null | undefined): string | null {\n        if (!s || s.team1 == null || s.team2 == null) return null;\n        return `${s.team1} - ${s.team2}`;\n    }\n\n    private static resolveResult(\n        predicted: { team1: number | null; team2: number | null } | null | undefined,\n        realScore: { team1: number | null; team2: number | null } | null | undefined\n    ): 'won' | 'lost' | 'pending' {\n        if (realScore?.team1 == null || realScore?.team2 == null) return 'pending';\n        const correct = predicted?.team1 === realScore.team1 && predicted?.team2 === realScore.team2;\n        return correct ? 'won' : 'lost';\n    }\n}\n"]}

package/dist/lib/modules/tournament/statistics/statistics.router.d.ts

@@ -0,0 +1,80 @@
+import { mongoose } from '@typegoose/typegoose';
+export declare const statisticsRouter: import("@trpc/server").TRPCBuiltRouter<{
+    ctx: import("@lyxa.ai/core/dist/libraries/trpc/context").LyxaHTTPContext;
+    meta: object;
+    errorShape: {
+        message: string;
+        data: {
+            stack: undefined;
+            path: undefined;
+            code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+            httpStatus: number;
+        };
+        stack: undefined;
+        code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+    };
+    transformer: false;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    getActiveByUser: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            userId: string | mongoose.Types.ObjectId;
+        };
+        output: {
+            message: string;
+            success: boolean;
+            data?: {
+                name: string;
+                joinedAt: Date | null;
+                stats: {
+                    predictionsMade: number;
+                    correctPredictions: number;
+                    couponsWon: number;
+                };
+                matches: {
+                    date: string | null;
+                    coupon: string | null;
+                    id: string;
+                    result: "won" | "lost" | "pending" | null;
+                    teams: string;
+                    prediction: string | null;
+                    realScore: string | null;
+                }[];
+                selectedTeam: {
+                    name: string;
+                    flag: string | null;
+                };
+            } | {
+                documents: ({
+                    name: string;
+                    joinedAt: Date | null;
+                    stats: {
+                        predictionsMade: number;
+                        correctPredictions: number;
+                        couponsWon: number;
+                    };
+                    matches: {
+                        date: string | null;
+                        coupon: string | null;
+                        id: string;
+                        result: "won" | "lost" | "pending" | null;
+                        teams: string;
+                        prediction: string | null;
+                        realScore: string | null;
+                    }[];
+                    selectedTeam: {
+                        name: string;
+                        flag: string | null;
+                    };
+                } | null)[];
+                metadata?: {
+                    page: number;
+                    size: number;
+                    totalElements: number;
+                    totalPages: number;
+                } | undefined;
+            } | null | undefined;
+        };
+        meta: object;
+    }>;
+}>>;
+//# sourceMappingURL=statistics.router.d.ts.map