Chaque type de message s’écrit à partir de tables, à raison d’un fichier par événement. Les principes sont communs aux trois messages :
-
les clés :
evt_iddésigne l’événement, donc le fichier ;rum_id(PMSI) relie les RUM à leurs diagnostics et actes ; -
l’en-tête : une liste
entete(version,emetteur,destinataire…), dont chaque clé peut aussi être une colonne deevenements, prioritaire ; -
les colonnes-chemins : toute colonne dont le nom
contient
/ou commence par@est un chemin XML relatif au noeud que décrit la table (`patient/@anonyme`,`@classant`) ; tout le XSD reste ainsi accessible sans colonne dédiée ; - la validation : chaque message est validé contre son XSD avant d’être écrit.
Les exemples ci-dessous sont les scripts de
inst/exemples/, exécutés tels quels.
Atomicité des messages
Chaque type de message a une unité atomique :
l’objet que le standard sait créer, modifier ou supprimer, parce qu’il
porte l’attribut action et un identifiant. Un message
atomique transporte une seule de ces unités : il peut être accepté,
rejeté ou renvoyé indépendamment des autres.
| message | unité atomique | argument |
|---|---|---|
ePMSI (evenementsPMSI) |
le RUM | par_rum = TRUE |
serveur d’actes (evenementsServeurActes) |
l’acte (acteCCAM) |
par_acte = TRUE |
états patient (evenementsServeurEtatsPatient) |
le diagnostic | par_diagnostic = TRUE |
Par défaut (FALSE), un message porte tout l’événement :
le séjour et ses RUM, l’intervention et ses actes, l’observation et ses
diagnostics. En mode atomique, le contexte (patient, venue…) est répété
dans chaque message, evt_id devient
{evt_id}_{rang} ({evt_id}_{rum_id} pour le
PMSI), et le gabarit filename dispose aussi de
{evt_origine}, {rang} et
{acte_id}.
Pour le PMSI, les diagnostics et les actes d’un RUM n’ont ni action ni identifiant : un message par diagnostic ou par acte n’y aurait pas de sens propre. Pour transmettre des diagnostics un par un, le canal naturel est le message états patient ; pour des actes, le serveur d’actes.
# Atomicité : un message par unité atomique, l'objet qui porte l'attribut `action` et un
# identifiant. Le RUM pour le PMSI, l'acte pour le serveur d'actes, le diagnostic pour les
# états patient. Le contexte (patient, venue…) est répété dans chaque message.
library(hprimxml)
library(tibble)
entete <- list(
version = "2.00", # version HPRIM XML des messages
emetteur = "DIM",
destinataire = "DPI",
date_heure_production = as.POSIXct("2024-03-10 08:00:00", tz = "UTC")
)
# contexte commun : patient et venue
contexte <- function(evt_id, ...) {
tibble(evt_id = evt_id, ipp = "190101337", sexe = "F", date_naissance = as.Date("1958-03-12"),
nda = "240000123", venue_date_entree = as.Date("2024-03-04"), ...)
}
# PMSI : un séjour, deux RUM -> deux messages (par_rum)
sejours <- contexte("S1")
rum <- tibble(
evt_id = "S1", rum_id = 1:2, rum_emetteur = c("S1_1", "S1_2"),
um = c("1201", "3405"), um_date_entree = as.Date(c("2024-03-04", "2024-03-06")),
um_mode_entree = c("8", "6"), dp = c("I21.0", "I50.1")
)
write_evenements_pmsi(sejours, rum, entete = entete, out_dir = "sortie/rum", par_rum = TRUE)
# Serveur d'actes : une intervention, trois actes -> trois messages (par_acte)
interventions <- contexte("A1", intervention_id = "INT0001", intervention_uf = "1201")
actes_ccam <- tibble(
evt_id = "A1", acte_id = c("ACT01", "ACT02", "ACT03"),
code = c("DEQP003", "ZBQK002", "YYYY033"), activite = 1L, phase = 0L,
date_execution = as.Date("2024-03-04"), medecin = "01234567"
)
write_evenements_serveur_actes(interventions, actes_ccam, entete = entete, out_dir = "sortie/actes",
par_acte = TRUE, filename = "{evt_origine}_{acte_id}.xml")
# États patient : une observation, deux diagnostics -> deux messages (par_diagnostic)
observations <- contexte("D1", recueil_id = "REC01", recueil_date = as.Date("2024-03-04"),
recueil_uf = "1201")
diagnostics <- tibble(
evt_id = "D1", type = c("dp", "da"), code = c("I21.0", "E11.9"),
date_action = as.POSIXct("2024-03-04 12:00:00", tz = "UTC")
)
write_evenements_etat_patient(observations, diagnostics, entete = entete,
out_dir = "sortie/diagnostics", par_diagnostic = TRUE)
# Bilan : un fichier par unité atomique
compte <- function(fichier, balise) {
x <- paste(readLines(file.path("sortie", fichier), warn = FALSE), collapse = "\n")
lengths(regmatches(x, gregexpr(paste0("<", balise), x, fixed = TRUE)))
}
fichiers <- sort(list.files("sortie", pattern = "\\.xml$", recursive = TRUE))
produits <- tibble(
fichier = fichiers,
RUM = vapply(fichiers, compte, integer(1), balise = "rum ", USE.NAMES = FALSE),
actes_ccam = vapply(fichiers, compte, integer(1), balise = "acteCCAM", USE.NAMES = FALSE),
diagnostics = vapply(fichiers, compte, integer(1), balise = "diagnostic ", USE.NAMES = FALSE)
)| fichier | RUM | actes_ccam | diagnostics |
|---|---|---|---|
| actes/A1_ACT01.xml | 0 | 1 | 0 |
| actes/A1_ACT02.xml | 0 | 1 | 0 |
| actes/A1_ACT03.xml | 0 | 1 | 0 |
| diagnostics/D1_1.xml | 0 | 0 | 1 |
| diagnostics/D1_2.xml | 0 | 0 | 1 |
| rum/S1_1.xml | 1 | 0 | 0 |
| rum/S1_2.xml | 1 | 0 | 0 |
Un rejet porte alors sur une seule unité, qu’on corrige et renvoie
seule ; une suppression se fait en renvoyant l’unité avec
action = "suppression" (colonne action de la
table de l’unité), le même identifiant d’unité et un nouvel identifiant
de message.
ePMSI : write_evenements_pmsi()
Un séjour avec mutation
Entrée par les urgences en cardiologie, mutation en médecine, sortie à domicile : un RSS de deux RUM. Le script écrit le séjour en un fichier, puis en RUM unitaires, et le relit.
# Séjour avec mutation : entrée par les urgences en cardiologie (UM 1201), puis mutation
# en médecine (UM 3405), sortie au domicile. Un RSS de deux RUM, écrit sans namespace,
# d'abord en un fichier par séjour, puis en RUM unitaires (un fichier par RUM).
library(hprimxml)
library(tibble)
ts <- function(x) as.POSIXct(x, tz = "UTC")
entete <- list(
version = "2.00", # version HPRIM XML des messages
emetteur = "DIM",
destinataire = "DPI",
date_heure_production = ts("2024-03-10 08:00:00") # par défaut : maintenant
)
# Une ligne par séjour
evenements <- tibble(
evt_id = "S240001", # -> S240001.xml, identifiantMessage S240001
ipp = "190101337",
sexe = "F",
date_naissance = as.Date("1958-03-12"),
nda = "240000123",
venue_date_entree = as.Date("2024-03-04"),
venue_heure_entree = hms::as_hms("10:20:00"),
venue_date_sortie = as.Date("2024-03-09"),
rss_emetteur = "240000123"
)
# Une ligne par RUM
rum <- tibble(
evt_id = "S240001",
rum_id = 1:2,
rum_emetteur = c("S240001_1", "S240001_2"), # identifiant XML du RUM
um = c("1201", "3405"),
um_date_entree = as.Date(c("2024-03-04", "2024-03-06")),
um_heure_entree = hms::as_hms(c("10:20:00", "14:00:00")),
um_mode_entree = c("8", "6"), # domicile, puis mutation
um_provenance = c("5", "1"), # urgences, puis MCO
um_date_sortie = as.Date(c("2024-03-06", "2024-03-09")),
um_mode_sortie = c("6", "8"), # mutation, puis domicile
um_destination = c("1", NA), # vers MCO
`medecinResponsable/noRPPS` = c("10003456789", "10009876543")
)
# Une ligne par diagnostic (le point des codes CIM-10 est retiré à l'écriture)
diagnostics <- tibble(
evt_id = "S240001",
rum_id = c(1L, 1L, 1L, 1L, 2L, 2L, 2L),
type = c("DP", "DAS", "DAS", "DAS", "DP", "DAS", "DAS"),
code = c("I21.0", "E11.9", "I10", "E78.0", "I50.1", "N18.3", "E11.9")
)
# Une ligne par acte CCAM
actes_ccam <- tibble(
evt_id = "S240001",
rum_id = c(1L, 1L, 2L),
code = c("DEQP003", "ZBQK002", "DEQP003"),
phase = 0L,
activite = 1L,
date_realisation = ts(c("2024-03-04 10:45:00", "2024-03-04 11:30:00", "2024-03-06 15:00:00"))
)
# Un fichier par séjour : sortie/sejour/S240001.xml
write_evenements_pmsi(
evenements, rum, diagnostics, actes_ccam,
entete = entete, out_dir = "sortie/sejour", xmlns = NULL
)
# RUM unitaires, avec marqueur de dépôt complet :
# sortie/rum/S240001_1.xml puis S240001_1.ok, sortie/rum/S240001_2.xml puis S240001_2.ok
write_evenements_pmsi(
evenements, rum, diagnostics, actes_ccam,
entete = entete, out_dir = "sortie/rum", xmlns = NULL, par_rum = TRUE, fichier_ok = TRUE
)
# Relecture : les mêmes tables (ici, diagnostics en colonnes de `rum`)
relu <- read_evenements_pmsi("sortie/sejour", format_diagnostics = "colonnes")
rum_relu <- relu$rum[, c("evt_id", "rum_id", "rum_emetteur", "um", "dp", "das")]Les quatre tables : evenements (une ligne par séjour),
rum (une ligne par RUM), diagnostics (format
long) et actes_ccam (une ligne par acte CCAM).
| evt_id | ipp | sexe | date_naissance | nda | venue_date_entree | venue_heure_entree | venue_date_sortie | rss_emetteur |
|---|---|---|---|---|---|---|---|---|
| S240001 | 190101337 | F | 1958-03-12 | 240000123 | 2024-03-04 | 10:20:00 | 2024-03-09 | 240000123 |
| evt_id | rum_id | rum_emetteur | um | um_date_entree | um_heure_entree | um_mode_entree | um_provenance | um_date_sortie | um_mode_sortie | um_destination | medecinResponsable/noRPPS |
|---|---|---|---|---|---|---|---|---|---|---|---|
| S240001 | 1 | S240001_1 | 1201 | 2024-03-04 | 10:20:00 | 8 | 5 | 2024-03-06 | 6 | 1 | 10003456789 |
| S240001 | 2 | S240001_2 | 3405 | 2024-03-06 | 14:00:00 | 6 | 1 | 2024-03-09 | 8 | 10009876543 |
| evt_id | rum_id | type | code |
|---|---|---|---|
| S240001 | 1 | DP | I21.0 |
| S240001 | 1 | DAS | E11.9 |
| S240001 | 1 | DAS | I10 |
| S240001 | 1 | DAS | E78.0 |
| S240001 | 2 | DP | I50.1 |
| S240001 | 2 | DAS | N18.3 |
| S240001 | 2 | DAS | E11.9 |
| evt_id | rum_id | code | phase | activite | date_realisation |
|---|---|---|---|---|---|
| S240001 | 1 | DEQP003 | 0 | 1 | 2024-03-04 10:45:00 |
| S240001 | 1 | ZBQK002 | 0 | 1 | 2024-03-04 11:30:00 |
| S240001 | 2 | DEQP003 | 0 | 1 | 2024-03-06 15:00:00 |
Le second RUM, en RUM unitaire :
<rum action="creation">
<dateAction>2024-03-06T00:00:00</dateAction>
<identifiant>
<emetteur>S240001_2</emetteur>
</identifiant>
<medecinResponsable>
<noRPPS>10009876543</noRPPS>
</medecinResponsable>
<uniteMedicale>
<code>3405</code>
<entree mode="6" complementMode="1">
<date>2024-03-06</date>
<heure>14:00:00</heure>
</entree>
<sortie mode="8">
<date>2024-03-09</date>
</sortie>
</uniteMedicale>
<diagnostics>
<diagnosticPrincipal>
<codeCim10>I501</codeCim10>
</diagnosticPrincipal>
<diagnosticsSignificatifs>
<diagnosticSignificatif>
<codeCim10>N183</codeCim10>
</diagnosticSignificatif>
<diagnosticSignificatif>
<codeCim10>E119</codeCim10>
</diagnosticSignificatif>
</diagnosticsSignificatifs>
</diagnostics>
<actes>
<acte>
<CCAM>
<codeActe>DEQP003</codeActe>
<codePhase>0</codePhase>
<codeActivite>1</codeActivite>
<quantite>1</quantite>
<dateRealisation>2024-03-06T15:00:00</dateRealisation>
</CCAM>
</acte>
</actes>
</rum>Diagnostics : format long, liste ou chaîne
Trois formes équivalentes, qui produisent le même fichier : la table
diagnostics en format long ; des colonnes dp,
dr, das, dad dans
rum, avec das et dad en colonne
liste ; ou ces mêmes colonnes avec das en chaîne séparée
par des virgules.
# Trois façons équivalentes de fournir les diagnostics d'un RUM avec plusieurs DAS.
# Les trois écritures produisent exactement le même fichier XML.
library(hprimxml)
library(tibble)
entete <- list(
version = "2.00", # version HPRIM XML des messages
emetteur = "DIM",
destinataire = "DPI",
date_heure_production = as.POSIXct("2024-03-10 08:00:00", tz = "UTC")
)
evenements <- tibble(
evt_id = "S240002", ipp = "190101338", sexe = "M",
date_naissance = as.Date("1951-07-02"), nda = "240000124",
venue_date_entree = as.Date("2024-03-04"), rss_emetteur = "240000124"
)
rum <- tibble(
evt_id = "S240002", rum_id = 1L, um = "1201",
um_date_entree = as.Date("2024-03-04"), um_mode_entree = "8"
)
# 1. Format long : une table `diagnostics`, une ligne par code
diagnostics <- tibble(
evt_id = "S240002",
rum_id = 1L,
type = c("DP", "DAS", "DAS", "DAS", "DAS"),
code = c("I21.0", "E11.9", "I10", "E78.0", "N18.3")
)
write_evenements_pmsi(evenements, rum, diagnostics, entete = entete, out_dir = "sortie/long")
# 2. Colonnes dans `rum`, DAS en colonne liste
rum_liste <- rum
rum_liste$dp <- "I21.0"
rum_liste$das <- list(c("E11.9", "I10", "E78.0", "N18.3"))
write_evenements_pmsi(evenements, rum_liste, entete = entete, out_dir = "sortie/liste")
# 3. Colonnes dans `rum`, DAS en chaîne séparée par des virgules
rum_chaine <- rum
rum_chaine$dp <- "I21.0"
rum_chaine$das <- "E11.9, I10, E78.0, N18.3"
write_evenements_pmsi(evenements, rum_chaine, entete = entete, out_dir = "sortie/chaine")
# Une chaîne se convertit aussi en liste d'une ligne : strsplit(rum_chaine$das, ", ")
fichiers <- lapply(c("long", "liste", "chaine"), function(f)
readBin(file.path("sortie", f, "S240002.xml"), "raw", 1e6))
stopifnot(identical(fichiers[[1]], fichiers[[2]]), identical(fichiers[[1]], fichiers[[3]]))Les deux approches se combinent (DP en colonne, DAS en format long…), mais un DP ou un DR donné deux fois est refusé.
RUM unitaires, identifiant et dépôts .ok
Avec par_rum = TRUE, chaque RUM devient un message. On
reprend ici les tables du séjour avec mutation, conservées dans la liste
sejour. Trois règles encadrent le nommage :
- l’identifiant du message est le nom du fichier sans
extension :
{evt_id}_{rum_id}par défaut, ou le résultat du gabaritfilename, qui dispose aussi de{rss_id}et{rum_id}; - le XSD limite cet identifiant à 12 caractères
(lettres, chiffres,
-,,,_) ; - deux messages de même nom font échouer l’écriture.
write_evenements_pmsi(sejour$evenements, sejour$rum, sejour$diagnostics, sejour$actes_ccam,
entete = sejour$entete, out_dir = "depot", xmlns = NULL, par_rum = TRUE,
filename = "R{rss_id}_{rum_id}.xml", fichier_ok = TRUE)
list.files("depot")
#> [1] "RS240001_1.ok" "RS240001_1.xml" "RS240001_2.ok" "RS240001_2.xml"Avec fichier_ok = TRUE, chaque .xml est
d’abord écrit sous un nom temporaire puis renommé, et son
.ok vide est déposé en dernier : le destinataire ne voit
jamais un fichier incomplet.
Partir de colonnes existantes : colmap
colmap renomme les colonnes d’une extraction existante
vers les noms attendus :
rum_source <- tibble::tibble(NAS = "S240001", NORUM = 1:2, CDURM = c("1201", "3405"),
D8EEUE = as.Date(c("2024-03-04", "2024-03-06")), MDEEUE = c("8", "6"),
DP = c("I21.0", "I50.1"))
f <- write_evenements_pmsi(
sejour$evenements, rum_source, entete = sejour$entete, out_dir = "colmap", xmlns = NULL,
colmap = list(NAS = "evt_id", NORUM = "rum_id", CDURM = "um", D8EEUE = "um_date_entree",
MDEEUE = "um_mode_entree", DP = "dp")
)
basename(f)
#> [1] "S240001.xml"Serveur d’actes : write_evenements_serveur_actes()
Deux tables : evenements (patient, venue, intervention
et demande) et actes_ccam (une ligne par acte CCAM, avec
son exécutant). Le script régénère le fichier d’exemple du projet.
# Régénère data/xml_tests/actes/00001.xml : une intervention et quatre actes CCAM.
library(hprimxml)
library(tibble)
ts <- function(x) as.POSIXct(x, tz = "UTC")
entete <- list(
version = "2.00", # version HPRIM XML des messages
emetteur = "TEST",
destinataire = NULL,
acquittement_attendu = "oui",
commentaire = "HPRIM-TEST",
date_heure_production = ts("2024-01-01 01:01:01")
)
# Une ligne par événement : patient, venue, intervention et demande
evenements <- tibble(
evt_id = "00001_acte",
ipp = "123456789", ipp_recepteur = "123456789",
sexe = "M", nom_usuel = "SANDWICK", prenom = "JOHN",
date_naissance = as.Date("1970-01-01"),
nda = "987654321", nda_recepteur = "987654321",
venue_date_entree = as.Date("2024-01-01"), venue_heure_entree = hms::as_hms("08:00:00"),
venue_uf_responsable = "4321",
`venue/@prive` = "non",
intervention_id = "000000000001",
intervention_date_debut = as.Date("2024-01-01"), intervention_heure_debut = hms::as_hms("08:10:00"),
intervention_date_fin = as.Date("2024-01-01"), intervention_heure_fin = hms::as_hms("09:00:00"),
intervention_uf = "4321",
demande_date = as.Date("2023-12-25"), demande_heure = hms::as_hms("02:30:00"), demande_uf = "4321"
)
# Une ligne par acte CCAM
actes_ccam <- tibble(
evt_id = "00001_acte",
acte_id = c("121212", "121213", "121214", "121215"),
code = c("EBLA003", "YYYY033", "EPLF002", "NFKA006"),
activite = 1L, phase = 0L,
date_execution = as.Date("2024-01-01"), heure_execution = hms::as_hms("08:10:00"),
medecin = "01234567", uf = "4321",
quantite = "1", # nombre5 : chaîne de chiffres dans le XSD
facturable = "oui", valide = "oui"
)
fichiers <- write_evenements_serveur_actes(
evenements, actes_ccam,
entete = entete,
out_dir = "sortie/actes", # -> sortie/actes/00001_acte.xml
validate_xsd = "warn"
)| evt_id | acte_id | code | activite | phase | date_execution | heure_execution | medecin | uf | quantite | facturable | valide |
|---|---|---|---|---|---|---|---|---|---|---|---|
| 00001_acte | 121212 | EBLA003 | 1 | 0 | 2024-01-01 | 08:10:00 | 01234567 | 4321 | 1 | oui | oui |
| 00001_acte | 121213 | YYYY033 | 1 | 0 | 2024-01-01 | 08:10:00 | 01234567 | 4321 | 1 | oui | oui |
| 00001_acte | 121214 | EPLF002 | 1 | 0 | 2024-01-01 | 08:10:00 | 01234567 | 4321 | 1 | oui | oui |
| 00001_acte | 121215 | NFKA006 | 1 | 0 | 2024-01-01 | 08:10:00 | 01234567 | 4321 | 1 | oui | oui |
Le premier acte produit :
<acteCCAM action="creation" facturable="oui" valide="oui">
<identifiant>
<emetteur>121212</emetteur>
</identifiant>
<codeActe>EBLA003</codeActe>
<codeActivite>1</codeActivite>
<codePhase>0</codePhase>
<execute>
<date>2024-01-01</date>
<heure>08:10:00</heure>
</execute>
<executant>
<medecins>
<medecinExecutant principal="oui">
<medecin>
<identification>
<code>01234567</code>
</identification>
</medecin>
</medecinExecutant>
</medecins>
<uniteFonctionnelle>
<code>4321</code>
</uniteFonctionnelle>
</executant>
<quantite>1</quantite>
</acteCCAM>quantite est ici une chaîne : le XSD la définit comme
nombre5, une chaîne de chiffres.
Actes NGAP : consultations, forfaits techniques, biologie
Un message serveur d’actes peut aussi porter des actes NGAP, seuls ou
à côté des actes CCAM : table actes_ngap, une ligne par
acte, passée par l’argument actes_ngap (la table
actes_ccam devient alors facultative). Colonnes
obligatoires : evt_id, acte_id,
lettre_cle, coefficient,
date_execution, medecin ; facultatives :
heure_execution, uf, quantite,
denombrement, nabm (codes NABM : colonne liste
ou chaîne séparée par des virgules), montant_total,
numero_forfait_technique,
numero_agrement_appareil (forfaits techniques),
action, facturable, valide. Le
reste passe par des colonnes-chemins relatives à acteNGAP.
Chaque acte NGAP porte sa propre action : avec
par_acte = TRUE, les actes CCAM puis NGAP d’un événement
donnent chacun un message.
Exemple (lettres-clés et codes illustratifs) :
# Actes NGAP dans un message serveur d'actes : une consultation, un forfait technique et un
# acte de biologie avec ses codes NABM. Lettres-clés, coefficients, codes et montants sont
# illustratifs : à remplacer par ceux de vos référentiels.
library(hprimxml)
library(tibble)
entete <- list(
version = "2.00", # version HPRIM XML des messages
emetteur = "DIM",
destinataire = "DPI",
date_heure_production = as.POSIXct("2024-03-10 08:00:00", tz = "UTC")
)
# Contexte : une ligne par événement (patient, venue)
evenements <- tibble(
evt_id = "EXT0001",
ipp = "190101337", sexe = "F", date_naissance = as.Date("1958-03-12"),
nda = "240000125", venue_date_entree = as.Date("2024-03-08")
)
# Actes NGAP : une ligne par acte
actes_ngap <- tibble(
evt_id = "EXT0001",
acte_id = c("NG01", "NG02", "NG03"),
lettre_cle = c("CS", "FTN", "B"), # consultation, forfait technique, biologie
coefficient = c("1", "1", "26"),
date_execution = as.Date("2024-03-08"),
heure_execution = hms::as_hms(c("09:30:00", "10:15:00", "11:00:00")),
medecin = "10003456789",
uf = c("2101", "3301", "5201"),
montant_total = c("30.00", "70.00", "7.02"), # montants en euros (illustratifs)
numero_forfait_technique = c(NA, "1", NA), # forfait technique
numero_agrement_appareil = c(NA, "12345678901234", NA),
nabm = list(NULL, NULL, c(1104L, 593L)) # codes NABM de l'acte de biologie
)
# Un message avec les trois actes : sortie/ngap/EXT0001.xml
write_evenements_serveur_actes(evenements, actes_ngap = actes_ngap, entete = entete,
out_dir = "sortie/ngap")
# Un message par acte (unité atomique) : sortie/ngap_atomique/EXT0001_1.xml… _3.xml
write_evenements_serveur_actes(evenements, actes_ngap = actes_ngap, entete = entete,
out_dir = "sortie/ngap_atomique", par_acte = TRUE)
# Relecture : la table actes_ngap, codes NABM compris
relu <- read_evenements_serveur_actes("sortie/ngap")$actes_ngapLa table actes_ngap relue :
| evt_id | acte_id | lettre_cle | coefficient | quantite | denombrement | date_execution | heure_execution | medecin | uf | nabm | montant_total | numero_forfait_technique | numero_agrement_appareil | action | facturable | valide |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| EXT0001 | NG01 | CS | 1 | 2024-03-08 | 09:30:00 | 10003456789 | 2101 | [] | 30.00 | creation | ||||||
| EXT0001 | NG02 | FTN | 1 | 2024-03-08 | 10:15:00 | 10003456789 | 3301 | [] | 70.00 | 1 | 12345678901234 | creation | ||||
| EXT0001 | NG03 | B | 26 | 2024-03-08 | 11:00:00 | 10003456789 | 5201 | [1104, 593] | 7.02 | creation |
États patient (ESEP) :
write_evenements_etat_patient()
Le message porte, au choix, des diagnostics, un IGS2, des
dépendances… mais un seul de ces contenus à la fois. Il exige aussi un
repère : une intervention (intervention_*), une date
d’observation (date_observation) ou un recueil
(recueil_id, recueil_date,
recueil_heure, recueil_uf). Le recueil est le
plus précis : il porte l’UF où les états ont été observés, qui permet au
récepteur de retrouver le RUM, même un jour de mutation. En 2.4, un
élément <divers/> est émis automatiquement.
Diagnostics
# Régénère data/xml_tests/etat_patient/00001.xml : diagnostics DP et DR.
library(hprimxml)
library(tibble)
ts <- function(x) as.POSIXct(x, tz = "UTC")
entete <- list(
version = "2.00", # version HPRIM XML des messages
emetteur = "TEST",
destinataire = NULL,
acquittement_attendu = "non",
commentaire = "HPRIM-TEST",
date_heure_production = ts("2024-01-01 01:01:01")
)
# Une ligne par événement : patient, venue, intervention
# (ici, les colonnes-chemins sont relatives à la racine du message)
evenements <- tibble(
evt_id = "00001_esep",
ipp = "123456789", ipp_recepteur = "123456789",
sexe = "M", nom_usuel = "SANDWICK", prenom = "JOHN",
date_naissance = as.Date("1970-01-01"),
nda = "987654321", nda_recepteur = "987654321",
venue_date_entree = as.Date("2024-01-01"), venue_heure_entree = hms::as_hms("08:00:00"),
venue_uf_responsable = "4321",
intervention_id = "000000000001", intervention_uf = "4321",
`patient/@confidentiel` = "non", `venue/@prive` = "non",
`patient/identifiant/emetteur/@etat` = "permanent",
`patient/identifiant/emetteur/@portee` = "local",
`patient/identifiant/emetteur/@referent` = "non",
`patient/identifiant/recepteur/@etat` = "permanent",
`patient/identifiant/recepteur/@portee` = "local",
`patient/identifiant/recepteur/@referent` = "non"
)
# Une ligne par diagnostic ; type dans dp, dr, da, ds, dd, fpc, mm, ae
diagnostics <- tibble(
evt_id = "00001_esep",
type = c("dp", "dr"),
code = c("Z511", "C10"),
date_action = ts("2024-01-01 08:10:00")
)
fichiers <- write_evenements_etat_patient(
evenements, diagnostics,
entete = entete,
out_dir = "sortie/etat_patient", # -> sortie/etat_patient/00001_esep.xml
validate_xsd = "warn"
)IGS2 détaillé
Chaque item de l’IGS2 est un attribut de <igs2>
portant une classe (age="60A69"…), plus le
score global valeurGlobale. Le script part des pires
valeurs des 24 premières heures et applique la grille de la SFAR (https://sfar.org/scores/igs2.php, d’après Le Gall JR et
coll., JAMA 1993; 270: 2957-2963). L’IGS2 passe entièrement par
des colonnes-chemins (`igs2/@age`,
`igs2/valeurGlobale`…) ; le repère est un recueil dans l’UF
de réanimation.
# IGS2 détaillé dans un message états patient (evenementsServeurEtatsPatient).
# Des mesures brutes (pires valeurs des 24 premières heures), on déduit pour chaque item
# la classe attendue par le XSD (attribut de <igs2>) et ses points, puis le score global.
# Un fichier par patient : l'élément <igs2> n'est pas répétable dans un message.
library(hprimxml)
library(tibble)
ts <- function(x) as.POSIXct(x, tz = "UTC")
entete <- list(
version = "2.00", # version HPRIM XML des messages
emetteur = "REA",
destinataire = "DIM",
date_heure_production = ts("2024-03-06 09:00:00")
)
# Pires valeurs des 24 premières heures, une ligne par patient
mesures <- tibble(
evt_id = c("IGS240001", "IGS240002"),
age = c(67, 82),
frequence_cardiaque = c(128, 105), # /min
pas = c(85, 210), # pression artérielle systolique, mmHg
temperature = c(38.2, 39.4), # °C
ventile = c(TRUE, FALSE), # ventilation mécanique ou CPAP
pao2_fio2 = c(180, NA), # mmHg, si ventilé
diurese = c(0.8, 1.6), # L/24 h
uree = c(18, 8), # mmol/L
leucocytes = c(14, 22), # 10³/mm³
kaliemie = c(4.1, 5.4), # mmol/L
natremie = c(132, 147), # mmol/L
hco3 = c(17, 22), # mmol/L
bilirubine = c(25, 110), # µmol/L
ictere = c(FALSE, TRUE), # la bilirubine ne compte que si ictère
glasgow = c(13, 15),
maladie_chronique = c("aucune", "cancerMetastatique"),
mode_admission = c("medecine", "chirUrgente")
)
# Barème IGS2 : attribut XSD -> mesure, bornes, points par classe XSD
# Source : grille et définitions de la SFAR, https://sfar.org/scores/igs2.php
# (Le Gall JR et coll., JAMA 1993; 270: 2957-2963). Recueil sur les 24 heures suivant
# l'admission : valeur la plus défavorable de chaque item ; Glasgow estimé avant sédation ;
# diurèse ramenée à 24 h si le séjour est plus court ; en cas d'arrêt cardiaque, FC 0,
# PAS 0 et Glasgow < 6. Unités : urée en mmol/L (seuils SFAR en g/L : 0,6 et 1,8),
# leucocytes en 10³/mm³, bilirubine en µmol/L (seuils en mg/L : 40 et 60).
# Les bornes sont fermées à gauche : 40 tombe dans « 40A59 ».
BAREME <- list(
age = list("age", c(40, 60, 70, 75, 80),
c(inferieurA40 = 0, `40A59` = 7, `60A69` = 12, `70A74` = 15, `75A79` = 16,
superieurEgalA80 = 18)),
frequenceCardiaque = list("frequence_cardiaque", c(40, 70, 120, 160),
c(inferieurA40 = 11, `40A69` = 2, `70A119` = 0, `120A159` = 4, superieurEgalA160 = 7)),
tensionArterielleSystolique = list("pas", c(70, 100, 200),
c(inferieurA70 = 13, `70A99` = 5, `100A199` = 0, superieurEgalA200 = 2)),
temperature = list("temperature", 39, c(inferieurA39 = 0, superieurEgalA39 = 3)),
paO2_FIO2 = list("pao2_fio2", c(100, 200), c(inferieurA100 = 11, `100A199` = 9, superieurEgalA200 = 6)),
diurese = list("diurese", c(0.5, 1), c(`inferieurA0,5` = 11, `0,5A0,999` = 4, superieurA1 = 0)),
ureeSanguine = list("uree", c(10, 30), c(inferieurA10 = 0, `10A29,9` = 6, superieurA30 = 10)),
leucocytes = list("leucocytes", c(1, 20), c(inferieurA1 = 12, `1A19,9` = 0, superieurEgalA20 = 3)),
kaliemie = list("kaliemie", c(3, 5), c(inferieurA3 = 3, `3A4,9` = 0, superieurEgalA5 = 3)),
natremie = list("natremie", c(125, 145), c(inferieurA125 = 5, `125A144` = 0, superieurEgalA145 = 1)),
HCO3 = list("hco3", c(15, 20), c(inferieurA15 = 6, `15A19` = 3, superieurEgalA20 = 0)),
bilirubine = list("bilirubine", c(68.4, 102.6),
c(`inferieurA68,4` = 0, `68,4A102,5` = 4, `superieurA102,6` = 9)),
scoreGlasgow = list("glasgow", c(6, 9, 11, 14),
c(inferieurA6 = 26, `6A8` = 13, `9A10` = 7, `11A13` = 5, `14A18` = 0))
)
POINTS_QUALITATIFS <- list(
maladieChronique = list("maladie_chronique",
c(aucune = 0, cancerMetastatique = 9, maladieHematologiqueMaligne = 10, sida = 17)),
modeAdmission = list("mode_admission", c(chirProgrammee = 0, medecine = 6, chirUrgente = 8))
)
# Classe d'une mesure : libelles[i] si bornes[i-1] <= mesure < bornes[i]
classer <- function(x, bornes, libelles) {
as.character(cut(x, c(-Inf, bornes, Inf), labels = libelles, right = FALSE))
}
igs2 <- mesures
for (attr in names(BAREME)) {
b <- BAREME[[attr]]
classe <- classer(mesures[[b[[1]]]], b[[2]], names(b[[3]]))
if (attr == "paO2_FIO2") classe <- ifelse(mesures$ventile, classe, "rien") # ni ventilé ni CPAP
if (attr == "bilirubine") classe <- ifelse(mesures$ictere, classe, "inferieurA68,4") # non ictérique
igs2[[attr]] <- classe
igs2[[paste0("points_", attr)]] <- as.integer(c(b[[3]], rien = 0)[classe])
}
for (attr in names(POINTS_QUALITATIFS)) {
q <- POINTS_QUALITATIFS[[attr]]
igs2[[attr]] <- mesures[[q[[1]]]]
igs2[[paste0("points_", attr)]] <- as.integer(q[[2]][mesures[[q[[1]]]]])
}
igs2$valeurGlobale <- as.integer(rowSums(igs2[grep("^points_", names(igs2))]))
attributs <- c(names(BAREME), names(POINTS_QUALITATIFS))
# Patient et venue, une ligne par message
evenements <- tibble(
evt_id = c("IGS240001", "IGS240002"),
ipp = c("190101337", "190101338"), sexe = c("M", "F"),
date_naissance = as.Date(c("1956-05-14", "1941-11-02")),
nda = c("240000123", "240000124"), venue_date_entree = as.Date("2024-03-05"),
# repère du message : le recueil, avec sa date et l'UF de réanimation où les états ont
# été observés (le récepteur retrouve ainsi le RUM, même un jour de mutation)
recueil_id = c("REC240001", "REC240002"),
recueil_date = as.Date("2024-03-06"),
recueil_uf = "4501"
)
# L'IGS2 passe par des colonnes-chemins relatives à la racine du message
evenements$`igs2/@action` <- "creation"
for (a in attributs) evenements[[paste0("igs2/@", a)]] <- igs2[[a]]
evenements$`igs2/dateAction` <- ts("2024-03-06 08:00:00")
evenements$`igs2/valeurGlobale` <- igs2$valeurGlobale
fichiers <- write_evenements_etat_patient(
evenements, NULL, # pas de table de diagnostics ici
entete = entete,
out_dir = "sortie/igs2", # -> sortie/igs2/IGS240001.xml, IGS240002.xml
xmlns = NULL
)
# Contrôle : une ligne par item, avec la classe et les points de chaque patient
controle <- tibble(item = attributs)
for (i in seq_len(nrow(igs2))) {
controle[[paste0("classe_", igs2$evt_id[i])]] <- unlist(igs2[i, attributs])
}
for (i in seq_len(nrow(igs2))) {
controle[[paste0("points_", igs2$evt_id[i])]] <- unlist(igs2[i, paste0("points_", attributs)])
}La table de contrôle, avec la classe et les points de chaque item :
| item | classe_IGS240001 | classe_IGS240002 | points_IGS240001 | points_IGS240002 |
|---|---|---|---|---|
| age | 60A69 | superieurEgalA80 | 12 | 18 |
| frequenceCardiaque | 120A159 | 70A119 | 4 | 0 |
| tensionArterielleSystolique | 70A99 | superieurEgalA200 | 5 | 2 |
| temperature | inferieurA39 | superieurEgalA39 | 0 | 3 |
| paO2_FIO2 | 100A199 | rien | 9 | 0 |
| diurese | 0,5A0,999 | superieurA1 | 4 | 0 |
| ureeSanguine | 10A29,9 | inferieurA10 | 6 | 0 |
| leucocytes | 1A19,9 | superieurEgalA20 | 0 | 3 |
| kaliemie | 3A4,9 | superieurEgalA5 | 0 | 3 |
| natremie | 125A144 | superieurEgalA145 | 0 | 1 |
| HCO3 | 15A19 | superieurEgalA20 | 3 | 0 |
| bilirubine | inferieurA68,4 | superieurA102,6 | 0 | 9 |
| scoreGlasgow | 11A13 | 14A18 | 5 | 0 |
| maladieChronique | aucune | cancerMetastatique | 0 | 9 |
| modeAdmission | medecine | chirUrgente | 6 | 8 |
<recueil>
<identifiant>
<emetteur>REC240001</emetteur>
</identifiant>
<date>2024-03-06</date>
<uniteFonctionnelle>
<code>4501</code>
</uniteFonctionnelle>
</recueil>
<igs2 action="creation" modeAdmission="medecine" maladieChronique="aucune" scoreGlasgow="11A13" age="60A69" tensionArterielleSystolique="70A99" frequenceCardiaque="120A159" temperature="inferieurA39" paO2_FIO2="100A199" diurese="0,5A0,999" ureeSanguine="10A29,9" leucocytes="1A19,9" kaliemie="3A4,9" natremie="125A144" HCO3="15A19" bilirubine="inferieurA68,4">
<dateAction>2024-03-06T08:00:00</dateAction>
<valeurGlobale>54</valeurGlobale>
</igs2>Les règles de recueil (pires valeurs, Glasgow avant sédation, bilirubine seulement en cas d’ictère…) restent celles de votre service.
Options communes
| argument | valeurs | effet |
|---|---|---|
xmlns |
HPRIM_NS (défaut), NULL,
""
|
namespace HPRIM ; aucune déclaration ; xmlns=""
littéral |
validate_xsd |
"error" (défaut), "warn",
FALSE
|
contrôle de chaque fichier contre son XSD |
version |
"2.4", "2.00"… |
version du schéma ; sinon entete$version, sinon
2.4 |
filename |
gabarit ou fonction | nom de chaque fichier |
fichier_ok |
FALSE (défaut), TRUE
|
dépose un .ok vide une fois chaque .xml
complet |
identifiant_egal_nom_fichier |
TRUE (défaut), FALSE
|
identifiantMessage = nom du fichier |
colmap |
list(ancien = "nouveau") |
renommage de colonnes |
encoding |
"UTF-8" (défaut), "ISO-8859-1"
|
encodage des fichiers |
par_rum (PMSI), par_acte (actes),
par_diagnostic (états patient) |
FALSE (défaut), TRUE
|
un message par unité atomique |