Merge pull request #2149 from AletheiaFact/feature/identified-personalities-on-verification-request-visual

Feature: Displays personalities mentioned in verification requests with their avatars and descriptions

Author: caneppelevitor

public/locales/en/verificationRequest.json

@@ -84,5 +84,12 @@
     "viewFullPage": "View full page",
     "automated_monitoring": "Automated Monitoring",
     "filterBySourceChannel": "Filter by Source Channel",
-    "errorUpdatingStatus": "Error updating status:"
+    "errorUpdatingStatus": "Error updating status:",
+    "identifiedPersonalities": "People Mentioned",
+    "loadingPersonalities": "Loading personalities...",
+    "personalitiesList": "List of identified personalities",
+    "noPersonalitiesFound": "No personalities identified in this request",
+    "errorLoadingPersonalities": "Error loading personalities. Please try again.",
+    "retryLoadingPersonalities": "Retry",
+    "viewPersonalityPage": "View personality page for {{name}}"
 }

public/locales/pt/verificationRequest.json

@@ -84,5 +84,12 @@
     "viewFullPage": "Ver página completa",
     "automated_monitoring": "Monitoramento Automatizado",
     "filterBySourceChannel": "Filtrar por Canal de Origem",
-    "errorUpdatingStatus": "Erro ao atualizar status:"
+    "errorUpdatingStatus": "Erro ao atualizar status:",
+    "identifiedPersonalities": "Pessoas Mencionadas",
+    "loadingPersonalities": "Carregando personalidades...",
+    "personalitiesList": "Lista de personalidades identificadas",
+    "noPersonalitiesFound": "Nenhuma personalidade identificada nesta denúncia",
+    "errorLoadingPersonalities": "Erro ao carregar personalidades. Por favor, tente novamente.",
+    "retryLoadingPersonalities": "Tentar novamente",
+    "viewPersonalityPage": "Ver página da personalidade {{name}}"
 }

server/verification-request/dto/personality-with-wikidata.dto.ts

@@ -0,0 +1,31 @@
+/**
+ * DTO for personality data enriched with Wikidata information
+ */
+export interface PersonalityWithWikidataDto {
+    /** Personality database ID */
+    personalityId: string;
+
+    /** Personality name */
+    name: string;
+
+    /** Personality URL slug */
+    slug: string;
+
+    /** Personality description (from database or Wikidata) */
+    description: string | null;
+
+    /** Wikidata avatar/image URL, null if not available */
+    avatar: string | null;
+
+    /** Wikidata entity ID (e.g., Q22686), null if not linked to Wikidata */
+    wikidata: string | null;
+}
+
+/**
+ * Type guard to check if a personality has a valid wikidata ID
+ */
+export function hasWikidataId(
+    personality: PersonalityWithWikidataDto
+): personality is PersonalityWithWikidataDto & { wikidata: string } {
+    return personality.wikidata !== null && personality.wikidata !== undefined;
+}

server/verification-request/verification-request.controller.ts

@@ -33,6 +33,8 @@ import {
     CheckAbilities,
 } from "../auth/ability/ability.decorator";
 import { Roles } from "../auth/ability/ability.factory";
+import { WikidataService } from "../wikidata/wikidata.service";
+import { PersonalityWithWikidataDto } from "./dto/personality-with-wikidata.dto";
 
 @Controller(":namespace?")
 export class VerificationRequestController {
@@ -44,7 +46,8 @@ export class VerificationRequestController {
         private viewService: ViewService,
         private reviewTaskService: ReviewTaskService,
         private captchaService: CaptchaService,
-        private verificationRequestStateMachineService: VerificationRequestStateMachineService
+        private readonly verificationRequestStateMachineService: VerificationRequestStateMachineService,
+        private readonly wikidataService: WikidataService
     ) {}
 
     @ApiTags("verification-request")
@@ -117,6 +120,113 @@ export class VerificationRequestController {
         return this.verificationRequestService.getById(verificationRequestId);
     }
 
+    /**
+     * Get personalities associated with a verification request, enriched with Wikidata information
+     * @param verificationRequestId - The verification request ID
+     * @param language - Language code for Wikidata labels (default: 'en')
+     * @returns Array of personalities with Wikidata avatar and metadata
+     */
+    @ApiTags("verification-request")
+    @Get("api/verification-request/:id/personalities")
+    @Header("Cache-Control", "max-age=60, must-revalidate")
+    @Public()
+    public async getPersonalitiesWithWikidata(
+        @Param("id") verificationRequestId: string,
+        @Query("language") language: string = "en"
+    ): Promise<PersonalityWithWikidataDto[]> {
+        const verificationRequest =
+            await this.verificationRequestService.getByIdWithPopulatedFields(
+                verificationRequestId,
+                ["identifiedData"]
+            );
+
+        if (
+            !verificationRequest?.identifiedData ||
+            verificationRequest.identifiedData.length === 0
+        ) {
+            this.logger.debug(
+                `No identifiedData found for VR ${verificationRequestId}`
+            );
+            return [];
+        }
+
+        this.logger.debug(
+            `Found ${verificationRequest.identifiedData.length} personalities for VR ${verificationRequestId}`
+        );
+
+        const personalities: PersonalityWithWikidataDto[] = await Promise.all(
+            verificationRequest.identifiedData.map(
+                async (
+                    personality: any
+                ): Promise<PersonalityWithWikidataDto> => {
+                    if (!personality?.name) {
+                        this.logger.warn(
+                            `Personality missing name field for VR ${verificationRequestId}`
+                        );
+                        return {
+                            personalityId: personality._id?.toString() || "",
+                            name: "Unknown",
+                            slug: "",
+                            description: null,
+                            avatar: null,
+                            wikidata: null,
+                        };
+                    }
+
+                    const baseData = {
+                        personalityId: personality._id.toString(),
+                        name: personality.name,
+                        slug: personality.slug || "",
+                        description: personality.description || null,
+                    };
+
+                    if (!personality.wikidata) {
+                        this.logger.debug(
+                            `Personality ${personality.name} has no wikidata ID`
+                        );
+                        return {
+                            ...baseData,
+                            avatar: null,
+                            wikidata: null,
+                        };
+                    }
+
+                    try {
+                        const wikidataProps =
+                            await this.wikidataService.fetchProperties({
+                                wikidataId: personality.wikidata,
+                                language,
+                            });
+
+                        return {
+                            ...baseData,
+                            name: wikidataProps.name || personality.name,
+                            description:
+                                wikidataProps.description ||
+                                personality.description ||
+                                null,
+                            avatar: wikidataProps.avatar || null,
+                            wikidata: personality.wikidata,
+                        };
+                    } catch (error) {
+                        this.logger.error(
+                            `Error fetching wikidata for personality ${personality.name} (${personality.wikidata}):`,
+                            error.message
+                        );
+
+                        return {
+                            ...baseData,
+                            avatar: null,
+                            wikidata: personality.wikidata,
+                        };
+                    }
+                }
+            )
+        );
+
+        return personalities;
+    }
+
     @ApiTags("verification-request")
     @Post("api/verification-request")
     async create(

server/verification-request/verification-request.module.ts

@@ -22,6 +22,7 @@ import { AbilityModule } from "../auth/ability/ability.module";
 import { TopicModule } from "../topic/topic.module";
 import { PersonalityModule } from "../personality/personality.module";
 import { VerificationRequestStateMachineService } from "./state-machine/verification-request.state-machine.service";
+import { WikidataModule } from "../wikidata/wikidata.module";
 
 const VerificationRequestModel = MongooseModule.forFeature([
     {
@@ -43,6 +44,7 @@ const VerificationRequestModel = MongooseModule.forFeature([
         AiTaskModule,
         CallbackDispatcherModule,
         AbilityModule,
+        WikidataModule,
         TopicModule,
         PersonalityModule.register(),
     ],

server/verification-request/verification-request.service.ts

@@ -605,7 +605,8 @@ export class VerificationRequestService {
                 .populate("group")
                 .populate("source")
                 .populate("impactArea")
-                .populate("topics");
+                .populate("topics")
+                .populate("identifiedData");
         }
 
         return this.VerificationRequestModel.findOne({ data_hash });
@@ -924,9 +925,9 @@ export class VerificationRequestService {
     async updateVerificationRequestWithTopics(topics, data_hash) {
         const verificationRequest = await this.findByDataHash(data_hash, false);
         const foundTopics = await this.topicService.findByWikidataIds(
-            topics.map(topic => topic.value || topic.wikidataId)
+            topics.map((topic) => topic.value || topic.wikidataId)
         );
-        const topicIds = foundTopics.map(topic => topic._id);
+        const topicIds = foundTopics.map((topic) => topic._id);
 
         const latestVerificationRequest = verificationRequest.toObject();
 
@@ -972,7 +973,7 @@ export class VerificationRequestService {
             status,
             impactArea,
             startDate,
-            endDate
+            endDate,
         } = filters;
         const query: any = {};
 
@@ -988,8 +989,7 @@ export class VerificationRequestService {
             Types.ObjectId(impactArea._id)
         );
 
-        if (topicIds.length)
-            orConditions.push({ topics: { $in: topicIds } });
+        if (topicIds.length) orConditions.push({ topics: { $in: topicIds } });
 
         if (impactAreaIds.length)
             orConditions.push({ impactArea: { $in: impactAreaIds } });
@@ -1000,9 +1000,9 @@ export class VerificationRequestService {
             }));
             orConditions.push(...contentConditions);
         }
-      
+
         const dateQuery = buildDateQuery(startDate, endDate);
-        
+
         if (dateQuery) query.date = dateQuery;
 
         if (orConditions.length) {