{/* Bouton refresh : déclenche un run de l'agent (nouveaux emails depuis
le dernier curseur de scan) puis recharge les notifications après un
délai. Le verrou PID de l'agent évite les exécutions concurrentes. */}
{notifError&&
⚠️ Impossible de charger les notifications : {notifError}
{factures.filter(n=>n.facture_status==="confirmée").length>0&&(
{factures.filter(n=>n.facture_status==="confirmée").length} à régler
)}
{factures.filter(n=>!n.facture_data&&n.status!=="dismissed").length>0&&(
{factures.filter(n=>!n.facture_data&&n.status!=="dismissed").length} à analyser
)}
{facturesVisible.length===0&&(
{notifShowAll?"Aucune facture reçue.":"Aucune facture en attente de traitement. 🎉"}
)}
{facturesVisible.map(notif=>{
let ref=null;
try{if(notif.attachment_ref)ref=JSON.parse(notif.attachment_ref);}catch(e){}
const fdRaw=notif.facture_data;
// Normalise : l'ancien format est un objet, le nouveau un tableau
const fdArray=Array.isArray(fdRaw)?fdRaw:(fdRaw?[fdRaw]:[]);
const fd=fdArray[0]||null;
const isMultiFacture=fdArray.length>1;
const fs=notif.facture_status;
const fsCfg=FACTURE_STATUS_CONFIG[fs]||null;
const pdfTmp=notif.pdf_tmp_path;
const pdfOd=notif.pdf_onedrive_url;
const isArchived=["réglée","refusée"].includes(fs)||notif.status==="dismissed";
const isEditing=editingFacture?.id===notif.id;
return (
⚠️ Le % appelé ({pctAppele}%) ne correspond pas à l'avancement total ({pctTotal}%) moins le cumul déjà appelé ({pctCumule}%). Écart : {Math.abs(pctAppeleNum-pctAttendu)}%.
)}
)}
);
}
/* ── Modale : Archivage attestation architecte (étape 1) ────────────────────── */
function AttestationArchiveModal({notif,onArchived,onCancel}){
const params=(notif.proposed_action&¬if.proposed_action.params)||{};
const initFolder =params.suggestedFolder ||'\\Blue\\Programmes\\Programmes validés';
const initFilename=params.suggestedFilename||'Attestation_avancement.pdf';
const [currentPath,setCurrentPath]=React.useState('');
const [folders, setFolders] =React.useState([]);
const [pathExists, setPathExists] =React.useState(true);
const [filename, setFilename] =React.useState(initFilename);
const [newName, setNewName] =React.useState('');
const [showCreate, setShowCreate] =React.useState(false);
const [loading, setLoading] =React.useState(false);
const [archiving, setArchiving] =React.useState(false);
const [creating, setCreating] =React.useState(false);
const [error, setError] =React.useState(null);
const inp={background:'#f8fafc',border:'1px solid #cbd5e1',borderRadius:6,padding:'7px 10px',fontSize:13,color:'#1e293b',width:'100%',boxSizing:'border-box'};
const btn=(bg,sm)=>({background:bg||'#2563eb',color:bg==='#e2e8f0'?'#475569':'#fff',border:'none',borderRadius:6,padding:sm?'5px 12px':'8px 18px',cursor:'pointer',fontSize:sm?12:13,fontWeight:600,whiteSpace:'nowrap'});
const browseTo=React.useCallback(async(path)=>{
setLoading(true);setError(null);
try{
const r=await fetch('/api/agent/onedrive/browse?path='+encodeURIComponent(path));
const d=await r.json();
setCurrentPath(path);setFolders(d.folders||[]);setPathExists(d.exists!==false);
}catch(e){setError('Impossible de charger le dossier : '+e.message);}
finally{setLoading(false);}
},[]);
// Au montage : essaie le chemin suggéré, puis remonte de niveau en niveau
React.useEffect(()=>{
const segs=(initFolder||'').replace(/\\+$/,'').split('\\').filter(Boolean);
const chain=[
initFolder,
segs.length>1?'\\'+segs.slice(0,-1).join('\\'):null,
'\\Blue\\Programmes\\Programmes validés',
].filter(Boolean);
(async()=>{
setLoading(true);
for(const path of chain){
try{
const r=await fetch('/api/agent/onedrive/browse?path='+encodeURIComponent(path));
const d=await r.json();
if(d.exists!==false){
setCurrentPath(path);setFolders(d.folders||[]);setPathExists(true);setLoading(false);
return;
}
}catch(_){}
}
// dernier recours : on affiche quand même le dernier chemin
browseTo('\\Blue\\Programmes\\Programmes validés');
})();
},[]);
const goUp=()=>{
const segs=currentPath.replace(/\\+$/,'').split('\\').filter(Boolean);
if(segs.length<=1)return;
browseTo('\\'+segs.slice(0,-1).join('\\'));
};
const createFolder=async()=>{
if(!newName.trim())return;
setCreating(true);setError(null);
try{
const full=currentPath.replace(/\\+$/,'')+'\\'+newName.trim();
const r=await fetch('/api/agent/onedrive/mkdir',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({path:full})});
const d=await r.json();
if(!d.ok)throw new Error(d.error||'Erreur création dossier');
setNewName('');setShowCreate(false);
await browseTo(full);
}catch(e){setError('Impossible de créer le dossier : '+e.message);}
finally{setCreating(false);}
};
const archive=async()=>{
if(!filename.trim()||!currentPath)return;
setArchiving(true);setError(null);
try{
const r=await fetch('/api/agent/notifications/'+notif.id+'/archive-attachment',{
method:'POST',headers:{'Content-Type':'application/json'},
body:JSON.stringify({folderPath:currentPath,filename:filename.trim()})
});
const d=await r.json();
if(!d.ok)throw new Error(d.error||'Erreur archivage');
onArchived(notif,d.shareUrl,currentPath);
}catch(e){setError('Archivage échoué : '+e.message);}
finally{setArchiving(false);}
};
// Breadcrumb : segments du chemin courant
const crumbs=currentPath?currentPath.replace(/\\+$/,'').split('\\').filter(Boolean):[];
return(
📁 Archiver l'attestation architecte
Sélectionnez le dossier de destination, puis cliquez sur Archiver pour continuer vers la génération de l'appel client.
✓ Appel de fonds {createdAppel?.eg_pct}% enregistré. Envoyez la facture EG à l'architecte pour demander son attestation.
{factureNotifId?(
🧾 Notification facture créée pour le paiement vers l'EG (n°{factureNotifId}). Elle apparaît dans l'onglet Notifications → Factures, prête à être réglée.
):(
ℹ️ Aucune notification facture générée (pas de pièce jointe ou source introuvable).
⚠️ Email de l'architecte non trouvé dans le CRM (cherchez "Karoubi" → Entreprises).
)}
{loadingAttach&&
⏳ Chargement de la facture EG…
}
{egAttachment&&!loadingAttach&&(
📎 PJ : {egAttachment.filename}
)}
{!egAttachment&&!loadingAttach&&(
ℹ️ Aucune PJ trouvée sur la notification. L'email sera envoyé sans pièce jointe.
)}
Corps de l'email
{archSent&&(
✅ Email envoyé. L'agent surveillera la réponse de l'architecte (attestation).
)}
{archErr&&
❌ {archErr}
}
{!archSent&&<>
}
{archSent&&(
)}
}
);
}
/* ── Modale : Générer appel de fonds client (depuis attestation architecte) ──── */
function AppelClientEgModal({notif,attestFolderPath,projects,fiches,crm,rows,values,onClose,onDone}) {
const meta=(notif.metadata)||{};
const params=(notif.proposed_action&¬if.proposed_action.params)||{};
// Sélection programme / lot (pré-rempli si metadata, fallback heuristique via params)
// Sprint F-a : meta.programme_id/lot_idx vient du classifier (whitelist CRM, fiable).
// params.programmeId/lotIdx vient du résultat enrichi de buildProposedAction()
// qui ajoute la résolution heuristique (sujet + preview + noms de PJ). On lit
// metadata d'abord (source de vérité), puis params en fallback (cas où le
// classifier n'a pas su trouver mais l'heuristique oui).
const preProjId=meta.programme_id||params.programmeId||"";
const preLotIdx=meta.lot_idx!=null?String(meta.lot_idx)
:params.lotIdx!=null?String(params.lotIdx)
:"";
const [projId,setProjId]=React.useState(preProjId);
const [lotIdx,setLotIdx]=React.useState(preLotIdx);
// Appel EG en attente pour ce lot
const [appel,setAppel]=React.useState(null);
const [appelLoading,setAppelLoading]=React.useState(false);
const [appelErr,setAppelErr]=React.useState("");
// PDF facture client
const [generating,setGenerating]=React.useState(false);
// Sprint Indivision-4 : tableau de 1 ou 2 entrées {pdf, filename, recipientEmail?, recipientName?, quotePartPct?, montant?, isPrincipal?}
// - seul/couple : 1 entrée, sans champs recipientEmail (utilise clientEmail du lot)
// - indivision : 2 entrées, chacune avec recipientEmail/recipientName/quotePartPct
const [facturePdfs,setFacturePdfs]=React.useState([]);
// PJ attestation
const [attestPdf,setAttestPdf]=React.useState(null);
const [loadingAttest,setLoadingAttest]=React.useState(false);
// Email
const [sending,setSending]=React.useState(false);
const [sent,setSent]=React.useState(false);
const [sendErr,setSendErr]=React.useState("");
// ── Sprint C : modale de replanification (étape 5) ────────────────────────
const [replanOpen,setReplanOpen]=React.useState(false);
// ── Cohérence attestation ↔ appel (sprint 2026-05-21) ─────────────────────
// Si l'avancement certifié dans le PDF (params.avancement_pct) ne correspond
// pas au pct_delta de l'appel en DB, on affiche un récap et un bouton qui
// PATCH l'appel (pct_delta + montant_client recalculé) pour réaligner avant
// génération de la facture.
const [updatingAppel,setUpdatingAppel]=React.useState(false);
const [updateAppelErr,setUpdateAppelErr]=React.useState("");
// ── Création d'un appel ad-hoc (cas historique : appel créé hors système) ─
// Quand aucun appel en attente n'est trouvé, on propose à l'utilisateur de
// saisir manuellement les infos pour créer un appel à la volée.
const [noAppelPending,setNoAppelPending]=React.useState(false);
const [adhocPct,setAdhocPct]=React.useState(params.pct_appele!=null?String(params.pct_appele):"");
const [adhocMontant,setAdhocMontant]=React.useState("");
const [adhocMontantManual,setAdhocMontantManual]=React.useState(false);
const [adhocAttestPct,setAdhocAttestPct]=React.useState(params.avancement_pct!=null?String(params.avancement_pct):"");
const [adhocCreating,setAdhocCreating]=React.useState(false);
// Helper : calcule travauxReel (même formule que FicheDetail)
const calcTravauxReelClient=React.useCallback((pId,lIdx)=>{
try{
const f=(fiches||{})[pId]||{};
const lot=((f.lots)||[])[parseInt(lIdx,10)]||{};
const toNl=v=>parseFloat(String(v||'').replace(/\s/g,'').replace(',','.'))||0;
const prixAchat=toNl(f.prixAchat), devisTravaux=toNl(f.devisTravaux);
const euribor=toNl(f.euribor), montantCredit=toNl(f.montantCredit);
const creditMensuel=montantCredit*(euribor/100+0.025)/12;
const montantCommerce=toNl(f.montantCommerceRdc);
const prixDenormandie=prixAchat-montantCommerce;
const creditTotal=creditMensuel*8;
const achatFNI=prixDenormandie*1.025+toNl(f.dossierBanque)+creditTotal;
const moe=devisTravaux*0.08;
const montantTravaux=moe+toNl(f.dp)+toNl(f.pc)+toNl(f.plaquette)+toNl(f.deplacements)
+toNl(f.avocat)+toNl(f.hommeArt)+toNl(f.geometre)+toNl(f.diagnostics)
+toNl(f.loyerMeuble)+toNl(f.doTrc)+toNl(f.gfa)+devisTravaux;
const prixTotalHorsMarge=achatFNI+montantTravaux;
const prixReelVal=toNl(lot.prixReel);
if(prixReelVal<=0||prixTotalHorsMarge<=0) return 0;
const foncierReelCalc=prixReelVal*achatFNI/prixTotalHorsMarge;
const foncierReelOv=lot.foncierReelO!==""&&lot.foncierReelO!=null?toNl(lot.foncierReelO):null;
const foncierReel=foncierReelOv!==null?foncierReelOv:foncierReelCalc;
return prixReelVal-foncierReel;
}catch(_){return 0;}
},[fiches]);
const inp={background:"#f8fafc",border:"1px solid #cbd5e1",borderRadius:6,color:"#1e293b",padding:"6px 8px",fontSize:13,width:"100%"};
// Lots VENDU
const lots=React.useMemo(()=>{
const fiche=fiches[projId];
if(!fiche||!fiche.lots) return [];
return fiche.lots.map((l,i)=>({idx:i,lot:l})).filter(({lot})=>
["VENDU","AV10","AV40","AV70","AV95","LIVRE"].includes(lot.statutCommercial||"")
);
},[projId,fiches]);
const fiche=fiches[projId]||{};
const proj=(projects||[]).find(p=>p.id===projId)||{};
const lotInfo=lots.find(l=>l.idx===parseInt(lotIdx));
const lot=lotInfo?.lot||{};
const programmeNom=[proj.ville,proj.nom].filter(Boolean).join(' ')||fiche.adresse||'';
// Infos contact client + CGP
// Email client : lookup CRM par clientId (le lot.clientEmail redondant a été
// supprimé au Sprint A3 — source de vérité = crm.clients).
const clientFromCrm=lot.clientId?(crm?.clients||[]).find(c=>c.id===lot.clientId):null;
const clientEmail=clientFromCrm?.email||'';
const cgpId=lot.cgpId||'';
const cgp=(crm?.cgps||[]).find(c=>c.id===cgpId)||null;
const cgpEmail=cgp?(cgp.emails||'').split(/[,;\s]/)[0].trim():'';
// ── Sprint C : données pour la modale de replanification ─────────────────
const lotN=lotIdx!==""?parseInt(lotIdx,10)+1:null;
const lotRow=React.useMemo(()=>{
if(!projId||lotN==null) return null;
return (rows||[]).find(r=>r.projetId===projId&&r.label===`Lot ${lotN}`)||null;
},[rows,projId,lotN]);
const lotRowValues=React.useMemo(()=>{
if(!lotRow) return [];
return (values||[]).filter(v=>v.rowId===lotRow.id);
},[values,lotRow]);
const prixReelLot=Number(lot.prixReel||0);
// Charger appel EG dès que projId+lotIdx sont connus
React.useEffect(()=>{
if(!projId||lotIdx===""){setAppel(null);setAppelErr("");setNoAppelPending(false);return;}
const lotId=String(parseInt(lotIdx)+1);
setAppelLoading(true); setAppelErr(""); setAppel(null); setNoAppelPending(false);
fetch(`/api/appels-eg?programme_id=${encodeURIComponent(projId)}&lot_id=${encodeURIComponent(lotId)}`)
.then(r=>r.json())
.then(rows=>{
const pending=(rows||[]).filter(r=>r.arch_email_sent&&!r.appel_client_sent);
// Pas d'appel en attente : on n'arrête pas le flux, on propose une
// création ad-hoc (cas historique d'appels créés hors système).
if(pending.length===0) setNoAppelPending(true);
else setAppel(pending[0]);
})
.catch(e=>setAppelErr(e.message))
.finally(()=>setAppelLoading(false));
},[projId,lotIdx]);
// Auto-calcul montant_client ad-hoc : pct_delta × travauxReel / 100
// Ne recalcule que si l'utilisateur n'a pas saisi le montant manuellement.
React.useEffect(()=>{
if(adhocMontantManual) return;
const pct=parseFloat(adhocPct);
if(isNaN(pct)||pct<=0||!projId||lotIdx==="") return;
const travauxReel=calcTravauxReelClient(projId,lotIdx);
if(travauxReel>0) setAdhocMontant((Math.round(travauxReel*pct/100*100)/100).toFixed(2));
},[adhocPct,projId,lotIdx,adhocMontantManual,calcTravauxReelClient]);
// Crée un appel ad-hoc via POST /api/appels-eg, marqué directement arch_email_sent=TRUE
// pour qu'il prenne la place de l'appel en attente.
const handleCreateAdhocAppel=async()=>{
if(!projId||lotIdx===""){setAppelErr("Sélectionnez programme + lot d'abord.");return;}
const pct=parseFloat(adhocPct);
const montant=parseFloat(adhocMontant);
const attestPct=adhocAttestPct?parseFloat(adhocAttestPct):pct;
if(isNaN(pct)||pct<=0){setAppelErr("Pct delta invalide.");return;}
if(isNaN(montant)||montant<=0){setAppelErr("Montant client invalide.");return;}
setAdhocCreating(true); setAppelErr("");
try{
const lotId=String(parseInt(lotIdx,10)+1);
const body={
programme_id:projId,
lot_id:lotId,
pct_delta:pct,
montant_client:montant,
attestation_pct:attestPct,
attestation_date:new Date().toISOString().slice(0,10),
// Sprint F-f : lier l'appel ad-hoc à la notif d'attestation source.
// On ne pose l'ID que si on a effectivement chargé une attestation
// depuis cette notif (pattern identique à ligne 2332 / handleReplanConfirm).
attest_notif_id:attestPdf?notif.id:null,
};
const r=await fetch("/api/appels-eg",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(body)});
const newAppel=await r.json();
if(!r.ok||newAppel.error) throw new Error(newAppel.error||"Erreur création appel");
// Marquer arch_email_sent=TRUE (l'appel ad-hoc saute l'étape 3 du workflow)
await fetch(`/api/appels-eg/${newAppel.id}`,{
method:"PATCH",headers:{"Content-Type":"application/json"},
body:JSON.stringify({arch_email_sent:true,arch_email_date:new Date().toISOString()}),
});
setAppel({...newAppel,arch_email_sent:true});
setNoAppelPending(false);
}catch(e){setAppelErr(e.message);}
setAdhocCreating(false);
};
// ── PATCH appel pour réaligner pct_delta / montant_client sur l'attestation
// Appelé depuis le récap cohérence quand l'utilisateur clique « Mettre à jour ».
// Recalcule montant_client = travauxReel × newPctDelta / 100.
// Efface la facture déjà générée pour forcer une regénération sur les bonnes
// valeurs.
const handleUpdateAppel=async()=>{
if(!appel||!projId||lotIdx==="") return;
const avancAttest=parseFloat(params.avancement_pct!=null?params.avancement_pct:meta.avancement_pct);
if(isNaN(avancAttest)){setUpdateAppelErr("Avancement attestation manquant — impossible de réaligner.");return;}
const pctCumuleAppel=Number(appel.pct_cumule||0);
const newPctDelta=params.pct_appele!=null?Number(params.pct_appele):(avancAttest-pctCumuleAppel);
if(!(newPctDelta>0)){setUpdateAppelErr("Le nouveau pct_delta serait ≤ 0 — vérifiez l'attestation.");return;}
const travauxReel=calcTravauxReelClient(projId,lotIdx);
if(!(travauxReel>0)){setUpdateAppelErr("Impossible de recalculer le montant (prixReel/foncier manquants).");return;}
const newMontant=Math.round(travauxReel*newPctDelta/100*100)/100;
setUpdatingAppel(true); setUpdateAppelErr("");
try{
const r=await fetch(`/api/appels-eg/${appel.id}`,{
method:"PATCH",
headers:{"Content-Type":"application/json"},
body:JSON.stringify({
pct_delta:newPctDelta,
montant_client:newMontant,
attestation_pct:avancAttest,
}),
});
const d=await r.json();
if(!r.ok||d.error) throw new Error(d.error||"Erreur PATCH appel");
// PATCH ne retourne pas pct_cumule (champ calculé) — on le préserve
setAppel({...d,pct_cumule:appel.pct_cumule});
setFacturePdfs([]); // force la regénération avec les bons chiffres
}catch(e){setUpdateAppelErr("Mise à jour échouée : "+e.message);}
setUpdatingAppel(false);
};
// Charger attestation PDF depuis la notification
const loadAttestation=React.useCallback(async()=>{
setLoadingAttest(true);
try{
const resp=await fetch(`/api/agent/notifications/${notif.id}/attachment`);
if(!resp.ok){setLoadingAttest(false);return;}
const blob=await resp.blob();
const base64=await new Promise(resolve=>{
const reader=new FileReader();
reader.onloadend=()=>resolve(reader.result.split(',')[1]);
reader.readAsDataURL(blob);
});
let filename='attestation.pdf';
try{const ref=JSON.parse(notif.attachment_ref||'{}');filename=ref.filename||filename;}catch(_){}
setAttestPdf({filename,contentType:'application/pdf',content:base64});
}catch(e){console.warn('Chargement attestation échoué:',e.message);}
setLoadingAttest(false);
},[notif.id,notif.attachment_ref]);
React.useEffect(()=>{loadAttestation();},[loadAttestation]);
const handleGeneratePdf=async()=>{
if(!appel) return;
setGenerating(true); setSendErr("");
try{
const r=await fetch(`/api/appels-eg/${appel.id}/generate-facture-client`,{
method:"POST",
headers:{"Content-Type":"application/json"},
body:JSON.stringify({folderPath:attestFolderPath||null}),
});
const d=await r.json();
if(!r.ok||d.error) throw new Error(d.error||"Erreur génération");
// Sprint Indivision-4 : la route peut renvoyer {pdf,filename} (legacy seul/couple)
// ou {pdfs:[{pdf,filename,recipientEmail,recipientName,quotePartPct,...}]} (indivision).
if(Array.isArray(d.pdfs)&&d.pdfs.length>0){
setFacturePdfs(d.pdfs);
}else if(d.pdf&&d.filename){
setFacturePdfs([{pdf:d.pdf,filename:d.filename}]);
}else{
throw new Error("Réponse inattendue du serveur (pdf|pdfs manquant)");
}
}catch(e){setSendErr(e.message);}
setGenerating(false);
};
const handlePreviewPdf=React.useCallback((idx)=>{
const target=facturePdfs[idx??0];
if(!target) return;
const chars=atob(target.pdf);
const bytes=new Uint8Array(chars.length);
for(let i=0;i{
if(!appel) return '';
const isIndivision=facturePdfs.length===2;
// Nom à utiliser dans la salutation
let clientNom;
if(isIndivision){
clientNom=`${facturePdfs[0].recipientName||'[Acquéreur 1]'} et ${facturePdfs[1].recipientName||'[Acquéreur 2]'}`;
}else{
clientNom=[lot.clientNom,lot.conjointNomPrenom||lot.clientNomConjoint].filter(Boolean).join(' & ')||'[Client]';
}
const pct=appel.pct_delta||appel.eg_pct||0;
const montant=appel.montant_client?Number(appel.montant_client).toLocaleString('fr-FR',{minimumFractionDigits:2,maximumFractionDigits:2}):'';
const iban=fiche.ibanProgramme||'[IBAN À COMPLÉTER]';
const bic=fiche.bic||'';
const lotN=parseInt(lotIdx)+1;
const fmtEur=n=>Number(n||0).toLocaleString('fr-FR',{minimumFractionDigits:2,maximumFractionDigits:2});
// Bloc spécifique indivision : détail par investisseur (quote-part + montant)
const indivisionBlock=isIndivision?`
Acquisition en indivision — détail par investisseur :
${facturePdfs.map(p=>` • ${p.recipientName} — Quote-part ${p.quotePartPct}% — Montant dû ${fmtEur(p.montant)} €`).join('\n')}
Chaque investisseur trouvera sa facture nominative en pièce jointe.`:'';
const facturesIntro=isIndivision
?`- Les factures correspondant à l'appel de fonds de ${pct}% des travaux${montant?`, d'un montant total de ${montant} €`:''}`
:`- La facture correspondant à l'appel de fonds de ${pct}% des travaux${montant?`, d'un montant de ${montant} €`:''}`;
return `Madame, Monsieur ${clientNom},
Suite à l'avancement des travaux du programme ${programmeNom}, nous avons le plaisir de vous adresser :
${facturesIntro}
- L'attestation d'avancement délivrée par l'architecte
${indivisionBlock}
INFORMATIONS :
─────────────────────────────────────────
Programme : ${programmeNom}
Lot N° : ${lotN}${lot.type?` (${lot.type})`:''}
Avancement : ${pct}%${montant?`\n Montant : ${montant} €`:''}
─────────────────────────────────────────
Conformément à nos conditions générales, nous vous demandons de bien vouloir procéder au règlement à réception par virement :
IBAN : ${iban}${bic?`\n BIC : ${bic}`:''}
Nous restons à votre disposition pour tout renseignement.
Cordialement,`;
},[appel,lot,lotIdx,programmeNom,fiche,facturePdfs]);
// ── Étape 5 (Sprint C) ────────────────────────────────────────────────────
// Le clic sur « Envoyer » ouvre la modale de replanification du plan. Elle
// appelle ensuite handleReplanConfirm qui exécute /replan (atomique : maj plan
// + appel_client_sent=TRUE) puis envoie l'email.
// Sprint Indivision-4 : en indivision, on utilise les recipientEmail renvoyés par
// le backend ; sinon (seul/couple) on utilise clientEmail du lot.
const isIndivisionFactures=facturePdfs.length===2;
const recipientsTo=React.useMemo(()=>{
if(isIndivisionFactures){
return facturePdfs.map(p=>p.recipientEmail).filter(Boolean);
}
return clientEmail?[clientEmail]:[];
},[isIndivisionFactures,facturePdfs,clientEmail]);
const handleSend=()=>{
if(facturePdfs.length===0){setSendErr("Générez d'abord la facture PDF.");return;}
if(isIndivisionFactures){
if(recipientsTo.length<2){
const missing=facturePdfs.filter(p=>!p.recipientEmail).map(p=>p.recipientName||'?').join(', ');
setSendErr(`Email manquant pour l'un des investisseurs (indivision) : ${missing}. Renseignez l'email dans la fiche CRM.`);
return;
}
}else{
if(!clientEmail){setSendErr("Email client introuvable sur ce lot.");return;}
}
if(!lotRow){setSendErr(`Ligne « Lot ${lotN} » introuvable dans le plan de trésorerie — impossible de replanifier.`);return;}
if(!(prixReelLot>0)){setSendErr("prixReel du lot non renseigné — impossible de vérifier l'invariant.");return;}
setSendErr("");
setReplanOpen(true);
};
// Appelé par AppelReplanModal après validation utilisateur.
// 1. POST /api/appels-eg/:id/replan (transaction : update plan_values + set appel_client_sent)
// 2. Si OK : ferme la modale, envoie l'email, marque sent, appelle onDone.
// Si l'email échoue après /replan : l'appel est marqué sent en DB ; on remonte
// l'erreur au parent pour permettre une action manuelle (sans rejouer /replan).
const handleReplanConfirm=async(changes,attestNotifIdArg)=>{
// 1. /replan (atomique côté serveur)
const rr=await fetch(`/api/appels-eg/${appel.id}/replan`,{
method:"POST",headers:{"Content-Type":"application/json"},
body:JSON.stringify({changes,attestNotifId:attestNotifIdArg||null}),
});
const rd=await rr.json();
if(!rr.ok||rd.error) throw new Error(rd.error||"Erreur lors de la replanification");
// Sprint F-d : l'appel vient de passer appel_client_sent=TRUE, donc pct_cumule
// change côté DB. On signale aux autres composants (FichesProgrammes notamment)
// qu'ils doivent rafraîchir le badge % avancement.
window.dispatchEvent(new CustomEvent('appels-eg-updated',{detail:{programme_id:projId,lot_id:String(parseInt(lotIdx,10)+1)}}));
// 2. Email — fermeture de la modale avant l'envoi pour rendre la main visuellement
setReplanOpen(false);
setSending(true);
try{
// Sprint Indivision-4 : 1 ou 2 factures + attestation. `to` = liste des destinataires
// séparés par virgule (Graph API et Nodemailer acceptent ce format nativement).
const attachments=facturePdfs.map(p=>({filename:p.filename,contentType:'application/pdf',content:p.pdf}));
if(attestPdf) attachments.push({filename:attestPdf.filename,contentType:attestPdf.contentType,content:attestPdf.content});
const pct=appel.pct_delta||appel.eg_pct||0;
const toField=recipientsTo.join(', ');
const payload={
to:toField,
subject:`Appel de fonds ${pct}% travaux — ${programmeNom} — Lot ${lotN}`,
body:emailBody,
attachments,
};
if(cgpEmail) payload.cc=cgpEmail;
const r=await fetch("/api/email/send",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(payload)});
const d=await r.json();
if(!r.ok||d.error) throw new Error(d.error||"Erreur envoi");
setSent(true);
await onDone();
}catch(e){
// L'appel est déjà marqué envoyé côté DB (par /replan). L'email lui n'est
// pas parti. On le signale clairement à l'utilisateur.
setSendErr(`Plan mis à jour avec succès, mais l'envoi email a échoué : ${e.message}. L'appel est marqué comme envoyé en base. Renvoyez le mail manuellement si nécessaire.`);
setSending(false);
}
};
const projs=(projects||[]).filter(p=>!p.isGlobal&&(!p.statut||p.statut==='En cours'));
return(<>
{if(e.target===e.currentTarget)onClose();}}>
e.stopPropagation()}>
💶 Générer appel de fonds client
Attestation reçue : {notif.subject}
{/* Sélection programme + lot */}
Programme *
Lot *
{appelLoading&&
⏳ Recherche de l'appel de fonds…
}
{appelErr&&
❌ {appelErr}
}
{/* ── Cas historique : pas d'appel en attente → création ad-hoc ── */}
{noAppelPending&&!appel&&(
⚠️ Aucun appel de fonds en attente pour ce lot.
Si cet email correspond à un appel créé manuellement (cas historique, antérieur à l'automatisation), saisissez les informations ci-dessous pour le rattacher au système :