@lyxa.ai/marketing 1.0.48 → 1.0.49

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

@@ -19,9 +19,9 @@ export declare const matchRouter: import("@trpc/server").TRPCBuiltRouter<{
             tournamentId: string | import("mongoose").Types.ObjectId;
             matches: {
                 stage: string;
+                startingDate: string | Date;
                 team1Id: string | import("mongoose").Types.ObjectId;
                 team2Id: string | import("mongoose").Types.ObjectId;
-                startingDate: string | Date;
                 endDate?: string | Date | undefined;
                 additionalTag?: string | undefined;
             }[];
@@ -31,71 +31,39 @@ export declare const matchRouter: import("@trpc/server").TRPCBuiltRouter<{
             success: boolean;
             data?: {
                 status: import("@lyxa.ai/core/dist/utilities/enum").Status;
-                _id: string | import("mongoose").Types.ObjectId;
+                name: string;
                 tag: string;
+                _id?: string | import("mongoose").Types.ObjectId | undefined;
                 createdAt?: Date | null | undefined;
                 startDate?: Date | null | undefined;
                 endDate?: Date | null | undefined;
                 updatedAt?: Date | null | undefined;
-                matches?: {
-                    _id: string | import("mongoose").Types.ObjectId;
-                    team1: {
-                        name: string;
-                        teamId: string | import("mongoose").Types.ObjectId;
-                    };
-                    team2: {
-                        name: string;
-                        teamId: string | import("mongoose").Types.ObjectId;
-                    };
-                    score: {
-                        team1: number | null;
-                        team2: number | null;
-                    };
-                    stage: string;
-                    endDate?: Date | null | undefined;
-                    startingDate?: Date | null | undefined;
-                    additionalTag?: string | undefined;
-                    winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
-                }[] | undefined;
-                teams?: {
-                    name: string;
-                    _id: string | import("mongoose").Types.ObjectId;
-                    picture?: string | null | undefined;
-                }[] | undefined;
+                reward?: {
+                    type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.FREE_DELIVERY;
+                } | {
+                    type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.COUPON;
+                    maxDiscountPerOrder?: number | null | undefined;
+                    couponNamePrefix?: string | undefined;
+                    percentage?: number | undefined;
+                } | undefined;
             } | {
                 documents: {
                     status: import("@lyxa.ai/core/dist/utilities/enum").Status;
-                    _id: string | import("mongoose").Types.ObjectId;
+                    name: string;
                     tag: string;
+                    _id?: string | import("mongoose").Types.ObjectId | undefined;
                     createdAt?: Date | null | undefined;
                     startDate?: Date | null | undefined;
                     endDate?: Date | null | undefined;
                     updatedAt?: Date | null | undefined;
-                    matches?: {
-                        _id: string | import("mongoose").Types.ObjectId;
-                        team1: {
-                            name: string;
-                            teamId: string | import("mongoose").Types.ObjectId;
-                        };
-                        team2: {
-                            name: string;
-                            teamId: string | import("mongoose").Types.ObjectId;
-                        };
-                        score: {
-                            team1: number | null;
-                            team2: number | null;
-                        };
-                        stage: string;
-                        endDate?: Date | null | undefined;
-                        startingDate?: Date | null | undefined;
-                        additionalTag?: string | undefined;
-                        winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
-                    }[] | undefined;
-                    teams?: {
-                        name: string;
-                        _id: string | import("mongoose").Types.ObjectId;
-                        picture?: string | null | undefined;
-                    }[] | undefined;
+                    reward?: {
+                        type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.FREE_DELIVERY;
+                    } | {
+                        type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.COUPON;
+                        maxDiscountPerOrder?: number | null | undefined;
+                        couponNamePrefix?: string | undefined;
+                        percentage?: number | undefined;
+                    } | undefined;
                 }[];
                 metadata?: {
                     page: number;
@@ -130,9 +98,9 @@ export declare const matchRouter: import("@trpc/server").TRPCBuiltRouter<{
                 };
                 stage: string;
                 endDate?: Date | null | undefined;
-                startingDate?: Date | null | undefined;
                 additionalTag?: string | undefined;
                 winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                startingDate?: Date | null | undefined;
                 prediction?: {
                     score: {
                         team1: number | null;
@@ -157,9 +125,9 @@ export declare const matchRouter: import("@trpc/server").TRPCBuiltRouter<{
                     };
                     stage: string;
                     endDate?: Date | null | undefined;
-                    startingDate?: Date | null | undefined;
                     additionalTag?: string | undefined;
                     winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                    startingDate?: Date | null | undefined;
                     prediction?: {
                         score: {
                             team1: number | null;
@@ -202,84 +170,9 @@ export declare const matchRouter: import("@trpc/server").TRPCBuiltRouter<{
                 };
                 stage: string;
                 endDate?: Date | null | undefined;
-                startingDate?: Date | null | undefined;
                 additionalTag?: string | undefined;
                 winnerId?: string | import("mongoose").Types.ObjectId | 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;
-                    };
-                    team2: {
-                        name: string;
-                        teamId: string | import("mongoose").Types.ObjectId;
-                    };
-                    score: {
-                        team1: number | null;
-                        team2: number | null;
-                    };
-                    stage: string;
-                    endDate?: Date | null | undefined;
-                    startingDate?: Date | null | undefined;
-                    additionalTag?: string | undefined;
-                    winnerId?: string | import("mongoose").Types.ObjectId | 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;
-        };
-        meta: object;
-    }>;
-    updateScore: import("@trpc/server").TRPCMutationProcedure<{
-        input: {
-            tournamentId: string | import("mongoose").Types.ObjectId;
-            matchId: string | import("mongoose").Types.ObjectId;
-            team1Score: number;
-            team2Score: number;
-            winnerId?: string | import("mongoose").Types.ObjectId | undefined;
-        };
-        output: {
-            message: string;
-            success: boolean;
-            data?: {
-                _id: string | import("mongoose").Types.ObjectId;
-                team1: {
-                    name: string;
-                    teamId: string | import("mongoose").Types.ObjectId;
-                };
-                team2: {
-                    name: string;
-                    teamId: string | import("mongoose").Types.ObjectId;
-                };
-                score: {
-                    team1: number | null;
-                    team2: number | null;
-                };
-                stage: string;
-                endDate?: Date | null | undefined;
                 startingDate?: Date | null | undefined;
-                additionalTag?: string | undefined;
-                winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
                 prediction?: {
                     score: {
                         team1: number | null;
@@ -304,9 +197,9 @@ export declare const matchRouter: import("@trpc/server").TRPCBuiltRouter<{
                     };
                     stage: string;
                     endDate?: Date | null | undefined;
-                    startingDate?: Date | null | undefined;
                     additionalTag?: string | undefined;
                     winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                    startingDate?: Date | null | undefined;
                     prediction?: {
                         score: {
                             team1: number | null;
@@ -329,8 +222,10 @@ export declare const matchRouter: import("@trpc/server").TRPCBuiltRouter<{
         input: {
             tournamentId: string | import("mongoose").Types.ObjectId;
             matchId: string | import("mongoose").Types.ObjectId;
-            endDate?: string | Date | undefined;
-            winnerId?: string | import("mongoose").Types.ObjectId | undefined;
+            finalScore?: {
+                team1: number;
+                team2: number;
+            } | undefined;
         };
         output: {
             message: string;
@@ -351,9 +246,9 @@ export declare const matchRouter: import("@trpc/server").TRPCBuiltRouter<{
                 };
                 stage: string;
                 endDate?: Date | null | undefined;
-                startingDate?: Date | null | undefined;
                 additionalTag?: string | undefined;
                 winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                startingDate?: Date | null | undefined;
                 prediction?: {
                     score: {
                         team1: number | null;
@@ -378,9 +273,9 @@ export declare const matchRouter: import("@trpc/server").TRPCBuiltRouter<{
                     };
                     stage: string;
                     endDate?: Date | null | undefined;
-                    startingDate?: Date | null | undefined;
                     additionalTag?: string | undefined;
                     winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                    startingDate?: Date | null | undefined;
                     prediction?: {
                         score: {
                             team1: number | null;
@@ -409,71 +304,39 @@ export declare const matchRouter: import("@trpc/server").TRPCBuiltRouter<{
             success: boolean;
             data?: {
                 status: import("@lyxa.ai/core/dist/utilities/enum").Status;
-                _id: string | import("mongoose").Types.ObjectId;
+                name: string;
                 tag: string;
+                _id?: string | import("mongoose").Types.ObjectId | undefined;
                 createdAt?: Date | null | undefined;
                 startDate?: Date | null | undefined;
                 endDate?: Date | null | undefined;
                 updatedAt?: Date | null | undefined;
-                matches?: {
-                    _id: string | import("mongoose").Types.ObjectId;
-                    team1: {
-                        name: string;
-                        teamId: string | import("mongoose").Types.ObjectId;
-                    };
-                    team2: {
-                        name: string;
-                        teamId: string | import("mongoose").Types.ObjectId;
-                    };
-                    score: {
-                        team1: number | null;
-                        team2: number | null;
-                    };
-                    stage: string;
-                    endDate?: Date | null | undefined;
-                    startingDate?: Date | null | undefined;
-                    additionalTag?: string | undefined;
-                    winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
-                }[] | undefined;
-                teams?: {
-                    name: string;
-                    _id: string | import("mongoose").Types.ObjectId;
-                    picture?: string | null | undefined;
-                }[] | undefined;
+                reward?: {
+                    type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.FREE_DELIVERY;
+                } | {
+                    type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.COUPON;
+                    maxDiscountPerOrder?: number | null | undefined;
+                    couponNamePrefix?: string | undefined;
+                    percentage?: number | undefined;
+                } | undefined;
             } | {
                 documents: {
                     status: import("@lyxa.ai/core/dist/utilities/enum").Status;
-                    _id: string | import("mongoose").Types.ObjectId;
+                    name: string;
                     tag: string;
+                    _id?: string | import("mongoose").Types.ObjectId | undefined;
                     createdAt?: Date | null | undefined;
                     startDate?: Date | null | undefined;
                     endDate?: Date | null | undefined;
                     updatedAt?: Date | null | undefined;
-                    matches?: {
-                        _id: string | import("mongoose").Types.ObjectId;
-                        team1: {
-                            name: string;
-                            teamId: string | import("mongoose").Types.ObjectId;
-                        };
-                        team2: {
-                            name: string;
-                            teamId: string | import("mongoose").Types.ObjectId;
-                        };
-                        score: {
-                            team1: number | null;
-                            team2: number | null;
-                        };
-                        stage: string;
-                        endDate?: Date | null | undefined;
-                        startingDate?: Date | null | undefined;
-                        additionalTag?: string | undefined;
-                        winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
-                    }[] | undefined;
-                    teams?: {
-                        name: string;
-                        _id: string | import("mongoose").Types.ObjectId;
-                        picture?: string | null | undefined;
-                    }[] | undefined;
+                    reward?: {
+                        type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.FREE_DELIVERY;
+                    } | {
+                        type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.COUPON;
+                        maxDiscountPerOrder?: number | null | undefined;
+                        couponNamePrefix?: string | undefined;
+                        percentage?: number | undefined;
+                    } | undefined;
                 }[];
                 metadata?: {
                     page: number;

package/dist/lib/modules/tournament/match/match.router.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"match.router.d.ts","sourceRoot":"/","sources":["modules/tournament/match/match.router.ts"],"names":[],"mappings":"AAiBA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DtB,CAAC"}
+{"version":3,"file":"match.router.d.ts","sourceRoot":"/","sources":["modules/tournament/match/match.router.ts"],"names":[],"mappings":"AAiBA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDtB,CAAC"}

package/dist/lib/modules/tournament/match/match.router.js

@@ -31,13 +31,6 @@ exports.matchRouter = (0, trpc_1.createTRPCRouter)({
         const result = await match_service_1.matchService.start(input);
         return (0, response_1.response)('Match started successfully', result);
     })),
-    updateScore: (0, auth_2.createAuthenticatedProcedure)({ entityTypes: [auth_1.AuthEntityType.CRM] })
-        .input(match_validation_1.UpdateMatchScoreSchema)
-        .output(match_validation_1.TournamentMatchResponseSchema)
-        .mutation(async ({ input }) => error_handler_1.ErrorHandler.wrapAsync(async () => {
-        const result = await match_service_1.matchService.updateScore(input);
-        return (0, response_1.response)('Match score updated successfully', result);
-    })),
     end: (0, auth_2.createAuthenticatedProcedure)({ entityTypes: [auth_1.AuthEntityType.CRM] })
         .input(match_validation_1.EndTournamentMatchSchema)
         .output(match_validation_1.TournamentMatchResponseSchema)

package/dist/lib/modules/tournament/match/match.router.js.map

@@ -1 +1 @@
-{"version":3,"file":"match.router.js","sourceRoot":"/","sources":["modules/tournament/match/match.router.ts"],"names":[],"mappings":"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","sourcesContent":["import { createTRPCRouter, publicProcedure } from '@lyxa.ai/core/dist/libraries/trpc';\nimport { AuthEntityType } from '@lyxa.ai/core/dist/libraries/auth';\nimport { createAuthenticatedProcedure } from '@lyxa.ai/core/dist/libraries/trpc/middlewares/auth';\nimport { ErrorHandler } from '@lyxa.ai/core/dist/utilities/error-handler';\nimport { response } from '@lyxa.ai/core/dist/utilities/response';\nimport { matchService as service } from './match.service';\nimport {\n\tAddTournamentMatchesSchema,\n\tEndTournamentMatchSchema,\n\tGetTournamentMatchesSchema,\n\tStartTournamentMatchSchema,\n\tTournamentMatchListResponseSchema,\n\tTournamentMatchResponseSchema,\n\tUpdateMatchScoreSchema,\n} from './match.validation';\nimport { TournamentConfigResponseSchema } from '../config/config.validation';\n\nexport const matchRouter = createTRPCRouter({\n\tadd: createAuthenticatedProcedure({ entityTypes: [AuthEntityType.CRM] })\n\t\t.input(AddTournamentMatchesSchema)\n\t\t.output(TournamentConfigResponseSchema)\n\t\t.mutation(async ({ input }) =>\n\t\t\tErrorHandler.wrapAsync(async () => {\n\t\t\t\tconst result = await service.add(input);\n\t\t\t\treturn response('Matches added successfully', result);\n\t\t\t})\n\t\t),\n\n\tgetAll: publicProcedure\n\t\t.input(GetTournamentMatchesSchema)\n\t\t.output(TournamentMatchListResponseSchema)\n\t\t.query(async ({ input }) =>\n\t\t\tErrorHandler.wrapAsync(async () => {\n\t\t\t\tconst result = await service.getAll(input.tournamentId);\n\t\t\t\treturn response('Matches fetched successfully', result);\n\t\t\t})\n\t\t),\n\n\tstart: createAuthenticatedProcedure({ entityTypes: [AuthEntityType.CRM] })\n\t\t.input(StartTournamentMatchSchema)\n\t\t.output(TournamentMatchResponseSchema)\n\t\t.mutation(async ({ input }) =>\n\t\t\tErrorHandler.wrapAsync(async () => {\n\t\t\t\tconst result = await service.start(input);\n\t\t\t\treturn response('Match started successfully', result);\n\t\t\t})\n\t\t),\n\n\tupdateScore: createAuthenticatedProcedure({ entityTypes: [AuthEntityType.CRM] })\n\t\t.input(UpdateMatchScoreSchema)\n\t\t.output(TournamentMatchResponseSchema)\n\t\t.mutation(async ({ input }) =>\n\t\t\tErrorHandler.wrapAsync(async () => {\n\t\t\t\tconst result = await service.updateScore(input);\n\t\t\t\treturn response('Match score updated successfully', result);\n\t\t\t})\n\t\t),\n\n\tend: createAuthenticatedProcedure({ entityTypes: [AuthEntityType.CRM] })\n\t\t.input(EndTournamentMatchSchema)\n\t\t.output(TournamentMatchResponseSchema)\n\t\t.mutation(async ({ input }) =>\n\t\t\tErrorHandler.wrapAsync(async () => {\n\t\t\t\tconst result = await service.end(input);\n\t\t\t\treturn response('Match ended successfully', result);\n\t\t\t})\n\t\t),\n\n\tdelete: createAuthenticatedProcedure({ entityTypes: [AuthEntityType.CRM] })\n\t\t.input(EndTournamentMatchSchema.pick({ tournamentId: true, matchId: true }))\n\t\t.output(TournamentConfigResponseSchema)\n\t\t.mutation(async ({ input }) =>\n\t\t\tErrorHandler.wrapAsync(async () => {\n\t\t\t\tconst result = await service.delete(input.tournamentId, input.matchId);\n\t\t\t\treturn response('Match deleted successfully', result);\n\t\t\t})\n\t\t),\n});\n"]}
+{"version":3,"file":"match.router.js","sourceRoot":"/","sources":["modules/tournament/match/match.router.ts"],"names":[],"mappings":"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","sourcesContent":["import { createTRPCRouter, publicProcedure } from '@lyxa.ai/core/dist/libraries/trpc';\nimport { AuthEntityType } from '@lyxa.ai/core/dist/libraries/auth';\nimport { createAuthenticatedProcedure } from '@lyxa.ai/core/dist/libraries/trpc/middlewares/auth';\nimport { ErrorHandler } from '@lyxa.ai/core/dist/utilities/error-handler';\nimport { response } from '@lyxa.ai/core/dist/utilities/response';\nimport { matchService as service } from './match.service';\nimport {\n\tAddTournamentMatchesSchema,\n\tEndTournamentMatchSchema,\n\tGetTournamentMatchesSchema,\n\tStartTournamentMatchSchema,\n\tTournamentMatchListResponseSchema,\n\tTournamentMatchResponseSchema,\n\tUpdateMatchScoreSchema,\n} from './match.validation';\nimport { TournamentConfigResponseSchema } from '../config/config.validation';\n\nexport const matchRouter = createTRPCRouter({\n\tadd: createAuthenticatedProcedure({ entityTypes: [AuthEntityType.CRM] })\n\t\t.input(AddTournamentMatchesSchema)\n\t\t.output(TournamentConfigResponseSchema)\n\t\t.mutation(async ({ input }) =>\n\t\t\tErrorHandler.wrapAsync(async () => {\n\t\t\t\tconst result = await service.add(input);\n\t\t\t\treturn response('Matches added successfully', result);\n\t\t\t})\n\t\t),\n\n\tgetAll: publicProcedure\n\t\t.input(GetTournamentMatchesSchema)\n\t\t.output(TournamentMatchListResponseSchema)\n\t\t.query(async ({ input }) =>\n\t\t\tErrorHandler.wrapAsync(async () => {\n\t\t\t\tconst result = await service.getAll(input.tournamentId);\n\t\t\t\treturn response('Matches fetched successfully', result);\n\t\t\t})\n\t\t),\n\n\tstart: createAuthenticatedProcedure({ entityTypes: [AuthEntityType.CRM] })\n\t\t.input(StartTournamentMatchSchema)\n\t\t.output(TournamentMatchResponseSchema)\n\t\t.mutation(async ({ input }) =>\n\t\t\tErrorHandler.wrapAsync(async () => {\n\t\t\t\tconst result = await service.start(input);\n\t\t\t\treturn response('Match started successfully', result);\n\t\t\t})\n\t\t),\n\n\tend: createAuthenticatedProcedure({ entityTypes: [AuthEntityType.CRM] })\n\t\t.input(EndTournamentMatchSchema)\n\t\t.output(TournamentMatchResponseSchema)\n\t\t.mutation(async ({ input }) =>\n\t\t\tErrorHandler.wrapAsync(async () => {\n\t\t\t\tconst result = await service.end(input);\n\t\t\t\treturn response('Match ended successfully', result);\n\t\t\t})\n\t\t),\n\n\tdelete: createAuthenticatedProcedure({ entityTypes: [AuthEntityType.CRM] })\n\t\t.input(EndTournamentMatchSchema.pick({ tournamentId: true, matchId: true }))\n\t\t.output(TournamentConfigResponseSchema)\n\t\t.mutation(async ({ input }) =>\n\t\t\tErrorHandler.wrapAsync(async () => {\n\t\t\t\tconst result = await service.delete(input.tournamentId, input.matchId);\n\t\t\t\treturn response('Match deleted successfully', result);\n\t\t\t})\n\t\t),\n});\n"]}

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

@@ -1,27 +1,17 @@
 import { mongoose } from '@typegoose/typegoose';
-import { AddTournamentMatchesInputDTO, EndTournamentMatchInputDTO, StartTournamentMatchInputDTO, TournamentMatchOutputDTO, UpdateMatchScoreInputDTO } from './match.validation';
+import { AddTournamentMatchesInputDTO, EndTournamentMatchInputDTO, StartTournamentMatchInputDTO, TournamentMatchOutputDTO } from './match.validation';
 import { TournamentConfigOutputDTO } from '../config/config.validation';
 export declare class MatchService {
     private repository;
     private notificationScheduler;
-    private notificationService;
-    private participantService;
-    private predictionRepository;
-    private rewardService;
     constructor();
     private getTournament;
     private getMatch;
-    private validateWinner;
     private resolveMatchTeams;
     private applyMatchUpdate;
-    handleMatchEnded(tournamentId: mongoose.Types.ObjectId, matchId: mongoose.Types.ObjectId, finalScore: {
-        team1: number;
-        team2: number;
-    }): Promise<void>;
     add(input: AddTournamentMatchesInputDTO): Promise<TournamentConfigOutputDTO>;
     getAll(tournamentId: mongoose.Types.ObjectId): Promise<TournamentMatchOutputDTO[]>;
     start(input: StartTournamentMatchInputDTO): Promise<TournamentMatchOutputDTO>;
-    updateScore(input: UpdateMatchScoreInputDTO): Promise<TournamentMatchOutputDTO>;
     end(input: EndTournamentMatchInputDTO): Promise<TournamentMatchOutputDTO>;
     delete(tournamentId: mongoose.Types.ObjectId, matchId: mongoose.Types.ObjectId): Promise<TournamentConfigOutputDTO>;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"match.service.d.ts","sourceRoot":"/","sources":["modules/tournament/match/match.service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAGhD,OAAO,EACH,4BAA4B,EAC5B,0BAA0B,EAC1B,4BAA4B,EAC5B,wBAAwB,EACxB,wBAAwB,EAC3B,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AAYxE,qBACa,YAAY;IACrB,OAAO,CAAC,UAAU,CAA4B;IAC9C,OAAO,CAAC,qBAAqB,CAA+B;IAC5D,OAAO,CAAC,mBAAmB,CAAgC;IAC3D,OAAO,CAAC,kBAAkB,CAAqB;IAC/C,OAAO,CAAC,oBAAoB,CAAuB;IACnD,OAAO,CAAC,aAAa,CAAgB;;YAWvB,aAAa;IAM3B,OAAO,CAAC,QAAQ;IAMhB,OAAO,CAAC,cAAc;IAOtB,OAAO,CAAC,iBAAiB;YAQX,gBAAgB;IAajB,gBAAgB,CACzB,YAAY,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,EACrC,OAAO,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,EAChC,UAAU,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,GAC7C,OAAO,CAAC,IAAI,CAAC;IA8BH,GAAG,CAAC,KAAK,EAAE,4BAA4B,GAAG,OAAO,CAAC,yBAAyB,CAAC;IAoB5E,MAAM,CAAC,YAAY,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,GAAG,OAAO,CAAC,wBAAwB,EAAE,CAAC;IAKlF,KAAK,CAAC,KAAK,EAAE,4BAA4B,GAAG,OAAO,CAAC,wBAAwB,CAAC;IAgB7E,WAAW,CAAC,KAAK,EAAE,wBAAwB,GAAG,OAAO,CAAC,wBAAwB,CAAC;IAO/E,GAAG,CAAC,KAAK,EAAE,0BAA0B,GAAG,OAAO,CAAC,wBAAwB,CAAC;IAqBzE,MAAM,CAAC,YAAY,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,EAAE,OAAO,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,GAAG,OAAO,CAAC,yBAAyB,CAAC;CASnI;AAED,eAAO,MAAM,YAAY,cAA8B,CAAC"}
+{"version":3,"file":"match.service.d.ts","sourceRoot":"/","sources":["modules/tournament/match/match.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,QAAQ,EAAC,MAAM,sBAAsB,CAAC;AAG9C,OAAO,EACH,4BAA4B,EAC5B,0BAA0B,EAC1B,4BAA4B,EAC5B,wBAAwB,EAC3B,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EAAC,yBAAyB,EAAC,MAAM,6BAA6B,CAAC;AAKtE,qBACa,YAAY;IACrB,OAAO,CAAC,UAAU,CAA4B;IAC9C,OAAO,CAAC,qBAAqB,CAA+B;;YAO9C,aAAa;IAM3B,OAAO,CAAC,QAAQ;IAMhB,OAAO,CAAC,iBAAiB;YAQX,gBAAgB;IAYjB,GAAG,CAAC,KAAK,EAAE,4BAA4B,GAAG,OAAO,CAAC,yBAAyB,CAAC;IAoB5E,MAAM,CAAC,YAAY,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,GAAG,OAAO,CAAC,wBAAwB,EAAE,CAAC;IAKlF,KAAK,CAAC,KAAK,EAAE,4BAA4B,GAAG,OAAO,CAAC,wBAAwB,CAAC;IAW7E,GAAG,CAAC,KAAK,EAAE,0BAA0B,GAAG,OAAO,CAAC,wBAAwB,CAAC;IAsBzE,MAAM,CAAC,YAAY,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,EAAE,OAAO,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,GAAG,OAAO,CAAC,yBAAyB,CAAC;CASnI;AAED,eAAO,MAAM,YAAY,cAA8B,CAAC"}

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

@@ -44,33 +44,18 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.matchService = exports.MatchService = void 0;
 const typedi_1 = __importStar(require("typedi"));
-const server_1 = require("@trpc/server");
 const error_common_1 = require("@lyxa.ai/core/dist/utilities/error-common");
 const event_1 = require("@lyxa.ai/core/dist/libraries/event");
 const match_repository_1 = require("./match.repository");
 const match_builder_1 = require("./match.builder");
 const notification_scheduler_service_1 = require("../notification/notification.scheduler.service");
-const notification_service_1 = require("../notification/notification.service");
-const participant_service_1 = require("../participant/participant.service");
-const prediction_repository_1 = require("../prediction/prediction.repository");
-const reward_service_1 = require("../reward/reward.service");
-const reward_types_1 = require("../reward/reward.types");
-const match_ended_event_1 = require("./events/match-ended.event");
-const FWC_COUPON_CODE = 'FWC01';
+const evaluate_predictions_event_1 = require("./events/evaluate-predictions.event");
 let MatchService = class MatchService {
     repository;
     notificationScheduler;
-    notificationService;
-    participantService;
-    predictionRepository;
-    rewardService;
     constructor() {
         this.repository = typedi_1.default.get(match_repository_1.TournamentMatchRepository);
         this.notificationScheduler = typedi_1.default.get(notification_scheduler_service_1.NotificationSchedulerService);
-        this.notificationService = typedi_1.default.get(notification_service_1.TournamentNotificationService);
-        this.participantService = typedi_1.default.get(participant_service_1.ParticipantService);
-        this.predictionRepository = typedi_1.default.get(prediction_repository_1.PredictionRepository);
-        this.rewardService = typedi_1.default.get(reward_service_1.RewardService);
     }
     async getTournament(tournamentId) {
         const tournament = await this.repository.findById(tournamentId);
@@ -84,13 +69,6 @@ let MatchService = class MatchService {
             throw (0, error_common_1.notFoundError)('Match not found');
         return match;
     }
-    validateWinner(match, winnerId) {
-        if (!winnerId)
-            return;
-        if (![match.team1.teamId.toString(), match.team2.teamId.toString()].includes(winnerId.toString())) {
-            throw (0, error_common_1.badRequestError)('Winner must be one of the match teams');
-        }
-    }
     resolveMatchTeams(tournament, team1Id, team2Id) {
         const teamsById = new Map(tournament.teams.map(team => [team._id.toString(), team]));
         const team1 = teamsById.get(team1Id.toString());
@@ -99,36 +77,15 @@ let MatchService = class MatchService {
             throw (0, error_common_1.badRequestError)('All match teams must exist in the tournament');
         return { team1, team2 };
     }
-    async applyMatchUpdate(tournamentId, matchId, updates, errorMessage) {
+    async applyMatchUpdate(tournamentId, matchId, updates) {
         const result = await this.repository.updateMatch(tournamentId, matchId, updates);
         if (!result)
-            throw new server_1.TRPCError({ code: 'INTERNAL_SERVER_ERROR', message: errorMessage });
+            throw (0, error_common_1.notFoundError)('Tournament not found');
         const updated = result.matches.find(m => m._id.toString() === matchId.toString());
         if (!updated)
             throw (0, error_common_1.notFoundError)('Match not found');
         return updated;
     }
-    async handleMatchEnded(tournamentId, matchId, finalScore) {
-        const participants = await this.participantService.getAll(tournamentId);
-        await Promise.all(participants.map(async (participant) => {
-            const prediction = participant.predictions.find(p => p.matchId.toString() === matchId.toString());
-            if (!prediction)
-                return;
-            const correct = prediction.score.team1 === finalScore.team1 &&
-                prediction.score.team2 === finalScore.team2;
-            await this.predictionRepository.setSucceeded(participant._id, matchId, correct);
-            if (correct) {
-                const expiresAt = new Date();
-                expiresAt.setMonth(expiresAt.getMonth() + 1);
-                await this.rewardService.grant(reward_types_1.RewardType.COUPON, {
-                    userId: participant.userId,
-                    tournamentId,
-                    matchId,
-                    payload: { code: FWC_COUPON_CODE, expiresAt },
-                });
-            }
-        }));
-    }
     async add(input) {
         const tournament = await this.getTournament(input.tournamentId);
         const matches = input.matches.map(match => {
@@ -137,7 +94,7 @@ let MatchService = class MatchService {
         });
         const result = await this.repository.addMatches(input.tournamentId, matches);
         if (!result)
-            throw new server_1.TRPCError({ code: 'INTERNAL_SERVER_ERROR', message: 'Failed to add matches' });
+            throw (0, error_common_1.notFoundError)('Tournament not found');
         await Promise.all(matches.map(match => this.notificationScheduler.scheduleForMatch(match._id, input.tournamentId, match.startingDate)));
         return result;
     }
@@ -148,38 +105,37 @@ let MatchService = class MatchService {
     async start(input) {
         const tournament = await this.getTournament(input.tournamentId);
         const match = this.getMatch(tournament, input.matchId);
+        if (!match.startingDate || match.startingDate > new Date())
+            throw (0, error_common_1.badRequestError)('This match has not started yet');
         if (match.endDate)
             throw (0, error_common_1.badRequestError)('This match has already ended');
         await this.notificationScheduler.cancelForMatch(input.matchId);
-        return this.applyMatchUpdate(input.tournamentId, input.matchId, { startingDate: new Date() }, 'Failed to start match');
-    }
-    async updateScore(input) {
-        const tournament = await this.getTournament(input.tournamentId);
-        const match = this.getMatch(tournament, input.matchId);
-        this.validateWinner(match, input.winnerId);
-        return this.applyMatchUpdate(input.tournamentId, input.matchId, match_builder_1.MatchBuilder.buildScoreUpdate(input), 'Failed to update match score');
+        return match;
     }
     async end(input) {
         const tournament = await this.getTournament(input.tournamentId);
         const match = this.getMatch(tournament, input.matchId);
-        this.validateWinner(match, input.winnerId);
-        const ended = await this.applyMatchUpdate(input.tournamentId, input.matchId, match_builder_1.MatchBuilder.buildEndUpdate(input), 'Failed to end match');
+        if (!match.startingDate || match.startingDate > new Date())
+            throw (0, error_common_1.badRequestError)('This match has not started yet');
+        if (match.endDate)
+            throw (0, error_common_1.badRequestError)('This match has already ended');
+        const matchUpdates = match_builder_1.MatchBuilder.buildEndUpdate(match, input.finalScore);
+        const ended = await this.applyMatchUpdate(input.tournamentId, input.matchId, matchUpdates);
         const { team1, team2 } = ended.score;
         if (team1 !== null && team1 !== undefined && team2 !== null && team2 !== undefined) {
-            await (0, event_1.publishEvent)(new match_ended_event_1.MatchEndedEvent({
-                tournamentId: input.tournamentId.toString(),
-                matchId: input.matchId.toString(),
+            await (0, event_1.publishEvent)(new evaluate_predictions_event_1.EvaluatePredictionsEvent({
+                tournamentId: input.tournamentId,
+                matchId: input.matchId,
                 finalScore: { team1, team2 },
             }));
         }
-        await this.notificationService.notifyMatchEnded(input.tournamentId, input.matchId);
         return ended;
     }
     async delete(tournamentId, matchId) {
         await this.getTournament(tournamentId);
         const result = await this.repository.deleteMatch(tournamentId, matchId);
         if (!result)
-            throw new server_1.TRPCError({ code: 'INTERNAL_SERVER_ERROR', message: 'Failed to delete match' });
+            throw (0, error_common_1.notFoundError)('Tournament not found');
         await this.notificationScheduler.cancelForMatch(matchId);
         return result;
     }