SONUM v7 - Évolution v6 (éditeurs/blocs CRUD, tableau de bord stats) + vue liste alternance couleurs
This commit is contained in:
Manus Agent
905
server/db.ts
Normal file
905
server/db.ts
Normal file
@@ -0,0 +1,905 @@
|
||||
import { and, desc, eq, ilike, inArray, like, or, sql } from "drizzle-orm";
|
||||
import { drizzle } from "drizzle-orm/mysql2";
|
||||
import {
|
||||
InsertUser,
|
||||
blocsFonctionnels,
|
||||
consultations,
|
||||
demandesContact,
|
||||
editeurs,
|
||||
etablissements,
|
||||
logicielsEtablissements,
|
||||
solutions,
|
||||
users,
|
||||
} from "../drizzle/schema";
|
||||
import { ENV } from "./_core/env";
|
||||
|
||||
let _db: ReturnType<typeof drizzle> | null = null;
|
||||
|
||||
export async function getDb() {
|
||||
if (!_db && process.env.DATABASE_URL) {
|
||||
try {
|
||||
_db = drizzle(process.env.DATABASE_URL);
|
||||
} catch (error) {
|
||||
console.warn("[Database] Failed to connect:", error);
|
||||
_db = null;
|
||||
}
|
||||
}
|
||||
return _db;
|
||||
}
|
||||
|
||||
// ─── Utilisateurs ─────────────────────────────────────────────────────────────
|
||||
|
||||
export async function upsertUser(user: InsertUser): Promise<void> {
|
||||
if (!user.openId) throw new Error("User openId is required for upsert");
|
||||
const db = await getDb();
|
||||
if (!db) { console.warn("[Database] Cannot upsert user: database not available"); return; }
|
||||
|
||||
const values: InsertUser = { openId: user.openId };
|
||||
const updateSet: Record<string, unknown> = {};
|
||||
|
||||
const textFields = ["name", "email", "loginMethod"] as const;
|
||||
for (const field of textFields) {
|
||||
const value = user[field];
|
||||
if (value === undefined) continue;
|
||||
const normalized = value ?? null;
|
||||
values[field] = normalized;
|
||||
updateSet[field] = normalized;
|
||||
}
|
||||
|
||||
if (user.lastSignedIn !== undefined) { values.lastSignedIn = user.lastSignedIn; updateSet.lastSignedIn = user.lastSignedIn; }
|
||||
if (user.role !== undefined) { values.role = user.role; updateSet.role = user.role; }
|
||||
else if (user.openId === ENV.ownerOpenId) { values.role = "admin"; updateSet.role = "admin"; }
|
||||
|
||||
if (!values.lastSignedIn) values.lastSignedIn = new Date();
|
||||
if (Object.keys(updateSet).length === 0) updateSet.lastSignedIn = new Date();
|
||||
|
||||
await db.insert(users).values(values).onDuplicateKeyUpdate({ set: updateSet });
|
||||
}
|
||||
|
||||
export async function getUserByOpenId(openId: string) {
|
||||
const db = await getDb();
|
||||
if (!db) return undefined;
|
||||
const result = await db.select().from(users).where(eq(users.openId, openId)).limit(1);
|
||||
return result.length > 0 ? result[0] : undefined;
|
||||
}
|
||||
|
||||
export async function updateUserCgu(userId: number) {
|
||||
const db = await getDb();
|
||||
if (!db) return;
|
||||
await db.update(users).set({ cguAccepted: true, cguAcceptedAt: new Date() }).where(eq(users.id, userId));
|
||||
}
|
||||
|
||||
export async function updateUserSonumRole(userId: number, sonumRole: "referent" | "gestionnaire" | "adherent") {
|
||||
const db = await getDb();
|
||||
if (!db) return;
|
||||
await db.update(users).set({ sonumRole }).where(eq(users.id, userId));
|
||||
}
|
||||
|
||||
export async function getAllUsers() {
|
||||
const db = await getDb();
|
||||
if (!db) return [];
|
||||
return db.select().from(users).orderBy(desc(users.createdAt));
|
||||
}
|
||||
|
||||
// ─── Référentiel ──────────────────────────────────────────────────────────────
|
||||
|
||||
export async function getEditeurs() {
|
||||
const db = await getDb();
|
||||
if (!db) return [];
|
||||
return db.select().from(editeurs).where(eq(editeurs.estValide, true)).orderBy(editeurs.nom);
|
||||
}
|
||||
|
||||
export async function createEditeur(nom: string, estValide = false) {
|
||||
const db = await getDb();
|
||||
if (!db) return null;
|
||||
const result = await db.insert(editeurs).values({ nom, estValide });
|
||||
return result[0];
|
||||
}
|
||||
|
||||
export async function getBlocsFonctionnels() {
|
||||
const db = await getDb();
|
||||
if (!db) return [];
|
||||
return db.select().from(blocsFonctionnels).orderBy(blocsFonctionnels.nom);
|
||||
}
|
||||
|
||||
export async function createBlocFonctionnel(nom: string, estValide = false) {
|
||||
const db = await getDb();
|
||||
if (!db) return null;
|
||||
const result = await db.insert(blocsFonctionnels).values({ nom, estValide });
|
||||
return result[0];
|
||||
}
|
||||
|
||||
export async function getSolutions(search?: string) {
|
||||
const db = await getDb();
|
||||
if (!db) return [];
|
||||
const query = db
|
||||
.select({
|
||||
id: solutions.id,
|
||||
nom: solutions.nom,
|
||||
editeurId: solutions.editeurId,
|
||||
editeurNom: editeurs.nom,
|
||||
blocFonctionnelId: solutions.blocFonctionnelId,
|
||||
blocFonctionnelNom: blocsFonctionnels.nom,
|
||||
estValide: solutions.estValide,
|
||||
})
|
||||
.from(solutions)
|
||||
.leftJoin(editeurs, eq(solutions.editeurId, editeurs.id))
|
||||
.leftJoin(blocsFonctionnels, eq(solutions.blocFonctionnelId, blocsFonctionnels.id))
|
||||
.where(
|
||||
search
|
||||
? and(eq(solutions.estValide, true), or(like(solutions.nom, `%${search}%`), like(editeurs.nom, `%${search}%`)))
|
||||
: eq(solutions.estValide, true)
|
||||
)
|
||||
.orderBy(solutions.nom);
|
||||
return query;
|
||||
}
|
||||
|
||||
export async function createSolution(nom: string, editeurId: number, blocFonctionnelId?: number | null, estValide = false) {
|
||||
const db = await getDb();
|
||||
if (!db) return null;
|
||||
const result = await db.insert(solutions).values({ nom, editeurId, blocFonctionnelId: blocFonctionnelId ?? null, estValide });
|
||||
// result[0] est un ResultSetHeader MySQL, on retourne l'insertId directement
|
||||
const insertId = (result[0] as any).insertId as number;
|
||||
return insertId;
|
||||
}
|
||||
|
||||
// ─── Établissements ───────────────────────────────────────────────────────────
|
||||
|
||||
export async function getEtablissementsByReferent(referentId: number) {
|
||||
const db = await getDb();
|
||||
if (!db) return [];
|
||||
return db.select().from(etablissements).where(eq(etablissements.referentId, referentId)).orderBy(etablissements.nom);
|
||||
}
|
||||
|
||||
export async function getAllEtablissements() {
|
||||
const db = await getDb();
|
||||
if (!db) return [];
|
||||
return db.select().from(etablissements).orderBy(etablissements.nom);
|
||||
}
|
||||
|
||||
export async function getEtablissementById(id: number) {
|
||||
const db = await getDb();
|
||||
if (!db) return null;
|
||||
const result = await db.select().from(etablissements).where(eq(etablissements.id, id)).limit(1);
|
||||
return result[0] ?? null;
|
||||
}
|
||||
|
||||
export async function searchEtablissements(filters: {
|
||||
solutionId?: number;
|
||||
editeurId?: number;
|
||||
blocFonctionnelId?: number;
|
||||
region?: string;
|
||||
typeActivite?: string;
|
||||
tailleEffectifs?: string;
|
||||
etatDeploiement?: string;
|
||||
userId?: number;
|
||||
sonumRole?: string;
|
||||
}) {
|
||||
const db = await getDb();
|
||||
if (!db) return [];
|
||||
const conditions: any[] = [];
|
||||
|
||||
// Visibilité : si pas gestionnaire, on ne montre que les fiches "tous"
|
||||
if (filters.sonumRole !== "gestionnaire") {
|
||||
conditions.push(eq(etablissements.visibilite, "tous"));
|
||||
}
|
||||
if (filters.region) conditions.push(eq(etablissements.region, filters.region));
|
||||
if (filters.typeActivite) conditions.push(eq(etablissements.typeActivite, filters.typeActivite));
|
||||
if (filters.tailleEffectifs) conditions.push(eq(etablissements.tailleEffectifs, filters.tailleEffectifs));
|
||||
|
||||
// Filtres sur les logiciels (nécessitent une jointure)
|
||||
const needsJoin = filters.solutionId || filters.editeurId || filters.blocFonctionnelId || filters.etatDeploiement;
|
||||
|
||||
if (needsJoin) {
|
||||
// Filtres sur la table logiciels_etablissements
|
||||
const leConditions: any[] = [eq(logicielsEtablissements.etablissementId, etablissements.id)];
|
||||
if (filters.solutionId) leConditions.push(eq(logicielsEtablissements.solutionId, filters.solutionId));
|
||||
if (filters.etatDeploiement) leConditions.push(eq(logicielsEtablissements.etatDeploiement, filters.etatDeploiement as any));
|
||||
|
||||
// Filtres sur les solutions (editeurId, blocFonctionnelId)
|
||||
const solConditions: any[] = [eq(solutions.id, logicielsEtablissements.solutionId)];
|
||||
if (filters.editeurId) solConditions.push(eq(solutions.editeurId, filters.editeurId));
|
||||
if (filters.blocFonctionnelId) solConditions.push(eq(solutions.blocFonctionnelId, filters.blocFonctionnelId));
|
||||
|
||||
const subquery = db
|
||||
.select({ etablissementId: logicielsEtablissements.etablissementId })
|
||||
.from(logicielsEtablissements)
|
||||
.innerJoin(solutions, and(...solConditions))
|
||||
.where(and(...leConditions));
|
||||
|
||||
conditions.push(inArray(etablissements.id, subquery));
|
||||
}
|
||||
|
||||
const result = await db
|
||||
.select({
|
||||
id: etablissements.id,
|
||||
finess: etablissements.finess,
|
||||
nom: etablissements.nom,
|
||||
region: etablissements.region,
|
||||
departement: etablissements.departement,
|
||||
typeActivite: etablissements.typeActivite,
|
||||
tailleEffectifs: etablissements.tailleEffectifs,
|
||||
referentId: etablissements.referentId,
|
||||
visibilite: etablissements.visibilite,
|
||||
accepteMiseEnRelation: etablissements.accepteMiseEnRelation,
|
||||
})
|
||||
.from(etablissements)
|
||||
.where(conditions.length > 0 ? and(...conditions) : undefined)
|
||||
.orderBy(etablissements.nom);
|
||||
return result;
|
||||
}
|
||||
|
||||
// ─── Logiciels par Établissement ─────────────────────────────────────────────
|
||||
|
||||
export async function getLogicielsByEtablissement(etablissementId: number) {
|
||||
const db = await getDb();
|
||||
if (!db) return [];
|
||||
return db
|
||||
.select({
|
||||
id: logicielsEtablissements.id,
|
||||
etablissementId: logicielsEtablissements.etablissementId,
|
||||
solutionId: logicielsEtablissements.solutionId,
|
||||
solutionNom: solutions.nom,
|
||||
editeurNom: editeurs.nom,
|
||||
blocFonctionnelNom: blocsFonctionnels.nom,
|
||||
etatDeploiement: logicielsEtablissements.etatDeploiement,
|
||||
modeHebergement: logicielsEtablissements.modeHebergement,
|
||||
modeFacturation: logicielsEtablissements.modeFacturation,
|
||||
interoperabilite: logicielsEtablissements.interoperabilite,
|
||||
versionMajeure: logicielsEtablissements.versionMajeure,
|
||||
commentaire: logicielsEtablissements.commentaire,
|
||||
contactNom: logicielsEtablissements.contactNom,
|
||||
contactFonction: logicielsEtablissements.contactFonction,
|
||||
contactEmail: logicielsEtablissements.contactEmail,
|
||||
createdAt: logicielsEtablissements.createdAt,
|
||||
updatedAt: logicielsEtablissements.updatedAt,
|
||||
})
|
||||
.from(logicielsEtablissements)
|
||||
.leftJoin(solutions, eq(logicielsEtablissements.solutionId, solutions.id))
|
||||
.leftJoin(editeurs, eq(solutions.editeurId, editeurs.id))
|
||||
.leftJoin(blocsFonctionnels, eq(solutions.blocFonctionnelId, blocsFonctionnels.id))
|
||||
.where(eq(logicielsEtablissements.etablissementId, etablissementId))
|
||||
.orderBy(logicielsEtablissements.createdAt);
|
||||
}
|
||||
|
||||
export async function upsertLogicielEtablissement(data: {
|
||||
id?: number;
|
||||
etablissementId: number;
|
||||
solutionId: number;
|
||||
etatDeploiement: "demarrage" | "en_cours" | "operationnel" | "en_remplacement";
|
||||
modeHebergement?: "hds" | "on_premise" | "hybride" | null;
|
||||
modeFacturation?: "saas" | "achat_maintenance" | "location" | null;
|
||||
interoperabilite?: "non" | "oui_interface" | "oui_eai" | null;
|
||||
versionMajeure?: string | null;
|
||||
commentaire?: string | null;
|
||||
contactNom?: string | null;
|
||||
contactFonction?: string | null;
|
||||
contactEmail?: string | null;
|
||||
saisiePar?: number;
|
||||
}) {
|
||||
const db = await getDb();
|
||||
if (!db) return null;
|
||||
if (data.id) {
|
||||
await db.update(logicielsEtablissements).set({ ...data, updatedAt: new Date() }).where(eq(logicielsEtablissements.id, data.id));
|
||||
return data.id;
|
||||
}
|
||||
const result = await db.insert(logicielsEtablissements).values(data);
|
||||
return result[0];
|
||||
}
|
||||
|
||||
export async function deleteLogicielEtablissement(id: number) {
|
||||
const db = await getDb();
|
||||
if (!db) return;
|
||||
await db.delete(logicielsEtablissements).where(eq(logicielsEtablissements.id, id));
|
||||
}
|
||||
|
||||
// ─── Traçabilité ──────────────────────────────────────────────────────────────
|
||||
|
||||
export async function recordConsultation(etablissementId: number, userId: number, userName: string) {
|
||||
const db = await getDb();
|
||||
if (!db) return;
|
||||
await db.insert(consultations).values({ etablissementId, consultePar: userId, consultéParNom: userName });
|
||||
}
|
||||
|
||||
export async function getConsultationCount(etablissementId: number) {
|
||||
const db = await getDb();
|
||||
if (!db) return 0;
|
||||
const result = await db
|
||||
.select({ count: sql<number>`count(*)` })
|
||||
.from(consultations)
|
||||
.where(eq(consultations.etablissementId, etablissementId));
|
||||
return Number(result[0]?.count ?? 0);
|
||||
}
|
||||
|
||||
export async function getConsultationsList(etablissementId: number) {
|
||||
const db = await getDb();
|
||||
if (!db) return [];
|
||||
return db
|
||||
.select()
|
||||
.from(consultations)
|
||||
.where(eq(consultations.etablissementId, etablissementId))
|
||||
.orderBy(desc(consultations.createdAt))
|
||||
.limit(50);
|
||||
}
|
||||
|
||||
// ─── Demandes de Contact ──────────────────────────────────────────────────────
|
||||
|
||||
export async function createDemandeContact(data: {
|
||||
etablissementCibleId: number;
|
||||
demandeurId: number;
|
||||
demandeurNom: string;
|
||||
demandeurEmail: string;
|
||||
message: string;
|
||||
}) {
|
||||
const db = await getDb();
|
||||
if (!db) return null;
|
||||
const result = await db.insert(demandesContact).values(data);
|
||||
return result[0];
|
||||
}
|
||||
|
||||
export async function getDemandesByDemandeur(demandeurId: number) {
|
||||
const db = await getDb();
|
||||
if (!db) return [];
|
||||
return db
|
||||
.select({
|
||||
id: demandesContact.id,
|
||||
etablissementNom: etablissements.nom,
|
||||
message: demandesContact.message,
|
||||
statut: demandesContact.statut,
|
||||
reponse: demandesContact.reponse,
|
||||
reponduAt: demandesContact.reponduAt,
|
||||
createdAt: demandesContact.createdAt,
|
||||
})
|
||||
.from(demandesContact)
|
||||
.leftJoin(etablissements, eq(demandesContact.etablissementCibleId, etablissements.id))
|
||||
.where(eq(demandesContact.demandeurId, demandeurId))
|
||||
.orderBy(desc(demandesContact.createdAt));
|
||||
}
|
||||
|
||||
export async function getDemandesRecuesParEtablissement(referentId: number) {
|
||||
const db = await getDb();
|
||||
if (!db) return [];
|
||||
return db
|
||||
.select({
|
||||
id: demandesContact.id,
|
||||
etablissementNom: etablissements.nom,
|
||||
demandeurNom: demandesContact.demandeurNom,
|
||||
demandeurEmail: demandesContact.demandeurEmail,
|
||||
message: demandesContact.message,
|
||||
statut: demandesContact.statut,
|
||||
reponse: demandesContact.reponse,
|
||||
reponduAt: demandesContact.reponduAt,
|
||||
createdAt: demandesContact.createdAt,
|
||||
})
|
||||
.from(demandesContact)
|
||||
.leftJoin(etablissements, eq(demandesContact.etablissementCibleId, etablissements.id))
|
||||
.where(eq(etablissements.referentId, referentId))
|
||||
.orderBy(desc(demandesContact.createdAt));
|
||||
}
|
||||
|
||||
export async function getAllDemandes() {
|
||||
const db = await getDb();
|
||||
if (!db) return [];
|
||||
return db
|
||||
.select({
|
||||
id: demandesContact.id,
|
||||
etablissementNom: etablissements.nom,
|
||||
demandeurNom: demandesContact.demandeurNom,
|
||||
demandeurEmail: demandesContact.demandeurEmail,
|
||||
message: demandesContact.message,
|
||||
statut: demandesContact.statut,
|
||||
reponse: demandesContact.reponse,
|
||||
reponduAt: demandesContact.reponduAt,
|
||||
createdAt: demandesContact.createdAt,
|
||||
})
|
||||
.from(demandesContact)
|
||||
.leftJoin(etablissements, eq(demandesContact.etablissementCibleId, etablissements.id))
|
||||
.orderBy(desc(demandesContact.createdAt));
|
||||
}
|
||||
|
||||
export async function repondreDemandeContact(id: number, reponse: string, reponsePar: number) {
|
||||
const db = await getDb();
|
||||
if (!db) return;
|
||||
await db
|
||||
.update(demandesContact)
|
||||
.set({ reponse, reponsePar, statut: "repondu", reponduAt: new Date(), updatedAt: new Date() })
|
||||
.where(eq(demandesContact.id, id));
|
||||
}
|
||||
|
||||
export async function getDemandeById(id: number) {
|
||||
const db = await getDb();
|
||||
if (!db) return null;
|
||||
const result = await db.select().from(demandesContact).where(eq(demandesContact.id, id)).limit(1);
|
||||
return result[0] ?? null;
|
||||
}
|
||||
|
||||
// ─── Auth locale ──────────────────────────────────────────────────────────────
|
||||
|
||||
import { localCredentials, userEtablissements } from "../drizzle/schema";
|
||||
import bcrypt from "bcryptjs";
|
||||
import { nanoid } from "nanoid";
|
||||
|
||||
/** Crée un utilisateur local (sans openId OAuth) avec un mot de passe hashé. */
|
||||
export async function createLocalUser(data: {
|
||||
name: string;
|
||||
email: string;
|
||||
sonumRole: "referent" | "gestionnaire" | "adherent";
|
||||
password: string;
|
||||
}) {
|
||||
const db = await getDb();
|
||||
if (!db) throw new Error("Database not available");
|
||||
|
||||
// Vérifier unicité email
|
||||
const existing = await db.select().from(users).where(eq(users.email, data.email)).limit(1);
|
||||
if (existing.length > 0) throw new Error("EMAIL_EXISTS");
|
||||
|
||||
// openId synthétique pour les comptes locaux
|
||||
const syntheticOpenId = `local_${nanoid(16)}`;
|
||||
const passwordHash = await bcrypt.hash(data.password, 12);
|
||||
|
||||
const insertResult = await db.insert(users).values({
|
||||
openId: syntheticOpenId,
|
||||
name: data.name,
|
||||
email: data.email,
|
||||
loginMethod: "local",
|
||||
sonumRole: data.sonumRole,
|
||||
cguAccepted: false,
|
||||
lastSignedIn: new Date(),
|
||||
});
|
||||
|
||||
const userId = Number((insertResult as any)[0]?.insertId ?? 0);
|
||||
if (!userId) throw new Error("Failed to create user");
|
||||
|
||||
await db.insert(localCredentials).values({ userId, passwordHash });
|
||||
|
||||
return userId;
|
||||
}
|
||||
|
||||
/** Authentifie un utilisateur par email + mot de passe. Retourne l'utilisateur ou null. */
|
||||
export async function authenticateLocalUser(email: string, password: string) {
|
||||
const db = await getDb();
|
||||
if (!db) return null;
|
||||
|
||||
const result = await db
|
||||
.select({
|
||||
user: users,
|
||||
passwordHash: localCredentials.passwordHash,
|
||||
})
|
||||
.from(users)
|
||||
.innerJoin(localCredentials, eq(localCredentials.userId, users.id))
|
||||
.where(eq(users.email, email))
|
||||
.limit(1);
|
||||
|
||||
if (!result.length) return null;
|
||||
|
||||
const { user, passwordHash } = result[0];
|
||||
const valid = await bcrypt.compare(password, passwordHash);
|
||||
if (!valid) return null;
|
||||
|
||||
// Mettre à jour lastSignedIn
|
||||
await db.update(users).set({ lastSignedIn: new Date() }).where(eq(users.id, user.id));
|
||||
|
||||
return user;
|
||||
}
|
||||
|
||||
/** Vérifie si un utilisateur possède des credentials locaux. */
|
||||
export async function hasLocalCredentials(userId: number) {
|
||||
const db = await getDb();
|
||||
if (!db) return false;
|
||||
const result = await db.select().from(localCredentials).where(eq(localCredentials.userId, userId)).limit(1);
|
||||
return result.length > 0;
|
||||
}
|
||||
|
||||
/** Met à jour le mot de passe d'un utilisateur. */
|
||||
export async function updateLocalPassword(userId: number, newPassword: string) {
|
||||
const db = await getDb();
|
||||
if (!db) return;
|
||||
const passwordHash = await bcrypt.hash(newPassword, 12);
|
||||
const existing = await db.select().from(localCredentials).where(eq(localCredentials.userId, userId)).limit(1);
|
||||
if (existing.length > 0) {
|
||||
await db.update(localCredentials).set({ passwordHash, updatedAt: new Date() }).where(eq(localCredentials.userId, userId));
|
||||
} else {
|
||||
await db.insert(localCredentials).values({ userId, passwordHash });
|
||||
}
|
||||
}
|
||||
|
||||
/** Met à jour les informations d'un utilisateur. */
|
||||
export async function updateUser(userId: number, data: {
|
||||
name?: string;
|
||||
email?: string;
|
||||
sonumRole?: "referent" | "gestionnaire" | "adherent";
|
||||
}) {
|
||||
const db = await getDb();
|
||||
if (!db) return;
|
||||
await db.update(users).set({ ...data, updatedAt: new Date() }).where(eq(users.id, userId));
|
||||
}
|
||||
|
||||
/** Supprime un utilisateur et ses credentials locaux. */
|
||||
export async function deleteUser(userId: number) {
|
||||
const db = await getDb();
|
||||
if (!db) return;
|
||||
await db.delete(localCredentials).where(eq(localCredentials.userId, userId));
|
||||
await db.delete(userEtablissements).where(eq(userEtablissements.userId, userId));
|
||||
await db.delete(users).where(eq(users.id, userId));
|
||||
}
|
||||
|
||||
// ─── Affectations Adhérents ↔ Établissements ─────────────────────────────────
|
||||
|
||||
/** Retourne les établissements affectés à un adhérent. */
|
||||
export async function getEtablissementsByAdherent(userId: number) {
|
||||
const db = await getDb();
|
||||
if (!db) return [];
|
||||
return db
|
||||
.select({
|
||||
id: etablissements.id,
|
||||
finess: etablissements.finess,
|
||||
nom: etablissements.nom,
|
||||
region: etablissements.region,
|
||||
departement: etablissements.departement,
|
||||
typeActivite: etablissements.typeActivite,
|
||||
tailleEffectifs: etablissements.tailleEffectifs,
|
||||
referentId: etablissements.referentId,
|
||||
visibilite: etablissements.visibilite,
|
||||
accepteMiseEnRelation: etablissements.accepteMiseEnRelation,
|
||||
})
|
||||
.from(userEtablissements)
|
||||
.innerJoin(etablissements, eq(userEtablissements.etablissementId, etablissements.id))
|
||||
.where(eq(userEtablissements.userId, userId))
|
||||
.orderBy(etablissements.nom);
|
||||
}
|
||||
|
||||
/** Retourne les IDs des établissements affectés à un adhérent. */
|
||||
export async function getAffectationsByUser(userId: number) {
|
||||
const db = await getDb();
|
||||
if (!db) return [];
|
||||
const result = await db
|
||||
.select({ etablissementId: userEtablissements.etablissementId })
|
||||
.from(userEtablissements)
|
||||
.where(eq(userEtablissements.userId, userId));
|
||||
return result.map((r) => r.etablissementId);
|
||||
}
|
||||
|
||||
/** Affecte un établissement à un adhérent (idempotent). */
|
||||
export async function assignEtablissementToUser(userId: number, etablissementId: number) {
|
||||
const db = await getDb();
|
||||
if (!db) return;
|
||||
const existing = await db
|
||||
.select()
|
||||
.from(userEtablissements)
|
||||
.where(and(eq(userEtablissements.userId, userId), eq(userEtablissements.etablissementId, etablissementId)))
|
||||
.limit(1);
|
||||
if (existing.length === 0) {
|
||||
await db.insert(userEtablissements).values({ userId, etablissementId });
|
||||
}
|
||||
}
|
||||
|
||||
/** Retire un établissement d'un adhérent. */
|
||||
export async function removeEtablissementFromUser(userId: number, etablissementId: number) {
|
||||
const db = await getDb();
|
||||
if (!db) return;
|
||||
await db
|
||||
.delete(userEtablissements)
|
||||
.where(and(eq(userEtablissements.userId, userId), eq(userEtablissements.etablissementId, etablissementId)));
|
||||
}
|
||||
|
||||
/** Remplace toutes les affectations d'un adhérent par une nouvelle liste. */
|
||||
export async function setAffectationsForUser(userId: number, etablissementIds: number[]) {
|
||||
const db = await getDb();
|
||||
if (!db) return;
|
||||
await db.delete(userEtablissements).where(eq(userEtablissements.userId, userId));
|
||||
if (etablissementIds.length > 0) {
|
||||
await db.insert(userEtablissements).values(etablissementIds.map((eid) => ({ userId, etablissementId: eid })));
|
||||
}
|
||||
}
|
||||
|
||||
/** Retourne tous les utilisateurs avec leurs affectations. */
|
||||
export async function getAllUsersWithAffectations() {
|
||||
const db = await getDb();
|
||||
if (!db) return [];
|
||||
|
||||
const allUsers = await db.select().from(users).orderBy(users.name);
|
||||
const allAffectations = await db
|
||||
.select({
|
||||
userId: userEtablissements.userId,
|
||||
etablissementId: userEtablissements.etablissementId,
|
||||
etablissementNom: etablissements.nom,
|
||||
})
|
||||
.from(userEtablissements)
|
||||
.innerJoin(etablissements, eq(userEtablissements.etablissementId, etablissements.id));
|
||||
|
||||
return allUsers.map((u) => ({
|
||||
...u,
|
||||
etablissements: allAffectations
|
||||
.filter((a) => a.userId === u.id)
|
||||
.map((a) => ({ id: a.etablissementId, nom: a.etablissementNom })),
|
||||
hasLocalCredentials: false, // sera enrichi côté router si besoin
|
||||
}));
|
||||
}
|
||||
|
||||
// ─── Mes Solutions Numériques ─────────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* Retourne toutes les solutions utilisées par les établissements dont l'utilisateur est référent/adhérent,
|
||||
* groupées par solution avec la liste des établissements équipés.
|
||||
*/
|
||||
export async function getMesSolutionsGroupees(userId: number, sonumRole: string) {
|
||||
const db = await getDb();
|
||||
if (!db) return [];
|
||||
|
||||
// Récupérer les établissements accessibles selon le rôle
|
||||
let etablissementIds: number[] = [];
|
||||
if (sonumRole === "gestionnaire") {
|
||||
const all = await db.select({ id: etablissements.id }).from(etablissements);
|
||||
etablissementIds = all.map((e) => e.id);
|
||||
} else if (sonumRole === "adherent") {
|
||||
etablissementIds = await getAffectationsByUser(userId);
|
||||
} else {
|
||||
// référent : établissements dont il est référent
|
||||
const refs = await db
|
||||
.select({ id: etablissements.id })
|
||||
.from(etablissements)
|
||||
.where(eq(etablissements.referentId, userId));
|
||||
etablissementIds = refs.map((e) => e.id);
|
||||
}
|
||||
|
||||
if (etablissementIds.length === 0) return [];
|
||||
|
||||
const rows = await db
|
||||
.select({
|
||||
solutionId: solutions.id,
|
||||
solutionNom: solutions.nom,
|
||||
editeurNom: editeurs.nom,
|
||||
blocFonctionnelNom: blocsFonctionnels.nom,
|
||||
etablissementId: etablissements.id,
|
||||
etablissementNom: etablissements.nom,
|
||||
etablissementRegion: etablissements.region,
|
||||
etatDeploiement: logicielsEtablissements.etatDeploiement,
|
||||
})
|
||||
.from(logicielsEtablissements)
|
||||
.innerJoin(solutions, eq(logicielsEtablissements.solutionId, solutions.id))
|
||||
.innerJoin(editeurs, eq(solutions.editeurId, editeurs.id))
|
||||
.leftJoin(blocsFonctionnels, eq(solutions.blocFonctionnelId, blocsFonctionnels.id))
|
||||
.innerJoin(etablissements, eq(logicielsEtablissements.etablissementId, etablissements.id))
|
||||
.where(inArray(logicielsEtablissements.etablissementId, etablissementIds))
|
||||
.orderBy(solutions.nom, etablissements.nom);
|
||||
|
||||
// Grouper par solution
|
||||
const map = new Map<number, {
|
||||
solutionId: number;
|
||||
solutionNom: string;
|
||||
editeurId: number | null;
|
||||
editeurNom: string;
|
||||
blocFonctionnelId: number | null;
|
||||
blocFonctionnelNom: string | null;
|
||||
nbEtablissements: number;
|
||||
etablissements: { id: number; nom: string; region: string | null; etatDeploiement: string }[];
|
||||
}>();
|
||||
for (const row of rows) {
|
||||
if (!map.has(row.solutionId)) {
|
||||
map.set(row.solutionId, {
|
||||
solutionId: row.solutionId,
|
||||
solutionNom: row.solutionNom ?? "",
|
||||
editeurId: null,
|
||||
editeurNom: row.editeurNom ?? "",
|
||||
blocFonctionnelId: null,
|
||||
blocFonctionnelNom: row.blocFonctionnelNom ?? null,
|
||||
nbEtablissements: 0,
|
||||
etablissements: [],
|
||||
});
|
||||
}
|
||||
const entry = map.get(row.solutionId)!;
|
||||
if (row.etablissementId) {
|
||||
entry.etablissements.push({
|
||||
id: row.etablissementId,
|
||||
nom: row.etablissementNom ?? "",
|
||||
region: row.etablissementRegion ?? null,
|
||||
etatDeploiement: row.etatDeploiement ?? "",
|
||||
});
|
||||
entry.nbEtablissements = entry.etablissements.length;
|
||||
}
|
||||
}
|
||||
return Array.from(map.values());
|
||||
}
|
||||
/***
|
||||
* Retourne toutes les solutions du référentiel avec les établissements équipés (vue globale).
|
||||
* Accessible à tous les utilisateurs connectés.
|
||||
*/
|
||||
export async function getToutesLesSolutionsGroupees() {
|
||||
const db = await getDb();
|
||||
if (!db) return [];
|
||||
|
||||
const rows = await db
|
||||
.select({
|
||||
solutionId: solutions.id,
|
||||
solutionNom: solutions.nom,
|
||||
editeurId: solutions.editeurId,
|
||||
editeurNom: editeurs.nom,
|
||||
blocFonctionnelId: solutions.blocFonctionnelId,
|
||||
blocFonctionnelNom: blocsFonctionnels.nom,
|
||||
etablissementId: etablissements.id,
|
||||
etablissementNom: etablissements.nom,
|
||||
etablissementRegion: etablissements.region,
|
||||
etatDeploiement: logicielsEtablissements.etatDeploiement,
|
||||
})
|
||||
.from(solutions)
|
||||
.leftJoin(editeurs, eq(solutions.editeurId, editeurs.id))
|
||||
.leftJoin(blocsFonctionnels, eq(solutions.blocFonctionnelId, blocsFonctionnels.id))
|
||||
.leftJoin(logicielsEtablissements, eq(logicielsEtablissements.solutionId, solutions.id))
|
||||
.leftJoin(etablissements, eq(logicielsEtablissements.etablissementId, etablissements.id))
|
||||
.orderBy(solutions.nom, etablissements.nom);
|
||||
const map = new Map<number, {
|
||||
solutionId: number;
|
||||
solutionNom: string;
|
||||
editeurId: number | null;
|
||||
editeurNom: string;
|
||||
blocFonctionnelId: number | null;
|
||||
blocFonctionnelNom: string | null;
|
||||
nbEtablissements: number;
|
||||
etablissements: { id: number; nom: string; region: string | null; etatDeploiement: string }[];
|
||||
}>();
|
||||
for (const row of rows) {
|
||||
if (!map.has(row.solutionId)) {
|
||||
map.set(row.solutionId, {
|
||||
solutionId: row.solutionId,
|
||||
solutionNom: row.solutionNom ?? "",
|
||||
editeurId: row.editeurId ?? null,
|
||||
editeurNom: row.editeurNom ?? "",
|
||||
blocFonctionnelId: row.blocFonctionnelId ?? null,
|
||||
blocFonctionnelNom: row.blocFonctionnelNom ?? null,
|
||||
nbEtablissements: 0,
|
||||
etablissements: [],
|
||||
});
|
||||
}
|
||||
if (row.etablissementId) {
|
||||
map.get(row.solutionId)!.etablissements.push({
|
||||
id: row.etablissementId,
|
||||
nom: row.etablissementNom ?? "",
|
||||
region: row.etablissementRegion ?? null,
|
||||
etatDeploiement: row.etatDeploiement ?? "",
|
||||
});
|
||||
map.get(row.solutionId)!.nbEtablissements++;
|
||||
}
|
||||
}
|
||||
|
||||
return Array.from(map.values());
|
||||
}
|
||||
|
||||
export async function updateSolution(id: number, nom: string, editeurId: number, blocFonctionnelId: number | null) {
|
||||
const db = await getDb();
|
||||
if (!db) throw new Error("DB unavailable");
|
||||
await db.update(solutions).set({ nom, editeurId, blocFonctionnelId }).where(eq(solutions.id, id));
|
||||
return { id };
|
||||
}
|
||||
|
||||
export async function deleteSolution(id: number) {
|
||||
const db = await getDb();
|
||||
if (!db) throw new Error("DB unavailable");
|
||||
await db.delete(solutions).where(eq(solutions.id, id));
|
||||
return { success: true };
|
||||
}
|
||||
|
||||
// ─── CRUD Éditeurs ────────────────────────────────────────────────────────────
|
||||
|
||||
export async function updateEditeur(id: number, nom: string) {
|
||||
const db = await getDb();
|
||||
if (!db) throw new Error("DB unavailable");
|
||||
await db.update(editeurs).set({ nom }).where(eq(editeurs.id, id));
|
||||
return { id };
|
||||
}
|
||||
|
||||
export async function deleteEditeur(id: number) {
|
||||
const db = await getDb();
|
||||
if (!db) throw new Error("DB unavailable");
|
||||
await db.delete(editeurs).where(eq(editeurs.id, id));
|
||||
return { id };
|
||||
}
|
||||
|
||||
// ─── CRUD Blocs Fonctionnels ──────────────────────────────────────────────────
|
||||
|
||||
export async function updateBlocFonctionnel(id: number, nom: string) {
|
||||
const db = await getDb();
|
||||
if (!db) throw new Error("DB unavailable");
|
||||
await db.update(blocsFonctionnels).set({ nom }).where(eq(blocsFonctionnels.id, id));
|
||||
return { id };
|
||||
}
|
||||
|
||||
export async function deleteBlocFonctionnel(id: number) {
|
||||
const db = await getDb();
|
||||
if (!db) throw new Error("DB unavailable");
|
||||
await db.delete(blocsFonctionnels).where(eq(blocsFonctionnels.id, id));
|
||||
return { id };
|
||||
}
|
||||
|
||||
// ─── Statistiques ─────────────────────────────────────────────────────────────
|
||||
|
||||
export async function getStatistiques() {
|
||||
const db = await getDb();
|
||||
if (!db) return null;
|
||||
|
||||
// Total établissements
|
||||
const [{ total: totalEtablissements }] = await db
|
||||
.select({ total: sql<number>`COUNT(*)` })
|
||||
.from(etablissements);
|
||||
|
||||
// Total solutions distinctes utilisées
|
||||
const [{ total: totalSolutions }] = await db
|
||||
.select({ total: sql<number>`COUNT(DISTINCT solutionId)` })
|
||||
.from(logicielsEtablissements);
|
||||
|
||||
// Total fiches logiciels (lignes logiciels_etablissements)
|
||||
const [{ total: totalFiches }] = await db
|
||||
.select({ total: sql<number>`COUNT(*)` })
|
||||
.from(logicielsEtablissements);
|
||||
|
||||
// Établissements avec au moins un logiciel
|
||||
const [{ total: etabAvecLogiciel }] = await db
|
||||
.select({ total: sql<number>`COUNT(DISTINCT etablissementId)` })
|
||||
.from(logicielsEtablissements);
|
||||
|
||||
// Répartition par bloc fonctionnel
|
||||
const parBloc = await db
|
||||
.select({
|
||||
blocNom: blocsFonctionnels.nom,
|
||||
count: sql<number>`COUNT(DISTINCT ${logicielsEtablissements.etablissementId})`,
|
||||
})
|
||||
.from(logicielsEtablissements)
|
||||
.innerJoin(solutions, eq(logicielsEtablissements.solutionId, solutions.id))
|
||||
.leftJoin(blocsFonctionnels, eq(solutions.blocFonctionnelId, blocsFonctionnels.id))
|
||||
.groupBy(blocsFonctionnels.nom)
|
||||
.orderBy(sql`COUNT(DISTINCT ${logicielsEtablissements.etablissementId}) DESC`);
|
||||
|
||||
// Répartition par région
|
||||
const parRegion = await db
|
||||
.select({
|
||||
region: etablissements.region,
|
||||
count: sql<number>`COUNT(DISTINCT ${etablissements.id})`,
|
||||
})
|
||||
.from(etablissements)
|
||||
.groupBy(etablissements.region)
|
||||
.orderBy(sql`COUNT(DISTINCT ${etablissements.id}) DESC`);
|
||||
|
||||
// Répartition par état de déploiement
|
||||
const parEtat = await db
|
||||
.select({
|
||||
etat: logicielsEtablissements.etatDeploiement,
|
||||
count: sql<number>`COUNT(*)`,
|
||||
})
|
||||
.from(logicielsEtablissements)
|
||||
.groupBy(logicielsEtablissements.etatDeploiement)
|
||||
.orderBy(sql`COUNT(*) DESC`);
|
||||
|
||||
// Top 10 solutions les plus utilisées
|
||||
const topSolutions = await db
|
||||
.select({
|
||||
solutionNom: solutions.nom,
|
||||
editeurNom: editeurs.nom,
|
||||
count: sql<number>`COUNT(DISTINCT ${logicielsEtablissements.etablissementId})`,
|
||||
})
|
||||
.from(logicielsEtablissements)
|
||||
.innerJoin(solutions, eq(logicielsEtablissements.solutionId, solutions.id))
|
||||
.leftJoin(editeurs, eq(solutions.editeurId, editeurs.id))
|
||||
.groupBy(solutions.id, solutions.nom, editeurs.nom)
|
||||
.orderBy(sql`COUNT(DISTINCT ${logicielsEtablissements.etablissementId}) DESC`)
|
||||
.limit(10);
|
||||
|
||||
// Taux de remplissage (% établissements avec au moins 1 logiciel)
|
||||
const tauxRemplissage = totalEtablissements > 0
|
||||
? Math.round((Number(etabAvecLogiciel) / Number(totalEtablissements)) * 100)
|
||||
: 0;
|
||||
|
||||
return {
|
||||
totalEtablissements: Number(totalEtablissements),
|
||||
totalSolutions: Number(totalSolutions),
|
||||
totalFiches: Number(totalFiches),
|
||||
etabAvecLogiciel: Number(etabAvecLogiciel),
|
||||
tauxRemplissage,
|
||||
parBloc: parBloc.map((r) => ({ nom: r.blocNom ?? "Non renseigné", count: Number(r.count) })),
|
||||
parRegion: parRegion.map((r) => ({ nom: r.region ?? "Non renseignée", count: Number(r.count) })),
|
||||
parEtat: parEtat.map((r) => ({ nom: r.etat ?? "Inconnu", count: Number(r.count) })),
|
||||
topSolutions: topSolutions.map((r) => ({
|
||||
nom: r.solutionNom ?? "",
|
||||
editeur: r.editeurNom ?? "",
|
||||
count: Number(r.count),
|
||||
})),
|
||||
};
|
||||
}
|
||||
Reference in New Issue
Block a user