@lyxa.ai/marketing 1.0.47 → 1.0.49

package/dist/types/modules/tournament/team/team.builder.d.ts

@@ -0,0 +1,19 @@
+import { mongoose } from '@typegoose/typegoose';
+interface TeamInput {
+    name: string;
+    picture?: string;
+}
+export declare class TeamBuilder {
+    static buildTeam(input: TeamInput): {
+        _id: mongoose.Types.ObjectId;
+        name: string;
+        picture: string | undefined;
+    };
+    static buildTeams(inputs: TeamInput[]): {
+        _id: mongoose.Types.ObjectId;
+        name: string;
+        picture: string | undefined;
+    }[];
+}
+export {};
+//# sourceMappingURL=team.builder.d.ts.map

package/dist/types/modules/tournament/team/team.builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"team.builder.d.ts","sourceRoot":"/","sources":["modules/tournament/team/team.builder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAEhD,UAAU,SAAS;IACf,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,qBAAa,WAAW;IACpB,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,SAAS;;;;;IAQjC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,SAAS,EAAE;;;;;CAGxC"}

package/dist/types/modules/tournament/team/team.repository.d.ts

@@ -0,0 +1,11 @@
+import { mongoose } from '@typegoose/typegoose';
+import { Tournament as Model } from '@lyxa.ai/core/dist/libraries/mongo/models';
+export declare class TournamentTeamRepository {
+    private model;
+    constructor();
+    findById(id: mongoose.Types.ObjectId): Promise<Model | null>;
+    findByTeamId(teamId: mongoose.Types.ObjectId): Promise<Model | null>;
+    addTeams(id: mongoose.Types.ObjectId, teams: object[]): Promise<Model | null>;
+}
+export declare const tournamentTeamRepository: TournamentTeamRepository;
+//# sourceMappingURL=team.repository.d.ts.map

package/dist/types/modules/tournament/team/team.repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"team.repository.d.ts","sourceRoot":"/","sources":["modules/tournament/team/team.repository.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAE,UAAU,IAAI,KAAK,EAAmB,MAAM,2CAA2C,CAAC;AAEjG,qBACa,wBAAwB;IACpC,OAAO,CAAC,KAAK,CAAyB;;IAMhC,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,GAAG,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC;IAI5D,YAAY,CAAC,MAAM,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,GAAG,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC;IAIpE,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC;CAKnF;AAED,eAAO,MAAM,wBAAwB,0BAA0C,CAAC"}

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

@@ -0,0 +1,205 @@
+import { mongoose } from '@typegoose/typegoose';
+export declare const teamRouter: import("@trpc/server").TRPCBuiltRouter<{
+    ctx: import("@lyxa.ai/core/dist/libraries/trpc/context").LyxaHTTPContext;
+    meta: object;
+    errorShape: {
+        message: string;
+        data: {
+            stack: undefined;
+            path: undefined;
+            code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+            httpStatus: number;
+        };
+        stack: undefined;
+        code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+    };
+    transformer: false;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    add: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            tournamentId: string | mongoose.Types.ObjectId;
+            teams: {
+                name: string;
+                picture?: string | undefined;
+            }[];
+        };
+        output: {
+            message: string;
+            success: boolean;
+            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;
+                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;
+                    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;
+                    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;
+                    size: number;
+                    totalElements: number;
+                    totalPages: number;
+                } | undefined;
+            } | undefined;
+        };
+        meta: object;
+    }>;
+    getAll: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            tournamentId: string | mongoose.Types.ObjectId;
+        };
+        output: {
+            message: string;
+            success: boolean;
+            data?: {
+                status: import("@lyxa.ai/core/dist/utilities/enum").Status;
+                tag: string;
+                tournamentId: string | mongoose.Types.ObjectId;
+                teams: {
+                    name: string;
+                    _id: string | mongoose.Types.ObjectId;
+                    picture?: string | undefined;
+                }[];
+                startDate?: Date | null | undefined;
+                endDate?: Date | null | undefined;
+            } | {
+                documents: {
+                    status: import("@lyxa.ai/core/dist/utilities/enum").Status;
+                    tag: string;
+                    tournamentId: string | mongoose.Types.ObjectId;
+                    teams: {
+                        name: string;
+                        _id: string | mongoose.Types.ObjectId;
+                        picture?: string | undefined;
+                    }[];
+                    startDate?: Date | null | undefined;
+                    endDate?: Date | null | undefined;
+                }[];
+                metadata?: {
+                    page: number;
+                    size: number;
+                    totalElements: number;
+                    totalPages: number;
+                } | undefined;
+            } | undefined;
+        };
+        meta: object;
+    }>;
+    getMatches: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            filter: "completed" | "upcoming";
+            tournamentId: string | mongoose.Types.ObjectId;
+        };
+        output: {
+            message: string;
+            success: boolean;
+            data?: {
+                status: import("@lyxa.ai/core/dist/utilities/enum").Status;
+                tag: string;
+                tournamentId: string | mongoose.Types.ObjectId;
+                matches: {
+                    _id: string | mongoose.Types.ObjectId;
+                    team1: {
+                        name: string;
+                        teamId: string | mongoose.Types.ObjectId;
+                    };
+                    team2: {
+                        name: string;
+                        teamId: string | mongoose.Types.ObjectId;
+                    };
+                    score: {
+                        team1: number | null;
+                        team2: number | null;
+                    };
+                    stage: string;
+                    prediction: {
+                        score: {
+                            team1: number | null;
+                            team2: number | null;
+                        };
+                        succeeded: boolean | null;
+                    } | null;
+                    canPredict: boolean;
+                    endDate?: Date | null | undefined;
+                    additionalTag?: string | undefined;
+                    winnerId?: string | mongoose.Types.ObjectId | null | undefined;
+                    startingDate?: Date | null | undefined;
+                }[];
+                startDate?: Date | null | undefined;
+                endDate?: Date | null | undefined;
+            } | {
+                documents: {
+                    status: import("@lyxa.ai/core/dist/utilities/enum").Status;
+                    tag: string;
+                    tournamentId: string | mongoose.Types.ObjectId;
+                    matches: {
+                        _id: string | mongoose.Types.ObjectId;
+                        team1: {
+                            name: string;
+                            teamId: string | mongoose.Types.ObjectId;
+                        };
+                        team2: {
+                            name: string;
+                            teamId: string | mongoose.Types.ObjectId;
+                        };
+                        score: {
+                            team1: number | null;
+                            team2: number | null;
+                        };
+                        stage: string;
+                        prediction: {
+                            score: {
+                                team1: number | null;
+                                team2: number | null;
+                            };
+                            succeeded: boolean | null;
+                        } | null;
+                        canPredict: boolean;
+                        endDate?: Date | null | undefined;
+                        additionalTag?: string | undefined;
+                        winnerId?: string | mongoose.Types.ObjectId | null | undefined;
+                        startingDate?: Date | null | undefined;
+                    }[];
+                    startDate?: Date | null | undefined;
+                    endDate?: Date | null | undefined;
+                }[];
+                metadata?: {
+                    page: number;
+                    size: number;
+                    totalElements: number;
+                    totalPages: number;
+                } | undefined;
+            } | undefined;
+        };
+        meta: object;
+    }>;
+}>>;
+//# sourceMappingURL=team.router.d.ts.map

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

@@ -0,0 +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"}

package/dist/types/modules/tournament/team/team.service.d.ts

@@ -0,0 +1,15 @@
+import { mongoose } from '@typegoose/typegoose';
+import { AddTournamentTeamsInputDTO, GetTeamMatchesInputDTO, TournamentWithMatchesOutputDTO, TournamentWithTeamsOutputDTO } from './team.validation';
+import { TournamentConfigOutputDTO } from '../config/config.validation';
+export declare class TeamService {
+    private repository;
+    private participantService;
+    constructor();
+    private filterMatchesByTeam;
+    private applyStatusFilter;
+    add(input: AddTournamentTeamsInputDTO): Promise<TournamentConfigOutputDTO>;
+    getAll(tournamentId: mongoose.Types.ObjectId): Promise<TournamentWithTeamsOutputDTO>;
+    getMatches(userId: mongoose.Types.ObjectId, input: GetTeamMatchesInputDTO): Promise<TournamentWithMatchesOutputDTO>;
+}
+export declare const teamService: TeamService;
+//# sourceMappingURL=team.service.d.ts.map

package/dist/types/modules/tournament/team/team.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"team.service.d.ts","sourceRoot":"/","sources":["modules/tournament/team/team.service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAEhD,OAAO,EACH,0BAA0B,EAC1B,sBAAsB,EAEtB,8BAA8B,EAC9B,4BAA4B,EAC/B,MAAM,mBAAmB,CAAC;AAI3B,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AAGxE,qBACa,WAAW;IACpB,OAAO,CAAC,UAAU,CAA2B;IAC7C,OAAO,CAAC,kBAAkB,CAAqB;;IAO/C,OAAO,CAAC,mBAAmB;IAM3B,OAAO,CAAC,iBAAiB;IAoBZ,GAAG,CAAC,KAAK,EAAE,0BAA0B,GAAG,OAAO,CAAC,yBAAyB,CAAC;IAU1E,MAAM,CAAC,YAAY,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,GAAG,OAAO,CAAC,4BAA4B,CAAC;IAcpF,UAAU,CAAC,MAAM,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,EAAE,sBAAsB,GAAG,OAAO,CAAC,8BAA8B,CAAC;CAiCnI;AAED,eAAO,MAAM,WAAW,aAA6B,CAAC"}