601 lines
25 KiB
TypeScript
601 lines
25 KiB
TypeScript
import { TRPCError } from "@trpc/server";
|
|
import { z } from "zod";
|
|
import {
|
|
assignEtablissementToUser,
|
|
authenticateLocalUser,
|
|
createDemandeContact,
|
|
createBlocFonctionnel,
|
|
updateBlocFonctionnel,
|
|
deleteBlocFonctionnel,
|
|
createEditeur,
|
|
updateEditeur,
|
|
deleteEditeur,
|
|
createLocalUser,
|
|
createSolution,
|
|
updateSolution,
|
|
deleteSolution,
|
|
getStatistiques,
|
|
deleteLogicielEtablissement,
|
|
deleteUser,
|
|
getAllDemandes,
|
|
getAllEtablissements,
|
|
getAllUsersWithAffectations,
|
|
getAffectationsByUser,
|
|
getBlocsFonctionnels,
|
|
getConsultationCount,
|
|
getConsultationsList,
|
|
getDemandeById,
|
|
getDemandesByDemandeur,
|
|
getDemandesRecuesParEtablissement,
|
|
getEditeurs,
|
|
getEtablissementById,
|
|
getEtablissementsByAdherent,
|
|
getEtablissementsByReferent,
|
|
getLogicielsByEtablissement,
|
|
getMesSolutionsGroupees,
|
|
getToutesLesSolutionsGroupees,
|
|
getSolutions,
|
|
recordConsultation,
|
|
removeEtablissementFromUser,
|
|
repondreDemandeContact,
|
|
setAffectationsForUser,
|
|
getUsersForEtablissement,
|
|
setReferentForEtablissement,
|
|
setAdherentsForEtablissement,
|
|
updateLocalPassword,
|
|
updateUser,
|
|
updateUserCgu,
|
|
updateUserSonumRole,
|
|
upsertLogicielEtablissement,
|
|
upsertUser,
|
|
} from "./db";
|
|
import { COOKIE_NAME } from "@shared/const";
|
|
import { getSessionCookieOptions } from "./_core/cookies";
|
|
import { systemRouter } from "./_core/systemRouter";
|
|
import { protectedProcedure, publicProcedure, router } from "./_core/trpc";
|
|
import { notifyOwner } from "./_core/notification";
|
|
import { getDb } from "./db";
|
|
import { etablissements } from "../drizzle/schema";
|
|
import { eq } from "drizzle-orm";
|
|
import { sdk } from "./_core/sdk";
|
|
|
|
// ─── Middleware gestionnaire SONUM ────────────────────────────────────────────
|
|
|
|
const gestionnaireProcedure = protectedProcedure.use(({ ctx, next }) => {
|
|
if (ctx.user.sonumRole !== "gestionnaire" && ctx.user.role !== "admin") {
|
|
throw new TRPCError({ code: "FORBIDDEN", message: "Accès réservé aux gestionnaires SONUM" });
|
|
}
|
|
return next({ ctx });
|
|
});
|
|
|
|
/** Bloque les mutations pour les utilisateurs en lecture seule (role === 'readonly') */
|
|
const writeProcedure = protectedProcedure.use(({ ctx, next }) => {
|
|
if (ctx.user.role === "readonly") {
|
|
throw new TRPCError({ code: "FORBIDDEN", message: "Votre compte est en lecture seule. Contactez un gestionnaire SONUM pour obtenir les droits de modification." });
|
|
}
|
|
return next({ ctx });
|
|
});
|
|
|
|
// ─── Router principal ─────────────────────────────────────────────────────────
|
|
|
|
export const appRouter = router({
|
|
system: systemRouter,
|
|
|
|
// ─── Auth ──────────────────────────────────────────────────────────────────
|
|
auth: router({
|
|
me: publicProcedure.query((opts) => opts.ctx.user),
|
|
|
|
logout: publicProcedure.mutation(({ ctx }) => {
|
|
const cookieOptions = getSessionCookieOptions(ctx.req);
|
|
ctx.res.clearCookie(COOKIE_NAME, { ...cookieOptions, maxAge: -1 });
|
|
return { success: true } as const;
|
|
}),
|
|
|
|
/**
|
|
* Connexion locale par email + mot de passe.
|
|
* Crée un cookie de session identique à celui de l'OAuth.
|
|
*/
|
|
loginLocal: publicProcedure
|
|
.input(z.object({
|
|
// Accepte email ou login court
|
|
email: z.string().min(1),
|
|
password: z.string().min(1),
|
|
}))
|
|
.mutation(async ({ input, ctx }) => {
|
|
const user = await authenticateLocalUser(input.email, input.password);
|
|
if (!user) {
|
|
throw new TRPCError({ code: "UNAUTHORIZED", message: "Identifiant ou mot de passe incorrect" });
|
|
}
|
|
|
|
// Créer un token de session avec l'openId de l'utilisateur local
|
|
// Le champ name doit être non vide pour passer la vérification JWT
|
|
const displayName = user.name
|
|
|| [user.firstName, user.lastName].filter(Boolean).join(' ')
|
|
|| user.login
|
|
|| user.email
|
|
|| 'Utilisateur';
|
|
const sessionToken = await sdk.createSessionToken(user.openId!, {
|
|
name: displayName,
|
|
});
|
|
|
|
const cookieOptions = getSessionCookieOptions(ctx.req);
|
|
ctx.res.cookie(COOKIE_NAME, sessionToken, {
|
|
...cookieOptions,
|
|
maxAge: 1000 * 60 * 60 * 24 * 365, // 1 an
|
|
});
|
|
|
|
return { success: true, user };
|
|
}),
|
|
}),
|
|
|
|
// ─── CGU ───────────────────────────────────────────────────────────────────
|
|
cgu: router({
|
|
accept: protectedProcedure.mutation(async ({ ctx }) => {
|
|
await updateUserCgu(ctx.user.id);
|
|
return { success: true };
|
|
}),
|
|
status: protectedProcedure.query(({ ctx }) => ({
|
|
// La CGU doit être acceptée à chaque session (pas seulement la première fois)
|
|
// On retourne toujours les données réelles mais le frontend gère la session
|
|
accepted: ctx.user.cguAccepted,
|
|
acceptedAt: ctx.user.cguAcceptedAt,
|
|
userId: ctx.user.id,
|
|
})),
|
|
}),
|
|
|
|
// ─── Référentiel ───────────────────────────────────────────────────────────
|
|
referentiel: router({
|
|
editeurs: publicProcedure.query(() => getEditeurs()),
|
|
blocsFonctionnels: publicProcedure.query(() => getBlocsFonctionnels()),
|
|
solutions: publicProcedure
|
|
.input(z.object({ search: z.string().optional() }))
|
|
.query(({ input }) => getSolutions(input.search)),
|
|
|
|
createEditeur: protectedProcedure
|
|
.input(z.object({ nom: z.string().min(1) }))
|
|
.mutation(async ({ input, ctx }) => {
|
|
const isGestionnaire = ctx.user.sonumRole === "gestionnaire" || ctx.user.role === "admin";
|
|
return createEditeur(input.nom, isGestionnaire);
|
|
}),
|
|
|
|
createBlocFonctionnel: protectedProcedure
|
|
.input(z.object({ nom: z.string().min(1) }))
|
|
.mutation(async ({ input, ctx }) => {
|
|
const isGestionnaire = ctx.user.sonumRole === "gestionnaire" || ctx.user.role === "admin";
|
|
return createBlocFonctionnel(input.nom, isGestionnaire);
|
|
}),
|
|
updateBlocFonctionnel: gestionnaireProcedure
|
|
.input(z.object({ id: z.number().int(), nom: z.string().min(1) }))
|
|
.mutation(({ input }) => updateBlocFonctionnel(input.id, input.nom)),
|
|
deleteBlocFonctionnel: gestionnaireProcedure
|
|
.input(z.object({ id: z.number().int() }))
|
|
.mutation(({ input }) => deleteBlocFonctionnel(input.id)),
|
|
updateEditeur: gestionnaireProcedure
|
|
.input(z.object({ id: z.number().int(), nom: z.string().min(1) }))
|
|
.mutation(({ input }) => updateEditeur(input.id, input.nom)),
|
|
deleteEditeur: gestionnaireProcedure
|
|
.input(z.object({ id: z.number().int() }))
|
|
.mutation(({ input }) => deleteEditeur(input.id)),
|
|
statistiques: gestionnaireProcedure.query(() => getStatistiques()),
|
|
|
|
createSolution: protectedProcedure
|
|
.input(z.object({
|
|
nom: z.string().min(1),
|
|
editeurId: z.number().int(),
|
|
blocFonctionnelId: z.number().int().optional().nullable(),
|
|
}))
|
|
.mutation(async ({ input, ctx }) => {
|
|
const isGestionnaire = ctx.user.sonumRole === "gestionnaire" || ctx.user.role === "admin";
|
|
return createSolution(input.nom, input.editeurId, input.blocFonctionnelId, isGestionnaire);
|
|
}),
|
|
updateSolution: protectedProcedure
|
|
.input(z.object({
|
|
id: z.number().int(),
|
|
nom: z.string().min(1),
|
|
editeurId: z.number().int(),
|
|
blocFonctionnelId: z.number().int().optional().nullable(),
|
|
}))
|
|
.mutation(async ({ input, ctx }) => {
|
|
if (ctx.user.sonumRole !== "gestionnaire" && ctx.user.role !== "admin") throw new TRPCError({ code: "FORBIDDEN" });
|
|
return updateSolution(input.id, input.nom, input.editeurId, input.blocFonctionnelId ?? null);
|
|
}),
|
|
deleteSolution: protectedProcedure
|
|
.input(z.object({ id: z.number().int() }))
|
|
.mutation(async ({ input, ctx }) => {
|
|
if (ctx.user.sonumRole !== "gestionnaire" && ctx.user.role !== "admin") throw new TRPCError({ code: "FORBIDDEN" });
|
|
return deleteSolution(input.id);
|
|
}),
|
|
}),
|
|
|
|
// ─── Établissements ────────────────────────────────────────────────────────
|
|
etablissements: router({
|
|
/**
|
|
* Retourne les établissements selon le rôle :
|
|
* - référent : ses établissements
|
|
* - adhérent : ses établissements affectés
|
|
* - gestionnaire : tous
|
|
*/
|
|
mesEtablissements: protectedProcedure.query(({ ctx }) => {
|
|
if (ctx.user.sonumRole === "gestionnaire" || ctx.user.role === "admin") {
|
|
return getAllEtablissements();
|
|
}
|
|
if (ctx.user.sonumRole === "adherent") {
|
|
return getEtablissementsByAdherent(ctx.user.id);
|
|
}
|
|
return getEtablissementsByReferent(ctx.user.id);
|
|
}),
|
|
|
|
all: gestionnaireProcedure.query(() => getAllEtablissements()),
|
|
|
|
byId: protectedProcedure
|
|
.input(z.object({ id: z.number().int() }))
|
|
.query(async ({ input, ctx }) => {
|
|
const etab = await getEtablissementById(input.id);
|
|
if (!etab) throw new TRPCError({ code: "NOT_FOUND" });
|
|
// Adhérent : vérifier qu'il a accès à cet établissement
|
|
if (ctx.user.sonumRole === "adherent") {
|
|
const affectations = await getAffectationsByUser(ctx.user.id);
|
|
if (!affectations.includes(input.id)) {
|
|
throw new TRPCError({ code: "FORBIDDEN" });
|
|
}
|
|
}
|
|
if (etab.visibilite === "gestionnaires" && ctx.user.sonumRole !== "gestionnaire" && ctx.user.role !== "admin") {
|
|
if (etab.referentId !== ctx.user.id) {
|
|
throw new TRPCError({ code: "FORBIDDEN" });
|
|
}
|
|
}
|
|
return etab;
|
|
}),
|
|
|
|
search: protectedProcedure
|
|
.input(z.object({
|
|
solutionId: z.number().int().optional(),
|
|
editeurId: z.number().int().optional(),
|
|
blocFonctionnelId: z.number().int().optional(),
|
|
region: z.string().optional(),
|
|
typeActivite: z.string().optional(),
|
|
tailleEffectifs: z.string().optional(),
|
|
etatDeploiement: z.string().optional(),
|
|
}))
|
|
.query(({ input, ctx }) => {
|
|
return import("./db").then(({ searchEtablissements }) =>
|
|
searchEtablissements({
|
|
...input,
|
|
userId: ctx.user.id,
|
|
sonumRole: ctx.user.sonumRole,
|
|
})
|
|
);
|
|
}),
|
|
|
|
create: gestionnaireProcedure
|
|
.input(z.object({
|
|
finess: z.string().optional(),
|
|
nom: z.string().min(1),
|
|
region: z.string().optional(),
|
|
departement: z.string().optional(),
|
|
typeActivite: z.string().optional(),
|
|
tailleEffectifs: z.string().optional(),
|
|
referentId: z.number().int().optional(),
|
|
}))
|
|
.mutation(async ({ input }) => {
|
|
const db = await getDb();
|
|
if (!db) throw new TRPCError({ code: "INTERNAL_SERVER_ERROR" });
|
|
const result = await db.insert(etablissements).values(input);
|
|
return result[0];
|
|
}),
|
|
|
|
update: protectedProcedure
|
|
.input(z.object({
|
|
id: z.number().int(),
|
|
visibilite: z.enum(["tous", "gestionnaires"]).optional(),
|
|
accepteMiseEnRelation: z.boolean().optional(),
|
|
}))
|
|
.mutation(async ({ input, ctx }) => {
|
|
const etab = await getEtablissementById(input.id);
|
|
if (!etab) throw new TRPCError({ code: "NOT_FOUND" });
|
|
if (etab.referentId !== ctx.user.id && ctx.user.sonumRole !== "gestionnaire" && ctx.user.role !== "admin") {
|
|
throw new TRPCError({ code: "FORBIDDEN" });
|
|
}
|
|
const db = await getDb();
|
|
if (!db) throw new TRPCError({ code: "INTERNAL_SERVER_ERROR" });
|
|
const { id, ...updateData } = input;
|
|
await db.update(etablissements).set(updateData).where(eq(etablissements.id, id));
|
|
return { success: true };
|
|
}),
|
|
}),
|
|
|
|
// ─── Logiciels ─────────────────────────────────────────────────────────────
|
|
logiciels: router({
|
|
byEtablissement: protectedProcedure
|
|
.input(z.object({ etablissementId: z.number().int() }))
|
|
.query(async ({ input, ctx }) => {
|
|
const etab = await getEtablissementById(input.etablissementId);
|
|
if (!etab) throw new TRPCError({ code: "NOT_FOUND" });
|
|
// Adhérent : vérifier affectation
|
|
if (ctx.user.sonumRole === "adherent") {
|
|
const affectations = await getAffectationsByUser(ctx.user.id);
|
|
if (!affectations.includes(input.etablissementId)) throw new TRPCError({ code: "FORBIDDEN" });
|
|
}
|
|
if (etab.visibilite === "gestionnaires" && ctx.user.sonumRole !== "gestionnaire" && ctx.user.role !== "admin") {
|
|
if (etab.referentId !== ctx.user.id) throw new TRPCError({ code: "FORBIDDEN" });
|
|
}
|
|
return getLogicielsByEtablissement(input.etablissementId);
|
|
}),
|
|
|
|
upsert: protectedProcedure
|
|
.input(z.object({
|
|
id: z.number().int().optional(),
|
|
etablissementId: z.number().int(),
|
|
solutionId: z.number().int(),
|
|
etatDeploiement: z.enum(["demarrage", "en_cours", "operationnel", "en_remplacement"]),
|
|
modeHebergement: z.enum(["hds", "on_premise", "hybride"]).optional().nullable(),
|
|
modeFacturation: z.enum(["saas", "achat_maintenance", "location"]).optional().nullable(),
|
|
interoperabilite: z.enum(["non", "oui_interface", "oui_eai"]).optional().nullable(),
|
|
versionMajeure: z.string().optional().nullable(),
|
|
commentaire: z.string().optional().nullable(),
|
|
contactNom: z.string().optional().nullable(),
|
|
contactFonction: z.string().optional().nullable(),
|
|
contactEmail: z.string().optional().nullable(),
|
|
}))
|
|
.mutation(async ({ input, ctx }) => {
|
|
const etab = await getEtablissementById(input.etablissementId);
|
|
if (!etab) throw new TRPCError({ code: "NOT_FOUND" });
|
|
if (etab.referentId !== ctx.user.id && ctx.user.sonumRole !== "gestionnaire" && ctx.user.role !== "admin") {
|
|
throw new TRPCError({ code: "FORBIDDEN" });
|
|
}
|
|
if (ctx.user.role === "readonly") throw new TRPCError({ code: "FORBIDDEN", message: "Compte en lecture seule" });
|
|
return upsertLogicielEtablissement({ ...input, saisiePar: ctx.user.id });
|
|
}),
|
|
|
|
delete: protectedProcedure
|
|
.input(z.object({ id: z.number().int(), etablissementId: z.number().int() }))
|
|
.mutation(async ({ input, ctx }) => {
|
|
if (ctx.user.role === "readonly") throw new TRPCError({ code: "FORBIDDEN", message: "Compte en lecture seule" });
|
|
const etab = await getEtablissementById(input.etablissementId);
|
|
if (!etab) throw new TRPCError({ code: "NOT_FOUND" });
|
|
if (etab.referentId !== ctx.user.id && ctx.user.sonumRole !== "gestionnaire" && ctx.user.role !== "admin") {
|
|
throw new TRPCError({ code: "FORBIDDEN" });
|
|
}
|
|
await deleteLogicielEtablissement(input.id);
|
|
return { success: true };
|
|
}),
|
|
mesSolutions: protectedProcedure
|
|
.query(({ ctx }) =>
|
|
getMesSolutionsGroupees(ctx.user.id, ctx.user.sonumRole ?? "referent")
|
|
),
|
|
toutesLesSolutions: protectedProcedure
|
|
.query(() => getToutesLesSolutionsGroupees()),
|
|
}),
|
|
|
|
// ─── Traçabilité ───────────────────────────────────────────────────────────
|
|
tracabilite: router({
|
|
enregistrerConsultation: protectedProcedure
|
|
.input(z.object({ etablissementId: z.number().int() }))
|
|
.mutation(async ({ input, ctx }) => {
|
|
await recordConsultation(input.etablissementId, ctx.user.id, ctx.user.name ?? "Inconnu");
|
|
return { success: true };
|
|
}),
|
|
|
|
compteur: protectedProcedure
|
|
.input(z.object({ etablissementId: z.number().int() }))
|
|
.query(async ({ input, ctx }) => {
|
|
const etab = await getEtablissementById(input.etablissementId);
|
|
if (!etab) throw new TRPCError({ code: "NOT_FOUND" });
|
|
const canSee = etab.referentId === ctx.user.id || ctx.user.sonumRole === "gestionnaire" || ctx.user.role === "admin";
|
|
if (!canSee) throw new TRPCError({ code: "FORBIDDEN" });
|
|
return { count: await getConsultationCount(input.etablissementId) };
|
|
}),
|
|
|
|
liste: protectedProcedure
|
|
.input(z.object({ etablissementId: z.number().int() }))
|
|
.query(async ({ input, ctx }) => {
|
|
const etab = await getEtablissementById(input.etablissementId);
|
|
if (!etab) throw new TRPCError({ code: "NOT_FOUND" });
|
|
const canSee = etab.referentId === ctx.user.id || ctx.user.sonumRole === "gestionnaire" || ctx.user.role === "admin";
|
|
if (!canSee) throw new TRPCError({ code: "FORBIDDEN" });
|
|
return getConsultationsList(input.etablissementId);
|
|
}),
|
|
}),
|
|
|
|
// ─── Demandes de Contact ───────────────────────────────────────────────────
|
|
contact: router({
|
|
envoyer: writeProcedure
|
|
.input(z.object({
|
|
etablissementCibleId: z.number().int(),
|
|
message: z.string().min(1),
|
|
}))
|
|
.mutation(async ({ input, ctx }) => {
|
|
const etab = await getEtablissementById(input.etablissementCibleId);
|
|
if (!etab) throw new TRPCError({ code: "NOT_FOUND" });
|
|
|
|
await createDemandeContact({
|
|
etablissementCibleId: input.etablissementCibleId,
|
|
demandeurId: ctx.user.id,
|
|
demandeurNom: ctx.user.name ?? "Inconnu",
|
|
demandeurEmail: ctx.user.email ?? "",
|
|
message: input.message,
|
|
});
|
|
|
|
await notifyOwner({
|
|
title: `Nouvelle demande de contact — ${etab.nom}`,
|
|
content: `${ctx.user.name} souhaite contacter le référent de ${etab.nom}.\n\nMessage : ${input.message}`,
|
|
});
|
|
|
|
return { success: true };
|
|
}),
|
|
|
|
mesDemandes: protectedProcedure.query(({ ctx }) =>
|
|
getDemandesByDemandeur(ctx.user.id)
|
|
),
|
|
|
|
demandesRecues: protectedProcedure.query(({ ctx }) =>
|
|
getDemandesRecuesParEtablissement(ctx.user.id)
|
|
),
|
|
|
|
toutesLesDemandes: gestionnaireProcedure.query(() => getAllDemandes()),
|
|
|
|
repondre: protectedProcedure
|
|
.input(z.object({
|
|
id: z.number().int(),
|
|
reponse: z.string().min(1),
|
|
}))
|
|
.mutation(async ({ input, ctx }) => {
|
|
const demande = await getDemandeById(input.id);
|
|
if (!demande) throw new TRPCError({ code: "NOT_FOUND" });
|
|
const etab = await getEtablissementById(demande.etablissementCibleId);
|
|
const canReply = (etab?.referentId === ctx.user.id) || ctx.user.sonumRole === "gestionnaire" || ctx.user.role === "admin";
|
|
if (!canReply) throw new TRPCError({ code: "FORBIDDEN" });
|
|
await repondreDemandeContact(input.id, input.reponse, ctx.user.id);
|
|
return { success: true };
|
|
}),
|
|
}),
|
|
|
|
// ─── Administration ────────────────────────────────────────────────────────
|
|
admin: router({
|
|
/** Liste tous les utilisateurs avec leurs établissements affectés */
|
|
users: gestionnaireProcedure.query(() => getAllUsersWithAffectations()),
|
|
|
|
/** Crée un utilisateur manuellement avec un mot de passe local */
|
|
createUser: gestionnaireProcedure
|
|
.input(z.object({
|
|
firstName: z.string().min(1),
|
|
lastName: z.string().min(1),
|
|
login: z.string().min(2).optional(),
|
|
email: z.string().email(),
|
|
sonumRole: z.enum(["referent", "gestionnaire", "adherent"]),
|
|
role: z.enum(["admin", "standard", "readonly"]).default("standard"),
|
|
isActive: z.boolean().default(true),
|
|
password: z.string().min(8, "Le mot de passe doit contenir au moins 8 caractères"),
|
|
}))
|
|
.mutation(async ({ input }) => {
|
|
try {
|
|
const userId = await createLocalUser(input);
|
|
return { success: true, userId };
|
|
} catch (err: any) {
|
|
if (err.message === "EMAIL_EXISTS") {
|
|
throw new TRPCError({ code: "CONFLICT", message: "Un utilisateur avec cet email existe déjà" });
|
|
}
|
|
if (err.message === "LOGIN_EXISTS") {
|
|
throw new TRPCError({ code: "CONFLICT", message: "Un utilisateur avec ce login existe déjà" });
|
|
}
|
|
throw new TRPCError({ code: "INTERNAL_SERVER_ERROR", message: err.message });
|
|
}
|
|
}),
|
|
|
|
/** Met à jour les informations d'un utilisateur */
|
|
updateUser: gestionnaireProcedure
|
|
.input(z.object({
|
|
userId: z.number().int(),
|
|
firstName: z.string().min(1).optional(),
|
|
lastName: z.string().min(1).optional(),
|
|
login: z.string().min(2).optional(),
|
|
email: z.string().email().optional(),
|
|
sonumRole: z.enum(["referent", "gestionnaire", "adherent"]).optional(),
|
|
role: z.enum(["admin", "standard", "readonly"]).optional(),
|
|
isActive: z.boolean().optional(),
|
|
}))
|
|
.mutation(async ({ input }) => {
|
|
const { userId, ...data } = input;
|
|
await updateUser(userId, data);
|
|
return { success: true };
|
|
}),
|
|
|
|
/** Réinitialise le mot de passe d'un utilisateur local */
|
|
resetPassword: gestionnaireProcedure
|
|
.input(z.object({
|
|
userId: z.number().int(),
|
|
newPassword: z.string().min(8),
|
|
}))
|
|
.mutation(async ({ input }) => {
|
|
await updateLocalPassword(input.userId, input.newPassword);
|
|
return { success: true };
|
|
}),
|
|
|
|
/** Supprime un utilisateur */
|
|
deleteUser: gestionnaireProcedure
|
|
.input(z.object({ userId: z.number().int() }))
|
|
.mutation(async ({ input }) => {
|
|
await deleteUser(input.userId);
|
|
return { success: true };
|
|
}),
|
|
|
|
/** Ancienne procédure de mise à jour du rôle (rétrocompatibilité) */
|
|
updateRole: gestionnaireProcedure
|
|
.input(z.object({
|
|
userId: z.number().int(),
|
|
sonumRole: z.enum(["referent", "gestionnaire", "adherent"]),
|
|
}))
|
|
.mutation(async ({ input }) => {
|
|
await updateUserSonumRole(input.userId, input.sonumRole);
|
|
return { success: true };
|
|
}),
|
|
|
|
/** Retourne les établissements affectés à un utilisateur */
|
|
affectations: gestionnaireProcedure
|
|
.input(z.object({ userId: z.number().int() }))
|
|
.query(({ input }) => getAffectationsByUser(input.userId)),
|
|
|
|
/** Remplace toutes les affectations d'un adhérent */
|
|
setAffectations: gestionnaireProcedure
|
|
.input(z.object({
|
|
userId: z.number().int(),
|
|
etablissementIds: z.array(z.number().int()),
|
|
}))
|
|
.mutation(async ({ input }) => {
|
|
await setAffectationsForUser(input.userId, input.etablissementIds);
|
|
return { success: true };
|
|
}),
|
|
|
|
/** Ajoute un établissement à un utilisateur */
|
|
assignEtablissement: gestionnaireProcedure
|
|
.input(z.object({
|
|
userId: z.number().int(),
|
|
etablissementId: z.number().int(),
|
|
}))
|
|
.mutation(async ({ input }) => {
|
|
await assignEtablissementToUser(input.userId, input.etablissementId);
|
|
return { success: true };
|
|
}),
|
|
|
|
/** Retire un établissement d'un utilisateur */
|
|
removeEtablissement: gestionnaireProcedure
|
|
.input(z.object({
|
|
userId: z.number().int(),
|
|
etablissementId: z.number().int(),
|
|
}))
|
|
.mutation(async ({ input }) => {
|
|
await removeEtablissementFromUser(input.userId, input.etablissementId);
|
|
return { success: true };
|
|
}),
|
|
|
|
/** Retourne les utilisateurs (adhérents + référent) d'un établissement */
|
|
getUsersForEtablissement: gestionnaireProcedure
|
|
.input(z.object({ etablissementId: z.number().int() }))
|
|
.query(({ input }) => getUsersForEtablissement(input.etablissementId)),
|
|
|
|
/** Définit le référent numérique d'un établissement */
|
|
setReferentForEtablissement: gestionnaireProcedure
|
|
.input(z.object({
|
|
etablissementId: z.number().int(),
|
|
referentId: z.number().int().nullable(),
|
|
}))
|
|
.mutation(async ({ input }) => {
|
|
await setReferentForEtablissement(input.etablissementId, input.referentId);
|
|
return { success: true };
|
|
}),
|
|
|
|
/** Remplace tous les adhérents affectés à un établissement */
|
|
setAdherentsForEtablissement: gestionnaireProcedure
|
|
.input(z.object({
|
|
etablissementId: z.number().int(),
|
|
userIds: z.array(z.number().int()),
|
|
}))
|
|
.mutation(async ({ input }) => {
|
|
await setAdherentsForEtablissement(input.etablissementId, input.userIds);
|
|
return { success: true };
|
|
}),
|
|
}),
|
|
});
|
|
|
|
export type AppRouter = typeof appRouter;
|