Merge pull request #1236 from AletheiaFact/create-daily-report-document

Send Unsolicited Latest Reviews in Daily Report

server/app.module.ts

@@ -54,6 +54,7 @@ import { NameSpaceGuard } from "./auth/name-space/name-space.guard";
 import { AutomatedFactCheckingModule } from "./automated-fact-checking/automated-fact-checking.module";
 import { CopilotChatModule } from "./copilot/copilot-chat.module";
 import { UnattributedModule } from "./claim/types/unattributed/unattributed.module";
+import { DailyReportModule } from "./daily-report/daily-report.module";
 
 @Module({})
 export class AppModule implements NestModule {
@@ -113,6 +114,7 @@ export class AppModule implements NestModule {
             AutomatedFactCheckingModule,
             CopilotChatModule,
             UnattributedModule,
+            DailyReportModule,
         ];
         if (options.feature_flag) {
             imports.push(

server/claim-review/claim-review.service.ts

@@ -85,24 +85,29 @@ export class ClaimReviewService {
         );
     }
 
-    async listDailyReviews(
+    /**
+     * FIXME: Claim review should have namespace on it to avoid filtering claim by namespaces
+     */
+    async listDailyClaimReviews({
         page,
         pageSize,
         order,
         query,
         nameSpace,
-        latest = false
-    ) {
-        const today = new Date();
-        today.setHours(0, 0, 0, 0);
-
-        const tomorrow = new Date(today);
-        tomorrow.setDate(today.getDate() + 1);
-
-        query.date = {
-            $gte: today,
-            $lt: tomorrow,
-        };
+        latest = false,
+    }) {
+        if (!query.date) {
+            const today = new Date();
+            today.setHours(0, 0, 0, 0);
+
+            const tomorrow = new Date(today);
+            tomorrow.setDate(today.getDate() + 1);
+
+            query.date = {
+                $gte: today,
+                $lt: tomorrow,
+            };
+        }
         const pipeline = this.ClaimReviewModel.find(query)
             .sort(latest ? { date: -1 } : { _id: order === "asc" ? 1 : -1 })
             .populate({

server/daily-report/daily-report.controller.ts

@@ -0,0 +1,64 @@
+import { Controller, Param, Post, UseGuards } from "@nestjs/common";
+import {
+    AdminUserAbility,
+    CheckAbilities,
+} from "../auth/ability/ability.decorator";
+import { AbilitiesGuard } from "../auth/ability/abilities.guard";
+import { DailyReportService } from "../daily-report/daily-report.service";
+import { ClaimReviewService } from "../claim-review/claim-review.service";
+import { NotificationService } from "../notifications/notifications.service";
+
+@Controller()
+export class DailyReportController {
+    constructor(
+        private readonly dailyReportService: DailyReportService,
+        private claimReviewService: ClaimReviewService,
+        private notificationService: NotificationService
+    ) {}
+
+    @Post("api/daily-report/topic/:topic/send/:nameSpace")
+    @UseGuards(AbilitiesGuard)
+    @CheckAbilities(new AdminUserAbility())
+    async sendDailyReport(
+        @Param("topic") topic,
+        @Param("nameSpace") nameSpace
+    ) {
+        const queryParams: any = { isHidden: false, isDeleted: false };
+        const [lastDailyReportSent] =
+            await this.dailyReportService.getLastDailyReportSent();
+
+        if (lastDailyReportSent) {
+            queryParams.date = { $gt: lastDailyReportSent?.date };
+        }
+
+        const dailyClaimReviews =
+            await this.claimReviewService.listDailyClaimReviews({
+                page: 0,
+                pageSize: 30,
+                order: "asc",
+                nameSpace,
+                query: queryParams,
+            });
+
+        if (dailyClaimReviews.length > 0) {
+            const reportIds = dailyClaimReviews.map(({ report }) => report._id);
+            await this.dailyReportService.create({
+                reports: reportIds,
+                date: new Date(),
+            });
+        }
+
+        const dailyReport = await this.dailyReportService.generateDailyReport(
+            dailyClaimReviews,
+            nameSpace
+        );
+
+        this.notificationService.sendDailyReviewsEmail(topic, dailyReport);
+
+        if (dailyClaimReviews.length < 1) {
+            throw new Error("No daily reports today");
+        }
+
+        return dailyClaimReviews;
+    }
+}

server/daily-report/daily-report.module.ts

@@ -0,0 +1,32 @@
+import { Module } from "@nestjs/common";
+import { DailyReport, DailyReportSchema } from "./schemas/daily-report.schema";
+import { DailyReportService } from "./daily-report.service";
+import { MongooseModule } from "@nestjs/mongoose";
+import { AbilityModule } from "../auth/ability/ability.module";
+import { SummarizationModule } from "../summarization/summarization.module";
+import { ClaimReviewModule } from "../claim-review/claim-review.module";
+import { NotificationModule } from "../notifications/notifications.module";
+import { DailyReportController } from "./daily-report.controller";
+import { ConfigModule } from "@nestjs/config";
+
+export const DailyReportModel = MongooseModule.forFeature([
+    {
+        name: DailyReport.name,
+        schema: DailyReportSchema,
+    },
+]);
+
+@Module({
+    imports: [
+        DailyReportModel,
+        ClaimReviewModule,
+        SummarizationModule,
+        AbilityModule,
+        NotificationModule,
+        ConfigModule,
+    ],
+    providers: [DailyReportService],
+    controllers: [DailyReportController],
+    exports: [DailyReportService],
+})
+export class DailyReportModule {}

server/daily-report/daily-report.service.ts

@@ -0,0 +1,46 @@
+import { Injectable, Scope, Logger } from "@nestjs/common";
+import { Model } from "mongoose";
+import {
+    DailyReport,
+    DailyReportDocument,
+} from "./schemas/daily-report.schema";
+import { InjectModel } from "@nestjs/mongoose";
+import { SummarizationService } from "../summarization/summarization.service";
+
+@Injectable({ scope: Scope.REQUEST })
+export class DailyReportService {
+    private readonly logger = new Logger("SummarizationLogger");
+    constructor(
+        @InjectModel(DailyReport.name)
+        private DailyReportModel: Model<DailyReportDocument>,
+        private summarizationService: SummarizationService
+    ) {}
+
+    async create(dailyReportBody: DailyReport): Promise<DailyReport> {
+        return new this.DailyReportModel(dailyReportBody).save();
+    }
+
+    async getLastDailyReportSent(): Promise<DailyReport[]> {
+        return await this.DailyReportModel.find({}).sort({ date: -1 }).limit(1);
+    }
+
+    async generateDailyReport(
+        dailyClaimReviews,
+        nameSpace?: string
+    ): Promise<string> {
+        try {
+            const summarizedReviews =
+                await this.summarizationService.getSummarizedReviews(
+                    dailyClaimReviews
+                );
+
+            return this.summarizationService.generateHTMLReport(
+                summarizedReviews,
+                nameSpace
+            );
+        } catch (error) {
+            this.logger.error("Error generating daily report:", error);
+            throw new Error("Failed to generate daily report");
+        }
+    }
+}

server/daily-report/schemas/daily-report.schema.ts

@@ -0,0 +1,24 @@
+import * as mongoose from "mongoose";
+import { Prop, Schema, SchemaFactory } from "@nestjs/mongoose";
+import { Report } from "../../report/schemas/report.schema";
+
+export type DailyReportDocument = DailyReport & mongoose.Document;
+
+@Schema({ toObject: { virtuals: true }, toJSON: { virtuals: true } })
+export class DailyReport {
+    @Prop({
+        type: [
+            {
+                type: mongoose.Types.ObjectId,
+                required: true,
+                ref: "Report",
+            },
+        ],
+    })
+    reports: Report[];
+
+    @Prop({ required: true })
+    date: Date;
+}
+
+export const DailyReportSchema = SchemaFactory.createForClass(DailyReport);

server/notifications/notification.controller.ts

@@ -1,33 +1,15 @@
-import { Body, Controller, Get, Param, Post, UseGuards } from "@nestjs/common";
+import { Body, Controller, Get, Param, Post } from "@nestjs/common";
 import { NotificationService } from "./notifications.service";
 import { ApiTags } from "@nestjs/swagger";
 import { ConfigService } from "@nestjs/config";
-import { SummarizationService } from "../summarization/summarization.service";
-import {
-    AdminUserAbility,
-    CheckAbilities,
-} from "../auth/ability/ability.decorator";
-import { AbilitiesGuard } from "../auth/ability/abilities.guard";
 
 @Controller()
 export class NotificationController {
     constructor(
         private readonly notificationService: NotificationService,
-        private summarizationService: SummarizationService,
         private configService: ConfigService
     ) {}
 
-    @Post("api/notification/topic-subscription/:key/send/:nameSpace")
-    @UseGuards(AbilitiesGuard)
-    @CheckAbilities(new AdminUserAbility())
-    async sendDailyReport(@Param("key") key, @Param("nameSpace") nameSpace) {
-        const dailyReport = await this.summarizationService.generateDailyReport(
-            nameSpace
-        );
-
-        return this.notificationService.sendDailyReviewsEmail(key, dailyReport);
-    }
-
     @ApiTags("notifications")
     @Post("api/notification")
     sendNotification(@Body() body) {

server/notifications/notifications.module.ts

@@ -3,19 +3,9 @@ import { ConfigModule } from "@nestjs/config";
 import { NotificationService } from "./notifications.service";
 import { NovuProvider } from "./novu.provider";
 import { NotificationController } from "./notification.controller";
-import { ClaimReviewModule } from "../claim-review/claim-review.module";
-import { SummarizationModule } from "../summarization/summarization.module";
-import { EmailModule } from "../email/email.module";
-import { AbilityModule } from "../auth/ability/ability.module";
 
 @Module({
-    imports: [
-        ConfigModule,
-        ClaimReviewModule,
-        SummarizationModule,
-        EmailModule,
-        AbilityModule,
-    ],
+    imports: [ConfigModule],
     exports: [NotificationService],
     providers: [NotificationService, NovuProvider],
     controllers: [NotificationController],

server/summarization/summarization.module.ts

@@ -1,7 +1,6 @@
 import { Module } from "@nestjs/common";
 import { SummarizationChainService } from "./summarization-chain.service";
 import { SummarizationService } from "./summarization.service";
-import { SummarizationController } from "./summarization.controller";
 import { ClaimReviewModule } from "../claim-review/claim-review.module";
 import { AbilityModule } from "../auth/ability/ability.module";
 import { ConfigModule } from "@nestjs/config";
@@ -10,6 +9,5 @@ import { ConfigModule } from "@nestjs/config";
     imports: [ClaimReviewModule, AbilityModule, ConfigModule],
     providers: [SummarizationChainService, SummarizationService],
     exports: [SummarizationService],
-    controllers: [SummarizationController],
 })
 export class SummarizationModule {}

server/summarization/summarization.service.ts

@@ -1,53 +1,16 @@
 import { Injectable, Logger } from "@nestjs/common";
 import { SummarizationChainService } from "./summarization-chain.service";
-import { ClaimReviewService } from "../claim-review/claim-review.service";
 import { ConfigService } from "@nestjs/config";
 
 @Injectable()
 export class SummarizationService {
     private readonly logger = new Logger("SummarizationLogger");
     constructor(
         private chainService: SummarizationChainService,
-        private claimReviewService: ClaimReviewService,
         private configService: ConfigService
     ) {}
 
-    async generateDailyReport(nameSpace?: string): Promise<string> {
-        const query = {
-            page: 0,
-            pageSize: 10,
-            order: "asc",
-            isHidden: false,
-            latest: false,
-            isDailyRange: true,
-            nameSpace: nameSpace,
-        };
-
-        try {
-            const dailyClaimReviews =
-                await this.claimReviewService.listDailyReviews(
-                    query.page,
-                    query.pageSize,
-                    query.order,
-                    { isHidden: query.isHidden, isDeleted: false },
-                    query.nameSpace,
-                    query.latest
-                );
-
-            const summarizedReviews = await this.getSummarizedReviews(
-                dailyClaimReviews
-            );
-
-            return this.generateHTMLReport(summarizedReviews, nameSpace);
-        } catch (error) {
-            this.logger.error("Error generating daily report:", error);
-            throw new Error("Failed to generate daily report");
-        }
-    }
-
-    private async getSummarizedReviews(
-        dailyClaimReviews: any[]
-    ): Promise<any[]> {
+    async getSummarizedReviews(dailyClaimReviews: any[]): Promise<any[]> {
         try {
             return await Promise.all(
                 dailyClaimReviews.map(async (claimReview) => {
@@ -67,10 +30,7 @@ export class SummarizationService {
         }
     }
 
-    private generateHTMLReport(
-        summarizedReviews: any[],
-        nameSpace: string
-    ): string {
+    generateHTMLReport(summarizedReviews: any[], nameSpace: string): string {
         const classificationTranslations = {
             "not-fact": "Não é fato",
             trustworthy: "Confiável",