4-1-question-de-qualification-fr29-fr30.md 26 KB

Story 4.1 : Question de qualification (FR29, FR30)

Status: done

Story

En tant que Transformateur, je veux poser une question de qualification à l'auteur d'une idée depuis la fiche détaillée, afin d'obtenir des précisions qui m'aident à qualifier ou prioriser l'idée.

Acceptance Criteria

  1. Given je suis sur la fiche détaillée d'une idée (/workspace/[workspaceId]/ideas/[ideaId]) When j'ouvre la section "Question de qualification" Then je vois un formulaire avec un champ texte (textarea) pour saisir ma question et un bouton "Envoyer la question" And les questions déjà posées sont affichées sous forme de liste chronologique (date + texte) au-dessus du formulaire

  2. Given je saisis une question (non vide) et je clique "Envoyer la question" When la mutation api.idea.askQualificationQuestion est appelée Then la question est enregistrée dans la base (QualificationQuestion liée à l'idée) And un email de notification est envoyé au contributeur (adresse : idea.contributorEmail) avec la question et un lien de réponse And la question apparaît immédiatement dans la liste (invalidation React Query) And le champ texte est réinitialisé

  3. Given l'envoi de la question est en cours When la mutation est en attente (isPending) Then le bouton "Envoyer la question" est désactivé avec un spinner And le textarea est désactivé

  4. Given la mutation échoue (erreur serveur, réseau) When l'erreur est reçue Then un toast d'erreur s'affiche : "Impossible d'envoyer la question" And la question n'est PAS ajoutée à la liste

  5. Given je tente d'envoyer une question vide (espaces uniquement) When je clique "Envoyer la question" Then la mutation n'est pas appelée And un message de validation inline s'affiche : "La question ne peut pas être vide"

  6. Given le contributeur reçoit l'email de notification When il ouvre l'email Then l'email contient : le texte de la question, le titre de l'idée (ou aperçu de description), le nom du workspace et un lien "Répondre à la question" (/qualify/[responseToken]) And le sujet de l'email est : "Question sur votre idée — {workspaceName}"

  7. Given l'envoi de l'email de qualification échoue (erreur Resend, réseau) When l'échec se produit Then la question est quand même enregistrée en base et retournée au frontend And l'erreur email est loggée côté serveur : [email] Qualification question email failed: And aucune erreur n'est exposée au Transformateur pour l'échec email (fire-and-forget)

  8. Given l'idée n'appartient pas au workspace ou le Transformateur n'est pas propriétaire When la procédure tRPC est appelée Then une erreur UNAUTHORIZED ou NOT_FOUND est retournée (défense en profondeur)

Tasks / Subtasks

  • [x] Task 1 : Migration Prisma — nouveau modèle QualificationQuestion (AC: #1, #2, #8)

    • [x] Subtask 1.1 : Ajouter dans prisma/schema.prisma le modèle QualificationQuestion :

      // Story 4.1 : Questions de qualification (FR29, FR30)
      model QualificationQuestion {
      id            String   @id @default(cuid())
      ideaId        String
      idea          Idea     @relation(fields: [ideaId], references: [id], onDelete: Cascade)
      workspaceId   String   // dénormalisé pour isolation multi-tenant
      questionText  String   @db.Text
      responseToken String   @unique @default(cuid()) // utilisé par Story 4.2 pour l'URL de réponse
      askedAt       DateTime @default(now())
      
      @@index([ideaId])
      @@index([workspaceId])
      }
      
    • [x] Subtask 1.2 : Ajouter la relation dans le modèle Idea :

      // Ajouter dans le modèle Idea (après `attachments IdeaAttachment[]`)
      qualificationQuestions QualificationQuestion[]
      
    • [x] Subtask 1.3 : Créer et exécuter la migration Prisma :

      cd aimpact-hub
      pnpm prisma migrate dev --name add_qualification_question
      
    • [x] Subtask 1.4 : Vérifier que pnpm prisma generate s'exécute sans erreur après la migration

  • [x] Task 2 : Service email — sendQualificationQuestionEmail (AC: #6, #7)

    • [x] Subtask 2.1 : Ajouter dans src/server/services/email.ts l'interface et la fonction :

      export interface SendQualificationQuestionEmailParams {
      contributorEmail: string;
      workspaceName: string;
      ideaTitle: string; // llmTitle ?? problemDescription.slice(0, 80)
      questionText: string;
      responseToken: string; // utilisé pour l'URL /qualify/[responseToken]
      }
      
      export async function sendQualificationQuestionEmail(
      params: SendQualificationQuestionEmailParams
      ): Promise<void> {
      const { contributorEmail, workspaceName, ideaTitle, questionText, responseToken } = params;
      const baseUrl = process.env.NEXTAUTH_URL ?? "http://localhost:3000";
      const responseUrl = `${baseUrl}/qualify/${responseToken}`;
      
      if (!resend) {
      console.log("[email] Qualification question (mock):", {
        to: contributorEmail,
        subject: `Question sur votre idée — ${workspaceName}`,
        responseUrl,
        questionText,
      });
      return;
      }
      
      const html = `
      <p>Bonjour,</p>
      <p>Le responsable du workspace <strong>${escapeHtml(workspaceName)}</strong> a une question sur votre idée :</p>
      <blockquote style="border-left: 4px solid #7c3aed; padding-left: 1rem; color: #374151;">
        ${escapeHtml(questionText)}
      </blockquote>
      <p><strong>Idée concernée :</strong> ${escapeHtml(ideaTitle)}</p>
      <p><a href="${responseUrl}" style="background: #7c3aed; color: white; padding: 0.5rem 1rem; border-radius: 0.375rem; text-decoration: none;">Répondre à la question →</a></p>
      <p style="color: #6b7280; font-size: 0.875rem;">Ce lien est personnel et valable pour cette idée uniquement.</p>
      <p>— AImpact Hub</p>
      `;
      
      const result = await resend.emails.send({
      from: "AImpact Hub <noreply@aimpact-hub.com>",
      to: contributorEmail,
      subject: `Question sur votre idée — ${workspaceName}`,
      html,
      });
      
      if (result.error) {
      throw new Error(`Resend error: ${result.error.message}`);
      }
      }
      
    • [x] Subtask 2.2 : Utiliser la fonction escapeHtml existante dans email.ts (déjà définie pour les autres emails)

  • [x] Task 3 : Procédure tRPC idea.askQualificationQuestion (AC: #2, #4, #7, #8)

    • [x] Subtask 3.1 : Ajouter dans src/server/api/routers/idea.ts la procédure :

      askQualificationQuestion: protectedProcedure
      .input(z.object({
      ideaId: z.string().cuid(),
      workspaceId: z.string().cuid(),
      questionText: z.string().min(1).max(2000),
      }))
      .mutation(async ({ ctx, input }) => {
      // Ownership check — défense en profondeur (pattern établi Stories 3.4, 3.1)
      const workspace = await ctx.db.workspace.findUnique({
        where: { id: input.workspaceId },
        select: { ownerId: true, name: true, contactEmail: true, owner: { select: { email: true } } },
      });
      if (!workspace || workspace.ownerId !== ctx.session.user.id) {
        throw new TRPCError({ code: "UNAUTHORIZED", message: "Vous n'êtes pas propriétaire de ce workspace." });
      }
      
      // Vérification idée appartient au workspace
      const idea = await ctx.db.idea.findUnique({
        where: { id: input.ideaId },
        select: { workspaceId: true, contributorEmail: true, llmTitle: true, problemDescription: true },
      });
      if (!idea || idea.workspaceId !== input.workspaceId) {
        throw new TRPCError({ code: "NOT_FOUND", message: "Idée non trouvée." });
      }
      
      // Création de la question
      const question = await ctx.db.qualificationQuestion.create({
        data: {
          ideaId: input.ideaId,
          workspaceId: input.workspaceId,
          questionText: input.questionText.trim(),
        },
      });
      
      // Envoi email — fire-and-forget (ne bloque jamais la mutation)
      const ideaTitle = idea.llmTitle ?? idea.problemDescription.slice(0, 80);
      void sendQualificationQuestionEmail({
        contributorEmail: idea.contributorEmail,
        workspaceName: workspace.name,
        ideaTitle,
        questionText: input.questionText.trim(),
        responseToken: question.responseToken,
      }).catch((err: unknown) => {
        console.error("[email] Qualification question email failed:", err);
      });
      
      return question;
      }),
      
    • [x] Subtask 3.2 : Importer sendQualificationQuestionEmail depuis ~/server/services/email

    • [x] Subtask 3.3 : Étendre la procédure getById (déjà dans idea.ts) pour inclure qualificationQuestions :

      // Dans le select de getById, ajouter après `attachments`:
      qualificationQuestions: {
      select: { id: true, questionText: true, responseToken: true, askedAt: true },
      orderBy: { askedAt: "asc" },
      },
      
  • [x] Task 4 : Composant QualificationQuestionSection (AC: #1, #2, #3, #4, #5)

    • [x] Subtask 4.1 : Créer src/components/idea/QualificationQuestionSection.tsx — composant client :

      "use client";
      // Props:
      //   ideaId: string
      //   workspaceId: string
      //   questions: Array<{ id: string, questionText: string, askedAt: Date }>
      //   onQuestionSent: () => void  // callback pour invalider React Query depuis IdeaDetailView
      
    • [x] Subtask 4.2 : Affichage liste des questions existantes (ordre chronologique) :

      // Si aucune question : message discret "Aucune question posée pour l'instant"
      // Sinon : liste avec date formatée (format "DD/MM/YYYY") + texte de la question
      // Chaque question dans un bloc distinct avec une bordure gauche violette (cohérence design)
      
    • [x] Subtask 4.3 : Formulaire de saisie nouvelle question :

      <textarea
      value={questionText}
      onChange={(e) => setQuestionText(e.target.value)}
      disabled={isPending}
      placeholder="Poser une question au contributeur..."
      className="w-full min-h-[80px] rounded-md border p-2 text-sm"
      maxLength={2000}
      />
      {validationError && (
      <p className="text-sm text-red-500">{validationError}</p>
      )}
      <Button
      onClick={handleSubmit}
      disabled={isPending}
      >
      {isPending ? <Spinner /> : "Envoyer la question"}
      </Button>
      
    • [x] Subtask 4.4 : Logique handleSubmit :

    • Trim du texte → si vide : afficher message "La question ne peut pas être vide" (ne pas appeler la mutation)

    • Sinon : appeler api.idea.askQualificationQuestion.useMutation

    • Sur succès : réinitialiser textarea + appeler onQuestionSent() (qui invalide api.idea.getById)

    • Sur erreur : afficher toast "Impossible d'envoyer la question"

    • [x] Subtask 4.5 : Toast d'erreur — utiliser le pattern toast déjà établi dans IdeaDetailView.tsx (sonner ou inline)

  • [x] Task 5 : Intégration dans IdeaDetailView (AC: #1, #2)

    • Subtask 5.1 : Étendre la réponse idea.getById.useQuery dans IdeaDetailView.tsx pour consommer qualificationQuestions
    • [x] Subtask 5.2 : Ajouter la section "Question de qualification" dans le rendu de IdeaDetailView (après la section pièces jointes) :

      <section>
      <h2 className="text-lg font-semibold mb-3">Questions de qualification</h2>
      <QualificationQuestionSection
      ideaId={ideaId}
      workspaceId={workspaceId}
      questions={idea.qualificationQuestions}
      onQuestionSent={() => utils.idea.getById.invalidate({ ideaId, workspaceId })}
      />
      </section>
      
    • [x] Subtask 5.3 : S'assurer que le skeleton de chargement dans IdeaDetailView couvre la nouvelle section (ajouter une 4e zone skeleton)

  • [x] Task 6 : Tests (AC: #1–#8)

    • Subtask 6.1 : Créer src/server/api/routers/idea.askQualificationQuestion.test.ts (Vitest) :
    • Test A : ownership check — erreur UNAUTHORIZED si l'utilisateur n'est pas owner
    • Test B : not found — erreur NOT_FOUND si l'idée n'appartient pas au workspace
    • Test C : succès — QualificationQuestion créée avec les bons champs, responseToken généré
    • Test D : email fire-and-forget — sendQualificationQuestionEmail appelé avec les bons params
    • Test E : email échec — la question est quand même retournée même si sendQualificationQuestionEmail throw
    • Test F : questionText vide après trim — z.string().min(1) rejette (Zod validation)
    • Subtask 6.2 : Créer src/server/services/email.qualificationQuestion.test.ts (Vitest) :
    • Test G : RESEND_API_KEY absent → console.log mock appelé, pas d'erreur
    • Test H : appel Resend avec les bons paramètres (to, subject, html contenant responseUrl)
    • Test I : Resend retourne { error: {...} } → throw new Error
    • Subtask 6.3 : Créer src/components/idea/QualificationQuestionSection.test.tsx (Vitest + RTL) :
    • Mock api.idea.askQualificationQuestion.useMutation
    • Test J : affiche "Aucune question posée" si questions = []
    • Test K : affiche la liste des questions existantes avec date et texte
    • Test L : clic "Envoyer" avec textarea vide → message de validation, mutation non appelée
    • Test M : clic "Envoyer" avec texte valide → mutation appelée avec questionText trimmé
    • Test N : état isPending → bouton et textarea désactivés
    • Test O : succès mutation → textarea réinitialisé, onQuestionSent appelé

Dev Notes

Contexte de la story

Cette story implémente le mécanisme de question de qualification : le Transformateur pose une question au contributeur depuis la fiche détaillée d'une idée, qui reçoit un email avec un lien de réponse.

Elle s'appuie sur :

  • Story 3.4 (IdeaDetailView) — la fiche détaillée déjà implémentée ; cette story ajoute une nouvelle section dans ce composant
  • Story 3.8 (email.ts) — le pattern email fire-and-forget, escapeHtml, mock dev Resend, déjà établi
  • Story 4.2 (future) — la page de réponse /qualify/[responseToken] consommera le responseToken stocké ici

Une migration Prisma est nécessaire. Le modèle QualificationQuestion n'existe pas dans le schéma actuel.

Modèle QualificationQuestion — décisions de design

Pourquoi responseToken maintenant (et non en Story 4.2) ? Le responseToken doit être inclus dans l'email de notification envoyé lors de cette story. Si on l'ajoutait en Story 4.2, les questions créées en 4.1 n'auraient pas de token et les emails seraient inutilisables. Il est donc indispensable de le créer dès maintenant, même si la page de réponse est implémentée dans la story suivante.

Format du lien de réponse : /qualify/[responseToken] — cette route sera créée par Story 4.2. Pour l'instant, le lien dans l'email pointe vers une URL qui retournera 404 jusqu'à ce que Story 4.2 soit déployée. C'est acceptable en MVP (les deux stories seront déployées dans la même session de développement).

Pas de table d'historique dédiée : Le PRD (FR29) demande que la question soit "enregistrée et visible dans l'historique de la fiche". L'implémentation MVP est simple : QualificationQuestion est une table distincte liée à Idea. Les questions sont affichées en ordre chronologique dans la section dédiée. Pas de journal d'audit complexe nécessaire.

Pattern ownership check — identique aux stories précédentes

// Pattern Stories 3.1, 3.4 — OBLIGATOIRE, ne pas simplifier
const workspace = await ctx.db.workspace.findUnique({
  where: { id: input.workspaceId },
  select: { ownerId: true, name: true },
});
if (!workspace || workspace.ownerId !== ctx.session.user.id) {
  throw new TRPCError({ code: "UNAUTHORIZED", message: "..." });
}
const idea = await ctx.db.idea.findUnique({
  where: { id: input.ideaId },
  select: { workspaceId: true, ... },
});
if (!idea || idea.workspaceId !== input.workspaceId) {
  throw new TRPCError({ code: "NOT_FOUND", message: "..." });
}

Extension de idea.getById — attention à ne pas casser les tests existants

La procédure getById (Story 3.4) doit être étendue pour inclure qualificationQuestions. Cette modification est rétro-compatible : le frontend Story 3.4 ignorera simplement le nouveau champ. Mais les tests existants de idea.getById.test.ts devront être mis à jour pour inclure qualificationQuestions: [] dans les mocks de retour.

// Ajouter dans le select de getById (après attachments)
qualificationQuestions: {
  select: { id: true, questionText: true, responseToken: true, askedAt: true },
  orderBy: { askedAt: "asc" },
},

Service email — escapeHtml existant

La fonction escapeHtml est déjà définie dans src/server/services/email.ts (utilisée dans les templates des autres emails). L'utiliser systématiquement pour toutes les données utilisateur insérées dans le HTML.

Pattern fire-and-forget email (Story 3.8)

// Dans la mutation tRPC — ne jamais await l'email
void sendQualificationQuestionEmail({...}).catch((err: unknown) => {
  console.error("[email] Qualification question email failed:", err);
});

L'email est toujours fire-and-forget : si Resend échoue, la question est quand même enregistrée. Le Transformateur ne reçoit pas d'erreur pour l'échec email.

Mock Resend en développement

// Pattern identique à email.ts lignes existantes
if (!resend) {
  console.log("[email] Qualification question (mock):", params);
  return;
}

resend est null si RESEND_API_KEY est absent — le mock console.log est le fallback prévu.

Composant QualificationQuestionSection — design

Architecture.md ligne 492 cite : components/idea/QualificationQuestion.tsx — créer sous le nom QualificationQuestionSection.tsx pour être cohérent avec la convention des autres composants de la feature idea/ (ex. IdeaAttachmentList.tsx, IdeaDetailView.tsx).

Séquence d'affichage :

IdeaDetailPage (Server Component, auth)
  → IdeaDetailView (Client Component)
    → api.idea.getById.useQuery — inclut désormais qualificationQuestions[]
    → [section existante : en-tête, scores, pièces jointes]
    → [NOUVEAU] section "Questions de qualification"
        → Liste questions (order: asc) si questions.length > 0
        → Message vide si questions.length === 0
        → Formulaire : textarea + bouton "Envoyer la question"
            → handleSubmit → validation trim → api.idea.askQualificationQuestion.mutate
                → succès : reset textarea + onQuestionSent() → invalidate getById
                → erreur : toast "Impossible d'envoyer la question"

Design des questions affichées

// Chaque question dans un bloc avec bordure gauche violette (cohérence avec enrichissement IA)
<div className="border-l-4 border-violet-300 pl-4 py-2">
  <p className="text-xs text-muted-foreground">
    {format(question.askedAt, "dd/MM/yyyy")}
  </p>
  <p className="text-sm mt-1">{question.questionText}</p>
</div>

Pas de réponse affichée dans cette story — Story 4.2 ajoutera la réponse du contributeur.

Format de date — pattern existant

Utiliser date-fns si déjà disponible dans le projet (vérifier package.json). Si non disponible :

// Fallback natif
new Intl.DateTimeFormat("fr-FR", { day: "2-digit", month: "2-digit", year: "numeric" }).format(new Date(question.askedAt))

Structure des fichiers

Fichier Action Notes
prisma/schema.prisma Modifier — ajouter QualificationQuestion, relation Idea.qualificationQuestions Migration requise
prisma/migrations/YYYYMMDDHHMMSS_add_qualification_question/migration.sql Créé automatiquement par prisma migrate dev
src/server/services/email.ts Modifier — ajouter sendQualificationQuestionEmail Après sendNewIdeaNotificationEmail
src/server/api/routers/idea.ts Modifier — ajouter askQualificationQuestion, étendre getById
src/components/idea/QualificationQuestionSection.tsx Créer — composant client (liste + formulaire)
src/components/idea/IdeaDetailView.tsx Modifier — ajouter section "Questions de qualification", invalider cache
src/server/api/routers/idea.askQualificationQuestion.test.ts Créer — tests Vitest 6 tests (A–F)
src/server/services/email.qualificationQuestion.test.ts Créer — tests Vitest 3 tests (G–I)
src/components/idea/QualificationQuestionSection.test.tsx Créer — tests Vitest + RTL 6 tests (J–O)

NFR concernés

  • NFR14 : isolation workspace — workspaceId dénormalisé dans QualificationQuestion, ownership check double (workspace + idée)
  • NFR2 : l'envoi email est fire-and-forget, ne ralentit pas la réponse de la mutation
  • NFR9 : si Resend indisponible, la question est quand même créée — la plateforme reste fonctionnelle

Apprentissages des stories précédentes

Story 3.4 (IdeaDetailView) :

  • Pattern mock tRPC pour les tests :

    vi.mock("~/trpc/react", () => ({
    api: {
      idea: {
        askQualificationQuestion: { useMutation: vi.fn() },
        getById: { useQuery: vi.fn() },
      },
    },
    }));
    
  • Utiliser utils.idea.getById.invalidate({ ideaId, workspaceId }) pour invalider le cache après mutation

  • Toast d'erreur : utiliser Sonner (toast.error(...)) ou alert() en fallback si non disponible

Story 3.8 (email notification) :

  • Pattern Resend mock dev : if (!resend) { console.log(...); return; }
  • Pattern fire-and-forget : void fn().catch((err: unknown) => { console.error(...); })
  • escapeHtml est déjà définie dans email.ts — l'utiliser pour TOUS les contenus utilisateur dans les templates HTML

Story 3.1 (enrichissement LLM) — retryEnrich :

  • Le pattern ownership check workspace.ownerId !== ctx.session.user.id est la vérification principale
  • La double vérification (workspaceId sur l'idée en plus) est obligatoire — défense en profondeur documentée dans architecture.md

Tests Vitest — commande PowerShell :

cd "c:\Users\USER\Documents\Intersel - Livinweb\dev\AImpact-Ai_Hub\aimpact-hub"; pnpm vitest run --reporter=verbose 2>&1 | Select-Object -First 150

References

  • [Source: epics.md#Story 4.1 — Question de qualification (FR29, FR30)]
  • [Source: prd.md#FR29 — Le Transformateur peut poser une question de qualification]
  • [Source: prd.md#FR30 — Le contributeur reçoit une notification email quand une question lui est posée]
  • [Source: architecture.md#Qualification (FR29–FR32) — components/idea/QualificationQuestion.tsx, services/email.ts]
  • [Source: architecture.md#API Patterns — tRPC protectedProcedure, ownership check, filtre workspaceId]
  • [Source: architecture.md#Implementation Patterns — fire-and-forget, error handling, NFR14]
  • [Source: prisma/schema.prisma — model Idea, IdeaAttachment (pattern dénormalisation workspaceId)]
  • [Source: implementation-artifacts/3-4-fiche-detaillee-dune-idee-fr25-fr19-fr20.md — IdeaDetailView, idea.getById, ownership check pattern]
  • [Source: implementation-artifacts/3-8-notification-email-a-nouvelle-idee-fr32.md — fire-and-forget email, sendNewIdeaNotificationEmail pattern, escapeHtml]
  • [Source: src/server/api/routers/idea.ts — askQualificationQuestion (à créer), getById (à étendre)]
  • [Source: src/server/services/email.ts — sendQualificationQuestionEmail (à créer), escapeHtml, resend mock]
  • [Source: src/components/idea/IdeaDetailView.tsx — à modifier pour ajouter QualificationQuestionSection]

Dev Agent Record

Agent Model Used

claude-4.6-sonnet-medium-thinking (Cursor)

Debug Log References

Completion Notes List

  • ✅ Task 1 : Migration Prisma add_qualification_question — modèle QualificationQuestion avec responseToken, relation Idea.qualificationQuestions
  • ✅ Task 2 : sendQualificationQuestionEmail dans services/email.ts — escapeHtml, mock Resend dev, template HTML
  • ✅ Task 3 : Procédure idea.askQualificationQuestion — ownership check, fire-and-forget email, extension getById avec qualificationQuestions
  • ✅ Task 4 : Composant QualificationQuestionSection — liste questions, formulaire, validation trim, toast erreur
  • ✅ Task 5 : Intégration dans IdeaDetailView — section "Questions de qualification", skeleton 4e zone
  • ✅ Task 6 : 16 tests — idea.askQualificationQuestion (7), email sendQualificationQuestionEmail (3), QualificationQuestionSection (7), IdeaDetailView mock mis à jour
  • ✅ Code review : 5 corrections appliquées — test XSS email, newlines dans questionText, refactor escapeHtml, titre section AC, aria-label, test max 2000

File List

  • aimpact-hub/prisma/schema.prisma (modifié — QualificationQuestion, relation Idea)
  • aimpact-hub/prisma/migrations/20260228164951_add_qualification_question/migration.sql (créé)
  • aimpact-hub/src/server/services/email.ts (modifié — escapeHtml, sendQualificationQuestionEmail)
  • aimpact-hub/src/server/api/routers/idea.ts (modifié — askQualificationQuestion, getById étendu)
  • aimpact-hub/src/components/idea/QualificationQuestionSection.tsx (créé)
  • aimpact-hub/src/components/idea/IdeaDetailView.tsx (modifié — section qualification)
  • aimpact-hub/src/server/api/routers/idea.askQualificationQuestion.test.ts (créé)
  • aimpact-hub/src/server/api/routers/idea.getById.test.ts (modifié — qualificationQuestions: [])
  • aimpact-hub/src/server/services/email.test.ts (modifié — sendQualificationQuestionEmail tests)
  • aimpact-hub/src/components/idea/QualificationQuestionSection.test.tsx (créé)
  • aimpact-hub/src/components/idea/IdeaDetailView.test.tsx (modifié — mock askQualificationQuestion, qualificationQuestions)

Change Log

  • 2026-02-28 : Implémentation complète Story 4.1 (FR29, FR30) — question de qualification, email contributeur, UI fiche détaillée
  • 2026-02-28 : Code review — 5 corrections : test XSS sendQualificationQuestionEmail, newlines → br dans email, refactor escapeHtml, titre "Question de qualification", aria-label textarea, test max 2000 chars