feat(events): implement backend logic and core infrastructure for event views

Author: LuizFNJ

server/app.module.ts

@@ -65,6 +65,7 @@ import { M2MGuard } from "./auth/m2m.guard";
 import { CallbackDispatcherModule } from "./callback-dispatcher/callback-dispatcher.module";
 import { AiTaskModule } from "./ai-task/ai-task.module";
 import { TrackingModule } from "./tracking/tracking.module";
+import { EventsModule } from "./events/event.module";
 
 @Module({})
 export class AppModule implements NestModule {
@@ -122,6 +123,7 @@ export class AppModule implements NestModule {
                 ClaimRevisionModule,
                 HistoryModule,
                 TrackingModule,
+                EventsModule,
                 StateEventModule,
                 SourceModule,
                 SpeechModule,

server/claim/types/sentence/sentence.service.ts

@@ -1,15 +1,18 @@
 import {
     BadRequestException,
     Injectable,
+    InternalServerErrorException,
+    Logger,
     NotFoundException,
 } from "@nestjs/common";
 import { Model } from "mongoose";
 import { SentenceDocument, Sentence } from "./schemas/sentence.schema";
 import { InjectModel } from "@nestjs/mongoose";
 import { ReportService } from "../../../report/report.service";
 import { UtilService } from "../../../util";
-import { allCop30WikiDataIds } from "../../../../src/constants/cop30Filters";
 import type { Cop30Sentence } from "../../../../src/types/Cop30Sentence";
+import { TopicRelatedSentencesResponse } from "./types/sentence.interfaces";
+import { allCop30WikiDataIds } from "../../../../src/constants/cop30Filters";
 import type { Cop30Stats } from "../../../../src/types/Cop30Stats";
 import { buildStats } from "../../../../src/components/Home/COP30/utils/classification";
 
@@ -24,13 +27,73 @@ interface FindAllOptionsFilters {
 
 @Injectable()
 export class SentenceService {
+    private readonly logger = new Logger(SentenceService.name);
+
     constructor(
         @InjectModel(Sentence.name)
         private SentenceModel: Model<SentenceDocument>,
         private reportService: ReportService,
         private util: UtilService
     ) {}
 
+    /**
+         * Fetches sentences based on topic values and enriches them with review classification.
+         * Uses an aggregation pipeline for cross-collection lookup.
+         * @param query - Topic wikidataId array to filter sentences.
+         * @returns A list of sentences with their respective classification.
+         */
+    async getSentencesByTopics(query: string[]): Promise<TopicRelatedSentencesResponse[]> {
+        try {
+            this.logger.debug(`Fetching sentences for topics: ${query.join(', ')}`);
+
+            const aggregation: any[] = [
+                { $match: { "topics.value": { $in: query } } },
+                {
+                    $lookup: {
+                        from: "reviewtasks",
+                        let: { sentenceDataHash: "$data_hash" },
+                        pipeline: [
+                            {
+                                $match: {
+                                    $expr: {
+                                        $eq: [
+                                            "$machine.context.reviewData.data_hash",
+                                            "$$sentenceDataHash",
+                                        ],
+                                    },
+                                },
+                            },
+                            {
+                                $project: {
+                                    _id: 0,
+                                    classification: "$machine.context.reviewData.classification",
+                                },
+                            },
+                        ],
+                        as: "reviewInfo",
+                    },
+                },
+                {
+                    $addFields: {
+                        classification: {
+                            $arrayElemAt: ["$reviewInfo.classification", 0],
+                        },
+                    },
+                },
+                { $project: { reviewInfo: 0 } },
+            ];
+
+            const result = await this.SentenceModel.aggregate(aggregation).exec();
+
+            this.logger.log(`Found ${result.length} sentences for the requested topics.`);
+
+            return result;
+        } catch (error) {
+            this.logger.error(`Error in getSentencesByTopics: ${error.message}`, error.stack);
+            throw new InternalServerErrorException("Failed to aggregate sentences with review data.");
+        }
+    }
+
     async getSentencesWithCop30Topics(): Promise<Cop30Sentence[]> {
         const aggregation = [
             { $match: { "topics.value": { $in: allCop30WikiDataIds } } },

server/claim/types/sentence/types/sentence.interfaces.ts

@@ -0,0 +1,12 @@
+import { Sentence } from "../schemas/sentence.schema";
+
+export interface Review {
+    personality: string;
+    usersId: string;
+    isPartialReview: boolean;
+}
+
+export type TopicRelatedSentencesResponse = Sentence & {
+    classification?: string;
+    review?: Review;
+}

server/events/dto/event.dto.ts

@@ -0,0 +1,57 @@
+import {
+    IsArray,
+    IsDate,
+    IsNotEmpty,
+    IsObject,
+    IsOptional,
+    IsString
+} from "class-validator";
+import { ApiProperty, PartialType } from "@nestjs/swagger";
+import { Type } from "class-transformer";
+import { TopicData } from "../../topic/types/topic.interfaces";
+
+export class CreateEventDTO {
+    @IsString()
+    @IsNotEmpty()
+    @ApiProperty()
+    badge: string;
+
+    @IsString()
+    @IsNotEmpty()
+    @ApiProperty()
+    name: string;
+
+    @IsString()
+    @IsNotEmpty()
+    @ApiProperty()
+    description: string;
+
+    @IsString()
+    @IsNotEmpty()
+    @ApiProperty()
+    location: string;
+
+    @IsDate()
+    @IsNotEmpty()
+    @Type(() => Date)
+    @ApiProperty()
+    startDate: Date;
+
+    @IsDate()
+    @IsNotEmpty()
+    @Type(() => Date)
+    @ApiProperty()
+    endDate: Date;
+
+    @IsObject()
+    @IsNotEmpty()
+    @ApiProperty()
+    mainTopic: TopicData;
+
+    @IsArray()
+    @IsOptional()
+    @ApiProperty()
+    filterTopics: TopicData[];
+}
+
+export class UpdateEventDTO extends PartialType(CreateEventDTO) {}

server/events/dto/filter.dto.ts

@@ -0,0 +1,29 @@
+import {
+    IsOptional,
+    IsInt,
+    Min,
+    IsString
+} from "class-validator";
+import { Type } from "class-transformer";
+
+export class FilterEventsDTO {
+    @IsOptional()
+    @Type(() => Number)
+    @IsInt()
+    @Min(0)
+    page?: number = 0;
+
+    @IsOptional()
+    @Type(() => Number)
+    @IsInt()
+    @Min(1)
+    pageSize?: number = 10;
+
+    @IsOptional()
+    @IsString()
+    order?: "asc" | "desc";
+
+    @IsOptional()
+    @IsString()
+    status?: string;
+}

server/events/event.controller.spec.ts

@@ -0,0 +1,161 @@
+import { Test, TestingModule } from "@nestjs/testing";
+import { NotFoundException } from "@nestjs/common";
+import { ConfigService } from "@nestjs/config";
+import { EventsController } from "./event.controller";
+import { EventsService } from "./event.service";
+import { ViewService } from "../view/view.service";
+import { AbilitiesGuard } from "../auth/ability/abilities.guard";
+import {
+    mockConfigService,
+    mockEventsService,
+    mockViewService,
+} from "../mocks/EventMock";
+
+describe("EventsController (Unit)", () => {
+    let controller: EventsController;
+
+    beforeEach(async () => {
+        const testingModule: TestingModule = await Test.createTestingModule({
+            controllers: [EventsController],
+            providers: [
+                { provide: ConfigService, useValue: mockConfigService },
+                { provide: EventsService, useValue: mockEventsService },
+                { provide: ViewService, useValue: mockViewService },
+            ],
+        })
+            .overrideGuard(AbilitiesGuard)
+            .useValue({})
+            .compile();
+
+        controller = testingModule.get<EventsController>(EventsController);
+    });
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    describe("create", () => {
+        it("should delegate creation to eventsService", async () => {
+            const dto = { name: "Event" };
+            const created = { _id: "e1", ...dto };
+            mockEventsService.create.mockResolvedValue(created);
+
+            const result = await controller.create(dto as any);
+
+            expect(mockEventsService.create).toHaveBeenCalledWith(dto);
+            expect(result).toEqual(created);
+        });
+    });
+
+    describe("update", () => {
+        it("should delegate update to eventsService", async () => {
+            const id = "507f1f77bcf86cd799439011";
+            const dto = { name: "Updated" };
+            const updated = { _id: id, ...dto };
+            mockEventsService.update.mockResolvedValue(updated);
+
+            const result = await controller.update(id, dto as any);
+
+            expect(mockEventsService.update).toHaveBeenCalledWith(id, dto);
+            expect(result).toEqual(updated);
+        });
+    });
+
+    describe("findAll", () => {
+        it("should delegate filtering to eventsService", async () => {
+            const query = { page: 0, pageSize: 10, order: "asc", status: "upcoming" };
+            const events = [{ _id: "e1" }];
+            mockEventsService.findAll.mockResolvedValue(events);
+
+            const result = await controller.findAll(query as any);
+
+            expect(mockEventsService.findAll).toHaveBeenCalledWith(query);
+            expect(result).toEqual(events);
+        });
+    });
+
+    describe("eventPage", () => {
+        it("should render /event-page with parsed query, namespace and site key", async () => {
+            const req = {
+                url: "/event?foo=bar",
+                params: { namespace: "main" },
+            };
+            const res = {};
+
+            await controller.eventPage(req as any, res as any);
+
+            expect(mockConfigService.get).toHaveBeenCalledWith("recaptcha_sitekey");
+            expect(mockViewService.render).toHaveBeenCalledWith(
+                req,
+                res,
+                "/event-page",
+                expect.objectContaining({
+                    foo: "bar",
+                    nameSpace: "main",
+                    sitekey: "test-site-key",
+                })
+            );
+        });
+    });
+
+    describe("eventViewPage", () => {
+        it("should render /event-view-page when event exists", async () => {
+            const req = {
+                url: "/event/hash-1?lang=en",
+                params: { namespace: "main", data_hash: "hash-1" },
+            };
+            const res = {};
+            const fullEvent = { _id: "e1", data_hash: "hash-1" };
+
+            mockEventsService.getFullEventByHash.mockResolvedValue(fullEvent);
+
+            await controller.eventViewPage(req as any, res as any);
+
+            expect(mockEventsService.getFullEventByHash).toHaveBeenCalledWith("hash-1");
+            expect(mockConfigService.get).toHaveBeenCalledWith("recaptcha_sitekey");
+            expect(mockViewService.render).toHaveBeenCalledWith(
+                req,
+                res,
+                "/event-view-page",
+                expect.objectContaining({
+                    lang: "en",
+                    fullEvent,
+                    namespace: "main",
+                    sitekey: "test-site-key",
+                })
+            );
+        });
+
+        it("should throw NotFoundException when service returns empty event", async () => {
+            const req = {
+                url: "/event/hash-1",
+                params: { namespace: "main", data_hash: "hash-1" },
+            };
+            const res = {};
+
+            mockEventsService.getFullEventByHash.mockResolvedValue(null);
+
+            await expect(controller.eventViewPage(req as any, res as any)).rejects.toThrow(
+                NotFoundException
+            );
+            expect(mockViewService.render).not.toHaveBeenCalled();
+        });
+
+        it("should rethrow service errors and log only non-NotFound errors", async () => {
+            const req = {
+                url: "/event/hash-1",
+                params: { namespace: "main", data_hash: "hash-1" },
+            };
+            const res = {};
+            const error = new Error("unexpected");
+            const loggerErrorSpy = jest.spyOn((controller as any).logger, "error");
+
+            mockEventsService.getFullEventByHash.mockRejectedValue(error);
+
+            await expect(controller.eventViewPage(req as any, res as any)).rejects.toThrow(
+                "unexpected"
+            );
+            expect(loggerErrorSpy).toHaveBeenCalled();
+        });
+    });
+});