326 lines
10 KiB
TypeScript
326 lines
10 KiB
TypeScript
import { SHEET_DOCUMENT_SCHEMA_VERSION } from '@faunosteo/domain'
|
|
import { AUTHORED_LABEL_CODE, regionLabelSubject } from './authored-labels'
|
|
import { countTree } from './catalog'
|
|
import { code, table } from '../markdown'
|
|
import type { Anomaly, ImportResult } from './types'
|
|
|
|
/**
|
|
* French Markdown import report, written for an osteopath (what to
|
|
* validate) and for the developer (what was mapped and how). No dates and
|
|
* no environment data: the report is a committed, byte-stable artifact.
|
|
*/
|
|
|
|
function intro(result: ImportResult): string {
|
|
return [
|
|
"# Rapport d'import : fiche anatomique équine v1",
|
|
'',
|
|
'Généré par `pnpm import:equine` à partir des données historiques. ' +
|
|
'Ne pas modifier à la main : relancer la commande.',
|
|
'',
|
|
`Statut : **brouillon** (version 1 en \`draft\`), jamais publié par ` +
|
|
`le seed. Fiche \`${result.sheetId}\`, espèce \`${result.document.species_id}\`.`,
|
|
'',
|
|
'Les éléments de la section « Anomalies à valider » demandent une ' +
|
|
'décision métier avant toute publication.',
|
|
].join('\n')
|
|
}
|
|
|
|
function sourcesSection(result: ImportResult): string {
|
|
const assetRows = result.assets.map((a) => [
|
|
code(a.file),
|
|
a.byte_size,
|
|
code(a.sha256),
|
|
code(a.svg_asset_id),
|
|
])
|
|
const otherRows = result.sourceDigests.map((d) => [
|
|
code(d.file),
|
|
d.byte_size,
|
|
code(d.sha256),
|
|
'-',
|
|
])
|
|
const viewBoxes = Object.entries(result.viewBoxes).map(
|
|
([view, box]) =>
|
|
`- vue \`${view}\` : viewBox \`${box ?? 'absent'}\` (view_box du ` +
|
|
`document laissé à null, le SVG porte le sien)`,
|
|
)
|
|
return [
|
|
'## 1. Sources et empreintes',
|
|
'',
|
|
table(
|
|
['Fichier', 'Octets', 'sha256', "Id d'asset"],
|
|
[...assetRows, ...otherRows],
|
|
),
|
|
'',
|
|
"Les ids d'asset sont dérivés du sha256 du fichier (UUID déterministe), " +
|
|
"les deux SVG sont copiés à l'identique dans `assets/`.",
|
|
'',
|
|
...viewBoxes,
|
|
].join('\n')
|
|
}
|
|
|
|
function volumesSection(result: ImportResult): string {
|
|
const s = result.stats
|
|
const out = countTree(
|
|
result.document.finding_zones.flatMap((z) => z.categories),
|
|
)
|
|
const rows: Array<[string, number]> = [
|
|
['Annotations', s.annotations],
|
|
['dont vue `main` (Horse.svg)', s.annotationsByView.main ?? 0],
|
|
['dont vue `head` (Horse_head.svg)', s.annotationsByView.head ?? 0],
|
|
['Annotations reliées à une zone de constats', s.linkedAnnotations],
|
|
['Déclencheurs de vue détail', s.triggers],
|
|
['Vues', s.views],
|
|
['Zones vertébrales avec code de région', s.vertebralAnnotations],
|
|
['Annotations bilatérales', s.bilateral],
|
|
['Zones de constats (catalogue)', s.findingZones],
|
|
['Nœuds (catégories incluses)', s.nodes],
|
|
['Feuilles', s.leaves],
|
|
['Orientations vétérinaires', s.vetReferrals],
|
|
]
|
|
return [
|
|
'## 2. Volumes',
|
|
'',
|
|
table(['Mesure', 'Valeur'], rows),
|
|
'',
|
|
'Contrôle entrée = sortie, compté des deux côtés (sources lues, ' +
|
|
"document écrit). L'importateur s'arrête au moindre écart :",
|
|
'',
|
|
table(
|
|
['Contrôle', 'Lu (sources)', 'Écrit (document)'],
|
|
[
|
|
[
|
|
'Annotations (data-anno-id distincts)',
|
|
s.legacyAnnotations,
|
|
s.annotations,
|
|
],
|
|
['Nœuds (catégories incluses)', s.nodes, out.nodes],
|
|
['Feuilles', s.leaves, out.leaves],
|
|
['Orientations vétérinaires', s.vetReferrals, out.vetReferrals],
|
|
],
|
|
),
|
|
].join('\n')
|
|
}
|
|
|
|
function annotationsSection(result: ImportResult): string {
|
|
const rows = result.annotationRows.map((r) => [
|
|
code(r.legacyId),
|
|
code(r.newId),
|
|
r.viewId,
|
|
r.kind,
|
|
r.laterality,
|
|
r.regionCode,
|
|
r.findingZoneId === null ? '-' : code(r.findingZoneId),
|
|
r.geometry,
|
|
])
|
|
return [
|
|
'## 3. Annotations',
|
|
'',
|
|
table(
|
|
[
|
|
'Id historique',
|
|
'Nouvel id',
|
|
'Vue',
|
|
'Type',
|
|
'Latéralité',
|
|
'Région',
|
|
'Zone de constats',
|
|
'Géométrie',
|
|
],
|
|
rows,
|
|
),
|
|
].join('\n')
|
|
}
|
|
|
|
function categoriesSection(result: ImportResult): string {
|
|
const legacyOf = Object.fromEntries(
|
|
Object.entries(result.legacyIdMap.categories).map(([legacy, id]) => [
|
|
id,
|
|
legacy,
|
|
]),
|
|
)
|
|
const authored = new Set(
|
|
result.anomalies
|
|
.filter((a) => a.code === 'category.label.authored')
|
|
.map((a) => a.subject),
|
|
)
|
|
const rows = result.document.categories.map((c) => [
|
|
code(legacyOf[c.id] ?? c.id),
|
|
code(c.id),
|
|
c.name.fr,
|
|
c.name.en,
|
|
authored.has(c.id) ? 'importateur, à valider' : 'SVG',
|
|
])
|
|
return [
|
|
"## 4. Catégories d'annotation",
|
|
'',
|
|
table(
|
|
['Id SVG', 'Id', 'Libellé FR', 'Libellé EN', 'Origine du libellé'],
|
|
rows,
|
|
),
|
|
'',
|
|
"Couleur : `null` partout (les couleurs du SVG restent dans l'asset). " +
|
|
'Dans les SVG, `data-anno-category-name` répète le slug (`articulations`, ' +
|
|
"`os`) : ce n'est pas un libellé, le libellé lisible de la table " +
|
|
"de l'importateur est utilisé.",
|
|
].join('\n')
|
|
}
|
|
|
|
function vertebralSection(result: ImportResult): string {
|
|
const authored = new Set(
|
|
result.anomalies
|
|
.filter((a) => a.code === AUTHORED_LABEL_CODE)
|
|
.map((a) => a.subject),
|
|
)
|
|
const regions = result.document.vertebral_config.regions.map((r) => [
|
|
code(r.code),
|
|
r.name.fr,
|
|
r.name.en,
|
|
r.count,
|
|
authored.has(regionLabelSubject(r.code))
|
|
? 'importateur, à valider'
|
|
: 'source',
|
|
])
|
|
const inferences = result.regionInferences.map((i) => [
|
|
code(result.legacyIdMap.annotations[i.annotationId] ?? i.annotationId),
|
|
i.label,
|
|
i.root === null ? '-' : code(i.root),
|
|
code(i.code),
|
|
])
|
|
return [
|
|
'## 5. Configuration vertébrale',
|
|
'',
|
|
table(
|
|
['Code', 'Nom FR', 'Nom EN', 'Vertèbres', 'Origine du libellé'],
|
|
regions,
|
|
),
|
|
'',
|
|
'Nombres de vertèbres : `vertebrae.ts`. Noms de région : écrits par ' +
|
|
"l'importateur (aucune source ne les porte).",
|
|
'',
|
|
'Codes de région déduits des libellés (racines `cervic`, `thorac`/`dors`, ' +
|
|
'`lombair`/`lumbar`, `sacral`/`sacre`, `caudal`/`coccyg`, FR puis ' +
|
|
'EN). Déduction faite une fois ici, le document porte le code :',
|
|
'',
|
|
table(['Annotation', 'Libellé lu', 'Racine', 'Code'], inferences),
|
|
].join('\n')
|
|
}
|
|
|
|
function findingsSection(result: ImportResult): string {
|
|
const names = new Map(
|
|
result.document.finding_zones.map((z) => [z.id, z.name.fr]),
|
|
)
|
|
const rows = result.zoneStats.map((z) => [
|
|
code(z.zoneId),
|
|
names.get(z.zoneId) ?? '-',
|
|
z.nodes,
|
|
z.leaves,
|
|
z.vetReferrals,
|
|
])
|
|
const s = result.stats
|
|
rows.push(['**Total**', '', s.nodes, s.leaves, s.vetReferrals])
|
|
return [
|
|
'## 6. Arbre de constats par zone',
|
|
'',
|
|
'Copie fidèle du catalogue : ids, libellés, descriptions présentes, ' +
|
|
'orientations vétérinaires et sources. Ordre des zones et des catégories ' +
|
|
'conservé. Nœuds = catégories incluses.',
|
|
'',
|
|
table(['Zone', 'Nom', 'Nœuds', 'Feuilles', 'Orientations vét.'], rows),
|
|
].join('\n')
|
|
}
|
|
|
|
function anomalyRows(anomalies: readonly Anomaly[]) {
|
|
return anomalies.map((a) => [code(a.code), a.subject, a.message])
|
|
}
|
|
|
|
function anomaliesSection(result: ImportResult): string {
|
|
const toValidate = result.anomalies.filter((a) => a.level === 'a_valider')
|
|
const informative = result.anomalies.filter((a) => a.level === 'informatif')
|
|
return [
|
|
'## 7. Anomalies à valider',
|
|
'',
|
|
`${toValidate.length} points demandent une décision, ${informative.length} sont informatifs.`,
|
|
'',
|
|
'### À valider',
|
|
'',
|
|
table(['Code', 'Objet', 'Détail'], anomalyRows(toValidate)),
|
|
'',
|
|
'### Informatif',
|
|
'',
|
|
table(['Code', 'Objet', 'Détail'], anomalyRows(informative)),
|
|
].join('\n')
|
|
}
|
|
|
|
/** Source keys the document does not carry, and where they live now. */
|
|
const NOT_CARRIED_OVER = [
|
|
'`schema_version` du catalogue (`2.0`) : version du format historique, ' +
|
|
`remplacée par \`schema_version: ${SHEET_DOCUMENT_SCHEMA_VERSION}\` du document canonique ; la valeur ` +
|
|
"d'origine est citée dans `attribution.notes`.",
|
|
'bloc `species` du catalogue (`equine`, Cheval / Horse) : porté par ' +
|
|
'`species_id` du document et par la table `public.species` ; le nom ' +
|
|
'de la fiche est écrit séparément (voir anomalies `label.authored`).',
|
|
'second élément graphique de chaque annotation (marqueur visuel) : ' +
|
|
"reste dans l'asset SVG copié à l'identique, le document ne garde que " +
|
|
'la zone de clic.',
|
|
'`data-anno-category-name` : répète le slug technique (`articulations`, ' +
|
|
"`os`), ce n'est pas un libellé ; le libellé de catégorie vient de la " +
|
|
"table de l'importateur (section 4).",
|
|
]
|
|
|
|
function notImportedSection(result: ImportResult): string {
|
|
const dropped = result.annotationRows.filter((r) => r.geometry === 'aucune')
|
|
const lines =
|
|
dropped.length === 0
|
|
? ['Aucune donnée métier écartée.']
|
|
: dropped.map(
|
|
(r) => `- géométrie de \`${r.legacyId}\` (forme non prise en charge)`,
|
|
)
|
|
return [
|
|
'## 8. Données non importées',
|
|
'',
|
|
...lines,
|
|
'',
|
|
'Non repris par construction :',
|
|
'',
|
|
...NOT_CARRIED_OVER.map((line) => `- ${line}`),
|
|
].join('\n')
|
|
}
|
|
|
|
function validationSection(result: ImportResult): string {
|
|
const errors = result.issues.filter((i) => i.severity === 'error')
|
|
const warnings = result.issues.filter((i) => i.severity === 'warning')
|
|
const rows = result.issues.map((i) => [
|
|
i.severity,
|
|
code(i.code),
|
|
code(i.path),
|
|
i.message,
|
|
])
|
|
return [
|
|
'## 9. Résultat de validation',
|
|
'',
|
|
'- Forme (`AnatomicalSheetDocumentSchema`) : conforme.',
|
|
`- Intégrité (\`validateSheetDocument\`) : ${errors.length} erreur(s), ` +
|
|
`${warnings.length} avertissement(s).`,
|
|
...(rows.length
|
|
? ['', table(['Gravité', 'Code', 'Chemin', 'Message'], rows)]
|
|
: []),
|
|
].join('\n')
|
|
}
|
|
|
|
export function renderImportReport(result: ImportResult): string {
|
|
return (
|
|
[
|
|
intro(result),
|
|
sourcesSection(result),
|
|
volumesSection(result),
|
|
annotationsSection(result),
|
|
categoriesSection(result),
|
|
vertebralSection(result),
|
|
findingsSection(result),
|
|
anomaliesSection(result),
|
|
notImportedSection(result),
|
|
validationSection(result),
|
|
].join('\n\n') + '\n'
|
|
)
|
|
}
|