- {section.children.map(leaf => {
+ {visibleChildren.map(leaf => {
const leafActive = isLeafActive(leaf.path!, location);
const LeafIcon = leaf.icon;
return (
diff --git a/client/src/components/MasseSalarialeDataState.test.tsx b/client/src/components/MasseSalarialeDataState.test.tsx
new file mode 100644
index 0000000..68af2b9
--- /dev/null
+++ b/client/src/components/MasseSalarialeDataState.test.tsx
@@ -0,0 +1,27 @@
+import { renderToStaticMarkup } from 'react-dom/server';
+import { describe, expect, it } from 'vitest';
+import { MasseSalarialeDataState } from './MasseSalarialeDataState';
+
+describe('MasseSalarialeDataState', () => {
+ it.each([
+ ['loading', 'Chargement des données salariales…'],
+ ['error', "Les données de masse salariale n'ont pas pu être chargées."],
+ ['empty', "Aucune donnée salariale n'est encore importée."],
+ ] as const)('rend réellement le message %s', (state, expectedText) => {
+ const html = renderToStaticMarkup(
+
{'TABLEAU NE DOIT PAS ÊTRE VISIBLE'} ,
+ );
+ // Le rendu statique encode les apostrophes en entités HTML ; la
+ // normalisation permet de tester le texte effectivement affiché.
+ const visibleText = html.replaceAll(''', "'");
+ expect(visibleText).toContain(expectedText);
+ expect(html).not.toContain('TABLEAU NE DOIT PAS ÊTRE VISIBLE');
+ });
+
+ it('rend réellement le contenu du tableau lorsque les données sont prêtes', () => {
+ const html = renderToStaticMarkup(
+
TABLEAU PRÊT
,
+ );
+ expect(html).toContain('TABLEAU PRÊT');
+ });
+});
diff --git a/client/src/components/MasseSalarialeDataState.tsx b/client/src/components/MasseSalarialeDataState.tsx
new file mode 100644
index 0000000..423971d
--- /dev/null
+++ b/client/src/components/MasseSalarialeDataState.tsx
@@ -0,0 +1,31 @@
+import type { ReactNode } from 'react';
+import type { MasseSalarialeUiState } from '../lib/masseSalariale';
+import { Loader2 } from 'lucide-react';
+
+/**
+ * Rend les états de données de la page de paie. Ce composant isolé permet de
+ * vérifier le rendu effectif de chaque état sans exposer de donnée salariale.
+ */
+export function MasseSalarialeDataState({
+ state,
+ children,
+}: {
+ state: MasseSalarialeUiState;
+ children: ReactNode;
+}) {
+ if (state === 'loading') {
+ return (
+
+
+ );
+ }
+ if (state === 'error') {
+ return
Les données de masse salariale n'ont pas pu être chargées.
;
+ }
+ if (state === 'empty') {
+ return
Aucune donnée salariale n'est encore importée.
;
+ }
+ return <>{children};
+}
diff --git a/client/src/lib/masseSalariale.test.ts b/client/src/lib/masseSalariale.test.ts
new file mode 100644
index 0000000..874050b
--- /dev/null
+++ b/client/src/lib/masseSalariale.test.ts
@@ -0,0 +1,43 @@
+import { describe, expect, it } from 'vitest';
+import { getMasseSalarialeUiState, getMasseSalarialeYearSummary } from './masseSalariale';
+
+describe('getMasseSalarialeUiState', () => {
+ it('distingue chargement, erreur, absence de données et affichage prêt', () => {
+ expect(getMasseSalarialeUiState(true, false, 0)).toBe('loading');
+ expect(getMasseSalarialeUiState(false, true, 0)).toBe('error');
+ expect(getMasseSalarialeUiState(false, false, 0)).toBe('empty');
+ expect(getMasseSalarialeUiState(false, false, 1)).toBe('ready');
+ });
+});
+
+describe('getMasseSalarialeYearSummary', () => {
+ const rows = [
+ { annee: 2025, salaireAnnuelBrutAvecPrimesCents: 4_000_000, statut: 'annuel' },
+ { annee: 2025, salaireAnnuelBrutAvecPrimesCents: 5_500_000, statut: 'annuel' },
+ { annee: 2026, salaireAnnuelBrutAvecPrimesCents: 2_000_000, statut: 'cumul_provisoire' },
+ ];
+
+ it('calcule le total et le statut annuel pour un exercice clôturé', () => {
+ expect(getMasseSalarialeYearSummary(rows, 2025)).toEqual({
+ salaryCount: 2,
+ annualGrossWithBonusesCents: 9_500_000,
+ status: 'annuel',
+ });
+ });
+
+ it('préserve le statut provisoire pour une année en cours', () => {
+ expect(getMasseSalarialeYearSummary(rows, 2026)).toMatchObject({
+ salaryCount: 1,
+ annualGrossWithBonusesCents: 2_000_000,
+ status: 'cumul_provisoire',
+ });
+ });
+
+ it('retourne null et non zéro pour une année sans rémunération importée', () => {
+ expect(getMasseSalarialeYearSummary(rows, 2027)).toEqual({
+ salaryCount: 0,
+ annualGrossWithBonusesCents: null,
+ status: 'empty',
+ });
+ });
+});
diff --git a/client/src/lib/masseSalariale.ts b/client/src/lib/masseSalariale.ts
new file mode 100644
index 0000000..d3e94c4
--- /dev/null
+++ b/client/src/lib/masseSalariale.ts
@@ -0,0 +1,59 @@
+/** Fonctions pures partagées par l'interface Masse salariale et ses tests. */
+
+export type RemunerationForSummary = {
+ annee: number;
+ salaireAnnuelBrutAvecPrimesCents: number;
+ statut: string;
+};
+
+export type MasseSalarialeUiState = 'loading' | 'error' | 'empty' | 'ready';
+
+export type YearSummary = {
+ salaryCount: number;
+ annualGrossWithBonusesCents: number | null;
+ status: 'annuel' | 'cumul_provisoire' | 'mixed' | 'empty';
+};
+
+/**
+ * Centralise les quatre états visuels afin que le tableau ne puisse jamais
+ * présenter une absence de données comme un état chargé à zéro.
+ */
+export function getMasseSalarialeUiState(
+ isLoading: boolean,
+ isError: boolean,
+ salaryCount: number,
+): MasseSalarialeUiState {
+ if (isLoading) return 'loading';
+ if (isError) return 'error';
+ return salaryCount === 0 ? 'empty' : 'ready';
+}
+
+/**
+ * Agrège uniquement les rémunérations réellement importées d'un exercice.
+ * L'absence de ligne renvoie `null` pour distinguer « non renseigné » de 0 €.
+ */
+export function getMasseSalarialeYearSummary(
+ remunerations: RemunerationForSummary[],
+ annee: number,
+): YearSummary {
+ const rows = remunerations.filter((row) => row.annee === annee);
+ if (rows.length === 0) {
+ return { salaryCount: 0, annualGrossWithBonusesCents: null, status: 'empty' };
+ }
+
+ const statuses = new Set(rows.map((row) => row.statut));
+ const status = statuses.size === 1 && statuses.has('annuel')
+ ? 'annuel'
+ : statuses.size === 1 && statuses.has('cumul_provisoire')
+ ? 'cumul_provisoire'
+ : 'mixed';
+
+ return {
+ salaryCount: rows.length,
+ annualGrossWithBonusesCents: rows.reduce(
+ (sum, row) => sum + row.salaireAnnuelBrutAvecPrimesCents,
+ 0,
+ ),
+ status,
+ };
+}
diff --git a/client/src/pages/MasseSalariale.tsx b/client/src/pages/MasseSalariale.tsx
new file mode 100644
index 0000000..deada39
--- /dev/null
+++ b/client/src/pages/MasseSalariale.tsx
@@ -0,0 +1,267 @@
+// MasseSalariale.tsx — Données de rémunération SANTINOVA (accès administrateur)
+
+import { Fragment, useMemo, useState } from 'react';
+import { AppSidebar } from '../components/AppSidebar';
+import { MasseSalarialeDataState } from '../components/MasseSalarialeDataState';
+import { trpc } from '../lib/trpc';
+import { getMasseSalarialeUiState, getMasseSalarialeYearSummary } from '../lib/masseSalariale';
+import { toast } from 'sonner';
+import {
+ Banknote,
+ CalendarDays,
+ CircleAlert,
+ ShieldCheck,
+ Users,
+} from 'lucide-react';
+
+const ANNEES = [2025, 2026, 2027] as const;
+
+function formatEuros(cents?: number | null) {
+ if (cents === undefined || cents === null) return '—';
+ return new Intl.NumberFormat('fr-FR', {
+ style: 'currency',
+ currency: 'EUR',
+ maximumFractionDigits: 0,
+ }).format(cents / 100);
+}
+
+function formatPercent(bps?: number | null) {
+ if (bps === undefined || bps === null) return '—';
+ return `${(bps / 100).toLocaleString('fr-FR', { maximumFractionDigits: 2 })} %`;
+}
+
+function formatDate(isoDate?: string | null) {
+ if (!isoDate) return '—';
+ const [year, month, day] = isoDate.split('-');
+ return year && month && day ? `${day}/${month}/${year}` : isoDate;
+}
+
+function evolutionKey(salarieId: number, annee: number) {
+ return `${salarieId}-${annee}`;
+}
+
+/**
+ * Les revenus annuels sont strictement ceux présents dans les bulletins
+ * importés. L'évolution, elle, reste une hypothèse utilisateur distincte et
+ * n'engendre donc jamais un montant 2027 artificiel.
+ */
+export default function MasseSalariale() {
+ const [sidebarCollapsed, setSidebarCollapsed] = useState(false);
+ const [editingKey, setEditingKey] = useState
(null);
+ const [evolutionDraft, setEvolutionDraft] = useState('');
+ const utils = trpc.useUtils();
+ const { data, isLoading, isError } = trpc.masseSalariale.get.useQuery();
+ const setEvolution = trpc.masseSalariale.setEvolution.useMutation({
+ onSuccess: async () => {
+ await utils.masseSalariale.get.invalidate();
+ setEditingKey(null);
+ setEvolutionDraft('');
+ toast.success('Évolution salariale enregistrée');
+ },
+ onError: () => toast.error("L'évolution salariale n'a pas pu être enregistrée"),
+ });
+
+ const remunerationByKey = useMemo(
+ () => new Map((data?.remunerations ?? []).map((row) => [evolutionKey(row.salarieId, row.annee), row])),
+ [data?.remunerations],
+ );
+ const evolutionByKey = useMemo(
+ () => new Map((data?.evolutions ?? []).map((row) => [evolutionKey(row.salarieId, row.annee), row])),
+ [data?.evolutions],
+ );
+
+ const uiState = getMasseSalarialeUiState(isLoading, isError, data?.salaries.length ?? 0);
+ const totalsByYear = useMemo(
+ () => new Map(ANNEES.map((annee) => [
+ annee,
+ getMasseSalarialeYearSummary(data?.remunerations ?? [], annee),
+ ])),
+ [data?.remunerations],
+ );
+
+ const startEvolutionEdit = (salarieId: number, annee: number) => {
+ const key = evolutionKey(salarieId, annee);
+ const current = evolutionByKey.get(key)?.evolutionSalarialeBps;
+ setEditingKey(key);
+ setEvolutionDraft(current === undefined || current === null ? '' : String(current / 100));
+ };
+
+ const saveEvolution = (salarieId: number, annee: number) => {
+ const normalized = evolutionDraft.trim().replace(',', '.');
+ const percentage = Number(normalized);
+ if (!normalized || !Number.isFinite(percentage) || percentage < -100 || percentage > 100) {
+ toast.error('Saisissez une évolution comprise entre -100 % et 100 %.');
+ return;
+ }
+ setEvolution.mutate({ salarieId, annee, evolutionSalarialeBps: Math.round(percentage * 100) });
+ };
+
+ return (
+
+
setSidebarCollapsed((value) => !value)} />
+
+
+
+
+
+
+ {ANNEES.map((annee) => {
+ const total = totalsByYear.get(annee);
+ const isProvisional = total?.status === 'cumul_provisoire';
+ return (
+
+
+
+
+
+ {total?.status === 'annuel' ? 'Année clôturée' : isProvisional ? 'Cumul au dernier bulletin' : 'À renseigner'}
+
+
+ {formatEuros(total?.annualGrossWithBonusesCents)}
+
+
+ Brut avec primes — {total?.salaryCount ?? 0} salarié{(total?.salaryCount ?? 0) > 1 ? 's' : ''}
+
+
+ );
+ })}
+
+
+
+
+
+ 2025 est issu des cumuls annuels de décembre. 2026 est un cumul provisoire au dernier bulletin disponible pour chaque salarié (janvier à août). Aucun salaire 2027 n’est calculé automatiquement ; seules les évolutions peuvent être saisies.
+
+
+
+
+
+
+
+
+
Détail par salarié
+
Cliquez sur une évolution pour la saisir ou la modifier.
+
+
+
+
+
+
+ Salarié
+ Poste
+ Embauche
+ {ANNEES.map((annee) => {annee} )}
+
+
+ {ANNEES.flatMap((annee) => [
+ Annuel hors primes ,
+ Annuel avec primes ,
+ Mensuel hors primes ,
+ Taux charges ,
+ Évolution ,
+ ])}
+
+
+
+ {data?.salaries.map((salarie) => (
+
+
+ {salarie.nom} {salarie.prenom}
+ {salarie.matricule}
+
+ {salarie.poste}
+ {formatDate(salarie.dateEmbauche)}
+ {ANNEES.map((annee) => {
+ const remuneration = remunerationByKey.get(evolutionKey(salarie.id, annee));
+ const evolution = evolutionByKey.get(evolutionKey(salarie.id, annee));
+ const key = evolutionKey(salarie.id, annee);
+ return (
+
+ {formatEuros(remuneration?.salaireAnnuelBrutHorsPrimesCents)}
+ {formatEuros(remuneration?.salaireAnnuelBrutAvecPrimesCents)}
+ {formatEuros(remuneration?.salaireMensuelBrutHorsPrimesCents)}
+ {formatPercent(remuneration?.tauxChargeBps)}
+
+ {editingKey === key ? (
+
+ saveEvolution(salarie.id, annee)}
+ className="text-[11px] font-semibold text-emerald-700 hover:text-emerald-900 disabled:opacity-50"
+ disabled={setEvolution.isPending}
+ >
+ OK
+
+
+ ) : (
+ startEvolutionEdit(salarie.id, annee)}
+ className="min-w-20 rounded px-2 py-1 text-xs font-semibold text-emerald-700 hover:bg-emerald-50 focus:outline-none focus:ring-2 focus:ring-emerald-300"
+ title="Saisir l'évolution salariale"
+ >
+ {formatPercent(evolution?.evolutionSalarialeBps)}
+
+ )}
+
+
+ );
+ })}
+
+ ))}
+
+
+
+
+
+ ).mockResolvedValue(source);
+ const { ctx } = createAuthCtx({ role: "admin" });
+
+ await expect(appRouter.createCaller(ctx).masseSalariale.get()).resolves.toEqual(source);
+ });
+
+ it("interdit la consultation à un profil standard", async () => {
+ const { ctx } = createAuthCtx({ role: "standard" });
+
+ await expect(appRouter.createCaller(ctx).masseSalariale.get()).rejects.toThrow();
+ });
+
+ it("importe les données validées uniquement pour un administrateur", async () => {
+ const { db } = await import("./db").then(m => ({ db: m }));
+ (db.importMasseSalariale as ReturnType).mockResolvedValue({ salaries: 1, remunerations: 1 });
+ const { ctx } = createAuthCtx({ role: "admin" });
+ const salaries = [{
+ matricule: "000001",
+ nom: "DUPONT",
+ prenom: "Alice",
+ poste: "Responsable administratif",
+ dateEmbauche: "2024-01-01",
+ }];
+ const remunerations = [{
+ matricule: "000001",
+ annee: 2026,
+ salaireAnnuelBrutHorsPrimesCents: 36_000_00,
+ salaireAnnuelBrutAvecPrimesCents: 40_000_00,
+ salaireMensuelBrutHorsPrimesCents: 3_000_00,
+ tauxChargeBps: 5_500,
+ periodeReference: "2026-08",
+ statut: "cumul_provisoire" as const,
+ source: "bulletin",
+ }];
+
+ await expect(appRouter.createCaller(ctx).masseSalariale.import({ salaries, remunerations }))
+ .resolves.toEqual({ salaries: 1, remunerations: 1 });
+ expect(db.importMasseSalariale).toHaveBeenCalledWith(salaries, remunerations);
+ });
+
+ it("interdit l'import de rémunérations à un profil standard", async () => {
+ const { db } = await import("./db").then(m => ({ db: m }));
+ const { ctx } = createAuthCtx({ role: "standard" });
+
+ await expect(appRouter.createCaller(ctx).masseSalariale.import({ salaries: [], remunerations: [] })).rejects.toThrow();
+ expect(db.importMasseSalariale).not.toHaveBeenCalled();
+ });
+
+ it("enregistre l'évolution manuelle avec l'identifiant de l'administrateur", async () => {
+ const { db } = await import("./db").then(m => ({ db: m }));
+ const { ctx } = createAuthCtx({ id: 42, role: "admin" });
+
+ await expect(appRouter.createCaller(ctx).masseSalariale.setEvolution({
+ salarieId: 7,
+ annee: 2027,
+ evolutionSalarialeBps: 250,
+ })).resolves.toEqual({ success: true });
+
+ expect(db.setMasseSalarialeEvolution).toHaveBeenCalledWith({
+ salarieId: 7,
+ annee: 2027,
+ evolutionSalarialeBps: 250,
+ createdBy: 42,
+ });
+ });
+
+ it("rejette un taux d'évolution hors plage avant l'accès à la base", async () => {
+ const { db } = await import("./db").then(m => ({ db: m }));
+ const { ctx } = createAuthCtx({ role: "admin" });
+
+ await expect(appRouter.createCaller(ctx).masseSalariale.setEvolution({
+ salarieId: 7,
+ annee: 2027,
+ evolutionSalarialeBps: 10_001,
+ })).rejects.toThrow();
+ expect(db.setMasseSalarialeEvolution).not.toHaveBeenCalled();
+ });
+});
diff --git a/server/db.ts b/server/db.ts
index 2d150ef..b37fb79 100644
--- a/server/db.ts
+++ b/server/db.ts
@@ -5,11 +5,17 @@ import {
etablissements,
InsertCapexLigne,
InsertEtablissement,
+ InsertMasseSalarialeEvolution,
+ InsertMasseSalarialeRemuneration,
+ InsertMasseSalarialeSalarie,
InsertOpexMontantEtab,
InsertOpexPoste,
InsertUser,
inventaireMeta,
inventairePostes,
+ masseSalarialeEvolutions,
+ masseSalarialeRemunerations,
+ masseSalarialeSalaries,
opexBasesRepartition,
opexMontantsEtab,
opexPostes,
@@ -448,3 +454,108 @@ export async function importOpexBasesRepartition(
);
});
}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// MASSE SALARIALE — accès exclusivement appelés par des procédures admin
+// ─────────────────────────────────────────────────────────────────────────────
+
+export type MasseSalarialeImportSalarie = Pick<
+ InsertMasseSalarialeSalarie,
+ "matricule" | "nom" | "prenom" | "poste" | "dateEmbauche"
+>;
+
+export type MasseSalarialeImportRemuneration = Omit<
+ InsertMasseSalarialeRemuneration,
+ "id" | "salarieId" | "createdAt" | "updatedAt"
+> & { matricule: string };
+
+/**
+ * Retourne les trois sources normalisées séparément. Le routeur réalise la
+ * jointure logique afin d'éviter une matrice SQL qui dupliquerait les années.
+ */
+export async function getMasseSalariale() {
+ const db = await getDb();
+ if (!db) throw new Error("Database not available");
+ const [salaries, remunerations, evolutions] = await Promise.all([
+ db.select().from(masseSalarialeSalaries).orderBy(asc(masseSalarialeSalaries.nom), asc(masseSalarialeSalaries.prenom)),
+ db.select().from(masseSalarialeRemunerations),
+ db.select().from(masseSalarialeEvolutions),
+ ]);
+ return { salaries, remunerations, evolutions };
+}
+
+/**
+ * Import idempotent : les salaires et leurs rémunérations annuelles sont
+ * remplacés dans une transaction, sans modifier les évolutions saisies à la
+ * main qui résident dans une table distincte.
+ */
+export async function importMasseSalariale(
+ salaries: MasseSalarialeImportSalarie[],
+ remunerations: MasseSalarialeImportRemuneration[],
+) {
+ const db = await getDb();
+ if (!db) throw new Error("Database not available");
+ if (salaries.length === 0) return { salaries: 0, remunerations: 0 };
+
+ return db.transaction(async (tx) => {
+ for (const salarie of salaries) {
+ await tx
+ .insert(masseSalarialeSalaries)
+ .values({ ...salarie, actif: true })
+ .onDuplicateKeyUpdate({
+ set: {
+ nom: salarie.nom,
+ prenom: salarie.prenom,
+ poste: salarie.poste,
+ dateEmbauche: salarie.dateEmbauche,
+ actif: true,
+ },
+ });
+ }
+
+ const persistedSalaries = await tx
+ .select({ id: masseSalarialeSalaries.id, matricule: masseSalarialeSalaries.matricule })
+ .from(masseSalarialeSalaries);
+ const idsByMatricule = new Map(persistedSalaries.map((row) => [row.matricule, row.id]));
+
+ for (const remuneration of remunerations) {
+ const salarieId = idsByMatricule.get(remuneration.matricule);
+ if (!salarieId) {
+ throw new Error(`Salarié introuvable lors de l'import : ${remuneration.matricule}`);
+ }
+ const { matricule: _matricule, ...values } = remuneration;
+ await tx
+ .insert(masseSalarialeRemunerations)
+ .values({ ...values, salarieId })
+ .onDuplicateKeyUpdate({
+ set: {
+ salaireAnnuelBrutHorsPrimesCents: values.salaireAnnuelBrutHorsPrimesCents,
+ salaireAnnuelBrutAvecPrimesCents: values.salaireAnnuelBrutAvecPrimesCents,
+ salaireMensuelBrutHorsPrimesCents: values.salaireMensuelBrutHorsPrimesCents,
+ tauxChargeBps: values.tauxChargeBps,
+ periodeReference: values.periodeReference,
+ statut: values.statut,
+ source: values.source,
+ },
+ });
+ }
+ return { salaries: salaries.length, remunerations: remunerations.length };
+ });
+}
+
+/** Sauvegarde l'évolution manuelle sans dépendre de l'existence d'un bulletin. */
+export async function setMasseSalarialeEvolution(
+ input: Pick,
+) {
+ const db = await getDb();
+ if (!db) throw new Error("Database not available");
+ await db
+ .insert(masseSalarialeEvolutions)
+ .values(input)
+ .onDuplicateKeyUpdate({
+ set: {
+ evolutionSalarialeBps: input.evolutionSalarialeBps,
+ createdBy: input.createdBy,
+ },
+ });
+}
diff --git a/server/routers.ts b/server/routers.ts
index e4bfa1f..c9c9ddd 100644
--- a/server/routers.ts
+++ b/server/routers.ts
@@ -248,6 +248,47 @@ export const appRouter = router({
}),
}),
+ // Les données de rémunération sont sensibles : aucune procédure de ce
+ // sous-routeur n'est accessible aux profils standard ou lecture seule.
+ masseSalariale: router({
+ get: adminProcedure.query(async () => db.getMasseSalariale()),
+
+ import: adminProcedure
+ .input(z.object({
+ salaries: z.array(z.object({
+ matricule: z.string().trim().min(1).max(32),
+ nom: z.string().trim().min(1).max(150),
+ prenom: z.string().trim().min(1).max(150),
+ poste: z.string().trim().min(1).max(255),
+ dateEmbauche: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Date d'embauche invalide"),
+ })).min(1).max(500),
+ remunerations: z.array(z.object({
+ matricule: z.string().trim().min(1).max(32),
+ annee: z.number().int().min(2000).max(2100),
+ salaireAnnuelBrutHorsPrimesCents: z.number().int().min(0).max(100_000_000),
+ salaireAnnuelBrutAvecPrimesCents: z.number().int().min(0).max(100_000_000),
+ salaireMensuelBrutHorsPrimesCents: z.number().int().min(0).max(10_000_000),
+ tauxChargeBps: z.number().int().min(0).max(100_000),
+ periodeReference: z.string().regex(/^\d{4}-\d{2}$/).nullable().optional(),
+ statut: z.enum(["annuel", "cumul_provisoire"]),
+ source: z.string().trim().min(1).max(64),
+ })).max(1_500),
+ }))
+ .mutation(async ({ input }) => db.importMasseSalariale(input.salaries, input.remunerations)),
+
+ setEvolution: adminProcedure
+ .input(z.object({
+ salarieId: z.number().int().positive(),
+ annee: z.number().int().min(2000).max(2100),
+ // ±100 % maximum : protège contre les erreurs de virgule dans la saisie.
+ evolutionSalarialeBps: z.number().int().min(-10_000).max(10_000),
+ }))
+ .mutation(async ({ input, ctx }) => {
+ await db.setMasseSalarialeEvolution({ ...input, createdBy: ctx.user.id });
+ return { success: true };
+ }),
+ }),
+
inventaire: router({
get: protectedProcedure
.input(z.object({ annee: z.number() }))
diff --git a/todo.md b/todo.md
index 92fdbc1..76401e7 100644
--- a/todo.md
+++ b/todo.md
@@ -105,3 +105,24 @@
- [x] Constater l'échec du commit 3b52527 puis confirmer le redéploiement du correctif ec597da
- [x] Diagnostiquer et corriger le routage du webhook vers le déploiement Budget SI
- [x] Déclencher et valider le workflow CI requis avant le redéploiement
+
+## Module Masse salariale Santinova
+- [x] Analyser les bulletins 2025 et 2026 fournis et relever les champs fiables
+- [x] Consolider les bulletins complémentaires de janvier à avril 2026 avec ceux de mai à août
+- [x] Résoudre les bulletins multiples d'un même matricule sur une période par une règle métier documentée
+- [x] Produire un jeu consolidé 2026 sans doublon par salarié et par année
+- [x] Créer le schéma BDD sécurisé pour les salariés et leurs rémunérations annuelles
+- [x] Restreindre le module Masse salariale aux administrateurs
+- [x] Créer les procédures tRPC de consultation, import et modification de l'évolution salariale
+- [x] Ajouter l'entrée de menu et la page Masse salariale avec tableau 2025–2027
+- [x] Importer les données contrôlées depuis les bulletins de salaire
+- [x] Tester le rendu réel des états d'interface : chargement, erreur, vide et affichage prêt
+- [x] Ajouter des tests d'agrégation : totaux annuels, statut annuel/provisoire et absence de valeur fictive 2027
+- [x] Documenter que l'import de bulletins est un import initial contrôlé hors interface, et prévoir son extension future
+
+## Vérification des exportations de factures
+- [x] Vérifier le projet Budget SI : aucun flux ou chemin d'export de factures BAP ou d'abonnement n'y est configuré
+- [x] Annulé : demande posée dans une autre application
+
+## Reprise du module Masse salariale
+- [x] Finaliser les validations et la documentation du module Masse salariale
diff --git a/vitest.config.ts b/vitest.config.ts
index 643de32..940f922 100644
--- a/vitest.config.ts
+++ b/vitest.config.ts
@@ -5,6 +5,11 @@ const templateRoot = path.resolve(import.meta.dirname);
export default defineConfig({
root: templateRoot,
+ // Le build Vite utilise la transformation JSX automatique de React 19.
+ // Vitest doit appliquer la même convention aux composants de test TSX.
+ esbuild: {
+ jsx: "automatic",
+ },
resolve: {
alias: {
"@": path.resolve(templateRoot, "client", "src"),
@@ -14,6 +19,12 @@ export default defineConfig({
},
test: {
environment: "node",
- include: ["server/**/*.test.ts", "server/**/*.spec.ts", "client/**/*.test.ts", "shared/**/*.test.ts"],
+ include: [
+ "server/**/*.test.ts",
+ "server/**/*.spec.ts",
+ "client/**/*.test.ts",
+ "client/**/*.test.tsx",
+ "shared/**/*.test.ts",
+ ],
},
});