@lyxa.ai/marketing 1.0.50 → 1.0.52

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

@@ -1 +1 @@
-{"version":3,"file":"tournament.router.d.ts","sourceRoot":"/","sources":["modules/tournament/tournament.router.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgB3B,CAAC"}
+{"version":3,"file":"tournament.router.d.ts","sourceRoot":"/","sources":["modules/tournament/tournament.router.ts"],"names":[],"mappings":"AAKA,OAAO,EAAC,QAAQ,EAAC,MAAM,sBAAsB,CAAC;AAY9C,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkB3B,CAAC"}

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

@@ -2,8 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tournamentRouter = void 0;
 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 typegoose_1 = require("@typegoose/typegoose");
 const config_router_1 = require("./config/config.router");
 const team_router_1 = require("./team/team.router");
 const match_router_1 = require("./match/match.router");
@@ -23,8 +26,10 @@ exports.tournamentRouter = (0, trpc_1.createTRPCRouter)({
     statistics: statistics_router_1.statisticsRouter,
     schedule: schedule_router_1.scheduleRouter,
     score: score_router_1.scoreRouter,
-    getActive: trpc_1.publicProcedure.output(tournament_validation_1.ActiveTournamentResponseSchema).query(() => error_handler_1.ErrorHandler.wrapAsync(async () => {
-        const result = await tournament_service_1.tournamentService.getActive();
+    getActive: (0, auth_2.createAuthenticatedProcedure)({ entityTypes: [auth_1.AuthEntityType.USER] })
+        .output(tournament_validation_1.ActiveTournamentResponseSchema)
+        .query(({ ctx }) => error_handler_1.ErrorHandler.wrapAsync(async () => {
+        const result = await tournament_service_1.tournamentService.getActive(new typegoose_1.mongoose.Types.ObjectId(ctx.entity?.id));
         return (0, response_1.response)('Active tournament fetched successfully', result);
     })),
 });

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

@@ -1 +1 @@
-{"version":3,"file":"tournament.router.js","sourceRoot":"/","sources":["modules/tournament/tournament.router.ts"],"names":[],"mappings":";;;AAAA,4DAAoF;AACpF,8EAAwE;AACxE,oEAA+D;AAC/D,0DAAoD;AACpD,oDAA8C;AAC9C,uDAAiD;AACjD,yEAAmE;AACnE,sEAAgE;AAChE,sEAAgE;AAChE,gEAA0D;AAC1D,uDAAiD;AACjD,mEAAuE;AACvE,6DAAkE;AAErD,QAAA,gBAAgB,GAAG,IAAA,uBAAgB,EAAC;IAChD,MAAM,EAAE,4BAAY;IACpB,IAAI,EAAE,wBAAU;IAChB,KAAK,EAAE,0BAAW;IAClB,WAAW,EAAE,sCAAiB;IAC9B,UAAU,EAAE,oCAAgB;IAC5B,UAAU,EAAE,oCAAgB;IAC5B,QAAQ,EAAE,gCAAc;IACxB,KAAK,EAAE,0BAAW;IAElB,SAAS,EAAE,sBAAe,CAAC,MAAM,CAAC,sDAA8B,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAC5E,4BAAY,CAAC,SAAS,CAAC,KAAK,IAAI,EAAE;QACjC,MAAM,MAAM,GAAG,MAAM,sCAAO,CAAC,SAAS,EAAE,CAAC;QACzC,OAAO,IAAA,mBAAQ,EAAC,wCAAwC,EAAE,MAAM,CAAC,CAAC;IACnE,CAAC,CAAC,CACF;CACD,CAAC,CAAC","sourcesContent":["import {createTRPCRouter, publicProcedure} from '@lyxa.ai/core/dist/libraries/trpc';\nimport {ErrorHandler} from '@lyxa.ai/core/dist/utilities/error-handler';\nimport {response} from '@lyxa.ai/core/dist/utilities/response';\nimport {configRouter} from './config/config.router';\nimport {teamRouter} from './team/team.router';\nimport {matchRouter} from './match/match.router';\nimport {participantRouter} from './participant/participant.router';\nimport {predictionRouter} from './prediction/prediction.router';\nimport {statisticsRouter} from './statistics/statistics.router';\nimport {scheduleRouter} from './schedule/schedule.router';\nimport {scoreRouter} from './score/score.router';\nimport {ActiveTournamentResponseSchema} from './tournament.validation';\nimport {tournamentService as service} from './tournament.service';\n\nexport const tournamentRouter = createTRPCRouter({\n\tconfig: configRouter,\n\tteam: teamRouter,\n\tmatch: matchRouter,\n\tparticipant: participantRouter,\n\tprediction: predictionRouter,\n\tstatistics: statisticsRouter,\n\tschedule: scheduleRouter,\n\tscore: scoreRouter,\n\n\tgetActive: publicProcedure.output(ActiveTournamentResponseSchema).query(() =>\n\t\tErrorHandler.wrapAsync(async () => {\n\t\t\tconst result = await service.getActive();\n\t\t\treturn response('Active tournament fetched successfully', result);\n\t\t})\n\t),\n});\n"]}
+{"version":3,"file":"tournament.router.js","sourceRoot":"/","sources":["modules/tournament/tournament.router.ts"],"names":[],"mappings":";;;AAAA,4DAAmE;AACnE,4DAAiE;AACjE,6EAAgG;AAChG,8EAAwE;AACxE,oEAA+D;AAC/D,oDAA8C;AAC9C,0DAAoD;AACpD,oDAA8C;AAC9C,uDAAiD;AACjD,yEAAmE;AACnE,sEAAgE;AAChE,sEAAgE;AAChE,gEAA0D;AAC1D,uDAAiD;AACjD,mEAAuE;AACvE,6DAAkE;AAErD,QAAA,gBAAgB,GAAG,IAAA,uBAAgB,EAAC;IAChD,MAAM,EAAE,4BAAY;IACpB,IAAI,EAAE,wBAAU;IAChB,KAAK,EAAE,0BAAW;IAClB,WAAW,EAAE,sCAAiB;IAC9B,UAAU,EAAE,oCAAgB;IAC5B,UAAU,EAAE,oCAAgB;IAC5B,QAAQ,EAAE,gCAAc;IACxB,KAAK,EAAE,0BAAW;IAElB,SAAS,EAAE,IAAA,mCAA4B,EAAC,EAAE,WAAW,EAAE,CAAC,qBAAc,CAAC,IAAI,CAAC,EAAE,CAAC;SAC7E,MAAM,CAAC,sDAA8B,CAAC;SACtC,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,CAClB,4BAAY,CAAC,SAAS,CAAC,KAAK,IAAI,EAAE;QACjC,MAAM,MAAM,GAAG,MAAM,sCAAO,CAAC,SAAS,CAAC,IAAI,oBAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,CAAC;QACpF,OAAO,IAAA,mBAAQ,EAAC,wCAAwC,EAAE,MAAM,CAAC,CAAC;IACnE,CAAC,CAAC,CACF;CACF,CAAC,CAAC","sourcesContent":["import {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 {mongoose} from '@typegoose/typegoose';\nimport {configRouter} from './config/config.router';\nimport {teamRouter} from './team/team.router';\nimport {matchRouter} from './match/match.router';\nimport {participantRouter} from './participant/participant.router';\nimport {predictionRouter} from './prediction/prediction.router';\nimport {statisticsRouter} from './statistics/statistics.router';\nimport {scheduleRouter} from './schedule/schedule.router';\nimport {scoreRouter} from './score/score.router';\nimport {ActiveTournamentResponseSchema} from './tournament.validation';\nimport {tournamentService as service} from './tournament.service';\n\nexport const tournamentRouter = createTRPCRouter({\n\tconfig: configRouter,\n\tteam: teamRouter,\n\tmatch: matchRouter,\n\tparticipant: participantRouter,\n\tprediction: predictionRouter,\n\tstatistics: statisticsRouter,\n\tschedule: scheduleRouter,\n\tscore: scoreRouter,\n\n\tgetActive: createAuthenticatedProcedure({ entityTypes: [AuthEntityType.USER] })\n\t\t.output(ActiveTournamentResponseSchema)\n\t\t.query(({ ctx }) =>\n\t\t\tErrorHandler.wrapAsync(async () => {\n\t\t\t\tconst result = await service.getActive(new mongoose.Types.ObjectId(ctx.entity?.id));\n\t\t\t\treturn response('Active tournament fetched successfully', result);\n\t\t\t})\n\t\t),\n});\n"]}

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

@@ -1,8 +1,10 @@
+import { mongoose } from '@typegoose/typegoose';
 import { ActiveTournamentOutputDTO } from './tournament.validation';
 export declare class TournamentService {
     private repository;
+    private participantRepository;
     constructor();
-    getActive(): Promise<ActiveTournamentOutputDTO | null>;
+    getActive(userId: mongoose.Types.ObjectId): Promise<ActiveTournamentOutputDTO | null>;
 }
 export declare const tournamentService: TournamentService;
 //# sourceMappingURL=tournament.service.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"tournament.service.d.ts","sourceRoot":"/","sources":["modules/tournament/tournament.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AAGpE,qBACa,iBAAiB;IAC7B,OAAO,CAAC,UAAU,CAA6B;;IAMlC,SAAS,IAAI,OAAO,CAAC,yBAAyB,GAAG,IAAI,CAAC;CAGnE;AAED,eAAO,MAAM,iBAAiB,mBAAmC,CAAC"}
+{"version":3,"file":"tournament.service.d.ts","sourceRoot":"/","sources":["modules/tournament/tournament.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AAKpE,qBACa,iBAAiB;IAC7B,OAAO,CAAC,UAAU,CAA6B;IAC/C,OAAO,CAAC,qBAAqB,CAAkC;;IAOlD,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,GAAG,OAAO,CAAC,yBAAyB,GAAG,IAAI,CAAC;CAelG;AAED,eAAO,MAAM,iBAAiB,mBAAmC,CAAC"}

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

@@ -45,13 +45,28 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.tournamentService = exports.TournamentService = void 0;
 const typedi_1 = __importStar(require("typedi"));
 const config_repository_1 = require("./config/config.repository");
+const participant_repository_1 = require("./participant/participant.repository");
+const tournament_types_1 = require("./tournament.types");
 let TournamentService = class TournamentService {
     repository;
+    participantRepository;
     constructor() {
         this.repository = typedi_1.default.get(config_repository_1.TournamentConfigRepository);
+        this.participantRepository = typedi_1.default.get(participant_repository_1.TournamentParticipantRepository);
     }
-    async getActive() {
-        return this.repository.findActive();
+    async getActive(userId) {
+        const tournament = await this.repository.findActiveFull();
+        if (!tournament)
+            return null;
+        const participant = await this.participantRepository.findByUserAndTournament(userId, tournament._id);
+        const userStatus = !participant ? tournament_types_1.TournamentParticipantStatus.NOT_SEEN : (participant.status ?? tournament_types_1.TournamentParticipantStatus.JOINED);
+        return {
+            name: tournament.name,
+            tag: tournament.tag,
+            startDate: tournament.startDate ?? null,
+            endDate: tournament.endDate ?? null,
+            userStatus: userStatus,
+        };
     }
 };
 exports.TournamentService = TournamentService;

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

@@ -1 +1 @@
-{"version":3,"file":"tournament.service.js","sourceRoot":"/","sources":["modules/tournament/tournament.service.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,iDAA4C;AAE5C,kEAAwE;AAGjE,IAAM,iBAAiB,GAAvB,MAAM,iBAAiB;IACrB,UAAU,CAA6B;IAE/C;QACC,IAAI,CAAC,UAAU,GAAG,gBAAS,CAAC,GAAG,CAAC,8CAA0B,CAAC,CAAC;IAC7D,CAAC;IAEM,KAAK,CAAC,SAAS;QACrB,OAAO,IAAI,CAAC,UAAU,CAAC,UAAU,EAA+C,CAAC;IAClF,CAAC;CACD,CAAA;AAVY,8CAAiB;4BAAjB,iBAAiB;IAD7B,IAAA,gBAAO,GAAE;;GACG,iBAAiB,CAU7B;AAEY,QAAA,iBAAiB,GAAG,gBAAS,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC","sourcesContent":["import Container, { Service } from 'typedi';\nimport { ActiveTournamentOutputDTO } from './tournament.validation';\nimport { TournamentConfigRepository } from './config/config.repository';\n\n@Service()\nexport class TournamentService {\n\tprivate repository: TournamentConfigRepository;\n\n\tconstructor() {\n\t\tthis.repository = Container.get(TournamentConfigRepository);\n\t}\n\n\tpublic async getActive(): Promise<ActiveTournamentOutputDTO | null> {\n\t\treturn this.repository.findActive() as Promise<ActiveTournamentOutputDTO | null>;\n\t}\n}\n\nexport const tournamentService = Container.get(TournamentService);\n"]}
+{"version":3,"file":"tournament.service.js","sourceRoot":"/","sources":["modules/tournament/tournament.service.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,iDAA4C;AAG5C,kEAAwE;AACxE,iFAAuF;AACvF,yDAAiE;AAG1D,IAAM,iBAAiB,GAAvB,MAAM,iBAAiB;IACrB,UAAU,CAA6B;IACvC,qBAAqB,CAAkC;IAE/D;QACC,IAAI,CAAC,UAAU,GAAG,gBAAS,CAAC,GAAG,CAAC,8CAA0B,CAAC,CAAC;QAC5D,IAAI,CAAC,qBAAqB,GAAG,gBAAS,CAAC,GAAG,CAAC,wDAA+B,CAAC,CAAC;IAC7E,CAAC;IAEM,KAAK,CAAC,SAAS,CAAC,MAA+B;QACrD,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,cAAc,EAAE,CAAC;QAC1D,IAAI,CAAC,UAAU;YAAE,OAAO,IAAI,CAAC;QAE7B,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,qBAAqB,CAAC,uBAAuB,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG,CAAC,CAAC;QACrG,MAAM,UAAU,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,8CAA2B,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,IAAI,8CAA2B,CAAC,MAAM,CAAC,CAAC;QAEpI,OAAO;YACN,IAAI,EAAE,UAAU,CAAC,IAAI;YACrB,GAAG,EAAE,UAAU,CAAC,GAAG;YACnB,SAAS,EAAE,UAAU,CAAC,SAAS,IAAI,IAAI;YACvC,OAAO,EAAE,UAAU,CAAC,OAAO,IAAI,IAAI;YACnC,UAAU,EAAE,UAAqD;SACjE,CAAC;IACH,CAAC;CACD,CAAA;AAxBY,8CAAiB;4BAAjB,iBAAiB;IAD7B,IAAA,gBAAO,GAAE;;GACG,iBAAiB,CAwB7B;AAEY,QAAA,iBAAiB,GAAG,gBAAS,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC","sourcesContent":["import Container, { Service } from 'typedi';\nimport { mongoose } from '@typegoose/typegoose';\nimport { ActiveTournamentOutputDTO } from './tournament.validation';\nimport { TournamentConfigRepository } from './config/config.repository';\nimport { TournamentParticipantRepository } from './participant/participant.repository';\nimport { TournamentParticipantStatus } from './tournament.types';\n\n@Service()\nexport class TournamentService {\n\tprivate repository: TournamentConfigRepository;\n\tprivate participantRepository: TournamentParticipantRepository;\n\n\tconstructor() {\n\t\tthis.repository = Container.get(TournamentConfigRepository);\n\t\tthis.participantRepository = Container.get(TournamentParticipantRepository);\n\t}\n\n\tpublic async getActive(userId: mongoose.Types.ObjectId): Promise<ActiveTournamentOutputDTO | null> {\n\t\tconst tournament = await this.repository.findActiveFull();\n\t\tif (!tournament) return null;\n\n\t\tconst participant = await this.participantRepository.findByUserAndTournament(userId, tournament._id);\n\t\tconst userStatus = !participant ? TournamentParticipantStatus.NOT_SEEN : (participant.status ?? TournamentParticipantStatus.JOINED);\n\n\t\treturn {\n\t\t\tname: tournament.name,\n\t\t\ttag: tournament.tag,\n\t\t\tstartDate: tournament.startDate ?? null,\n\t\t\tendDate: tournament.endDate ?? null,\n\t\t\tuserStatus: userStatus as ActiveTournamentOutputDTO['userStatus'],\n\t\t};\n\t}\n}\n\nexport const tournamentService = Container.get(TournamentService);\n"]}

package/dist/lib/modules/tournament/tournament.types.d.ts

@@ -1,9 +1,11 @@
-export declare enum TournamentTag {
-    FOOTBALL_WORLD_CUP = "world-cup"
-}
 export declare enum MatchStatus {
     UPCOMING = "upcoming",
     STARTED = "started",
     ENDED = "ended"
 }
+export declare enum TournamentParticipantStatus {
+    JOINED = "joined",
+    SEEN = "seen",
+    NOT_SEEN = "not_seen"
+}
 //# sourceMappingURL=tournament.types.d.ts.map

package/dist/lib/modules/tournament/tournament.types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tournament.types.d.ts","sourceRoot":"/","sources":["modules/tournament/tournament.types.ts"],"names":[],"mappings":"AAAA,oBAAY,aAAa;IACrB,kBAAkB,cAAc;CACnC;AAED,oBAAY,WAAW;IACnB,QAAQ,aAAa;IACrB,OAAO,YAAY;IACnB,KAAK,UAAU;CAClB"}
+{"version":3,"file":"tournament.types.d.ts","sourceRoot":"/","sources":["modules/tournament/tournament.types.ts"],"names":[],"mappings":"AAAA,oBAAY,WAAW;IACnB,QAAQ,aAAa;IACrB,OAAO,YAAY;IACnB,KAAK,UAAU;CAClB;AAED,oBAAY,2BAA2B;IACnC,MAAM,WAAW;IACjB,IAAI,SAAS;IACb,QAAQ,aAAa;CACxB"}

package/dist/lib/modules/tournament/tournament.types.js

@@ -1,14 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MatchStatus = exports.TournamentTag = void 0;
-var TournamentTag;
-(function (TournamentTag) {
-    TournamentTag["FOOTBALL_WORLD_CUP"] = "world-cup";
-})(TournamentTag || (exports.TournamentTag = TournamentTag = {}));
+exports.TournamentParticipantStatus = exports.MatchStatus = void 0;
 var MatchStatus;
 (function (MatchStatus) {
     MatchStatus["UPCOMING"] = "upcoming";
     MatchStatus["STARTED"] = "started";
     MatchStatus["ENDED"] = "ended";
 })(MatchStatus || (exports.MatchStatus = MatchStatus = {}));
+var TournamentParticipantStatus;
+(function (TournamentParticipantStatus) {
+    TournamentParticipantStatus["JOINED"] = "joined";
+    TournamentParticipantStatus["SEEN"] = "seen";
+    TournamentParticipantStatus["NOT_SEEN"] = "not_seen";
+})(TournamentParticipantStatus || (exports.TournamentParticipantStatus = TournamentParticipantStatus = {}));
 //# sourceMappingURL=tournament.types.js.map

package/dist/lib/modules/tournament/tournament.types.js.map

@@ -1 +1 @@
-{"version":3,"file":"tournament.types.js","sourceRoot":"/","sources":["modules/tournament/tournament.types.ts"],"names":[],"mappings":";;;AAAA,IAAY,aAEX;AAFD,WAAY,aAAa;IACrB,iDAAgC,CAAA;AACpC,CAAC,EAFW,aAAa,6BAAb,aAAa,QAExB;AAED,IAAY,WAIX;AAJD,WAAY,WAAW;IACnB,oCAAqB,CAAA;IACrB,kCAAmB,CAAA;IACnB,8BAAe,CAAA;AACnB,CAAC,EAJW,WAAW,2BAAX,WAAW,QAItB","sourcesContent":["export enum TournamentTag {\n    FOOTBALL_WORLD_CUP = 'world-cup',\n}\n\nexport enum MatchStatus {\n    UPCOMING = 'upcoming',\n    STARTED = 'started',\n    ENDED = 'ended',\n}\n"]}
+{"version":3,"file":"tournament.types.js","sourceRoot":"/","sources":["modules/tournament/tournament.types.ts"],"names":[],"mappings":";;;AAAA,IAAY,WAIX;AAJD,WAAY,WAAW;IACnB,oCAAqB,CAAA;IACrB,kCAAmB,CAAA;IACnB,8BAAe,CAAA;AACnB,CAAC,EAJW,WAAW,2BAAX,WAAW,QAItB;AAED,IAAY,2BAIX;AAJD,WAAY,2BAA2B;IACnC,gDAAiB,CAAA;IACjB,4CAAa,CAAA;IACb,oDAAqB,CAAA;AACzB,CAAC,EAJW,2BAA2B,2CAA3B,2BAA2B,QAItC","sourcesContent":["export enum MatchStatus {\n    UPCOMING = 'upcoming',\n    STARTED = 'started',\n    ENDED = 'ended',\n}\n\nexport enum TournamentParticipantStatus {\n    JOINED = 'joined',\n    SEEN = 'seen',\n    NOT_SEEN = 'not_seen',\n}\n"]}

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

@@ -1,18 +1,23 @@
 import { z } from 'zod';
 import { DTO } from '@lyxa.ai/core/dist/utilities/validation/global-validation';
+import { TournamentParticipantStatus } from './tournament.types';
+export declare const UserTournamentStatus: z.ZodNativeEnum<typeof TournamentParticipantStatus>;
 export declare const ActiveTournamentSchema: z.ZodObject<{
     name: z.ZodString | z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
     tag: z.ZodString | z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
     startDate: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
     endDate: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+    userStatus: z.ZodNativeEnum<typeof TournamentParticipantStatus>;
 }, "strip", z.ZodTypeAny, {
     name: string;
     tag: string;
+    userStatus: TournamentParticipantStatus;
     startDate?: Date | null | undefined;
     endDate?: Date | null | undefined;
 }, {
     name: string;
     tag: string;
+    userStatus: TournamentParticipantStatus;
     startDate?: Date | null | undefined;
     endDate?: Date | null | undefined;
 }>;
@@ -39,11 +44,13 @@ export declare const ActiveTournamentResponseSchema: z.ZodObject<{
         documents: z.ZodArray<z.ZodType<{
             name: string;
             tag: string;
+            userStatus: TournamentParticipantStatus;
             startDate?: Date | null | undefined;
             endDate?: Date | null | undefined;
         } | null, z.ZodTypeDef, {
             name: string;
             tag: string;
+            userStatus: TournamentParticipantStatus;
             startDate?: Date | null | undefined;
             endDate?: Date | null | undefined;
         } | null>, "many">;
@@ -51,6 +58,7 @@ export declare const ActiveTournamentResponseSchema: z.ZodObject<{
         documents: ({
             name: string;
             tag: string;
+            userStatus: TournamentParticipantStatus;
             startDate?: Date | null | undefined;
             endDate?: Date | null | undefined;
         } | null)[];
@@ -64,6 +72,7 @@ export declare const ActiveTournamentResponseSchema: z.ZodObject<{
         documents: ({
             name: string;
             tag: string;
+            userStatus: TournamentParticipantStatus;
             startDate?: Date | null | undefined;
             endDate?: Date | null | undefined;
         } | null)[];
@@ -76,11 +85,13 @@ export declare const ActiveTournamentResponseSchema: z.ZodObject<{
     }>, z.ZodType<{
         name: string;
         tag: string;
+        userStatus: TournamentParticipantStatus;
         startDate?: Date | null | undefined;
         endDate?: Date | null | undefined;
     } | null, z.ZodTypeDef, {
         name: string;
         tag: string;
+        userStatus: TournamentParticipantStatus;
         startDate?: Date | null | undefined;
         endDate?: Date | null | undefined;
     } | null>]>>;
@@ -90,12 +101,14 @@ export declare const ActiveTournamentResponseSchema: z.ZodObject<{
     data?: {
         name: string;
         tag: string;
+        userStatus: TournamentParticipantStatus;
         startDate?: Date | null | undefined;
         endDate?: Date | null | undefined;
     } | {
         documents: ({
             name: string;
             tag: string;
+            userStatus: TournamentParticipantStatus;
             startDate?: Date | null | undefined;
             endDate?: Date | null | undefined;
         } | null)[];
@@ -112,12 +125,14 @@ export declare const ActiveTournamentResponseSchema: z.ZodObject<{
     data?: {
         name: string;
         tag: string;
+        userStatus: TournamentParticipantStatus;
         startDate?: Date | null | undefined;
         endDate?: Date | null | undefined;
     } | {
         documents: ({
             name: string;
             tag: string;
+            userStatus: TournamentParticipantStatus;
             startDate?: Date | null | undefined;
             endDate?: Date | null | undefined;
         } | null)[];

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

@@ -1 +1 @@
-{"version":3,"file":"tournament.validation.d.ts","sourceRoot":"/","sources":["modules/tournament/tournament.validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,GAAG,EAAiB,MAAM,2DAA2D,CAAC;AAG/F,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;EAKjC,CAAC;AAEH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA0D,CAAC;AAEtG,MAAM,MAAM,yBAAyB,GAAG,GAAG,CAAC,OAAO,sBAAsB,CAAC,CAAC"}
+{"version":3,"file":"tournament.validation.d.ts","sourceRoot":"/","sources":["modules/tournament/tournament.validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,GAAG,EAAiB,MAAM,2DAA2D,CAAC;AAE/F,OAAO,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAC;AAEjE,eAAO,MAAM,oBAAoB,qDAA4C,CAAC;AAE9E,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;EAMjC,CAAC;AAEH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA0D,CAAC;AAEtG,MAAM,MAAM,yBAAyB,GAAG,GAAG,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

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

@@ -1,14 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ActiveTournamentResponseSchema = exports.ActiveTournamentSchema = void 0;
+exports.ActiveTournamentResponseSchema = exports.ActiveTournamentSchema = exports.UserTournamentStatus = 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 tournament_types_1 = require("./tournament.types");
+exports.UserTournamentStatus = zod_1.z.nativeEnum(tournament_types_1.TournamentParticipantStatus);
 exports.ActiveTournamentSchema = zod_1.z.object({
     name: global_validation_1.ZodValidation.string('Tournament name'),
     tag: global_validation_1.ZodValidation.string('Tournament tag'),
     startDate: zod_1.z.date().nullable().optional(),
     endDate: zod_1.z.date().nullable().optional(),
+    userStatus: exports.UserTournamentStatus,
 });
 exports.ActiveTournamentResponseSchema = (0, validation_1.createResponseSchema)(exports.ActiveTournamentSchema.nullable());
 //# sourceMappingURL=tournament.validation.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"tournament.validation.js","sourceRoot":"/","sources":["modules/tournament/tournament.validation.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AACxB,iGAA+F;AAC/F,wEAA+E;AAElE,QAAA,sBAAsB,GAAG,OAAC,CAAC,MAAM,CAAC;IAC9C,IAAI,EAAE,iCAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC;IAC7C,GAAG,EAAE,iCAAa,CAAC,MAAM,CAAC,gBAAgB,CAAC;IAC3C,SAAS,EAAE,OAAC,CAAC,IAAI,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;IACzC,OAAO,EAAE,OAAC,CAAC,IAAI,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;CACvC,CAAC,CAAC;AAEU,QAAA,8BAA8B,GAAG,IAAA,iCAAoB,EAAC,8BAAsB,CAAC,QAAQ,EAAE,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 ActiveTournamentSchema = z.object({\n\tname: ZodValidation.string('Tournament name'),\n\ttag: ZodValidation.string('Tournament tag'),\n\tstartDate: z.date().nullable().optional(),\n\tendDate: z.date().nullable().optional(),\n});\n\nexport const ActiveTournamentResponseSchema = createResponseSchema(ActiveTournamentSchema.nullable());\n\nexport type ActiveTournamentOutputDTO = DTO<typeof ActiveTournamentSchema>;\n"]}
+{"version":3,"file":"tournament.validation.js","sourceRoot":"/","sources":["modules/tournament/tournament.validation.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AACxB,iGAA+F;AAC/F,wEAA+E;AAC/E,yDAAiE;AAEpD,QAAA,oBAAoB,GAAG,OAAC,CAAC,UAAU,CAAC,8CAA2B,CAAC,CAAC;AAEjE,QAAA,sBAAsB,GAAG,OAAC,CAAC,MAAM,CAAC;IAC9C,IAAI,EAAE,iCAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC;IAC7C,GAAG,EAAE,iCAAa,CAAC,MAAM,CAAC,gBAAgB,CAAC;IAC3C,SAAS,EAAE,OAAC,CAAC,IAAI,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;IACzC,OAAO,EAAE,OAAC,CAAC,IAAI,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;IACvC,UAAU,EAAE,4BAAoB;CAChC,CAAC,CAAC;AAEU,QAAA,8BAA8B,GAAG,IAAA,iCAAoB,EAAC,8BAAsB,CAAC,QAAQ,EAAE,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 { TournamentParticipantStatus } from './tournament.types';\n\nexport const UserTournamentStatus = z.nativeEnum(TournamentParticipantStatus);\n\nexport const ActiveTournamentSchema = z.object({\n\tname: ZodValidation.string('Tournament name'),\n\ttag: ZodValidation.string('Tournament tag'),\n\tstartDate: z.date().nullable().optional(),\n\tendDate: z.date().nullable().optional(),\n\tuserStatus: UserTournamentStatus,\n});\n\nexport const ActiveTournamentResponseSchema = createResponseSchema(ActiveTournamentSchema.nullable());\n\nexport type ActiveTournamentOutputDTO = DTO<typeof ActiveTournamentSchema>;\n"]}