bastouu/mdb
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

pocket

Browse Source
This commit is contained in:
Bastien COIGNOUX
2026-05-04 08:28:32 +02:00
parent 7f94f83940
commit 695d4e76d0
46 changed files with 13390 additions and 251 deletions
Download Patch File Download Diff File Expand all files Collapse all files

166
app/hooks/useAnalyse.ts Normal file
View File

@ -0,0 +1,166 @@
import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
import { getCurrentUserId, pb } from '@/services/pocketbase';
import type { AnalyseFinanciereRecord, TypeBienFiscal } from '@/types/collections';
import { roundMoney } from '@/utils/format';
export type AnalyseFormInput = {
prix_achat?: number;
type_bien_fiscal?: TypeBienFiscal;
frais_notaire?: number;
frais_agence_achat?: number;
budget_travaux?: number;
reserve_imprevus_pct?: number;
duree_portage_mois?: number;
taux_credit?: number;
taxe_fonciere_annuelle?: number;
charges_copropriete_mensuelle?: number;
prix_revente_cible?: number;
frais_agence_vente_pct?: number;
taux_impot?: number;
};
export type AnalyseCalculated = {
frais_notaire: number;
travaux_total: number;
frais_portage_total: number;
prix_revient: number;
marge_brute: number;
marge_nette: number;
marge_brute_pct: number;
marge_nette_pct: number;
rendement_net_pct: number;
};
export function calculateResults(data: AnalyseFormInput): AnalyseCalculated {
const prixAchat = data.prix_achat ?? 0;
const typeFiscal = data.type_bien_fiscal ?? 'ancien';
const fraisNotaireAuto = prixAchat * (typeFiscal === 'neuf' ? 0.02 : 0.075);
const fraisNotaire = data.frais_notaire ?? fraisNotaireAuto;
const budgetTravaux = data.budget_travaux ?? 0;
const reservePct = data.reserve_imprevus_pct ?? 0;
const travauxTotal = budgetTravaux * (1 + reservePct / 100);
const tauxCredit = data.taux_credit ?? 0;
const taxeFon = data.taxe_fonciere_annuelle ?? 0;
const charges = data.charges_copropriete_mensuelle ?? 0;
const dureeMois = data.duree_portage_mois ?? 0;
const mensualiteCredit = (prixAchat * (tauxCredit / 100)) / 12;
const mensualiteFoncier = taxeFon / 12;
const fraisPortageTotal = (mensualiteCredit + mensualiteFoncier + charges) * dureeMois;
const fraisAgenceAchat = data.frais_agence_achat ?? 0;
const prixRevient = prixAchat + fraisNotaire + fraisAgenceAchat + travauxTotal + fraisPortageTotal;
const prixRevente = data.prix_revente_cible ?? 0;
const margeBrute = prixRevente - prixRevient;
const fraisAgenceVentePct = data.frais_agence_vente_pct ?? 0;
const tauxImpot = data.taux_impot ?? 0;
const fraisAgenceVente = prixRevente * (fraisAgenceVentePct / 100);
const impotSurMarge = margeBrute * (tauxImpot / 100);
const margeNette = margeBrute - fraisAgenceVente - impotSurMarge;
const margeBrutePct = prixRevient > 0 ? (margeBrute / prixRevient) * 100 : 0;
const margeNettePct = prixRevente > 0 ? (margeNette / prixRevente) * 100 : 0;
const rendementNetPct = prixRevient > 0 ? (margeNette / prixRevient) * 100 : 0;
return {
frais_notaire: roundMoney(fraisNotaire),
travaux_total: roundMoney(travauxTotal),
frais_portage_total: roundMoney(fraisPortageTotal),
prix_revient: roundMoney(prixRevient),
marge_brute: roundMoney(margeBrute),
marge_nette: roundMoney(margeNette),
marge_brute_pct: roundMoney(margeBrutePct),
marge_nette_pct: roundMoney(margeNettePct),
rendement_net_pct: roundMoney(rendementNetPct),
};
}
export function rendementColor(rendementNetPct: number): string {
if (rendementNetPct > 15) return '#16A34A';
if (rendementNetPct >= 8) return '#EA580C';
return '#DC2626';
}
function formToRecord(form: AnalyseFormInput, calc: AnalyseCalculated): Record<string, unknown> {
return {
prix_achat: form.prix_achat,
type_bien_fiscal: form.type_bien_fiscal,
frais_notaire: calc.frais_notaire,
frais_agence_achat: form.frais_agence_achat,
budget_travaux: form.budget_travaux,
reserve_imprevus_pct: form.reserve_imprevus_pct,
duree_portage_mois: form.duree_portage_mois,
taux_credit: form.taux_credit,
taxe_fonciere_annuelle: form.taxe_fonciere_annuelle,
charges_copropriete_mensuelle: form.charges_copropriete_mensuelle,
prix_revente_cible: form.prix_revente_cible,
frais_agence_vente_pct: form.frais_agence_vente_pct,
taux_impot: form.taux_impot,
marge_brute: calc.marge_brute,
marge_brute_pct: calc.marge_brute_pct,
marge_nette: calc.marge_nette,
marge_nette_pct: calc.marge_nette_pct,
};
}
export function useAnalyse(bienId: string | undefined) {
const uid = getCurrentUserId();
const queryClient = useQueryClient();
const query = useQuery({
queryKey: ['analyse_financiere', bienId, uid],
queryFn: async (): Promise<AnalyseFinanciereRecord | null> => {
if (!bienId || !uid) return null;
const res = await pb.collection('analyses_financieres').getList<AnalyseFinanciereRecord>(1, 1, {
filter: `bien="${bienId}" && user="${uid}"`,
sort: '-id',
});
return res.items[0] ?? null;
},
enabled: Boolean(bienId && uid),
});
const saveMutation = useMutation({
mutationFn: async (data: AnalyseFormInput & { notes?: string }) => {
if (!bienId || !uid) throw new Error('Données manquantes');
const res = await pb.collection('analyses_financieres').getList<AnalyseFinanciereRecord>(1, 1, {
filter: `bien="${bienId}" && user="${uid}"`,
sort: '-id',
});
const existing = res.items[0];
const calc = calculateResults(data);
const payload = {
...formToRecord(data, calc),
notes: data.notes,
};
if (existing) {
return pb.collection('analyses_financieres').update<AnalyseFinanciereRecord>(existing.id, payload);
}
return pb.collection('analyses_financieres').create<AnalyseFinanciereRecord>({
user: uid,
bien: bienId,
...payload,
});
},
onSuccess: () => {
void queryClient.invalidateQueries({ queryKey: ['analyse_financiere', bienId, uid] });
void queryClient.invalidateQueries({ queryKey: ['bien_detail', bienId] });
void queryClient.invalidateQueries({ queryKey: ['biens', uid] });
},
});
return {
analyse: query.data ?? null,
isLoading: query.isPending,
error: query.error,
refetch: query.refetch,
fetchAnalyse: query.refetch,
saveAnalyse: saveMutation.mutateAsync,
isSaving: saveMutation.isPending,
calculateResults,
};
}

204
app/hooks/useBiens.ts Normal file
View File

@ -0,0 +1,204 @@
import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
import { ClientResponseError } from 'pocketbase';
import { getCurrentUserId, pb } from '@/services/pocketbase';
import type {
AnalyseFinanciereRecord,
BienCreate,
BienRecord,
BienUpdate,
ContactRecord,
DocumentRecord,
EtapePipelineRecord,
NoteRecord,
VisiteRecord,
} from '@/types/collections';
export type BiensFilters = {
search?: string;
};
export type BienExpanded = BienRecord & {
expand?: {
etape?: EtapePipelineRecord;
source_contact?: ContactRecord;
};
};
export type BienDetailBundle = {
bien: BienExpanded;
visites: VisiteRecord[];
notes: NoteRecord[];
documents: DocumentRecord[];
analyse: AnalyseFinanciereRecord | null;
};
async function fetchPrixMapForUser(uid: string): Promise<Map<string, number>> {
const analyses = await pb.collection('analyses_financieres').getFullList<AnalyseFinanciereRecord>({
filter: `user="${uid}"`,
});
const map = new Map<string, number>();
for (const a of analyses) {
if (a.prix_achat != null && a.bien) {
map.set(a.bien, a.prix_achat);
}
}
return map;
}
export async function fetchBienDetail(bienId: string): Promise<BienDetailBundle> {
const uid = getCurrentUserId();
if (!uid) throw new Error('Utilisateur non connecté');
let bien: BienExpanded;
try {
bien = await pb.collection('biens').getOne<BienExpanded>(bienId, {
expand: 'etape,source_contact',
});
} catch (e) {
if (e instanceof ClientResponseError && (e.status === 404 || e.status === 400)) {
throw new Error(
"Ce bien n'existe pas ou a été supprimé (vérifie l'admin PocketBase). Retourne à la liste des biens.",
);
}
throw e;
}
if (bien.user !== uid) {
throw new Error('Accès refusé');
}
const [visites, notes, documents, analyses] = await Promise.all([
pb.collection('visites').getFullList<VisiteRecord>({
filter: `bien="${bienId}"`,
sort: '-date_visite',
}),
pb.collection('notes_biens').getFullList<NoteRecord>({
filter: `bien="${bienId}"`,
sort: '-id',
}),
pb.collection('documents_biens').getFullList<DocumentRecord>({
filter: `bien="${bienId}"`,
sort: '-id',
}),
pb.collection('analyses_financieres').getList<AnalyseFinanciereRecord>(1, 1, {
filter: `bien="${bienId}" && user="${uid}"`,
sort: '-id',
}),
]);
const analyse = analyses.items[0] ?? null;
const byUpdatedDesc = (a: { updated?: string }, b: { updated?: string }) =>
(b.updated ?? '').localeCompare(a.updated ?? '');
return {
bien,
visites,
notes: [...notes].sort(byUpdatedDesc),
documents: [...documents].sort(byUpdatedDesc),
analyse,
};
}
export function useBiens(filters?: BiensFilters) {
const uid = getCurrentUserId();
const queryClient = useQueryClient();
const search = filters?.search?.trim() ?? '';
const query = useQuery({
queryKey: ['biens', uid, search],
queryFn: async () => {
if (!uid) return { biens: [] as BienExpanded[], prixByBien: new Map<string, number>() };
const parts = [`user="${uid}"`];
if (search.length > 0) {
const esc = search.replace(/"/g, '\\"');
parts.push(`(titre ~ "${esc}" || ville ~ "${esc}" || adresse ~ "${esc}" || code_postal ~ "${esc}")`);
}
const filter = parts.join(' && ');
const [biens, prixByBien] = await Promise.all([
pb.collection('biens').getFullList<BienExpanded>({
filter,
sort: '-id',
expand: 'etape,source_contact',
}),
fetchPrixMapForUser(uid),
]);
return { biens, prixByBien };
},
enabled: Boolean(uid),
});
const invalidateBiens = () => {
void queryClient.invalidateQueries({ queryKey: ['biens'] });
};
const createBien = useMutation({
mutationFn: async (payload: { bien: BienCreate; prixEstime?: number }) => {
if (!uid) throw new Error('Utilisateur non connecté');
const created = await pb.collection('biens').create<BienRecord>(payload.bien);
if (
payload.prixEstime != null &&
!Number.isNaN(payload.prixEstime) &&
payload.prixEstime > 0
) {
await pb.collection('analyses_financieres').create({
user: uid,
bien: created.id,
prix_achat: payload.prixEstime,
type_bien_fiscal: 'ancien',
});
}
return created.id;
},
onSuccess: invalidateBiens,
});
const updateBien = useMutation({
mutationFn: async ({ id, data }: { id: string; data: BienUpdate }) => {
return pb.collection('biens').update<BienRecord>(id, data);
},
onSuccess: (_, variables) => {
invalidateBiens();
void queryClient.invalidateQueries({ queryKey: ['bien_detail', variables.id] });
},
});
const deleteBien = useMutation({
mutationFn: async (id: string) => pb.collection('biens').delete(id),
onSuccess: invalidateBiens,
});
const moveBienToEtape = useMutation({
mutationFn: async ({ bienId, etapeId }: { bienId: string; etapeId: string }) => {
return pb.collection('biens').update(bienId, { etape: etapeId });
},
onSuccess: (_, variables) => {
invalidateBiens();
void queryClient.invalidateQueries({ queryKey: ['bien_detail', variables.bienId] });
},
});
return {
biens: query.data?.biens ?? [],
prixByBien: query.data?.prixByBien ?? new Map<string, number>(),
isLoading: query.isPending,
error: query.error,
refetch: query.refetch,
fetchBiens: query.refetch,
createBien: createBien.mutateAsync,
updateBien: updateBien.mutateAsync,
deleteBien: deleteBien.mutateAsync,
moveBienToEtape: moveBienToEtape.mutateAsync,
};
}
export function useBienDetail(bienId: string | undefined) {
const query = useQuery({
queryKey: ['bien_detail', bienId],
queryFn: () => fetchBienDetail(bienId!),
enabled: Boolean(bienId),
});
return {
bundle: query.data ?? null,
isLoading: query.isPending,
error: query.error,
refetch: query.refetch,
fetchBienDetail: query.refetch,
};
}

67
app/hooks/useEtapes.ts Normal file
View File

@ -0,0 +1,67 @@
import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
import { getCurrentUserId, pb } from '@/services/pocketbase';
import type { EtapePipelineRecord } from '@/types/collections';
const DEFAULT_ETAPES: { nom: string; ordre: number; couleur: string; is_terminal?: boolean }[] = [
{ nom: 'Prospection', ordre: 1, couleur: '#64748B' },
{ nom: 'Contact établi', ordre: 2, couleur: '#0EA5E9' },
{ nom: 'Visite', ordre: 3, couleur: '#8B5CF6' },
{ nom: 'Analyse', ordre: 4, couleur: '#F59E0B' },
{ nom: 'Offre', ordre: 5, couleur: '#EC4899' },
{ nom: 'Compromis', ordre: 6, couleur: '#10B981' },
{ nom: 'Acte / acquisition', ordre: 7, couleur: '#16A34A', is_terminal: true },
];
export function useEtapes() {
const uid = getCurrentUserId();
const queryClient = useQueryClient();
const query = useQuery({
queryKey: ['etapes_pipeline', uid],
queryFn: async () => {
if (!uid) return [] as EtapePipelineRecord[];
const list = await pb.collection('etapes_pipeline').getFullList<EtapePipelineRecord>({
filter: `user="${uid}"`,
sort: 'ordre',
});
return list;
},
enabled: Boolean(uid),
});
const initMutation = useMutation({
mutationFn: async () => {
if (!uid) throw new Error('Non connecté');
const existing = await pb.collection('etapes_pipeline').getFullList<EtapePipelineRecord>({
filter: `user="${uid}"`,
});
if (existing.length > 0) return existing;
for (const e of DEFAULT_ETAPES) {
await pb.collection('etapes_pipeline').create({
user: uid,
nom: e.nom,
ordre: e.ordre,
couleur: e.couleur,
is_terminal: e.is_terminal ?? false,
});
}
return pb.collection('etapes_pipeline').getFullList<EtapePipelineRecord>({
filter: `user="${uid}"`,
sort: 'ordre',
});
},
onSuccess: () => {
void queryClient.invalidateQueries({ queryKey: ['etapes_pipeline'] });
},
});
return {
etapes: query.data ?? [],
isLoading: query.isPending,
error: query.error,
initEtapesDefaut: initMutation.mutateAsync,
initError: initMutation.error,
isInitPending: initMutation.isPending,
};
}

79
app/hooks/useNoteLibre.ts Normal file
View File

@ -0,0 +1,79 @@
import { useQueryClient } from '@tanstack/react-query';
import { useEffect, useRef, useState } from 'react';
import { getCurrentUserId, pb } from '@/services/pocketbase';
import type { NoteRecord } from '@/types/collections';
/**
* Note libre : hydrate depuis le bundle `useBienDetail` (évite un 2e GET sur notes_biens).
*/
export function useNoteLibre(bienId: string | undefined, notesFromBundle: NoteRecord[] | undefined) {
const uid = getCurrentUserId();
const queryClient = useQueryClient();
const [draft, setDraftState] = useState('');
const [hydrated, setHydrated] = useState(false);
const noteIdRef = useRef<string | null>(null);
const userEdited = useRef(false);
const prevBienId = useRef<string | undefined>(undefined);
useEffect(() => {
if (prevBienId.current !== bienId) {
prevBienId.current = bienId;
userEdited.current = false;
}
}, [bienId]);
useEffect(() => {
if (!bienId || !uid) {
setHydrated(false);
return;
}
if (notesFromBundle === undefined) {
setHydrated(false);
return;
}
const libre =
notesFromBundle.find((r) => {
const t = r.type_note as string | undefined;
return t == null || t === '' || t === 'libre';
}) ?? null;
noteIdRef.current = libre?.id ?? null;
if (!userEdited.current) {
setDraftState(libre?.contenu ?? '');
}
setHydrated(true);
}, [bienId, uid, notesFromBundle]);
useEffect(() => {
if (!bienId || !uid || !hydrated || !userEdited.current) return;
const t = setTimeout(() => {
void (async () => {
try {
if (!draft.trim()) return;
if (noteIdRef.current) {
await pb.collection('notes_biens').update(noteIdRef.current, { contenu: draft });
} else {
const c = await pb.collection('notes_biens').create<NoteRecord>({
user: uid,
bien: bienId,
contenu: draft,
type_note: 'libre',
});
noteIdRef.current = c.id;
}
void queryClient.invalidateQueries({ queryKey: ['bien_detail', bienId] });
} catch {
/* ignore autosave */
}
})();
}, 500);
return () => clearTimeout(t);
}, [draft, bienId, uid, hydrated, queryClient]);
const setDraft = (text: string) => {
userEdited.current = true;
setDraftState(text);
};
return { draft, setDraft, hydrated };
}