{data.saved_at ? (
Enregistré {chStamp(data.saved_at)}
) : command(
'save',
data.propose_ccam_after_save
? 'Enregistrer et proposer le CCAM'
: ((msg.widget === 'ordonnance' || msg.widget === 'courrier')
? 'Enregistrer au dossier' : 'Enregistrer'),
)}
);
}
return (
{discarded ? (
<>
Codage écarté
{command('discard', 'Rétablir', { discarded: false })}
) : (
<>
{/* Une signature déjà posée ne se repose pas : elle s'affiche. Toute
modification l'efface côté serveur, et le bouton revient. */}
{confirmed ? (
Confirmé {chStamp(data.confirmed_at)}
) : command('confirm', 'Confirmer')}
{command('discard', 'Rejeter', { discarded: true })}
)}
);
}
return (
{capabilities.map((capability) => {
const meta = CH_ACTION_META[capability.action];
if (!meta) return null;
// Le codage s'édite en cochant les actes dans la carte elle-même, et se
// confirme ou s'écarte au pied de celle-ci : l'en-tête ne garde que
// « copier », dont l'effet ne dépend pas de ce qu'on vient de décider.
if (msg.widget === 'ccam' && capability.action !== 'copy') return null;
// Enregistrer se lit au pied de la carte, sous le compte rendu – ou sous le
// relevé – qu'il fait entrer au dossier : une icône de plus dans l'en-tête ne
// dirait pas ce qu'elle engage.
if ((msg.widget === 'cr' || msg.widget === 'constantes' || msg.widget === 'ordonnance'
|| msg.widget === 'courrier')
&& capability.action === 'save') return null;
return (
void run(capability.action)}
/>
);
})}
);
}
// Aucun libellé pour `send` : tant qu'aucun canal sécurisé n'est configuré, le serveur
// refuse l'envoi, et un mot d'aboutissement gardé au chaud ici finirait par s'afficher.
// Il reviendra avec l'adaptateur MSSanté ou Apicrypt, et dira ce que le reçu prouve.
const CH_ACTION_RESULTS = {
open: 'Ouverture enregistrée',
copy: 'Copié',
print: 'PDF ouvert',
confirm: 'Rendez-vous confirmé',
};
// Confirmer un codage n'est pas confirmer un rendez-vous, et écarter n'est pas
// rétablir : un message unique par action mentirait une fois sur deux.
function chActionResult(widget, action, options) {
if (widget === 'ccam' && action === 'confirm') return 'Codage confirmé';
if (action === 'save') return 'Enregistré au dossier';
if (action === 'discard') {
return options?.discarded === false ? 'Codage rétabli' : 'Codage écarté';
}
return CH_ACTION_RESULTS[action] || 'Action enregistrée';
}
// Horodatage d'une signature : jour et heure, sans les secondes que personne ne lit.
function chStamp(value) {
const at = new Date(value);
if (Number.isNaN(at.getTime())) return '';
return `le ${at.toLocaleDateString('fr-FR', { day: '2-digit', month: '2-digit' })} à ${
at.toLocaleTimeString('fr-FR', { hour: '2-digit', minute: '2-digit' })}`;
}
// Le presse-papiers doit recevoir le contenu réellement affiché, pas un JSON.
function chWidgetPlainText(msg) {
const data = msg.data || {};
if (msg.widget === 'email') return `${data.subject || ''}\n\n${data.body || ''}`.trim();
if (msg.widget === 'courrier') return `${data.to || ''}\n${data.subject || ''}\n\n${data.body || ''}`.trim();
if (msg.widget === 'cr') {
return [data.title, ...(data.sections || []).map((s) => `${s.heading}\n${s.content}`)]
.filter(Boolean).join('\n\n');
}
if (msg.widget === 'constantes') {
return (data.vitals || []).map((v) => `${v.label} ${v.value} ${v.unit || ''}`.trim()).join('\n');
}
if (msg.widget === 'ccam') {
const principal = data.principal ? `${data.principal.code} ${data.principal.label}` : '';
const extras = (data.complementaires || []).map((c) => `${c.code} ${c.label}`).join('\n');
return [principal, extras].filter(Boolean).join('\n');
}
return msg.text || '';
}
async function chOpenDocumentPdf(widget, runtime, previewWindow) {
const data = widget?.data || {};
if (!previewWindow || !runtime?.documentPdf || !data.patient_id
|| !data.document_id || !Number.isInteger(data.document_version)) {
throw new Error('La version PDF de ce document est indisponible');
}
const result = await runtime.documentPdf(data.patient_id, {
id: data.document_id,
version: data.document_version,
document_type: widget.type === 'courrier' ? 'LETTRE' : 'ORD',
}, false);
previewWindow.location.replace(result.url);
window.setTimeout(() => URL.revokeObjectURL(result.url), 60000);
}
// ═══════════════════════════════════════════════════════════
// Rendu Markdown minimal des réponses
// ═══════════════════════════════════════════════════════════
// Le modèle répond en Markdown : sans interprétation, l'utilisateur lit des
// astérisques au milieu d'un texte clinique. Les éléments sont construits en
// React et jamais injectés en HTML : la réponse reste une donnée non fiable,
// et `dangerouslySetInnerHTML` ouvrirait une injection depuis une pièce jointe
// ou un message d'un tiers.
function chInline(text, keyPrefix) {
const nodes = [];
// Gras, italique et code littéral, dans cet ordre : `**` doit être reconnu
// avant `*`, sinon un gras se lit comme deux italiques.
const pattern = /(\*\*[^*]+\*\*|__[^_]+__|`[^`]+`|\*[^*\n]+\*|_[^_\n]+_)/g;
let last = 0;
let match = pattern.exec(text);
let index = 0;
while (match) {
if (match.index > last) nodes.push(text.slice(last, match.index));
const token = match[0];
const key = `${keyPrefix}-i${index}`;
index += 1;
if (token.startsWith('**') || token.startsWith('__')) {
nodes.push({token.slice(2, -2)});
} else if (token.startsWith('`')) {
nodes.push(
{token.slice(1, -1)},
);
} else {
nodes.push({token.slice(1, -1)});
}
last = match.index + token.length;
match = pattern.exec(text);
}
if (last < text.length) nodes.push(text.slice(last));
return nodes.length ? nodes : [text];
}
function ChatMarkdown({ text }) {
if (!text) return null;
const lines = String(text).replace(/\r/g, '').split('\n');
const blocks = [];
let list = null;
const flushList = () => {
if (!list) return;
const Tag = list.ordered ? 'ol' : 'ul';
blocks.push(
{chInline(heading[2], `h${lineIndex}`)}
,
);
return;
}
const bullet = /^\s*[-*•]\s+(.*)$/.exec(line);
const ordered = /^\s*(\d+)[.)]\s+(.*)$/.exec(line);
if (bullet || ordered) {
const isOrdered = Boolean(ordered);
if (!list || list.ordered !== isOrdered) { flushList(); list = { ordered: isOrdered, items: [] }; }
list.items.push(isOrdered ? ordered[2] : bullet[1]);
return;
}
flushList();
blocks.push(
{chInline(line, `p${lineIndex}`)}
,
);
});
flushList();
return {blocks}
;
}
// ═══════════════════════════════════════════════════════════
// Pièces jointes d'un message – vignette, ouverture, téléchargement
// ═══════════════════════════════════════════════════════════
// Comme dans une messagerie ordinaire : l'image se voit, le PDF s'ouvre dans le
// lecteur du navigateur, et le Word se télécharge – aucun navigateur ne sait
// l'afficher. Une pièce jointe qu'on ne peut ni voir ni ouvrir n'est qu'un nom
// de fichier, et l'expéditeur ne peut pas vérifier ce qu'il a envoyé.
const CH_DOCX_MEDIA_TYPE =
'application/vnd.openxmlformats-officedocument.wordprocessingml.document';
const CH_KIND_LABELS = {
'application/pdf': 'PDF',
[CH_DOCX_MEDIA_TYPE]: 'Document Word',
'text/plain': 'Texte',
};
function chAttachmentLabel(attachment) {
if (attachment.mediaType?.startsWith('image/')) return 'Image';
return CH_KIND_LABELS[attachment.mediaType] || 'Document';
}
function ChatAttachment({ attachment, runtime, isUser, onPreview }) {
const { InteractiveRow } = window.VascoUI;
const isImage = Boolean(attachment.mediaType?.startsWith('image/'));
const [url, setUrl] = React.useState(attachment.previewUrl || null);
const [failed, setFailed] = React.useState(false);
const [busy, setBusy] = React.useState(false);
const ownedRef = React.useRef(null);
// Une URL d'objet non libérée retient le fichier entier en mémoire tant que
// l'onglet vit.
React.useEffect(() => () => {
if (ownedRef.current) URL.revokeObjectURL(ownedRef.current);
}, []);
const ensureUrl = React.useCallback(async () => {
if (url) return url;
if (!runtime?.attachmentObjectUrl || !attachment.id) return null;
const next = await runtime.attachmentObjectUrl(attachment);
ownedRef.current = next;
setUrl(next);
return next;
}, [url, runtime, attachment]);
// La vignette se charge d'elle-même ; le reste attend un geste explicite.
React.useEffect(() => {
if (!isImage || url || failed || !runtime?.attachmentObjectUrl) return undefined;
let cancelled = false;
(async () => {
try {
const next = await ensureUrl();
if (cancelled && next) URL.revokeObjectURL(next);
} catch {
if (!cancelled) setFailed(true);
}
})();
return () => { cancelled = true; };
}, [isImage, url, failed, runtime, ensureUrl]);
const open = async () => {
if (busy) return;
setBusy(true);
try {
const target = await ensureUrl();
if (!target) return;
if (isImage) { onPreview?.({ url: target, filename: attachment.filename }); return; }
if (attachment.mediaType === 'application/pdf') {
// Le navigateur sait afficher un PDF ; il ne sait pas afficher un Word.
window.open(target, '_blank', 'noopener');
return;
}
const link = document.createElement('a');
link.href = target;
link.download = attachment.filename || 'document';
document.body.appendChild(link);
link.click();
link.remove();
} catch (error) {
showToast(error?.message || 'Pièce jointe indisponible', 'error');
} finally {
setBusy(false);
}
};
const meta = [
chAttachmentLabel(attachment),
attachment.sizeBytes ? readableFileSize(attachment.sizeBytes) : null,
].filter(Boolean).join(' · ');
if (isImage && url) {
return (
);
}
return (
{preview.filename}
{options.map((option) => (
))}
)}
{pinned.map((option) => (
onPick(option.value)} style={{
width: '100%', textAlign: 'left', padding: '11px 12px', marginBottom: 6,
borderRadius: 14, background: option.active ? CH_MED_TINT : 'rgba(10,10,10,0.03)',
border: 'none', cursor: 'pointer',
fontSize: 13.5, fontWeight: 600, color: option.active ? CH_MED : CH_INK,
}}>{option.label}
))}
{searchError && (
onPick(patient.id)} style={{
width: '100%', textAlign: 'left', padding: '9px 12px', marginBottom: 6,
borderRadius: 14, background: active ? CH_MED_TINT : 'rgba(10,10,10,0.03)',
border: 'none', cursor: 'pointer',
}}>
);
})}
{searchError}
)}
{!searchError && searching && (
Recherche…
)}
{/* « Aucun patient » n'apparaît que devant une réponse réelle du
serveur, jamais pendant l'attente. */}
{!searchError && !searching && roster !== null && roster.length === 0 && term && (
Aucun patient ne correspond à « {term} »
)}
{!searchError && (roster || []).map((patient) => {
const active = activePatientId != null && patient.id === activePatientId;
return (
{patient.last} {patient.first}{patient.deceased ? ' · décédé' : ''}
IPP {patient.ipp}{patient.age != null ? ` · ${patient.age} ans` : ''}
{kind === 'email' && <>
setTo(e.target.value)} maxLength={254} style={chEditInput} />
setSubject(e.target.value)} maxLength={200} style={chEditInput} />