@lyxa.ai/marketing 1.0.49 → 1.0.51

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

@@ -0,0 +1 @@
+{"version":3,"file":"statistics.router.d.ts","sourceRoot":"/","sources":["modules/tournament/statistics/statistics.router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAShD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAU3B,CAAC"}

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.statisticsRouter = void 0;
+const typegoose_1 = require("@typegoose/typegoose");
+const trpc_1 = require("@lyxa.ai/core/dist/libraries/trpc");
+const auth_1 = require("@lyxa.ai/core/dist/libraries/auth");
+const auth_2 = require("@lyxa.ai/core/dist/libraries/trpc/middlewares/auth");
+const error_handler_1 = require("@lyxa.ai/core/dist/utilities/error-handler");
+const response_1 = require("@lyxa.ai/core/dist/utilities/response");
+const statistics_service_1 = require("./statistics.service");
+const statistics_validation_1 = require("./statistics.validation");
+exports.statisticsRouter = (0, trpc_1.createTRPCRouter)({
+    getActiveByUser: (0, auth_2.createAuthenticatedProcedure)({ entityTypes: [auth_1.AuthEntityType.CRM] })
+        .input(statistics_validation_1.GetUserTournamentStatsSchema)
+        .output(statistics_validation_1.UserTournamentStatsResponseSchema)
+        .query(async ({ input }) => error_handler_1.ErrorHandler.wrapAsync(async () => {
+        const result = await statistics_service_1.statisticsService.getActiveByUser(new typegoose_1.mongoose.Types.ObjectId(input.userId));
+        return (0, response_1.response)('User tournament stats fetched successfully', result);
+    })),
+});
+//# sourceMappingURL=statistics.router.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"statistics.router.js","sourceRoot":"/","sources":["modules/tournament/statistics/statistics.router.ts"],"names":[],"mappings":";;;AAAA,oDAAgD;AAChD,4DAAqE;AACrE,4DAAmE;AACnE,6EAAkG;AAClG,8EAA0E;AAC1E,oEAAiE;AACjE,6DAAoE;AACpE,mEAA0G;AAE7F,QAAA,gBAAgB,GAAG,IAAA,uBAAgB,EAAC;IAChD,eAAe,EAAE,IAAA,mCAA4B,EAAC,EAAE,WAAW,EAAE,CAAC,qBAAc,CAAC,GAAG,CAAC,EAAE,CAAC;SAClF,KAAK,CAAC,oDAA4B,CAAC;SACnC,MAAM,CAAC,yDAAiC,CAAC;SACzC,KAAK,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,CAC1B,4BAAY,CAAC,SAAS,CAAC,KAAK,IAAI,EAAE;QACjC,MAAM,MAAM,GAAG,MAAM,sCAAO,CAAC,eAAe,CAAC,IAAI,oBAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC;QACxF,OAAO,IAAA,mBAAQ,EAAC,4CAA4C,EAAE,MAAM,CAAC,CAAC;IACvE,CAAC,CAAC,CACF;CACF,CAAC,CAAC","sourcesContent":["import { mongoose } from '@typegoose/typegoose';\nimport { createTRPCRouter } 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 { statisticsService as service } from './statistics.service';\nimport { GetUserTournamentStatsSchema, UserTournamentStatsResponseSchema } from './statistics.validation';\n\nexport const statisticsRouter = createTRPCRouter({\n\tgetActiveByUser: createAuthenticatedProcedure({ entityTypes: [AuthEntityType.CRM] })\n\t\t.input(GetUserTournamentStatsSchema)\n\t\t.output(UserTournamentStatsResponseSchema)\n\t\t.query(async ({ input }) =>\n\t\t\tErrorHandler.wrapAsync(async () => {\n\t\t\t\tconst result = await service.getActiveByUser(new mongoose.Types.ObjectId(input.userId));\n\t\t\t\treturn response('User tournament stats fetched successfully', result);\n\t\t\t})\n\t\t),\n});\n"]}

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

@@ -0,0 +1,11 @@
+import { mongoose } from '@typegoose/typegoose';
+import { UserTournamentStatsOutputDTO } from './statistics.validation';
+export declare class StatisticsService {
+    private participantRepository;
+    private configRepository;
+    private rewardRepository;
+    constructor();
+    getActiveByUser(userId: mongoose.Types.ObjectId): Promise<UserTournamentStatsOutputDTO | null>;
+}
+export declare const statisticsService: StatisticsService;
+//# sourceMappingURL=statistics.service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"statistics.service.d.ts","sourceRoot":"/","sources":["modules/tournament/statistics/statistics.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAKhD,OAAO,EAAE,4BAA4B,EAAE,MAAM,yBAAyB,CAAC;AAEvE,qBACa,iBAAiB;IAC1B,OAAO,CAAC,qBAAqB,CAAkC;IAC/D,OAAO,CAAC,gBAAgB,CAA6B;IACrD,OAAO,CAAC,gBAAgB,CAAmB;;IAQ9B,eAAe,CAAC,MAAM,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,GAAG,OAAO,CAAC,4BAA4B,GAAG,IAAI,CAAC;CAkB9G;AAED,eAAO,MAAM,iBAAiB,mBAAmC,CAAC"}

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

@@ -0,0 +1,80 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.statisticsService = exports.StatisticsService = void 0;
+const typedi_1 = __importStar(require("typedi"));
+const participant_repository_1 = require("../participant/participant.repository");
+const config_repository_1 = require("../config/config.repository");
+const reward_repository_1 = require("../reward/reward.repository");
+const statistics_builder_1 = require("./statistics.builder");
+let StatisticsService = class StatisticsService {
+    participantRepository;
+    configRepository;
+    rewardRepository;
+    constructor() {
+        this.participantRepository = typedi_1.default.get(participant_repository_1.TournamentParticipantRepository);
+        this.configRepository = typedi_1.default.get(config_repository_1.TournamentConfigRepository);
+        this.rewardRepository = typedi_1.default.get(reward_repository_1.RewardRepository);
+    }
+    async getActiveByUser(userId) {
+        const tournament = await this.configRepository.findActiveFull();
+        if (!tournament)
+            return null;
+        const participant = await this.participantRepository.findByUserAndTournament(userId, tournament._id);
+        if (!participant)
+            return null;
+        const couponIds = participant.predictions
+            .filter(p => p.coupon)
+            .map(p => p.coupon);
+        const couponCodeMap = await this.rewardRepository.findCouponCodesByIds(couponIds);
+        return statistics_builder_1.StatisticsBuilder.buildUserTournamentStats(participant, tournament, couponCodeMap);
+    }
+};
+exports.StatisticsService = StatisticsService;
+exports.StatisticsService = StatisticsService = __decorate([
+    (0, typedi_1.Service)(),
+    __metadata("design:paramtypes", [])
+], StatisticsService);
+exports.statisticsService = typedi_1.default.get(StatisticsService);
+//# sourceMappingURL=statistics.service.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"statistics.service.js","sourceRoot":"/","sources":["modules/tournament/statistics/statistics.service.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,iDAA4C;AAE5C,kFAAwF;AACxF,mEAAyE;AACzE,mEAA+D;AAC/D,6DAAyD;AAIlD,IAAM,iBAAiB,GAAvB,MAAM,iBAAiB;IAClB,qBAAqB,CAAkC;IACvD,gBAAgB,CAA6B;IAC7C,gBAAgB,CAAmB;IAE3C;QACI,IAAI,CAAC,qBAAqB,GAAG,gBAAS,CAAC,GAAG,CAAC,wDAA+B,CAAC,CAAC;QAC5E,IAAI,CAAC,gBAAgB,GAAG,gBAAS,CAAC,GAAG,CAAC,8CAA0B,CAAC,CAAC;QAClE,IAAI,CAAC,gBAAgB,GAAG,gBAAS,CAAC,GAAG,CAAC,oCAAgB,CAAC,CAAC;IAC5D,CAAC;IAEM,KAAK,CAAC,eAAe,CAAC,MAA+B;QACxD,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,cAAc,EAAE,CAAC;QAChE,IAAI,CAAC,UAAU;YAAE,OAAO,IAAI,CAAC;QAE7B,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,qBAAqB,CAAC,uBAAuB,CACxE,MAAM,EACN,UAAU,CAAC,GAAG,CACjB,CAAC;QACF,IAAI,CAAC,WAAW;YAAE,OAAO,IAAI,CAAC;QAE9B,MAAM,SAAS,GAAG,WAAW,CAAC,WAAW;aACpC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC;aACrB,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAiC,CAAC,CAAC;QAEnD,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,oBAAoB,CAAC,SAAS,CAAC,CAAC;QAElF,OAAO,sCAAiB,CAAC,wBAAwB,CAAC,WAAkB,EAAE,UAAU,EAAE,aAAa,CAAC,CAAC;IACrG,CAAC;CACJ,CAAA;AA7BY,8CAAiB;4BAAjB,iBAAiB;IAD7B,IAAA,gBAAO,GAAE;;GACG,iBAAiB,CA6B7B;AAEY,QAAA,iBAAiB,GAAG,gBAAS,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC","sourcesContent":["import Container, { Service } from 'typedi';\nimport { mongoose } from '@typegoose/typegoose';\nimport { TournamentParticipantRepository } from '../participant/participant.repository';\nimport { TournamentConfigRepository } from '../config/config.repository';\nimport { RewardRepository } from '../reward/reward.repository';\nimport { StatisticsBuilder } from './statistics.builder';\nimport { UserTournamentStatsOutputDTO } from './statistics.validation';\n\n@Service()\nexport class StatisticsService {\n    private participantRepository: TournamentParticipantRepository;\n    private configRepository: TournamentConfigRepository;\n    private rewardRepository: RewardRepository;\n\n    constructor() {\n        this.participantRepository = Container.get(TournamentParticipantRepository);\n        this.configRepository = Container.get(TournamentConfigRepository);\n        this.rewardRepository = Container.get(RewardRepository);\n    }\n\n    public async getActiveByUser(userId: mongoose.Types.ObjectId): Promise<UserTournamentStatsOutputDTO | null> {\n        const tournament = await this.configRepository.findActiveFull();\n        if (!tournament) return null;\n\n        const participant = await this.participantRepository.findByUserAndTournament(\n            userId,\n            tournament._id\n        );\n        if (!participant) return null;\n\n        const couponIds = participant.predictions\n            .filter(p => p.coupon)\n            .map(p => p.coupon as mongoose.Types.ObjectId);\n\n        const couponCodeMap = await this.rewardRepository.findCouponCodesByIds(couponIds);\n\n        return StatisticsBuilder.buildUserTournamentStats(participant as any, tournament, couponCodeMap);\n    }\n}\n\nexport const statisticsService = Container.get(StatisticsService);\n"]}

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

@@ -0,0 +1,404 @@
+import { z } from 'zod';
+import { DTO } from '@lyxa.ai/core/dist/utilities/validation/global-validation';
+export declare const GetUserTournamentStatsSchema: z.ZodObject<{
+    userId: 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>]>;
+}, "strip", z.ZodTypeAny, {
+    userId: import("mongoose").Types.ObjectId;
+}, {
+    userId: string | import("mongoose").Types.ObjectId;
+}>;
+export declare const UserTournamentMatchViewSchema: z.ZodObject<{
+    id: z.ZodString;
+    teams: z.ZodString;
+    date: z.ZodNullable<z.ZodString>;
+    prediction: z.ZodNullable<z.ZodString>;
+    realScore: z.ZodNullable<z.ZodString>;
+    result: z.ZodNullable<z.ZodEnum<["won", "lost", "pending"]>>;
+    coupon: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    date: string | null;
+    coupon: string | null;
+    id: string;
+    result: "won" | "lost" | "pending" | null;
+    teams: string;
+    prediction: string | null;
+    realScore: string | null;
+}, {
+    date: string | null;
+    coupon: string | null;
+    id: string;
+    result: "won" | "lost" | "pending" | null;
+    teams: string;
+    prediction: string | null;
+    realScore: string | null;
+}>;
+export declare const UserTournamentStatsSchema: z.ZodNullable<z.ZodObject<{
+    name: z.ZodString;
+    joinedAt: z.ZodNullable<z.ZodDate>;
+    selectedTeam: z.ZodObject<{
+        name: z.ZodString;
+        flag: z.ZodNullable<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        flag: string | null;
+    }, {
+        name: string;
+        flag: string | null;
+    }>;
+    stats: z.ZodObject<{
+        predictionsMade: z.ZodNumber;
+        correctPredictions: z.ZodNumber;
+        couponsWon: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        predictionsMade: number;
+        correctPredictions: number;
+        couponsWon: number;
+    }, {
+        predictionsMade: number;
+        correctPredictions: number;
+        couponsWon: number;
+    }>;
+    matches: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        teams: z.ZodString;
+        date: z.ZodNullable<z.ZodString>;
+        prediction: z.ZodNullable<z.ZodString>;
+        realScore: z.ZodNullable<z.ZodString>;
+        result: z.ZodNullable<z.ZodEnum<["won", "lost", "pending"]>>;
+        coupon: z.ZodNullable<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        date: string | null;
+        coupon: string | null;
+        id: string;
+        result: "won" | "lost" | "pending" | null;
+        teams: string;
+        prediction: string | null;
+        realScore: string | null;
+    }, {
+        date: string | null;
+        coupon: string | null;
+        id: string;
+        result: "won" | "lost" | "pending" | null;
+        teams: string;
+        prediction: string | null;
+        realScore: string | null;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    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;
+    };
+}, {
+    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;
+    };
+}>>;
+export declare const UserTournamentStatsResponseSchema: 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<{
+            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, z.ZodTypeDef, {
+            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>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        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;
+    }, {
+        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;
+    }>, z.ZodType<{
+        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, z.ZodTypeDef, {
+        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>]>>;
+}, "strip", z.ZodTypeAny, {
+    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;
+}, {
+    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;
+}>;
+export type GetUserTournamentStatsInputDTO = DTO<typeof GetUserTournamentStatsSchema>;
+export type UserTournamentStatsOutputDTO = DTO<typeof UserTournamentStatsSchema>;
+//# sourceMappingURL=statistics.validation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"statistics.validation.d.ts","sourceRoot":"/","sources":["modules/tournament/statistics/statistics.validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,GAAG,EAAiB,MAAM,2DAA2D,CAAC;AAG/F,eAAO,MAAM,4BAA4B;;;;;;EAEvC,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;EAQxC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAe1B,CAAC;AAEb,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAkD,CAAC;AAEjG,MAAM,MAAM,8BAA8B,GAAG,GAAG,CAAC,OAAO,4BAA4B,CAAC,CAAC;AACtF,MAAM,MAAM,4BAA4B,GAAG,GAAG,CAAC,OAAO,yBAAyB,CAAC,CAAC"}

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserTournamentStatsResponseSchema = exports.UserTournamentStatsSchema = exports.UserTournamentMatchViewSchema = exports.GetUserTournamentStatsSchema = 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");
+exports.GetUserTournamentStatsSchema = zod_1.z.object({
+    userId: global_validation_1.ZodValidation.objectId('User id'),
+});
+exports.UserTournamentMatchViewSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    teams: zod_1.z.string(),
+    date: zod_1.z.string().nullable(),
+    prediction: zod_1.z.string().nullable(),
+    realScore: zod_1.z.string().nullable(),
+    result: zod_1.z.enum(['won', 'lost', 'pending']).nullable(),
+    coupon: zod_1.z.string().nullable(),
+});
+exports.UserTournamentStatsSchema = zod_1.z
+    .object({
+    name: zod_1.z.string(),
+    joinedAt: zod_1.z.date().nullable(),
+    selectedTeam: zod_1.z.object({
+        name: zod_1.z.string(),
+        flag: zod_1.z.string().nullable(),
+    }),
+    stats: zod_1.z.object({
+        predictionsMade: zod_1.z.number(),
+        correctPredictions: zod_1.z.number(),
+        couponsWon: zod_1.z.number(),
+    }),
+    matches: zod_1.z.array(exports.UserTournamentMatchViewSchema),
+})
+    .nullable();
+exports.UserTournamentStatsResponseSchema = (0, validation_1.createResponseSchema)(exports.UserTournamentStatsSchema);
+//# sourceMappingURL=statistics.validation.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"statistics.validation.js","sourceRoot":"/","sources":["modules/tournament/statistics/statistics.validation.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AACxB,iGAA+F;AAC/F,wEAA+E;AAElE,QAAA,4BAA4B,GAAG,OAAC,CAAC,MAAM,CAAC;IACpD,MAAM,EAAE,iCAAa,CAAC,QAAQ,CAAC,SAAS,CAAC;CACzC,CAAC,CAAC;AAEU,QAAA,6BAA6B,GAAG,OAAC,CAAC,MAAM,CAAC;IACrD,EAAE,EAAE,OAAC,CAAC,MAAM,EAAE;IACd,KAAK,EAAE,OAAC,CAAC,MAAM,EAAE;IACjB,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC3B,UAAU,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACjC,SAAS,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAChC,MAAM,EAAE,OAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,QAAQ,EAAE;IACrD,MAAM,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAC7B,CAAC,CAAC;AAEU,QAAA,yBAAyB,GAAG,OAAC;KACxC,MAAM,CAAC;IACP,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE;IAChB,QAAQ,EAAE,OAAC,CAAC,IAAI,EAAE,CAAC,QAAQ,EAAE;IAC7B,YAAY,EAAE,OAAC,CAAC,MAAM,CAAC;QACtB,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE;QAChB,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;KAC3B,CAAC;IACF,KAAK,EAAE,OAAC,CAAC,MAAM,CAAC;QACf,eAAe,EAAE,OAAC,CAAC,MAAM,EAAE;QAC3B,kBAAkB,EAAE,OAAC,CAAC,MAAM,EAAE;QAC9B,UAAU,EAAE,OAAC,CAAC,MAAM,EAAE;KACtB,CAAC;IACF,OAAO,EAAE,OAAC,CAAC,KAAK,CAAC,qCAA6B,CAAC;CAC/C,CAAC;KACD,QAAQ,EAAE,CAAC;AAEA,QAAA,iCAAiC,GAAG,IAAA,iCAAoB,EAAC,iCAAyB,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';\n\nexport const GetUserTournamentStatsSchema = z.object({\n\tuserId: ZodValidation.objectId('User id'),\n});\n\nexport const UserTournamentMatchViewSchema = z.object({\n\tid: z.string(),\n\tteams: z.string(),\n\tdate: z.string().nullable(),\n\tprediction: z.string().nullable(),\n\trealScore: z.string().nullable(),\n\tresult: z.enum(['won', 'lost', 'pending']).nullable(),\n\tcoupon: z.string().nullable(),\n});\n\nexport const UserTournamentStatsSchema = z\n\t.object({\n\t\tname: z.string(),\n\t\tjoinedAt: z.date().nullable(),\n\t\tselectedTeam: z.object({\n\t\t\tname: z.string(),\n\t\t\tflag: z.string().nullable(),\n\t\t}),\n\t\tstats: z.object({\n\t\t\tpredictionsMade: z.number(),\n\t\t\tcorrectPredictions: z.number(),\n\t\t\tcouponsWon: z.number(),\n\t\t}),\n\t\tmatches: z.array(UserTournamentMatchViewSchema),\n\t})\n\t.nullable();\n\nexport const UserTournamentStatsResponseSchema = createResponseSchema(UserTournamentStatsSchema);\n\nexport type GetUserTournamentStatsInputDTO = DTO<typeof GetUserTournamentStatsSchema>;\nexport type UserTournamentStatsOutputDTO = DTO<typeof UserTournamentStatsSchema>;\n"]}

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

@@ -29,12 +29,12 @@ export declare const teamRouter: import("@trpc/server").TRPCBuiltRouter<{
             data?: {
                 status: import("@lyxa.ai/core/dist/utilities/enum").Status;
                 name: string;
-                tag: string;
                 _id?: string | mongoose.Types.ObjectId | undefined;
                 createdAt?: Date | null | undefined;
                 startDate?: Date | null | undefined;
                 endDate?: Date | null | undefined;
                 updatedAt?: Date | null | undefined;
+                tag?: import("../tournament.types").TournamentTag | undefined;
                 reward?: {
                     type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.FREE_DELIVERY;
                 } | {
@@ -47,12 +47,12 @@ export declare const teamRouter: import("@trpc/server").TRPCBuiltRouter<{
                 documents: {
                     status: import("@lyxa.ai/core/dist/utilities/enum").Status;
                     name: string;
-                    tag: string;
                     _id?: string | mongoose.Types.ObjectId | undefined;
                     createdAt?: Date | null | undefined;
                     startDate?: Date | null | undefined;
                     endDate?: Date | null | undefined;
                     updatedAt?: Date | null | undefined;
+                    tag?: import("../tournament.types").TournamentTag | undefined;
                     reward?: {
                         type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.FREE_DELIVERY;
                     } | {
@@ -115,8 +115,8 @@ export declare const teamRouter: import("@trpc/server").TRPCBuiltRouter<{
     }>;
     getMatches: import("@trpc/server").TRPCQueryProcedure<{
         input: {
-            filter: "completed" | "upcoming";
             tournamentId: string | mongoose.Types.ObjectId;
+            filter?: import("../tournament.types").MatchStatus | undefined;
         };
         output: {
             message: string;
@@ -130,16 +130,19 @@ export declare const teamRouter: import("@trpc/server").TRPCBuiltRouter<{
                     team1: {
                         name: string;
                         teamId: string | mongoose.Types.ObjectId;
+                        picture?: string | undefined;
                     };
                     team2: {
                         name: string;
                         teamId: string | mongoose.Types.ObjectId;
+                        picture?: string | undefined;
                     };
                     score: {
                         team1: number | null;
                         team2: number | null;
                     };
                     stage: string;
+                    matchStatus: import("../tournament.types").MatchStatus;
                     prediction: {
                         score: {
                             team1: number | null;
@@ -165,16 +168,19 @@ export declare const teamRouter: import("@trpc/server").TRPCBuiltRouter<{
                         team1: {
                             name: string;
                             teamId: string | mongoose.Types.ObjectId;
+                            picture?: string | undefined;
                         };
                         team2: {
                             name: string;
                             teamId: string | mongoose.Types.ObjectId;
+                            picture?: string | undefined;
                         };
                         score: {
                             team1: number | null;
                             team2: number | null;
                         };
                         stage: string;
+                        matchStatus: import("../tournament.types").MatchStatus;
                         prediction: {
                             score: {
                                 team1: number | null;

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

@@ -1 +1 @@
-{"version":3,"file":"team.router.d.ts","sourceRoot":"/","sources":["modules/tournament/team/team.router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAgBhD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BrB,CAAC"}
+{"version":3,"file":"team.router.d.ts","sourceRoot":"/","sources":["modules/tournament/team/team.router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAgBhD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BrB,CAAC"}