Utilisateurs, compte et signalement : six points

-- Signalements de bug, deposes depuis l'application.

--

-- POURQUOI EN BASE, ET PAS UN SIMPLE COURRIEL. L'envoi de courriel n'est pas

-- configure sur toutes les instances — il ne l'est meme pas par defaut. Un

-- signalement qui n'existerait que dans un message serait alors perdu au

-- moment ou il est ecrit, sans que personne ne s'en apercoive. La table est la

-- memoire ; le courriel n'est qu'un avertissement.

--

-- `tenantId` est NULLABLE et en SET NULL : la suppression d'une organisation ne

-- doit pas effacer les signalements qu'elle a produits, qui documentent l'etat

-- du produit et non celui du client.

CREATE TABLE "BugReport" (

  "id" TEXT NOT NULL,

  "tenantId" TEXT,

  "tenantName" TEXT,

  "reporterUserId" TEXT,

  "reporterEmail" TEXT NOT NULL,

  "title" TEXT NOT NULL,

  "body" TEXT NOT NULL,

  -- Ou l'utilisateur se trouvait, et avec quoi. Renseigne par l'interface :

  -- un signalement sans contexte oblige a rappeler son auteur pour l'obtenir.

  "page" TEXT,

  "userAgent" TEXT,

  "status" TEXT NOT NULL DEFAULT 'OPEN',

  "handledAt" TIMESTAMP(3),

  "handledByUserId" TEXT,

  "handledNote" TEXT,

  "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,

  CONSTRAINT "BugReport_pkey" PRIMARY KEY ("id")

);

CREATE INDEX "BugReport_status_createdAt_idx" ON "BugReport"("status", "createdAt");

ALTER TABLE "BugReport"

  ADD CONSTRAINT "BugReport_tenantId_fkey"

  FOREIGN KEY ("tenantId") REFERENCES "Tenant"("id") ON DELETE SET NULL ON UPDATE CASCADE;

  /// deploiement (RETENTION_DAYS). En SaaS, la retention releve de la politique

  /// de chaque client, pas de celle de l'hebergeur.

  retentionDays Int?

  /// Signalements de bug emis depuis cette organisation.

  bugReports    BugReport[]

  /// Logo de l'organisation (cle de fichier televerse). Avatar par defaut du

  /// compte officiel sur les reseaux simules ; un exercice peut le remplacer.

  logoPath     String?

  @@index([tenantId])

  @@index([questionId])

}

/// Signalement de bug depose depuis l'application.

///

/// EN BASE, et pas un simple courriel : l'envoi n'est pas configure sur toutes

/// les instances, et un signalement qui n'existerait que dans un message serait

/// perdu au moment meme ou il est ecrit. La table est la memoire ; le courriel

/// n'est qu'un avertissement.

model BugReport {

  id             String    @id @default(cuid())

  /// Organisation d'ou vient le signalement. SET NULL a sa suppression : le

  /// signalement documente le produit, pas le client.

  tenantId       String?

  tenant         Tenant?   @relation(fields: [tenantId], references: [id], onDelete: SetNull)

  /// Recopie a la creation : le nom survit a la suppression de l'organisation.

  tenantName     String?

  reporterUserId String?

  reporterEmail  String

  title          String

  body           String

  /// Ou l'auteur se trouvait, et avec quoi. Sans contexte, il faut le rappeler.

  page           String?

  userAgent      String?

  status         String    @default("OPEN")

  handledAt      DateTime?

  handledByUserId String?

  handledNote    String?

  createdAt      DateTime  @default(now())

  @@index([status, createdAt])

}

import { CurrentUser } from '../auth/current-user.decorator';

import type { AuthUser } from '../auth/auth.types';

import type { UserRole } from '@prisma/client';

import type { ApiInvitationAvailability } from '@enkadenn/shared';

import type { ApiInvitationAvailability, ApiInvitationLigne } from '@enkadenn/shared';

import { PrismaService } from '../prisma/prisma.service';

import { AccountService } from './account.service';

import { MailerService } from '../platform-mail/mailer.service';

import { SignupService } from './signup.service';

import { ConsumeTokenDto, ForgotPasswordDto, InviteDto, SignupDto } from './dto/signup.dto';

import {

  ConsumeTokenDto,

  ForgotPasswordDto,

  InviteCsvDto,

  InviteDto,

  SignupDto,

} from './dto/signup.dto';

import { docsUrl } from '../common/docs-url';

const MINUTE = 60_000;

      tenant?.name ?? 'votre organisation',

    );

  }

  /**

   * Invitation en masse, depuis un CSV : `email` et, facultativement, `role`.

   *

   * LE LOT N'EST PAS ATOMIQUE, et c'est voulu. Une adresse deja membre ou

   * malformee ne doit pas annuler les neuf autres : l'administrateur repartirait

   * corriger son fichier a l'aveugle, sans savoir lesquelles etaient passees. Un

   * compte rendu ligne par ligne dit exactement ou en est chacune.

   *

   * L'analyse est faite ICI et non dans le navigateur : c'est le meme analyseur

   * que les imports de kit, qui respecte les guillemets — un nom contenant une

   * virgule ne decale pas les colonnes.

   */

  @Post('csv')

  @Roles('TENANT_ADMIN')

  async inviteCsv(

    @CurrentUser() me: AuthUser,

    @Body() dto: InviteCsvDto,

  ): Promise<{ lignes: ApiInvitationLigne[] }> {

    const tenant = await this.prisma.tenant.findUnique({ where: { id: me.tenantId } });

    return {

      lignes: await this.account.inviteEnMasse(

        me.tenantId,

        dto.csv,

        tenant?.name ?? 'votre organisation',

      ),

    };

  }

}

import {

  BadRequestException,

  ForbiddenException,

  HttpException,

  Injectable,

  Logger,

  ServiceUnavailableException,

import { AppUrlService } from '../common/app-url.service';

import { MailerService } from '../platform-mail/mailer.service';

import { isTenantRole } from '../auth/roles';

import { parseCsvTable } from '../common/csv';

import type { ApiInvitationLigne } from '@enkadenn/shared';

import { SessionEpochService } from '../common/session-epoch.service';

const BCRYPT_ROUNDS = 12;

/** Plafond d'un lot d'invitations : autant d'envois que de lignes acceptees. */

const MAX_INVITATIONS_CSV = 200;

/** Duree de vie d'un lien envoye par courriel, par nature de jeton. */

const TTL_HOURS: Record<AuthTokenKind, number> = {

  // Une premiere prise de main peut attendre quelques jours (vacances, congés).

    this.audit.record('account.invited', { tenantId, role });

  }

  /**

   * Invite en masse depuis un CSV. Colonnes : `email`, et `role` facultatif.

   *

   * Chaque ligne est traitee POUR ELLE-MEME : une adresse deja membre ou

   * malformee n'annule pas les autres. Le compte rendu dit ou en est chacune,

   * ce qui evite de renvoyer l'administrateur corriger son fichier a l'aveugle.

   *

   * Le refus global — pas de serveur de courriel — reste global : sans lui,

   * aucune ligne ne peut aboutir, et pretendre le contraire ligne par ligne

   * serait bavard pour rien.

   */

  async inviteEnMasse(

    tenantId: string,

    csv: string,

    organisationName: string,

  ): Promise<ApiInvitationLigne[]> {

    if (!(await this.mailer.isConfigured())) {

      throw new ServiceUnavailableException(

        "Aucun serveur de courriel n'est configuré sur cette instance : les invitations ne partiraient pas.",

      );

    }

    const { entetes, lignes } = parseCsvTable(csv);

    if (!entetes.includes('email')) {

      throw new BadRequestException("Le fichier doit comporter une colonne « email ».");

    }

    if (lignes.length === 0) {

      throw new BadRequestException('Aucune ligne à traiter.');

    }

    if (lignes.length > MAX_INVITATIONS_CSV) {

      throw new BadRequestException(

        `Trop de lignes : ${MAX_INVITATIONS_CSV} au plus par fichier.`,

      );

    }

    const resultats: ApiInvitationLigne[] = [];

    const vues = new Set<string>();

    for (const ligne of lignes) {

      if (ligne.vide) continue;

      // `numero` est celui du FICHIER, en-tete comprise : il correspond a ce que

      // l'administrateur voit dans son tableur.

      const numero = ligne.numero;

      const email = ligne.valeur('email', 'e-mail', 'courriel').trim().toLowerCase();

      if (!email) {

        resultats.push({ ligne: numero, email: '', etat: 'erreur', motif: 'Adresse absente' });

        continue;

      }

      if (vues.has(email)) {

        resultats.push({ ligne: numero, email, etat: 'ignoree', motif: 'Doublon dans le fichier' });

        continue;

      }

      vues.add(email);

      const role = ligne.valeur('role', 'rôle').trim().toUpperCase() || 'ANIMATOR';

      if (!isTenantRole(role)) {

        resultats.push({ ligne: numero, email, etat: 'erreur', motif: `Rôle inconnu : ${role}` });

        continue;

      }

      try {

        await this.invite(tenantId, email, role as UserRole, organisationName);

        resultats.push({ ligne: numero, email, etat: 'envoyee' });

      } catch (err) {

        const motif = err instanceof HttpException ? err.message : 'Invitation impossible';

        // « Déjà membre » n'est pas une erreur de l'administrateur : c'est un

        // état, et le distinguer évite de faire chercher une faute inexistante.

        const etat = /déjà membre/i.test(motif) ? 'ignoree' : 'erreur';

        resultats.push({ ligne: numero, email, etat, motif });

      }

    }

    return resultats;

  }

  // --- Consommation ---

  /** Ce qu'un lien propose, sans encore le consommer (pour l'afficher). */

  @IsString()

  role!: string;

}

/**

 * Invitation en masse depuis un CSV.

 *

 * La borne haute vaut pour ce qu'elle empeche : un fichier de plusieurs mega-

 * octets colle par megarde, dont chaque ligne declencherait un envoi.

 */

export class InviteCsvDto {

  @IsString()

  @MaxLength(200_000)

  csv!: string;

}