Salut la Communauté !

Si le sujet FHIR vous intéresse, vous trouverez ci-dessous une sélection d'articles intéressants qui aideront les débutants à le comprendre et à approfondir les connaissances de ceux qui l'utilisent déjà.

Ce Template s'agit du modèle de base pour utiliser InterSystems IRIS for Health Community Edition en tant que serveur FHIR.

Il configure un SERVEUR FHIR, importe les données de test, fait la démonstration de l'utilisation de l'API REST avec une simple page web.

Conditions préalables

Assurez-vous que vous avez installé git et Docker desktop.

Installation

IPM

Ouvrez l'installation d'IRIS for Health avec le client IPM installé. Appel dans n'importe quel espace de nom :

USER>zpm "install fhir-server"

Ainsi, le serveur FHIR sera installé dans l'espace de noms FHIRSERVER.

Intersystems IRIS for Health offre un excellent support pour la norme sectorielle FHIR. Les principales caractéristiques sont :

1. Serveur FHIR
2. Base de données FHIR
3. API REST et ObjectScript pour les opérations CRUD sur les ressources FHIR (patient, questionnaire, vaccins, etc.)

Cet article explique comment utiliser chacune de ces fonctionnalités, et présente un front-end angulaire permettant de créer et d'afficher des ressources FHIR de type Quiz.

Étape 1 - Déploiement de votre serveur FHIR à l'aide d'InterSystems IRIS for Health

Pour créer votre serveur FHIR, il faut ajouter les instructions suivantes dans le fichier iris.script ( à partir de : https://openexchange.intersystems.com/package/iris-fhir-template)

    zn "HSLIB"
    set namespace="FHIRSERVER"
    Set appKey = "/fhir/r4"
    Set strategyClass = "HS.FHIRServer.Storage.Json.InteractionsStrategy"
    set metadataPackages = $lb("hl7.fhir.r4.core@4.0.1")
    set importdir="/opt/irisapp/src"

    //Install a Foundation namespace and change to it
    Do ##class(HS.HC.Util.Installer).InstallFoundation(namespace)
    zn namespace

    // Install elements that are required for a FHIR-enabled namespace
    Do ##class(HS.FHIRServer.Installer).InstallNamespace()

    // Install an instance of a FHIR Service into the current namespace
    Do ##class(HS.FHIRServer.Installer).InstallInstance(appKey, strategyClass, metadataPackages)

    // Configure FHIR Service instance to accept unauthenticated requests
    set strategy = ##class(HS.FHIRServer.API.InteractionsStrategy).GetStrategyForEndpoint(appKey)
    set config = strategy.GetServiceConfigData()
    set config.DebugMode = 4
    do strategy.SaveServiceConfigData(config)

    zw ##class(HS.FHIRServer.Tools.DataLoader).SubmitResourceFiles("/opt/irisapp/fhirdata/", "FHIRServer", appKey)

    do $System.OBJ.LoadDir("/opt/irisapp/src","ck",,1)

    zn "%SYS"
    Do ##class(Security.Users).UnExpireUserPasswords("*")

    zn "FHIRSERVER"
    zpm "load /opt/irisapp/ -v":1:1

    //zpm "install fhir-portal"
    halt

En utilisant la classe utilitaire HS.FHIRServer.Installer, vous pouvez créer votre serveur FHIR.

Étape 2 - Utilisez l'API FHIR REST ou ObjectScript pour lire, mettre à jour, supprimer et trouver des données FHIR

Je préfère utiliser la classe ObjectScript HS.FHIRServer.Service pour faire toutes les opérations CRUD.

Pour obtenir toutes les données FHIR provenant d'un type de ressource (comme le questionnaire) :

/// Retreive all the records of questionnaire
ClassMethod GetAllQuestionnaire() As %Status
{

    set tSC = $$$OK
    Set %response.ContentType = ..#CONTENTTYPEJSON
    Set %response.Headers("Access-Control-Allow-Origin")="*"

    Try {
        set fhirService = ##class(HS.FHIRServer.Service).EnsureInstance(..#URL)
        set request = ##class(HS.FHIRServer.API.Data.Request).%New()
        set request.RequestPath = "/Questionnaire/"
        set request.RequestMethod = "GET"
        do fhirService.DispatchRequest(request, .pResponse)
        set json = pResponse.Json
        set resp = []
        set iter = json.entry.%GetIterator()
        while iter.%GetNext(.key, .value) { 
          do resp.%Push(value.resource)
        }
        
        write resp.%ToJSON()    
    } Catch Err {
        set tSC = 1
        set message = {}
        set message.type= "ERROR"
        set message.details = "Error on get all questionnairies"       
    }
    
    Quit tSC
}

Pour obtenir un élément de données spécifique du référentiel de données FHIR (comme une occurrence de questionnaire) :

/// Retreive a questionnaire by id
ClassMethod GetQuestionnaire(id As %String) As %Status
{

    set tSC = $$$OK
    Set %response.ContentType = ..#CONTENTTYPEJSON
    Set %response.Headers("Access-Control-Allow-Origin")="*"

    Try {
        set fhirService = ##class(HS.FHIRServer.Service).EnsureInstance(..#URL)
        set request = ##class(HS.FHIRServer.API.Data.Request).%New()
        set request.RequestPath = "/Questionnaire/"_id
        set request.RequestMethod = "GET"
        do fhirService.DispatchRequest(request, .pResponse)
        write pResponse.Json.%ToJSON()    
    } Catch Err {
        set tSC = 1
        set message = {}
        set message.type= "ERROR"
        set message.details = "Error on get the questionnaire"       
    }
    
    Quit tSC
}

Pour créer une nouvelle occurrence de ressource FHIR (comme un nouveau questionnaire) :

/// Create questionnaire
ClassMethod CreateQuestionnaire() As %Status
{
  set tSC = $$$OK
  Set %response.ContentType = ..#CONTENTTYPEJSON
  Set %response.Headers("Access-Control-Allow-Origin")="*"

  Try {
    set fhirService = ##class(HS.FHIRServer.Service).EnsureInstance(..#URL)
    set request = ##class(HS.FHIRServer.API.Data.Request).%New()
    set request.RequestPath = "/Questionnaire/"
    set request.RequestMethod = "POST"
    set data = {}.%FromJSON(%request.Content)
    set data.resourceType = "Questionnaire"
    set request.Json = data
    do fhirService.DispatchRequest(request, .response)
    write response.Json.%ToJSON()
  } Catch Err {
    set tSC = 1
    set message = {}
    set message.type= "ERROR"
    set message.details = "Error on create questionnaire"
  }
  
  Return tSC
}

Pour mettre à jour une ressource FHIR (comme un questionnaire) :

/// Update a questionnaire
ClassMethod UpdateQuestionnaire(id As %String) As %Status
{
  set tSC = $$$OK
  Set %response.ContentType = ..#CONTENTTYPEJSON
  Set %response.Headers("Access-Control-Allow-Origin")="*"

  Try {
    set fhirService = ##class(HS.FHIRServer.Service).EnsureInstance(..#URL)
    set request = ##class(HS.FHIRServer.API.Data.Request).%New()
    set request.RequestPath = "/Questionnaire/"_id
    set request.RequestMethod = "PUT"
    set data = {}.%FromJSON(%request.Content)
    set data.resourceType = "Questionnaire"
    set request.Json = data
    do fhirService.DispatchRequest(request, .response)
    write response.Json.%ToJSON()
  }Catch Err {
    set tSC = 1
    set message = {}
    set message.type= "ERROR"
    set message.details = "Error on update questionnaire"
  }
  Return tSC
}

Pour supprimer un occurrence de ressource FHIR (comme un questionnaire) :

/// Delete a questionnaire by id
ClassMethod DeleteQuestionnaire(id As %String) As %Status
{

    set tSC = $$$OK
    Set %response.ContentType = ..#CONTENTTYPEJSON
    Set %response.Headers("Access-Control-Allow-Origin")="*"

    Try {
        set fhirService = ##class(HS.FHIRServer.Service).EnsureInstance(..#URL)
        set request = ##class(HS.FHIRServer.API.Data.Request).%New()
        set request.RequestPath = "/Questionnaire/"_id
        set request.RequestMethod = "DELETE"
        do fhirService.DispatchRequest(request, .pResponse)
    } Catch Err {
        set tSC = 1
        set message = {}
        set message.type= "ERROR"
        set message.details = "Error on delete the questionnaire"       
    }
    
    Quit tSC
}

Comme vous pouvez le voir, pour créer, il faut utiliser POST, pour mettre à jour, il faut utiliser PUT, pour supprimer, il faut utiliser DELETE et pour lancer une requête, il faut utiliser le verbe GET.

Étape 3 - Créez un client en Angular pour utiliser votre application de serveur FHIR.

J'ai créé une application angulaire en utilisant PrimeNG et en installant le paquet npm install --save @types/fhir. Ce paquet a tous les types FHIR mappé à TypeScript.

Classe de contrôleur en Angular :

import { Component, OnInit, ViewEncapsulation } from '@angular/core';
import { ActivatedRoute, Router } from '@angular/router';
import { Period, Questionnaire } from 'fhir/r4';
import { ConfirmationService, MessageService, SelectItem } from 'primeng/api';
import { QuestionnaireService } from './questionnaireservice';

const QUESTIONNAIREID = 'questionnaireId';

@Component({
    selector: 'app-questionnaire',
    templateUrl: './questionnaire.component.html',
    providers: [MessageService, ConfirmationService],
    styleUrls: ['./questionnaire.component.css'],
    encapsulation: ViewEncapsulation.None
})
export class QuestionnaireComponent implements OnInit {

    public questionnaire: Questionnaire;
    public questionnairies: Questionnaire[];
    public selectedQuestionnaire: Questionnaire;
    public questionnaireId: string;
    public sub: any;
    public publicationStatusList: SelectItem[];
    
    constructor(
        private questionnaireService: QuestionnaireService,
        private router: Router,
        private route: ActivatedRoute,
        private confirmationService: ConfirmationService,
        private messageService: MessageService){
            this.publicationStatusList = [
                {label: 'Draft', value: 'draft'},
                {label: 'Active', value: 'active'},
                {label: 'Retired', value: 'retired'},
                {label: 'Unknown', value: 'unknown'}
            ]
        }

    ngOnInit() {
        this.reset();
        this.listQuestionnaires();
        this.sub = this.route.params.subscribe(params => {

            this.questionnaireId = String(+params[QUESTIONNAIREID]);

            if (!Number.isNaN(this.questionnaireId)) {
                this.loadQuestionnaire(this.questionnaireId);
            }
        });
    }

    private loadQuestionnaire(questionnaireId) {
        this.questionnaireService.load(questionnaireId).subscribe(response => {
            this.questionnaire = response;
            this.selectedQuestionnaire = this.questionnaire;
            if(!response.effectivePeriod) {
                this.questionnaire.effectivePeriod = {};
            }
        }, error => {
            console.log(error);
            this.messageService.add({ severity: 'error', summary: 'Error', detail: 'Error on load questionnaire.' });
        });
    }


    public loadQuestions() {
        if(this.questionnaire && this.questionnaire.id) {
            this.router.navigate(['/question', this.questionnaire.id]);
        } else {
            this.messageService.add({ severity: 'warn', summary: 'Warning', detail: 'Choose a questionnaire.' });
        }
    }

    private listQuestionnaires() {
        this.questionnaireService.list().subscribe(response => {
            this.questionnairies = response;
            this.reset();
        }, error => {
            console.log(error);
            this.messageService.add({ severity: 'error', summary: 'Error', detail: 'Error on load the questionnaries.' });
        });
    }

    public onChangeQuestionnaire() {
        if (this.selectedQuestionnaire && !this.selectedQuestionnaire.id) {
            this.messageService.add({ severity: 'warn', summary: 'Warning', detail: 'Select a questionnaire.' });
        } else {
            if(this.selectedQuestionnaire && this.selectedQuestionnaire.id) {
                this.loadQuestionnaire(this.selectedQuestionnaire.id);
            }
        }
    }

    public reset() {
        this.questionnaire = {};
        this.questionnaire.effectivePeriod = {};
    }


    public save() {

        if(this.questionnaire.id && this.questionnaire.id != "") {
            this.questionnaireService.update(this.questionnaire).subscribe(
                (resp) => {
                    this.messageService.add({
                        severity: 'success',
                        summary: 'Success', detail: 'Questionnaire saved.'
                    });
                    this.listQuestionnaires()
                    this.loadQuestionnaire(this.questionnaire.id);
                },
                error => {
                    console.log(error);
                    this.messageService.add({
                        severity: 'error',
                        summary: 'Error', detail: 'Error on save the questionnaire.'
                    });
                }
            );
        } else {
            this.questionnaireService.save(this.questionnaire).subscribe(
                (resp) => {
                    this.messageService.add({
                        severity: 'success',
                        summary: 'Success', detail: 'Questionnaire saved.'
                    });
                    this.listQuestionnaires()
                    this.loadQuestionnaire(resp.id);
                },
                error => {
                    console.log(error);
                    this.messageService.add({
                        severity: 'error',
                        summary: 'Error', detail: 'Error on save the questionnaire.'
                    });
                }
            );
        }
        
    }
    
    public delete(id: string) {

        if (!this.questionnaire || !this.questionnaire.id) {
            this.messageService.add({ severity: 'warn', summary: 'Warning', detail: 'Select a questionnaire.' });
        } else {
            this.confirmationService.confirm({
                message: 'Do you confirm?',
                accept: () => {
                    this.questionnaireService.delete(id).subscribe(
                        () => {
                            this.messageService.add({ severity: 'success', summary: 'Success', detail: 'Questionnaire deleted.' });
                            this.listQuestionnaires();
                            this.reset();
                        },
                        error => {
                            console.log(error);
                            this.messageService.add({ severity: 'error', summary: 'Error', detail: 'Error on delete questionnaire.' });
                        }
                    );
                }
            });
        }
    }
   
}

Fichier HTML Angular

Name
Title
Date
Status
Publisher
Start Period
End Period
Description

Classe de Service Angular

import { Injectable } from '@angular/core';
import { HttpClient, HttpHeaders } from '@angular/common/http';
import { Observable } from 'rxjs';
import { environment } from 'src/environments/environment';
import { take } from 'rxjs/operators';
import { Questionnaire } from 'fhir/r4';

@Injectable({
  providedIn: 'root'
})
export class QuestionnaireService {

  private url = environment.host2 + 'questionnaire';

  constructor(private http: HttpClient) { }

  public save(Questionnaire: Questionnaire): Observable {
    return this.http.post(this.url, Questionnaire).pipe(take(1));
  }

  public update(Questionnaire: Questionnaire): Observable {
    return this.http.put(`${this.url}/${Questionnaire.id}`, Questionnaire).pipe(take(1));
  }

  public load(id: string): Observable {
    return this.http.get(`${this.url}/${id}`).pipe(take(1));
  }

  public delete(id: string): Observable {
    return this.http.delete(`${this.url}/${id}`).pipe(take(1));
  }

  public list(): Observable {
    return this.http.get(this.url).pipe(take(1));
  }

}

Step 4 - Application in action

1. Aller à l'application https://openexchange.intersystems.com/package/FHIR-Questionnaires.

2. Clone/git dépose le dépôt dans n'importe quel répertoire local.

$ git clone https://github.com/yurimarx/fhir-questions.git

3. Ouvrir le terminal dans ce répertoire et exécutez :

$ docker-compose up -d

4. Ouvrir l'application web : http://localhost:52773/fhirquestions/index.html

Voici quelques illustrations :

Bonjour aux développeurs d'InterSystems !

Récemment, j'ai mis à jour le modèle FHIR dev template afin qu'il publie maintenant un paquet IPM fhir-server permettant de faire de la configuration du serveur FHIR d'InterSystems une procédure manuelle, automatique ou programmatique triviale d'une seule commande.

Découvrez ci-dessous comment vous pouvez en bénéficier.

TLDR

USER>zpm "install fhir-server"

Tous les détails ci-dessous.

Configuration du serveur InterSystems FHIR sans IPM 

Bien sûr, vous pouvez configurer le serveur InterSystems FHIR sans utiliser le gestionnaire de paquets IPM. Vous avez le choix :

1. Vous pouvez configurer un serveur FHIR en nuage et l'essayer pendant plusieurs jours en suivant les instructions suivantes. Il s'agira d'un serveur FHIR d'InterSystems dans le nuage AWS.

2. Vous pouvez configurer le serveur FHIR d'InterSystems en exécutant InterSystems IRIS for Health en suivant les étapes suivantes.

3. Vous pouvez également cloner git le dépôt de ce modèle et l'exécuter dans un répertoire cloné :

$ docker-compose up -d

pour que le serveur FHIR d'InterSystems fonctionne sur votre ordinateur portable.

Ce que je suggère dans l'article est le point 2 où vous pouvez sauter toutes les étapes manuelles et avoir le serveur FHIR en marche sur un ordinateur portable IRIS soit dans Docker soit dans l'OS hôte.

**Configuration du serveur FHIR avec IPM **

AVIS DE NON-RESPONSABILITÉ ! Les étapes décrites ci-dessous se rapportent à une instance d'IRIS for Health récemment installée ou à une utilisation avec des images Docker. Le paquet crée un nouvel espace de noms et une nouvelle application Web, ce qui pourrait nuire à la configuration précédente.

IPM est l'acronyme anglais pour InterSystems Package manager, précédemment connu sous le nom de ZPM. Vérifiez que [IPM-client est installé] (https://openexchange.intersystems.com/package/InterSystems-Package-Manager-1). Vous pouvez le vérifier en exécutant la commande zpm dans le terminal IRIS et en obtenant le résultat suivant :

IRISAPP>zpm     

=============================================================================
|| Welcome to the Package Manager Shell (ZPM).                             ||
|| Enter q/quit to exit the shell. Enter ?/help to view available commands ||
=============================================================================
zpm:IRISAPP>

Vous aurez besoin d'IRIS for Health pour les versions 2022.x et plus récentes.  

Comment exécuter iris for health sur votre ordinateur portable ?

Exécution d'une opération hôte

Téléchargez la version la plus récente d'IRIS for Health sur le [site d'évaluation d'InterSystems] (https://evaluation.intersystems.com/Eval/index.html) qui correspond à votre plate-forme (Windows, Mac, Linux) et installez-la. Installez ZPM. Voici un exemple :

USER>zn "%SYS" d ##class(Security.SSLConfigs).Create("z") s r=##class(%Net.HttpRequest).%New(),r.Server="pm.community.intersystems.com",r.SSLConfiguration="z" d r.Get("/packages/zpm/latest/installer"),$system.OBJ.LoadStream(r.HttpResponse.Data,"c")

Exécution d'une version docker

Appelez votre terminal pour le lancement :

docker run --rm --name iris4h -d --publish 9091:1972 --publish 9092:52773 intersystemsdc/irishealth-community

Puis lancez le terminal :

docker exec -it iris4h iris session IRIS

Installation du serveur FHIR

Après avoir fait fonctionner IRIS sur l'hôte ou simplement dans le terminal IRIS :

USER>zpm "install fhir-server"

Cela installera le serveur FHIR dans l'espace de noms FHIRSERVER avec des paramètres :

Set appKey = "/fhir/r4"
Set strategyClass = "HS.FHIRServer.Storage.Json.InteractionsStrategy"
set metadataPackages = $lb("hl7.fhir.r4.core@4.0.1")

Set metadataConfigKey = "HL7v40"

L'API REST FHIR sera disponible ici : http://yourserver/fhir/r4.

Il ajoutera également quelques données synthétiques.

Comment comprendre que le serveur fonctionne ?

Pour tester la version hôte :

http://localhost:52773/fhir/r4/metadata

Pour tester la version docker :

http://localhost:9092/fhir/r4/metadata

zpm installe également l'interface utilisateur simple qui est disponible à l'adresse suivante : yourserver/fhirUI/FHIRAppDemo.html.

Et vous verrez apparaître quelque chose comme ceci (avec le patient id=1 entré) :

Comment ça marche ?

En fait, vous pouvez observer ce qui est installé avec ce module ZPM dans le scénario suivant following module.xml. On peut voir qu'il importe du code, installe l'application frontale de démonstration fhirUI, exécute le script de post-installation, qui appelle la méthode suivante. Le script de la méthode effectue la configuration du serveur FHIR.

Installation programmatique du serveur FHIR

Vous pouvez également l'installer de manière programmatique en utilisant la commande suivante :

set sc=$zpm("install fhir-server")

Joyeux codage FHIR !

Dans la newsletter de décembre 2022, découvrez d'autres moyens de transformer, d'analyser, de partager et de visualiser vos données à l'aide des technologies InterSystems, y compris la façade FHIR ! De plus, écoutez un nouvel épisode de podcast sur AI Link, un pont entre l'apprentissage automatique et l'intelligence d'affaires. Assurez-vous de vous inscrire à la newsletter pour obtenir les dernières ressources !

Une production simple qui permet de charger des paquets de transactions FHIR dans le serveur FHIR® d'InterSystems® via Box et Dropbox.&nbsp ; En utilisant les composants de connexion MFT inclus et un processus personnalisé Custom Business Process de 14 lignes, cette production traitera vos paquets de transactions vers les ressources FHIR pour une consommation immédiate à la manière magique digne d'Harry Potter.  Idéal pour les Hackathons, la recherche et les cocktails FHIR®.

Tout d'abord, je vous propose une brève visite vidéo de la production, des connexions MFT et de la configuration de l'application Oauth2 pour Box et Dropbox sur IRIS. Ensuite, je vous propose quelques étapes pour vous aider à utiliser le Fournisseur de MFT de votre choix et le flux de travail de votre choix (Desktop, API ou Web Console glisser-déposer).

Quelques gaffes :

• Les rappels OAUTH2 Call Backs nécessitent des Points d'extrémité SSL pour qu'IRIS fournisse la redirection... le mieux est de tenter le coup sur Health Connect Cloud !
• Dropbox pour les entreprises a des difficultés avec les jetons basés sur l'équipe, mais Dropbox personnel fonctionne bien. Ce n'est pas un problème, mais cela demande un peu plus.
• Faites attention au "/" de l'URL de base de Dropbox lorsque vous configurez les connexions MFT (assurez-vous qu'il existe).
• Les adaptateurs MFT sortants doivent avoir un "/" de fin de ligne pour les chemins d'accès à Box et DropBox.

Maintenant, étant donné que la performance exceptionnelle du contenu alimenté par OBS n'a peut-être pas été à la hauteur, voici les étapes à suivre si la Documentation d'InterSytems ne suffit pas.

Présentation des étapes :

• Créez l'application FHIRDrop ou FHIRBox à un point, puis STOP ! (Collaborez et écoutez)
• Configurez les connexions MFT sur votre serveur FHIR InterSystems, HealthConnect ou I4H.
• Complétez votre application FHIRDrop ou FHIRBox, en fournissant l'url de redirection de la connexion MFT.
• Autorisez vos connexions MFT.
• Créez votre production.
• Lâchez-la comme si c'était chaud ! 

Création de l'application FHIRDrop ou FHIRBox L'idée ici est de "démarrer" la configuration de votre application dans chacune des consoles Box et Dropbox Developer, ce qui vous permet de révéler l'identifiant et le secret du client, puis de laisser l'onglet en suspens et de passer aux connexions IRIS MFT.
(Collaborez et écoutez) Rassemblez votre identifiant et votre secret client, fermez l'onglet du navigateur et passez à la suite : Configurez la ou les connexions MFT
L'URL de base : https://api.box.com/2.0	L'URL de base : https://api.dropboxapi.com/2/ (attention à la barre de fraction de fin)
L'enregistrement complet de l'application Maintenant, retournez à l'enregistrement de l'application et complétez l'App.&nbsp ; Assurez-vous de brancher l'URL de redirection de l'étape ci-dessus, et ajoutez les paramètres qui ont quelque chose à faire avec file.read, file.write.
Autorisation de vos connexions de transfert de fichiers gérées Revenez à vos connexions de transfert de fichiers gérées et "autorisez" vos connexions en invoquant "Get Access Token".
Création de votre production
Production La source pour les processus opérationnels personnalisés, la production est ici : https://gitlab.com/isc_cloud/fhir-drop-fhir-box-mft-2-fhir
Lâchez-la comme si c'était chaud !

Et maintenant, obtenez FHIR !

Bonjour à tous, c'est avec grand plaisir que je vous annonce la V2 de mon application 'Contest-FHIR'.

Dans cette nouvelle version, j'ai utilisé de nouveaux outils et techniques que j'ai découverts lors de l'EUROPEAN HEALTHCARE HACKATHON auquel j'ai été invité par InterSystems en tant qu'invité et mentor pour présenter les multiples projets que j'ai réalisés lors de mon stage en avril 2022.

Aujourd'hui je vous présente la V2 de mon application, elle peut maintenant transformer un fichier CSV en FHIR en SQL en JUPYTER notebook.

C'est pour moi un grand pas en avant dans les technologies d'InterSystems et je pense que cet outil sera utilisé pour de nombreux autres usages et cas.

Visitez mon GitHub pour plus d'informations, et pour ceux d'entre vous qui ne veulent pas perdre de temps, consultez la partie 5. Walkthrough de mon GitHub.

Cet article aborde les questions de Questionnaire et QuestionnaireResponse de FHIR depuis la création du formulaire jusqu'au téléchargement sur le serveur et la façon de les remplir.

tl;dr :

• En utilisant cet outil en ligne vous pouvez facilement créer votre propre formulaire en partant de zéro ou en utilisant un modèle d'un formulaire existant.
• En utilisant ce serveur FHIR local d'InterSystems you can easily store your FHIR resources and Questionnaire.
• En utilisant cet application vous pouvez manipuler, comme si vous étiez un praticien, le questionnaire et la réponse pour chaque patient sur votre serveur FHIR.

Il est à noter que l'application ne communique pas en utilisant le Content-Type 'application/json+fhir' mais juste le Content-Type 'application/json' donc cela ne fonctionnera pas de cette manière avec notre serveur FHIR local d' InterSystems.

C'est pourquoi j'ai créé ce repo GitHub contenant une version modifiée de l'application, fonctionnant avec Content-Type 'application/json+fhir', contenant un serveur FHIR local et un lien vers l'outil de construction de questionnaires avec quelques explications.
Après avoir cloné le repo, en faisant docker-compose up -d, npm ci, npm run build et ensuite npm run start vous serez accueilli avec un accès à l'app, en sélectionnant le serveur FHIR que vous voulez et le Patient avec lequel vous voulez travailler, vous pourrez remplir Questionnaire et les enregistrer sur votre serveur en 2 clics.

Fin de tl;dr Ce qui suit est le ReadMe du GitHub.

1. Application pour les formulaires FHIR utilisant un serveur fhir local

• 1.Application pour les formulaires FHIR utilisant un serveur fhir local
• 2. Conditions requises
  • 2.1. Ajout de Node.js et npm à votre route
  • 2.2. Installation des dépendances
• 3. Serveur FHIR local
• 4. Utilisation de l'application
  • 4.1. Construction de l'application
  • 4.2. Lancement de l'application
• 5. Formulaire FHIR / questionnaire
  • 5.1. Développement de votre propre formulaire FHIR
  • 5.2. Importation de votre propre formulaire FHIR

Il s'agit d'une application principalement basée sur ce référentiel qui peut être utilisée pour afficher les éléments suivants
FHIR
SDC
Questionnaire
et collecter les données en tant que ressources FHIR QuestionnaireResponse.
En la développant à l'aide de docker-compose up -d vous aurez accès à un serveur FHIR local qui pourra ensuite être utilisé pour tester l'application.

2. Conditions requises

L'application s'appuie sur le widget de visualisation LHC-Forms pour l'affichage des formulaires. Elle prend partiellement en charge les FHIR Questionnaires (versions STU3 et R4) et le Guide d'implémentation de la capture de données structurées.
Ce widget sera installé avec les dépendances.

Pour essayer des exemples de formulaires, ce référentiel est livré avec des formulaires dans le répertoire e2e-test/data/R4 qui sont automatiquement chargés dans le serveur FHIR local lors de la construction.

2.1. Ajout de Node.js et npm à votre route

Le fichier bashrc.lforms-fhir-app spécifie la version de Node.js utilisée pour le développement. Téléchargez cette version de Node.js, et ajoutez son répertoire bin à votre route.

2.2. Installation des dépendances

En exécutant cette commande, vous serez en mesure d'installer tout ce qui est nécessaire pour que l'application fonctionne.

npm ci

3. Serveur FHIR local

Si vous ne disposez pas d'un serveur FHIR pour essayer cette application, vous pouvez démarrer et utiliser un serveur FHIR local alimenté par les technologies InterSystems en faisant dans le dossier fhir-form :

docker-compose up -d

After some wait, your local FHIR server is up and you can access it by using http://localhost:32783/fhir/r4
Sachez que ce lien est déjà enregistré dans l'application.

4. Utilisation de l'application

Pour utiliser l'application, vous devez la construire et ensuite la lancer.
Vous pouvez maintenant accéder à n'importe quel serveur FHIR à l'aide du menu de l'application, mais si vous le souhaitez, vous pouvez utiliser ce serveur FHIR local

4.1. Construction de l'application

npm run build

Les fichiers pour la production seront créés dans un répertoire "dist", mais certains fichiers nécessaires seront également copiés à partir de node_modules.

4.2. Lancement de l'application

npm run start

va lancer un serveur http fonctionnant sur le port 8000.

Maintenant, naviguez vers l'application à localhost:8000/lforms-fhir-app/.

Ici, vous pouvez choisir un serveur auquel vous voulez vous connecter.
Si vous souhaitez utiliser le serveur FHIR local, démarrez le serveur FHIR local puis, dans l'application, sélectionnez le premier choix http://localhost:32783/fhir/r4

5. Formulaire FHIR / questionnaire

5.1. Développement de votre propre formulaire FHIR

En utilisant this online tool ous pouvez facilement créer votre propre formulaire en partant de zéro ou en utilisant un formulaire existant.
Il est conseillé d'importer l'un de ceux qui existent dans le dossier e2e-tests/data/R4 et de commencer à partir de là pour comprendre le fonctionnement de l'outil.

5.2. Importation de votre propre formulaire FHIR

En utilisant l'application, vous pouvez facilement importer vos formulaires locaux et les utiliser immédiatement en utilisant le bouton de téléchargement upload.

Si vous utilisez l'outil de construction de formulaires [formbuilder tool] (https://lhcformbuilder.nlm.nih.gov/beta/), vous pouvez, si votre serveur FHIR prend en charge le type de contenu 'application/json', exporter le formulaire que vous créez directement vers le serveur FHIR en utilisant le bouton d'exportation export.

Si votre serveur ne supporte pas le Content-Type 'application/json' mais seulement le Content-Type 'application/json+fhir' par exemple, comme notre serveur FHIR local vous devez exporter le formulaire dans un fichier, puis dans l'application, et télécharger par upload le fichier sur le serveur en tant que l'application communique en Content-Type 'application/json+fhir'.

Nous sommes une startup technologique - Virtual Lab qui développe des solutions utilisant des technologies avancées VR / AR. Nous disposons d’un vaste portefeuille de produits et de solutions personnalisés. Aujourd’hui, nous aimerions vous présenter le projet VR ICU® – une plate-forme de formation pour le personnel médical de l’uci, créée à l’ère du Covid pour les besoins des hôpitaux.

Salut la communauté,

Nous sommes heureux de vous inviter au prochain webinaire de lancement du concours de programmation FHIR pour la santé des femmes.

FemTech (logiciel pour la santé des femmes) fait partie intégrante de la prestation de soins de santé modernes qui individualise les soins et encourage l'autonomisation des patientes. Le marché de la santé numérique des femmes devrait continuer de croître à mesure que nous priorisons et déstigmatisons les problèmes de santé des femmes.

Dans ce webinaire, nous vous montrerons certains des principes généraux et des problèmes de résolution des problèmes liés à la santé des femmes, ainsi que de partager de bonnes idées pour votre inspiration. Comme toujours, nous discuterons et répondrons aux questions sur la façon de créer des solutions à l'aide d'InterSystems IRIS for Health.

Date et heure : lundi 14 novembre – 11 h 00 HAE

Intervenants :  
🗣 @Aya Heshmat, Product Specialist
🗣 @Dean Andrews, Head of Developer Relations  
🗣 @Evgeny Shvarov, InterSystems Developer Ecosystem Manager

>> Inscrivez-vous ici <<

Salut les développeurs,

Nous sommes heureux de vous inviter à rejoindre le webinaire Création et activation d'applications de santé avec HL7 FHIR!

Date : mercredi, 9 novembre 2022
Heure : 13 h 00 EST
Durée : 30 minutes

Salut la communauté !

Nous aimerions vous inviter à participer à notre prochain concours pour partager vos connaissances de FHIR :

🏆 Concours InterSystems IRIS for Health : FHIR pour la santé des femmes 🏆

Soumettez une application qui utilise InterSystems FHIR ou InterSystems Healthcare Interoperability !

Durée: 14 novembre - 4 décembre 2022

Prix: $13,500!

>> Téléchargez votre application ici <<

Salut la Сommunauté !

Nous sommes ravis de vous annoncer le lancement de notre nouveau sujet de publications sur la Communauté de Developpeurs francophones ! Cette rentrée scolaire on commence à parler de FHIR !

Bonjour aux développeurs !

Il est possible que vous ayez à mettre en œuvre des scénarios qui ne nécessitent pas de référentiel FHIR, mais qui transmettent des demandes FHIR, gèrent les réponses et, éventuellement, exécutent des transformations ou extraient certaines valeurs entre les deux. Je vous propose ici quelques exemples qui peuvent être mis en œuvre en utilisant les systèmes InterSystems IRIS For Health et HealthShare Health Connect.

Dans les exemples suivants, j'ai utilisé des productions d'interopérabilité avec l'adaptateur d'interopérabilité FHIR Interoperability Adapter et les messages HS.FHIRServer.Interop.Request.

Le premier scénario consiste à créer une demande FHIR à partir de zéro (à partir d'un fichier ou d'une requête SQL), puis à l'envoyer à un service FHIR externe.

Le scénario suivant est une sorte de l'accès direct à FHIR pour les demandes et les réponses à un référentiel FHIR externe, gérant également les jetons OAuth.

Enfin, le dernier scénario consiste à recevoir des demandes FHIR pour les transmettre ensuite à un service FHIR externe, mais en extrayant des informations ou en modifiant certains champs entre les deux.

Vous trouverez les détails de mise en œuvre dans l'application Open Exchange :)

J'espère que cela vous sera utile !

Lancement du serveur FHIR d'InterSystems lors du HL7 FHIR Connectathon à Baltimore le week-end dernier, avec affichage de bundles, utilisation de toutes les RESTy avec les ressources et interrogation du Guide de mise en œuvre de Vulcan Vulcan Implementation Guide. Nous avons chevauché les projets Real World Data (RWD) et Schedule of Activity (SoA) pour Vulcan IG, qui font avancer la connexion des données de recherche clinique et de santé. Nous avons utilisé une approche assez décente pour répondre aux exigences,

MMoi-même, ainsi que les collègues d'InterSystems (Huy, Russell, Regilo), nous étions chargés de soutenir le serveur FHIR et l'appropriation des données pour l'événement. Si vous avez déjà été chargé de rédiger des Bundles FHIR pour un cas d'utilisation spécifique, je pense que vous pouvez apprécier à quel point la difficulté peut être insurmontable.

Nous avons provisionné deux serveurs InterSystems FHIR de la taille d'un radiocassette "ghetto blaster", 16 cœurs/128 Go, un pour chaque projet et nous nous sommes mis au travail pour chaque équipe. Les équipes sont arrivées préparées avec leurs Python Notebooks sur nos points de terminaison, avec l'intention d'écrire une histoire FHIR pour ACS avec un script de test procédural qui valide les appels retournés avec les résultats attendus.

La cible de cohorte pour RWD me semble assez simple dans l'exemple des requêtes pour le syndrome coronarien aigu :

N'est-ce pas ?

/Patient?birthdate=le2002-09-01&gender=male,female
/Encounter?reason-code:below=I20,I21,I22,I23,I24,I25&date=ge2020-09-01&date=le2021-09-31&status=finished&dischargeDisposition:not=exp
/MedicationAdministration?status=completed&effective-time=ge[Encounter-Start-Date]&
code=http://www.nlm.nih.gov/research/umls/rxnorm|1116632,http://www.nlm.nih.gov/research/umls/rxnorm|613391,http://www.nlm.nih.gov/research/umls/rxnorm|32968,http://www.nlm.nih.gov/research/umls/rxnorm|687667,http://www.nlm.nih.gov/research/umls/rxnorm|153658

Mais oui...

ÉchecsBombe de sous-module Synthea Bien que plein d'espoir, notre premier essai a consisté à générer 2 millions de ressources et des milliers de bundles Synthea (en utilisant ce super InterSystems repo pour le faire) vers le point de terminaison des transactions et l'installation de téléchargement de la Gestion des données, y compris un tas de submodules centrés sur le cœur, et des commutateurs sophistiqués...

docker run --rm -v $PWD/output:/output -v $PWD/modules:/modules --name synthea-docker intersystemsdc/irisdemo-base-synthea:version-$VERSION --exporter.practitioner.fhir.export true --exporter.hospital.fhir.export true --exporter.fhir.use_us_core_ig true -p 500 -s 21 -d /modules

Cela n'a pas marché, ce qui n'est pas surprenant, mais j'espérais qu'on s'en rapprocherait au moins. Nous n'avons pas réussi.

GainsLe processus de génération des données Ainsi Geoff Low nous a mis au courant de son processus, nous l'avons repris et nous nous sommes mis au travail..... Voici comment le processus fonctionne.

1. Voici un bundle de départ, en particulier celui qui est pertinent pour la recherche et qui comporte au moins des patients et des rendez-vous. Utilisez le bundle SDTM ici sur sourceforge:

2. Maintenant, exécutez une étape de correction, pour fixer le bundle en place, assurez-vous qu'il se charge avec succès sur le serveur FHIR, téléchargez ou déposez le bundle POST.

3. Une fois que nous avons un point de départ précis, complétez les rendez-vous avec les codes de motif de rendez-vous anticipés ( I20,I21,I22,I23,I24,I25 ).

  raisons = ["I21","I22","I23","I24","I25"]```

4. Ajoutez les médicaments aux rendez-vous, en incluant tous les médicaments prévus pour le rendez-vous pour le Sondage du SCA.

        medchoices = [
            {
                "code": "1116632",
                "affichage": "ticagrelor"
            },
            {
                "code": "613391",
                "affichage": "prasurgrel"
            },
            {
                "code": "32968",
                "affichage": "clopidogrel"
            }
        ]
        medchoice = random.choice(medchoices)
        medconcept = CodeableConcept(
                    coding=[
                        Coding(
                            code=medchoice["code"],
                            display=medchoice["affichage"],
                            system="http://www.nlm.nih.gov/research/umls/rxnorm",
                        )
                    ]
                )

AVIS IMPORTANT !   Assurez-vous que les médicaments correspondent aux dates/heures du rendez-vous

5. Ensuite, assurez-vous que les rendez-vous sont effectivement des hospitalisations et qu'ils incluent tous les types applicables.

        statuts = ["en cours", "achevé"]
        dischargeCodes =
            {
                "code": "home",
                "affichage": "Maison"
            },
            {
                "code": "hosp",
                "affichage": "Hospice"
            },
            {
                "code": "exp",
                "affichage": "Expiré"
            },
            {
                "code": "long",
                "affichage": "Soins à long terme"
            },
            {
                "code": "alt-home",
                "affichage": "Maison alternative"
            },
        ]

Encore un gainImplémentation du paramètre de recherche IG Le Guide de mise en œuvre de Vulcan comprend un paramètre de recherche qui doit retourner les rendez-vous par disposition de sortie, nous avons abordé cela de deux façons :

a. Téléchargez l'ensemble de l'IG b. Téléchargez le paramètre de recherche "Search Parameter"

Le chargement du paramètre de recherche par lui-même était le chemin le plus court et nous en portions l'entière responsabilité depuis assez longtemps, voici donc comment se déroule ce processu.

On crée un dossier /tmp/mypackage, on ajoute le paramètre de recherche de l'IG, et son propre fichier de paquetage.

[irisdeploy@ip-192-168-0-37 tmp]$ tree /tmp/mypackage
/tmp/mypackage
├── package.json
└── parameter.json

Votre fichier de paquetage peut avoir une forme similaire à celle-ci :

{
  "nom":"ron.sweeney.r4",
  "version":"0.0.1",
  "dépendances": {
    "hl7.fhir.r4.core":"4.0.1"
  }
}

Ensuite, on télécharge le tout dans IRIS comme suit :

TL4:IRIS:FHIRDB>do ##class(HS.FHIRMeta.Load.NpmLoader).importPackages($lb("/tmp/mypackage"))
Saving ron.sweeney.r4@0.0.1
Load Resources: ron.sweeney.r4@0.0.1

L'étape suivante consiste à associer le bundle au point de terminaison :

Ensuite, réindexez les rendez-vous dans le référentiel :

Le paramètre de recherche/bundle devrait maintenant être téléchargé à votre point de terminaison :

Une fois le paramètre de recherche téléchargé, nous avons pu l'utiliser comme suit !

curl https://fhir.ggyxlz8lbozu.workload-prod-fhiraas.isccloud.io/Encounter?dischargeDisposition=hosp

Quoi qu'il en soit, le processus a fonctionné, et l'approche de la création de bundles par le biais de Python s'est avérée bien meilleure que celle de Synthea, notamment pour les ensembles de données précis.

L'ensemble de données que nous avons obtenu dimanche se trouve ici.

Je voulais juste partager cette expérience et remercier les équipes des projets pour avoir rendu cette expérience, que je pensais être un cauchemar, amusante et éducative !

Salut la Communauté!

Regardez cette vidéo pour savoir comment vous pouvez projeter des données FHIR vers SQL pour faciliter l’exploitation des données et le reporting :

Ces dernières années, l'émergence de la norme FHIR (Fast Healthcare Interoperability Resources) a suscité un enthousiasme croissant parmi les experts en informatique médicale du monde entier. Cette tendance n'est pas juste une autre itération des normes et de la technologie. Elle a le potentiel de transformer et révolutionner l'ensemble du secteur. Il est donc nécessaire de la rendre accessible au plus grand nombre, pour qu’elle ne se cantonne pas au domaine technique, mais soit adoptée par les décideurs et leaders d'opinion. Si SantExpo 2022 a déjà dévoilé de grands progrès à cet égard, nous devons aller encore plus loin.

Salut les Développeurs!

Grâce à cette vidéo, vous découvrirez le service InterSystems IRIS FHIR Accelerator, la solution de données FHIR entièrement gérée qui permet aux développeurs d'applications FHIR de se concentrer sur la création d'applications de soins de santé qui changent la vie.

Swift-FHIR-Iris

Application iOS pour exporter les données HealthKit vers InterSystems IRIS for Health (ou n'importe quel référentiel FHIR)

Table des matières

• Objectif de cette démo
• Comment lancer cette démo
  • Préalables
  • Installation de Xcode
  • Ouvrir le projet SwiftUi
  • Configuration du simulateur
  • Lancement du serveur FHIR d'InterSystems
  • Jeu avec l'application iOS
• Comment ça marche
  • iOS
    • Comment vérifier l'autorisation pour les travaux sur les données de santé
    • Comment se connecter à un référentiel FHIR ?
    • Comment enregistrer un patient dans le référentiel FHIR ?
    • Comment extraire les données de HealthKit ?
    • Comment transformer les données de HealthKit en FHIR ?
  • Logiciel de gestion (FHIR)
  • Interface utilisateur
• ToDos

Objectif de cette démo

L'objectif est de créer une démonstration de bout en bout du protocole FHIR.

Ce que j'entends par de bout en bout, à partir d'une source d'information telle qu'un iPhone. Collectez vos données de santé au format Apple (HealthKit), transformez-les en FHIR, puis envoyez-les au référentiel IRIS for Health d'InterSystems.

Ces informations doivent être accessibles via une interface web.

TL;DR: iPhone -> InterSystems FHIR -> Page Web.

Comment lancer cette démo

Préalables

• Pour la partie client (iOS)
  • Xcode 12
• Pour le serveur et l'application Web
  • Docker

Installation de Xcode

Pas grand chose à dire ici, ouvrez l'AppStore, cherchez Xcode, installez.

Ouvrir le projet SwiftUi

Swift est la language de programmation d'Apple pour iOS, Mac, Apple TV et Apple Watch. Elle est le remplaçant d'objective-C.

Double-cliquez sur Swift-FHIR-Iris.xcodeproj.

Ouvrez le simulateur par un clic sur la flèche en haut à gauche.

Configuration du simulateur

Accéder à Santé

Cliquez sur Étapes

Ajouter des données

Lancement du serveur FHIR d'InterSystems

Dans le dossier racine de ce git, exécutez la commande suivante :

docker-compose up -d

À la fin du processus de construction, vous serez en mesure de vous connecter au référentiel FHIR :

http://localhost:32783/fhir/portal/patientlist.html

Ce portail a été réalisé par @diashenrique.

Avec quelques modifications pour gérer les pas d'activité d'Apple.

Jeu avec l'application iOS

L'application vous demandera d'abord d'accepter de partager certaines informations.

Cliquez sur autoriser

Vous pouvez ensuite tester le serveur FHIR en cliquant sur "Sauvegarder et tester le serveur".

Les paramètres par défaut pointent vers la configuration docker.

En cas de succès, vous pouvez entrer les informations de votre patient.

Prénom, Nom de famille, Date de naissance, Genre.

Enregistrez le patient dans Fhir. Une fenêtre pop-up vous montrera votre ID Fhir unique.

Consultez ce patient sur le portail :

Accédez à: http://localhost:32783/fhir/portal/patientlist.html

Nous pouvons voir ici, qu'il y a un nouveau patient "toto" avec 0 activités.

Envoyez ses activités :

Retournez dans l'application iOS et cliquez sur Compteur de pas.

Ce panneau résume le nombre de pas de la semaine. Dans notre cas, il s'agit de 2 entrées.

Maintenant vous pouvez les envoyer à InterSystems IRIS FHIR par un clic sur envoi.

Consultez les nouvelles activités sur le portail :

Nous pouvons voir maintenant que Toto a deux nouvelles observations et activités.

Vous pouvez éventuellement cliquer sur le bouton de graphique pour l'afficher comme un graphique.

Comment ça marche

iOS

La plupart de cette démo est construite sur SwiftUI.

https://developer.apple.com/xcode/swiftui/

Qui est le dernier framework pour iOS et co.

Comment vérifier l'autorisation pour les travaux sur les données de santé

Il se trouve dans la classe SwiftFhirIrisManager.

Cette classe est un élément singleton et elle sera transportée tout autour de l'application avec l'annotation @EnvironmentObject.

Plus d'informations ici : https://www.hackingwithswift.com/quick-start/swiftui/how-to-use-environmentobject-to-share-data-between-views

La méthode requestAuthorization :

    // Demander l'autorisation pour accéder à HealthKit.
    func requestAuthorization() {
        // Demande d'accès.
        /// - Tag: RequestAuthorization

        let writeDataTypes: Set<HKSampleType> = dataTypesToWrite()
        let readDataTypes: Set<HKObjectType> = dataTypesToRead()

        // demande d'accès
        healthStore.requestAuthorization(toShare: writeDataTypes, read: readDataTypes) { (succès, erreur) dans
            if !success {
                // Traitez l'erreur ici.
            } else {

                DispatchQueue.main.async {
                    self.authorizedHK = true
                }

            }
        }
    }

Où healthStore est l'objet de HKHealthStore().

Le HKHealthStore est comme la base de données de santé dans iOS.

dataTypesToWrite et dataTypesToRead sont les objets que nous souhaitons interroger dans la base de données.

L'autorisation doit avoir un but et cela est fait dans le fichier xml Info.plist en ajoutant :

    <key>NSHealthClinicalHealthRecordsShareUsageDescription</key>
    <string>Lisez les données pour IrisExporter</string>
    <key>NSHealthShareUsageDescription</key>
    <string>Envoyez les données à IRIS</string>
    <key>NSHealthUpdateUsageDescription</key>
    <string>Date d'inscription pour IrisExporter</string>

Comment se connecter à un référentiel FHIR ?

Pour cette partie, j'ai utilisé le paquet FHIR de Smart-On-FHIR : https://github.com/smart-on-fhir/Swift-FHIR.

La classe utilisée est le FHIROpenServer.

    private func test() {

        progress = true

        let url = URL(string: self.url)

        swiftIrisManager.fhirServer = FHIROpenServer(baseURL : url! , auth: nil)

        swiftIrisManager.fhirServer.getCapabilityStatement() { FHIRError in

            progress = false
            showingPopup = true

            if FHIRError == nil {
                showingSuccess = true
                textSuccess = "Connecté au référentiel fhir"
            } else {
                textError = FHIRError?.description ?? "Erreur inconnue"
                showingSuccess = false
            }

            return
        }

    }

Cela permet de créer un nouvel objet fhirServer dans le singleton swiftIrisManager.

Ensuite, nous utilisons la fonction getCapabilityStatement().

Si nous pouvons récupérer le capabilityStatement du serveur FHIR, cela signifie que nous nous sommes connectés avec succès au référentiel FHIR.

Ce référentiel n'est pas en HTTPS, par défaut apple interdit ce type de communication.

Pour permettre le support HTTP, le fichier xml Info.plist est édité comme suit :

    <key>NSAppTransportSecurity</key>
    <dict>
        <key>NSExceptionDomains</key>
        <dict>
            <key>localhost</key>
            <dict>
                <key>NSIncludesSubdomains</key>
                <true/>
                <key>NSExceptionAllowsInsecureHTTPLoads</key>
                <true/>
            </dict>
        </dict>
    </dict>

Comment enregistrer un patient dans le référentiel FHIR ?

Opération de base en vérifiant d'abord si le patient existe déjà dans le référentiel.

Patient.search(["family": "\(self.lastName)"]).perform(fhirServer)

Cela permet de rechercher les patients ayant le même nom de famille.

Ici, nous pouvons imaginer d'autres scénarios comme avec Oauth2 et un jeton JWT pour joindre le patient et son jeton. Mais pour cette démo, nous gardons les choses simples.

Ensuite, si le patient existe, nous le récupérons, sinon nous le créons :

    func createPatient(callback: @escaping (Patient?, Error?) -> Void) {
        // Créer une nouvelle ressource pour le patient
        let patient = Patient.createPatient(prénom: firstName, nom: lastName, date de naissance: birthDay, sex: gender)

        patient?.create(fhirServer, callback: { (erreur) dans
            callback(patient, erreur)
        })
    }

Comment extraire les données de HealthKit ?

Cela se fait en interrogeant le magasin Healthkit (HKHealthStore()).

Ici, nous faisons une requête pour les pas.

Préparez la requête avec le prédicat.

        //La semaine dernière
        let startDate = swiftFhirIrisManager.startDate
        //Now
        let endDate = swiftFhirIrisManager.endDate

        print("Collecte des séances d'entraînement entre \(startDate) et \(endDate)")

        let predicate = HKQuery.predicateForSamples(withStart: startDate, end: endDate, options: HKQueryOptions.strictEndDate)

Puis la requête elle-même avec son type de données (HKQuantityType.quantityType(forIdentifier : .stepCount)) et le prédicat.

func queryStepCount(){

        //La semaine dernière
        let startDate = swiftFhirIrisManager.startDate
        //Maintenant
        let endDate = swiftFhirIrisManager.endDate

        print("Collecte des séances d'entraînement entre \(startDate) et \(endDate)")

        let predicate = HKQuery.predicateForSamples(withStart: startDate, end: endDate, options: HKQueryOptions.strictEndDate)

        let query = HKSampleQuery(sampleType: HKQuantityType.quantityType(forIdentifier: .stepCount)!, predicate: predicate, limit: HKObjectQueryNoLimit, sortDescriptors: nil) { (requête, résultats, erreur) dans

            guard let results = results as? [HKQuantitySample] else {
                   return
            }

            process(results, type: .stepCount)

        }

        healthStore.execute(query)

    }

Comment transformer les données de HealthKit en FHIR ?

Pour cette partie, nous utilisons le paquet Microsoft HealthKitToFHIR

https://github.com/microsoft/healthkit-to-fhir

Il s'agit d'un paquet utile qui offre des facteurs pour transformer HKQuantitySample en FHIR Observation

     let observation = try! ObservationFactory().observation(from: item)
      let patientReference = try! Reference(json: ["référence" : "Patient/\(patientId)"])
      observation.category = try! [CodeableConcept(json: [
          "coding": [
            [
              "system": "http://terminology.hl7.org/CodeSystem/observation-category",
              "code": "activité",
              "display": "Activité"
            ]
          ]
      ])]
      observation.subject = patientReference
      observation.status = .final
      print(observation)
      observation.create(self.fhirServer,callback: { (erreur) dans
          if error != nil {
              completion(error)
          }
      })

Où élément est un HKQuantitySample, dans notre cas un type stepCount.

Le facteur fait le gros du travail en convertissant 'élément' et 'type' en FHIR codeableConcept et 'valeur' en FHIR valueQuantity.

La référence au patientId est faite manuellement en intégrant une référence json fhir.

let patientReference = try! Reference(json: ["référence" : "Patient/\(patientId)"])

On fait de même pour la catégorie :

      observation.category = try! [CodeableConcept(json: [
          "codage": [
            [
              "systèmem": "http://terminology.hl7.org/CodeSystem/observation-category",
              "code": "activité",
              "affichage": "Activité"
            ]
          ]
      ])]

Enfin, l'observation est créée dans le référentiel fhir :

      observation.create(self.fhirServer,callback: { (erreur) in
          if error != nil {
              completion(error)
          }
      })

Logiciel de gestion (FHIR)

Pas grand chose à dire, il est basé sur le modèle fhir de la communauté InterSystems :

https://openexchange.intersystems.com/package/iris-fhir-template

Interface utilisateur

Il est basé sur les travaux de Henrique et est un joli interface utilisateur pour les dépôts FHIR fait en jquery.

https://openexchange.intersystems.com/package/iris-fhir-portal

Salut la Communauté!

Dans cette vidéo, vous apprendrez comment FHIR peut devenir la pierre angulaire de votre application santée.

Bonjour, chers développeurs !

Dans cet article, nous allons nous concentrer sur OAuth2, un protocole qui est de plus en plus utilisé en combinaison avec FHIR pour effectuer des autorisations.

Dans cette partie 1, nous allons démarrer le conteneur Docker pour IRIS for Health et Apache, configurer la fonction de serveur d'autorisation OAuth2 sur IRIS for Health, y accéder depuis l'outil de développement REST Postman, et obtenir un jeton d'accès. En outre, dans la deuxième partie et au-delà, nous ajouterons la fonctionnalité de référentiel FHIR à IRIS for Health, nous ajouterons la configuration du serveur de ressources OAuth2 et nous expliquerons comment exécuter des requêtes FHIR avec des jetons d'accès depuis Postman.

Plusieurs excellents articles ont déjà été publiés au sein de la communauté des développeurs pour expliquer la fonctionnalité OAuth2 des produits d'InterSystems ; cependant, je voudrais expliquer à nouveau comment configurer la dernière version. Mise en œuvre d'InterSystems IRIS Open Authorization Framework (OAuth 2.0) - partie 1

Dans cet article, nous utiliserons la dernière version d'InterSystems IRIS for Health 2020.3 Preview Edition. Si vous envisagez de créer un environnement basé sur cet article, veillez à utiliser cette version ou une version ultérieure du kit. Certaines fonctionnalités ne sont pas incluses dans les produits antérieurs à cette version.

Préparatifs préliminaires

La première étape consiste à effectuer des préparatifs préliminaires. Il y a beaucoup de choses à préparer pour construire un environnement sécurisé.

IRIS for Health 2020.3 Preview Edition est uniquement disponible en version conteneur Docker. (InterSystems Docker Hub/IRIS for Health)
Pour effectuer la configuration d'OAuth2, vous devrez également effectuer la configuration du serveur web et de SSL. Dans cet article, nous utiliserons Apache. Lors de la configuration SSL sur Apache, le certificat de configuration SSL doit correspondre au nom d'hôte du serveur. Veuillez tenir compte de ce point.

Obtenir des fichiers d'exemple à partir du dépôt GitHub d'intersystems-jp

Le fichier docker-compose.yml/Dockerfile et d'autres exemples de fichiers utilisés dans cette configuration sont disponibles dans le dépôt GitHub réservé à la communauté des développeurs InterSystems. Tout d'abord, décompressez ce fichier dans votre environnement à l'aide de la commande suivante. (Vous pouvez également le faire à partir de la pièce jointe à cet article). Ce fichier docker-compose.yml/Dockerfile et d'autres fichiers sont créés en se référant à l' application iris-webgateway-example published on OpenExchange.

git clone https://github.com/Intersystems-jp/IRIS4H-OAuth2-handson.git

Modification de la configuration en fonction du kit utilisé

Dans ce fichier docker-compose.yml, deux conteneurs sont configurés pour être démarrés : le conteneur IRIS for Health et le conteneur Apache (httpd) seront créés par la commande docker build. Le fichier docker-compose.yml, disponible sur GitHub, fait référence à IRIS for Health Community Edition Preview Edition (2020.3.200.0). L'édition communautaire peut être utilisée pour l'évaluation des produits InterSystems.

iris:
    image: store/intersystems/irishealth-community:2020.3.0.200.0

Si vous utilisez une version différente (version officielle ou version plus récente), veuillez modifier cette partie de la spécification.

Le conteneur Apache sera construit avec le contenu du Dockerfile, qui nécessite un kit WebGateway pour se connecter à IRIS depuis Apache. Pour savoir comment obtenir ce kit, les partenaires d'InterSystems peuvent consulter le site de téléchargement du kit WRC ou contacter le centre de support WRC. Pour toute autre question, veuillez nous contacter à cet adresse.

Modifiez les parties suivantes du Dockerfile en fonction du produit que vous avez obtenu. Quel que soit le système d'exploitation de la machine hôte (Windows/Ubuntu/CentOS), la plate-forme sera lnxubuntux64 car le système d'exploitation du conteneur httpd de base est Debian.

ARG version=2020.3.0.200.0
ARG platform=lnxubuntux64
ADD WebGateway-${version}-${platform}.tar.gz /tmp/

Préparation d'un certificat SSL

À l'étape suivante, un certificat SSL est préparé. Lorsque l'on accède à l'autorisation OAuth2, le certificat SSL défini dans le serveur Web est vérifié pour voir s'il correspond à l'URL à laquelle on accède. Il n'est pas nécessaire d'utiliser un certificat officiel ; il est possible d'utiliser OpenSSL, etc. Saisissez le nom d'hôte dans le champ "Nom commun" lors de la création du certificat.

De plus, comme le certificat que vous avez créé sera chargé automatiquement au moment du lancement, vous devez modifier le fichier pour qu'il ne nécessite pas de mot de passe. Veuillez vous référer à la commande suivante.

$ openssl rsa -in cert.key.org -out cert.key

Placez les fichiers CRT et KEY créés dans le même répertoire que le Dockerfile, avec les noms de fichiers server.crt / server.key respectivement.

En plus de l'utiliser avec le serveur web Apache, vous aurez besoin d'un certificat SSL pour la configuration d'OAuth2. Il n'est pas nécessaire d'entrer un nom d'hôte, etc., mais vous devez créer trois ensembles. (Dans les configurations suivantes, ils apparaissent sous la forme auth.cer/auth.key , client.cer/client.key , resserver.cer/resserver.key)

Construction de docker et démarrage d'un conteneur docker

Maintenant, vous êtes enfin prêt ! En plus des quatre fichiers que vous avez téléchargés, vous avez maintenant un ensemble d'installation de la passerelle Web et deux certificats SSL dans votre répertoire. Faites attention aux autorisations d'accès et d'exécution de chaque fichier. (Par exemple, j'ai ajouté la permission d'exécution à webgateway-entrypoint.sh).

docker-compose build
docker-compose up -d

Une fois lancé, utilisez la commande docker ps pour vérifier que les deux conteneurs fonctionnent.

Nom du conteneur Apache：<directoryname>_web
Nom du conteneur IRIS for Health：store/intersystems/irishealth-community:2020.3.0.200.0（ou autre nom en fonction de l'ensemble)

Essayez maintenant d'accéder au portail de gestion selon les trois méthodes suivantes. Si la troisième méthode fonctionne, votre configuration SSL via le serveur web Apache est un succès !

http://[hostname]:52773/csp/sys/UtilHome.csp　：L'accès à cette URL se fait par le biais de Private Apache dans le conteneur IRIS. Elle ne passe pas par l'Apache configuré.

http://[hostname]/csp/sys/UtilHome.csp　： Cette URL permet d'accéder au portail de gestion via l'Apache configuré.

https://[hostname]/csp/sys/UtilHome.csp　： Cette URL permet d'accéder au portail de gestion en utilisant une connexion SSL via Apache, que vous avez configurée.

Création d'une configuration SSL

Maintenant que IRIS for Health est opérationnel et que nous avons accès au portail de gestion, créons la configuration SSL pour les derniers préparatifs.

Allez sur le Portail de gestion -> Administration du système -> Sécurité -> Configuration SSL/TLS et créez trois configurations SSL en utilisant les trois paires de clés de certificat que vous avez préparées.

Vous pouvez choisir le nom que vous voulez, mais dans cet article, nous utiliserons SSL4AUTH/SSL4CLIENT/SSL4RESSERVER, conformément aux articles précédents sur OAuth2.

*À propos du partage de répertoire entre les hôtes et les conteneurs

La spécification des volumes suivants dans le fichier docker-compose indique l'emplacement actuel du répertoire hôte = /ISC dans le conteneur. Veuillez utiliser ce répertoire lorsque vous spécifiez le fichier de certificat dans les paramètres ci-dessus, etc.

    volumes:
      - .:/ISC

Ce répertoire contiendra non seulement des fichiers mais aussi des fichiers de base de données IRIS et des fichiers de configuration. Consultez le document “Persistant %SYS pour le stockage des données d'instance persistantes” pour plus d'information.

Configuration de OAuth2 dans IRIS for Health

Il est maintenant temps d'entrer dans les détails de l'accès à IRIS for Health en utilisant OAuth2 !

Configuration du serveur d'autorisation OAuth2

Tout d'abord, configurons le serveur d'autorisation OAuth2 ! Allez dans Portail de gestion → Administration du système → Sécurité → OAuth 2.0 → Serveur.

Suivez les instructions ci-dessous pour configurer les paramètres.

Dans l'onglet "Scopes", cliquez sur " Ajouter un Scope supporté " pour les ajouter. Plus tard, l'écran de connexion du code d'autorisation affichera la "description" que vous avez écrite ici.

Ne modifiez pas l'onglet "Intervalles" par rapport à la valeur par défaut. Dans l'onglet " Paramètres JWT ", sélectionnons " RS512 " comme algorithme de signature.

Dans le denier onglet "Personnalisation", changez la spécification "Génération de classe de jeton" en %OAuth2.Server.JWT.

Une fois que vous avez saisi les informations, cliquez sur le bouton "Enregistrer" pour sauvegarder la configuration.

Maintenant que vous avez la configuration nécessaire pour qu'IRIS for Health fonctionne comme un serveur d'autorisation OAuth2, vous êtes prêt à l'essayer ! Essayons d'y accéder à partir de Postman et voyons si nous pouvons obtenir un jeton d'accès !

Cependant, avant de faire cela, nous devons effectuer deux autres configurations.

Ajout d'une description du client

Tout d'abord, ajoutez les informations de Postman auxquelles vous souhaitez accéder en tant que client OAuth2. L'enregistrement du client OAuth2 peut être ajouté par le biais d'un enregistrement dynamique ou d'autres méthodes.

Cliquez sur "Description du client" sur la page de configuration du serveur pour continuer.

Cliquez sur "Créer une description du client" pour ajouter une entrée.

Suivez les instructions ci-dessous pour créer une souscription du client.

Une fois que vous avez saisi les informations, cliquez sur le bouton "Enregistrer" pour sauvegarder la description du client.

Cliquez sur l'onglet " Références du client " pour voir l'ID du client et la clé privée du client pour cette entrée. Vous aurez besoin de cet ID et de cette clé privée lorsque vous effectuerez des tests à partir de POSTMAN.

Ajout d'une application Web

Un autre paramètre important doit être ajouté avant d'y accéder à partir de POSTMAN. L'écran de configuration du serveur d'autorisation OAuth2 a déterminé que le point de terminaison pour cette configuration est https://<hostname>/authserver/oauth2. Pour que l'accès à ce point de terminaison soit traité correctement par IRIS, nous devons ajouter une application Web pour cette route URL.

Allez dans Administration système→Sécurité→Applications→Applications Web, et cliquez sur "Créer une nouvelle application Web".

Un modèle d'application web OAuth2 est fourni, il faut donc d'abord sélectionner "/oauth2" dans " Copier à partir de ".

Après avoir saisi chaque valeur, enregistrez-la.

Test d'OAuth2 à partir de POSTMAN

Testons-le à partir de POSTMAN. Les tests peuvent également être effectués à partir d'autres outils ou du programme lui-même. L'explication détaillée de POSTMAN dépasse le cadre de cet article, mais un point à noter est que la vérification du certificat SSL doit être changée en OFF dans les paramètres de POSTMAN.

Après avoir créé une nouvelle demande dans POSTMAN, sélectionnez "OAuth 2.0" dans l'onglet TYPE d'autorisation et cliquez sur "Obtenir un nouveau jeton d'accès".

Dans l'écran suivant, saisissez les valeurs selon les indications suivantes.

Après avoir entré les paramètres et cliqué sur le bouton " Demande de jeton ", vous voyez l'écran de connexion comme indiqué ci-dessous.

Essayez de vous connecter avec les informations de l'utilisateur (par exemple, _SYSTEM) ayant accès au portail de gestion.

Sur l'écran suivant après la connexion, vous pouvez décider d'accorder des permissions à cette application. Après avoir cliqué sur " Autoriser ", si le jeton d'accès s'affiche sur l'écran suivant, comme indiqué ci-dessous, le test d'acquisition du jeton d'accès est réussi !

Test d'OpenID Connect

IRIS for Health peut effectuer un traitement d'autorisation OAuth2 ainsi qu'un traitement d'authentification conforme à OpenID Connect. Pour plus de détails consultez ce document.

Dans cette configuration, OpenID Connect est activé, alors testons si nous pouvons également obtenir le jeton d'identification OpenID Connect !

C'est facile à mettre en œuvre. Dans l'écran GET NEW ACCESS TOKEN, ajoutez "openid" à son champ d'application et faites une demande.

OpenID Connect sera également affiché sur la page de demande d'autorisation. Après avoir ouvert une session et donné vos autorisations, assurez-vous que vous obtenez également un jeton d'identification (id_token) lorsque vous voyez l'écran suivant. (Vous devrez peut-être faire défiler l'écran).

Avez-vous réussi à obtenir le jeton d'accès et l'id_token ?

Bien que certains préparatifs, tels que les certificats, nécessitent un peu de temps et d'efforts, nous pourrions construire un serveur d'autorisation OAuth2 avec une telle simplicité en utilisant IRIS for Health, une plateforme de base de données.

Dans la prochaine partie de cette série, je vous montrerai enfin comment construire un référentiel FHIR, enregistrer le référentiel FHIR en tant que serveur de ressources OAuth2 et vous montrer comment accéder par REST au référentiel FHIR en utilisant un jeton d'accès OAuth2 depuis POSTMAN.

Salut les Développeurs!

Dans cette vidéo, vous découvrirez InterSystems FHIR Server, la solution de données FHIR clé en main qui permet aux développeurs d'applications FHIR de se concentrer sur la création d'applications de soins de santé qui changent la vie.

Bonjour, chers développeurs !

Dans cet article, je vais vous montrer comment configurer le référentiel FHIR + le serveur d'autorisation OAuth2/serveur de ressources sur IRIS for Health en suivant l'article précédent.

Dans la partie 1, nous vous présentons les préparatifs préliminaires, la configuration du serveur d'autorisation OAuth2 et l'obtention du jeton d'accès.
La partie 2 vous explique comment construire un référentiel FHIR et configurer un client/serveur de ressources OAuth2.

La configuration du référentiel FHIR et le serveur client/ressource OAuth2 que nous allons configurer aujourd'hui peuvent être utilisés séparément de l'instance IRIS du serveur d'autorisation OAuth2 que nous avons configuré dans la partie 1 précédente, ou ils peuvent être co-localisés dans la même instance. Dans cet article, nous allons le configurer dans la même instance que le précédent.

Construction du référentiel FHIR et spécification du nom du client OAuth

La construction d'un référentiel FHIR est décrite dans le document “Installer et configurer un serveur FHIR”.

Dans l'écran suivant, après l'avoir construit, cliquez sur l'URL du point de terminaison /csp/healthshare/fhirserver/fhir/r4 pour ouvrir l'écran de configuration.

Sur l'écran de configuration, saisissez le nom de configuration client OAuth2 que vous allez créer dans le champ Nom du client OAuth. Si vous avez déjà configuré un client OAuth2, veuillez faire correspondre son nom.

Dans cet exemple, nous allons utiliser la chaîne "FHIRResource". Pour la modifier, cliquez sur le bouton "Modifier" dans l'écran ci-dessus, puis sur le bouton "Mettre à jour" pour enregistrer les modifications.

Configuration client OAuth2

Dans ce qui suit, nous allons créer la configuration client OAuth2.

Accédez à Administration du système → Sécurité → OAuth2.0 dans le portail de gestion et sélectionnez "Client " au lieu de "Serveur ", contrairement à la partie précédente 1.

Sur l'écran suivant, cliquez sur "Creation de la Description du Serveur" pour créer la configuration de la connexion au serveur d'autorisation OAuth2.

Pour le point de terminaison de l'émetteur, la page Description du serveur indique le point de terminaison du serveur d'autorisation configuré dans la partie 1.

Voici l'écran de configuration du serveur d'autorisation OAuth2 configuré dans la partie 1.

Pour la configuration SSL/TLS, entrez la configuration SSL/TLS "SSL4CLIENT" que vous avez créée lors de la préparation de la Partie 1.

Après avoir saisi les éléments, exécutez " Découvrir et sauvegarder " pour obtenir les informations du serveur d'autorisation OAuth2 !

Si l'accès est réussi, les informations obtenues s'afficheront, comme indiqué ci-dessous. Veuillez noter qu'une erreur peut se produire au cours de ce processus si le certificat SSL spécifiant le nom d'hôte que vous avez préparé précédemment dans la préparation de la partie 1 n'est pas créé correctement et reconnu.

Attention: Même si vous utilisez le fichier docker-container DL dans la partie 1 de cette série, vous pouvez avoir des difficultés à accéder au conteneur IRIS -> conteneur Apache en spécifiant le nom d'hôte. Dans ce cas, vous pouvez résoudre le problème en entrant le nom d'hôte et l'adresse IP de votre machine dans le fichier docker-compose.yml en tant que extra_hosts, comme indiqué ci-dessous.

  extra_hosts:
    - <yourhostname>:<your ip address>

Une fois que vous avez enregistré la configuration, cliquez sur " Sauvegarder " pour revenir à la page suivante, puis sélectionnez " Configuration client " pour créer la configuration du référentiel FHIR.

Ajout d'une configuration client au client OAuth2

C'est un titre compliqué, mais l'étape suivante consiste à ajouter la configuration client (informations sur le référentiel FHIR spécifique, l'application CSP, etc. que vous souhaitez connecter au serveur d'autorisation OAuth2 en tant que client OAuth2) à la configuration client OAuth2 que vous venez de créer ( avec des informations sur le serveur d'autorisation OAuth2 auquel se connecter).

Sur l'écran suivant, cliquez sur " Créer une configuration client " pour afficher l'écran suivant et régler les éléments nécessaires.

Si vous sélectionnez d'abord le type de client = Serveur de ressources, l'écran de saisie sera le même que ci-dessous.

Après avoir rempli le formulaire, cliquez sur le bouton " Enregistrement dynamique et sauvegarde " pour sauvegarder et enregistrer le fichier sur le serveur. C'est un peu confus, mais lorsque le bouton passe de " Enregistrement dynamique et sauvegarde " à " Obtenir les métadonnées de mise à jour et sauvegarder ", l'enregistrement a réussi.

Examinons les informations de configuration de l'autorisation OAuth2 côté serveur et vérifions si elle est enregistrée.

Sur la page Portail de gestion→Administration du système→Gestion de la sécurité→OAuth2.0→Serveur, cliquez sur "Description du client", et vous verrez qu'il est enregistré comme indiqué ci-dessous.

Confirmez que le nom est celui que vous avez spécifié dans le nom du client.

Dans la première partie, lorsque nous avons testé l'accès à partir de Postman, nous avons copié manuellement l'ID client et la clé privée qui s'affichent plus bas dans l'écran du descripteur client. Cependant, cette fois-ci, ces informations sont transmises au côté client pendant le processus d'enregistrement dynamique.

Accès au référentiel FHIR à partir de Postman en utilisant un jeton d'accès OAuth2

Et enfin, il est temps d'y accéder depuis Postman !

Tout d'abord, nous devons obtenir un jeton d'accès. La méthode de base est la même que celle utilisée à la fin de la partie 1, mais nous devons ajouter un paramètre audience pour indiquer où le jeton d'accès sera émis.

aud=https://[hostname]/csp/healthshare/fhirserver/fhir/r4

Pour l'ajouter spécifiquement dans Postman, ajoutez-le comme paramètre à l'URL du point de terminaison du code d'autorisation comme suit : ( A cause des limitations de l'écran de Postman, vous ne pouvez pas voir tous les paramètres, mais veuillez inclure tous les éléments ci-dessus aud=https://[hostname]/csp/healthshare/fhirserver/fhir/r4 )

Attention : Vous n'avez pas besoin de changer l'ID client et le Secret client que vous entrez dans Postman pour ceux émis dans l'enregistrement dynamique du serveur de ressources plus tôt. Utilisez l'ID et la clé secrète du client émis pour Postman que vous avez ajouté dans la partie 1.

Après avoir obtenu le jeton d'accès, veuillez copier son contenu.

Dans Postman, si vous laissez le TYPE d'autorisation comme OAuth2, vous disposez d'une fonction pour envoyer le jeton d'accès. Toutefois, dans le référentiel FHIR d'IRIS for Health, il est également nécessaire d'envoyer les informations relatives à l'utilisateur et au mot de passe de l'autorisation de base.

À cette fin, lors d'un accès à partir de Postman, le TYPE d'Autorisation (qui est un peu difficile) doit être Basic Auth, le nom d'utilisateur et le mot de passe doivent être saisis, et le jeton d'accès doit être envoyé comme paramètre dans la demande REST au référentiel FHIR.

En détail : tout d'abord, saisissez le nom d'utilisateur et le mot de passe comme indiqué dans l'écran suivant. Ces informations d'utilisateur seront vérifiées pour voir si elles correspondent aux informations d'utilisateur dans le sous jeton d'accès ; il doit donc s'agir du même utilisateur que celui que vous avez saisi lorsque vous avez obtenu le jeton d'accès.

Dans l'onglet Params, pour access_token, entrez la valeur du jeton d'accès que vous venez de saisir pour le paramètre.

Si vous venez de construire le référentiel FHIR, il n'y a pas de données dans le référentiel, mais vous pouvez demander les données du patient !

Pour l'URL de la demande, entrez https://[hostname]/csp/healthshare/fhirserver/fhir/r4/Patient, et sélectionnez GET comme méthode HTTP (comme indiqué dans la figure ci-dessus).

Appuyez sur le bouton "Envoyer" pour soumettre la demande ! Si vous obtenez le Paquet FHIR comme indiqué ci-dessous, vous avez réussi à accéder au référentiel FHIR en utilisant le jeton d'accès !

Pour plus d'informations sur la manière d'enregistrer et de rechercher des données dans le référentiel FHIR, veuillez consulter la documentation et les articles de la communauté IRIS for Health.

Documentation d'IRIS pour la santé 2020.3 Dépôt de ressources

Comment avez-vous réussi à accéder au référentiel FHIR ?

La configuration décrite dans cette série est la plus simple. Dans un projet FHIR réel, le contenu des données à renvoyer dépendra du contenu approuvé par l'utilisateur, ce qui devra être pris en compte et mis en œuvre.

Nous continuerons à tenir la communauté des développeurs informée de FHIR.

L'interopérabilité des soins de santé permet d'améliorer les soins aux patients, de réduire les coûts des prestataires de soins et de fournir une image plus précise aux prestataires. Cependant, avec un si grand nombre de systèmes différents, les données sont formatées de nombreuses manières différentes. De nombreuses normes ont été créées pour tenter de résoudre ce problème, notamment HL7v2, HL7v3 et CDA, mais toutes présentent des inconvénients.

FHIR (Fast Healthcare Interoperability Resources), ou Ressources rapides d'interopérabilité des soins de santé, est un nouveau format pour les échanges des informations médicales qui vise à résoudre ces problèmes. Il est développé par Health Level Seven International (HL7), une organisation qui a également développé HL7v2, HL7v3 et CDA.

Aujourd'hui nous allons explorer comment créer et valider une ressource FHIR en utilisant le schéma FHIR à l'aide d'IntelliSense et de la fonctionnalité de complétion automatique dans VS Code.

Etape 1 : Téléchargement du fichier de schéma JSON pour la validation des ressources sur le site officiel de FHIR https://www.hl7.org/fhir/.

Étape 2: Création d'un dossier (dans cet exemple, j'utilise le dossier Patient et la ressource Patient) et copiage du fichier fhir.schema.json extrait dans le même dossier, puis ouverture du dossier à partir du code VS. 

 

Étape 3: Configurez le code VS pour reconnaître le schéma FHIR en modifiant le fichier setting.json.
Appuyez sur CTRL+SHIFT+P et tapez les paramètres de l'espace de travail JSON
 

Étape 4: Création d'un nouveau fichier patient.fhir.json dans le même dossier.
Appuyez sur Ctrl+Espace et vous obtiendrez tous les attributs des ressources FHIR à travers IntelliSense

#

Ajoutez le type de ressource Patient et tous les attributs liés à la ressource Patient vont apparaître dans l'IntelliSense.

VS Code validera automatiquement la structure et la syntaxe de la ressource.

Avec l'aide d'IntelliSense et de la fonction de complétion automatique, nous avons créé et validé notre ressource patient.

Step 5: Affichez la ressource créée dans le serveur FHIR d'InterSystems en utilisant l'API Rest à partir de postman

Récupérer la ressource patient créée en utilisant la méthode "Get"

Félicitations, nous avons créé, validé notre ressource patient et réussi à l'envoyer et la récupérer sur le serveur FHIR d'InterSystems en utilisant postman.
De cette façon, nous pouvons facilement créer et valider n'importe quelle ressource FHIR.

Est-ce que vous souhaitez inclure une implémentation FHIR® de qualité commerciale dans votre écosystème de micro-services et vous avez à peine le temps de remplir les formulaires de sélection de votre régime d'assurance maladie ?

Voici un moyen rapide d'inviter le service InterSystems® FHIR®Accelerator à votre groupe de microservices Kubernetes pour une utilisation immédiate. La solution fait appel à des mouvements de proxy ninja de Nginx pour faire le travail. Bien qu'il s'agisse d'une solution rustique qui ne manquera pas de susciter des débats techniques, je suis plutôt satisfait des résultats obtenus, et ce jusqu'à ce que la communauté me dise le contraire, alors, comme on dit, " FHIR® ", mais ce serait formidable si vous m'écoutiez d'abord.

Clause de non-responsabilité

Vous verrez des secrets dans les manifestes, l'utilisation des port de nœuds nodePort et un nœud maître corrompu pour faire passer le message, la discrétion parentale est conseillée.

Préalables

Vous aurez besoin de quelques éléments si vous souhaitez le déployer vous-même. Il s'agit principalement d'un point de départ ou d'une approche pour ceux qui souhaitent intégrer rapidement la fonctionnalité FHIR® à des fins de développement.

🔥 Environnement

Pour cette démonstration, nous sommes parqués directement sur un nœud maître de Kubernetes corrompu pour mettre en œuvre le travail.

FHIR up le service FHIR® Accelerator

• [X ] Créez un compte dans l'InterSystems® Cloud
• [ X] Créez un déploiement de service InterSystems FHIR® Accelerator

• Créez une clé Api

🖇 Enregistrez le point de terminaison et la clé API

C'est tout ce que nous avons besoin de l'accélérateur FHIR®, nous interagirons avec le service à notre manière à l'intérieur du cluster Kubernetes.

Clonage de ce Repo

Pour le "reste du README", placez-vous sur un nœud maître Kubernetes corrompu.

git clone https://gitlab.com/isc_cloud/fhiraas-microservice-kubernetes.git
cd fhir-microservice-kubernetes

Déploiement vers le cluster Kubernetes

• [X ] Créez un espace de nom Namespace, afin de disposer d'un rayon d'explosion dans lequel jouer pour l'instant.
• Creez une ConfigMap, il s'agit en fait de la folie du reverse proxy implémentée dans le nginx.conf.

✏ IL FAUT MODIFIER QUELQUE CHOSE ICI

Rappelez-vous la clé et le point de terminaison que nous avons générés à partir du service FHIR Accelerator ? Il faut les mettre à jour ici, dans le déploiement

• [ X] Créez un déploiement, voici les conteneurs eux-mêmes, avec 3 modules pour le groupe de répliques de déploiement.
• [ X] Créez un Service, Exposez-le !, c'est un simple service NodePort qui lie un port sur le nœud pour accéder au service FHIR Accelerator. Il expose 30036 sur le nœud, et transmet au module de déploiement sur 52773.

cd fhir-microservice-kubernetes # devrait déjà être ici, mais juste pour être sûr.
kubectl apply -f k8s/

Testez-le !

Faisons un test rapide pour vérifier si FHIR est bien servi à travers le NodePort.

[✔] Port du noeud Socket en écoute ? [✔] Écouter le port du noeud Socket ? [✔] Consultation des patients ?
[✔] Obtenez le patient ?

Mettre à l'échelle !

Nous sommes sur un seul nœud et exposons le service à un port de nœud, donc nous ne sommes pas sûrs que cela augmentera notre débit, mais allons-y quand même.

kubectl scale deployments/isc-fhiraas-deployment --replicas=30 -n isc-fhiraas

Mettons-y un peu de FHIR !

Ce dépôt contient un script shell hostile et rustique qui permet de placer des patients aléatoires dans la ressource Patient, avec quelques cloches et sans sifflets. J'ai besoin de quelques variables d'environnement ou vous pouvez simplement éditer les variables directement dans le script. Lors de l'exécution de ce script, assurez-vous du bon fonctionnement du ventilateur du processeur et déplacez les objets de la zone de l'ordinateur portable pour éviter le déplacement des objets dans le cas où votre ordinateur portable s'envole.

bash bin/fhirbench.sh

🏆 Résultats

50 placements, et 50 recherches en 13 secondes.

Personne responsable

Ce matériel se trouve dans le référentiel, Ron Sweeney (ron.sweeney@integrationrequired.com) de [Intégration requise] (https://www.integrationrequired.com). Ce sont les opinions de mon employeur.

Bonjour, chers développeurs !

Cet article est le deuxième d'une série sur la façon d'utiliser SUSHI, un outil de création de profils FHIR, en tant que technologie associée à FHIR. Six mois se sont écoulés avant cette deuxième partie.

Dans la précédente partie 1, nous avons abordé les questions suivantes : qu'est-ce que FHIR, qu'est-ce que le profil FHIR, qu'est-ce que FHIR Shorthand ? Et quel genre d'outil est SUSHI ? Que peut-il produire ? Avec des captures d'écran pour des exemples de résultats.

Cet article présente un exemple d'utilisation réelle d'un profil créé avec SUSHI, dans lequel une Extension est ajoutée à une ressource Patient à l'aide de SUSHI, et un nouveau SearchParameter est défini pour l'élément de cette Extension, jusqu'à ce que le nouveau SearchParameter puisse être utilisé dans l'IRIS for Health's FHIR Repositoy jusqu'à ce que le nouveau SearchParameter puisse être utilisé.

Mise à jour de SUSHI

Je suis désolé de m'écarter du sujet principal, mais si vous êtes comme moi et que vous n'avez pas touché à SUSHI depuis un moment, vous devriez mettre à jour SUSHI. Au cours des six derniers mois, SUSHI a fait l'objet d'une importante mise à jour, et la version 2.0.0 est sortie en août. La dernière version au moment de la rédaction de cet article était SUSHI 2.1.1.

Comme décrit dans ce lien, la mise à jour est la commande suivante de même que l'installation.

$ npm install -g fsh-sushi

Vous pouvez vérifier la version en exécutant sushi -version. De même, l'outil IG Publisher, qui crée un ensemble de fichiers HTML pour le Guide de mise en œuvre sur la base des Profils générés par SUSHI, peut être mis à jour en exécutant la commande _updatePublisher.

Création de fichiers FISH

Tout d'abord, créez un projet en utilisant la commande sushi --init comme précédemment. Dans cet article, nous allons modifier le fichier patient.fsh généré par le modèle.

Cette fois, nous ajouterons une extension de type lieu de naissance, qui est une chaîne de caractères String représentant le lieu de naissance du patient, et nous définirons également un SearchParameter pour ce lieu de naissance, afin de pouvoir effectuer une recherche par lieu de naissance du patient !

Ajout d'Extension

Tout d'abord, ajoutez la définition suivante pour ajouter Extension.

Comme dans US Core et JP Core, le type Adresse est habituellement utilisé, mais ici il s'agit simplement du type String

Extension: BirthPlace
Id: birthPlace
Title: "出身地"
Description: "生まれた場所をstring型で表現する"
* ^url = "http://isc-demo/fhir/StructureDefinition/patient-birthPlace" 
* value[x] only string 

Chaque élément correspond à la StructureDefinition d'Extension comme suit. Certains éléments sont placés à plusieurs endroits. Certaines informations, comme la version du fhir de base et la version de cette Extension elle-même, proviennent du fichier sushi-config.yml.

La StructureDefinition réelle d'Extension générée. Il est difficile de créer cela à partir de rien et à la main, mais avec SUSHI, c'est relativement facile.

{
  "resourceType": "StructureDefinition",
  "id": "birthPlace",
  "url": "http://isc-demo/fhir/StructureDefinition/patient-birthPlace",
  "version": "0.1.0",
  "name": "BirthPlace",
  "title": "出身地",
  "status": "active",
  "description": "生まれた場所をstring型で表現する",
  "fhirVersion": "4.0.1",
  "mapping": [
    {
      "identity": "rim",
      "uri": "http://hl7.org/v3",
      "name": "RIM Mapping"
    }
  ],
  "kind": "complex-type",
  "abstract": false,
  "context": [
    {
      "type": "element",
      "expression": "Element"
    }
  ],
  "type": "Extension",
  "baseDefinition": "http://hl7.org/fhir/StructureDefinition/Extension",
  "derivation": "constraint",
  "differential": {
    "element": [
      {
        "id": "Extension",
        "path": "Extension",
        "short": "出身地",
        "definition": "生まれた場所をstring型で表現する"
      },
      {
        "id": "Extension.extension",
        "path": "Extension.extension",
        "max": "0"
      },
      {
        "id": "Extension.url",
        "path": "Extension.url",
        "fixedUri": "http://isc-demo/fhir/StructureDefinition/patient-birthPlace"
      },
      {
        "id": "Extension.value[x]",
        "path": "Extension.value[x]",
        "type": [
          {
            "code": "string"
          }
        ]
      }
    ]
  }
}

Les données d'Extension aux ressources Patient ajoutées avec cette Extension ressembleront à ceci.

  "extension": [
    {
      "url": "http://isc-demo/fhir/StructureDefinition/patient-birthPlace",
      "valueString": "鹿児島"
    }
  ],

Ajout de SearchParamter

Ensuite, ajoutez un SearchParamter afin de pouvoir rechercher des ressources en utilisant l'entrée Extension que vous venez d'ajouter comme clé, mais seules les entrées (≒elements) définies dans le SearchParamter peuvent être recherchées. Ceci est un peu différent des tables SQL.

Le nom de SearchParamter est défini séparément du nom de l'élément, et certains éléments correspondent au nom de l'élément = nom de SearchParameter, comme le sexe dans la ressource Patient, alors que d'autres ne correspondent pas, comme le nom de l'élément = adresse. country -> nom de SearchParamter = Certains ne correspondent pas aux éléments structurés, comme address-country.

Naturellement, les éléments ajoutés à l'extension ne sont pas des SearchParameters par défaut (car vous ne savez pas ce qui sera inclus), mais les extensions qui osent définir l'extension et définir une politique pour les stocker sont souvent des éléments importants.

Ajoutez ce qui suit au fichier patient.fsh pour créer la définition de SearchParameter

Instance: BirthPlaceSearchParameter
InstanceOf: SearchParameter
Usage: #definition
* url = "http://isc-demo/fhir/SearchParameter/patient-birthPlace"
* version = "0.0.1"
* name = "birthPlace"
* status = #active
* description = "出身地検索のパラメータ"
* code = #birthPlace
* base = #Patient
* type = #string
* expression = "Patient.extension.where(url='http://isc-demo/fhir/StructureDefinition/patient-birthPlace').value"
* comparator = #eq

Voici la StructureDefinition générée par SearchParameter. Comme il s'agit d'une définition relativement simple, le mappage avec l'information SUSHI ci-dessus devrait être facile à comprendre.

{
  "resourceType": "SearchParameter",
  "id": "BirthPlaceSearchParameter",
  "url": "http://isc-demo/fhir/SearchParameter/patient-birthPlace",
  "version": "0.0.1",
  "name": "birthPlace",
  "status": "active",
  "description": "出身地検索のパラメータ",
  "code": "birthPlace",
  "base": [
    "Patient"
  ],
  "type": "string",
  "expression": "Patient.extension.where(url='http://isc-demo/fhir/StructureDefinition/patient-birthPlace').value",
  "comparator": [
    "eq"
  ]
}

Les principales composantes de la définition de SearchParameter sont l' expression et le comparateur. L'élément expression décrit l'expression FHIRPath pour le SearchParameter cible. Si vous êtes intéressé par FHIRPath, veuillez vous référer à [cette page officielle](. html).

Définition utilisée cette fois-ci

Patient.extension.where(url='http://isc-demo/fhir/StructureDefinition/patient-birthPlace').value"

Cette expression spécifie Patient.extension dans un ordre hiérarchique selon la structure Json de la ressource Patient, et réduit l'extension avec url=(omitted) par rapport aux multiples extensions qui peuvent exister, et spécifie la valeur de l'extension.

comparator spécifie le type d'expressions de comparaison qui peuvent être utilisées. Pour plus d'informations, voir ici.

Ajout de la définition d'Extension créée dans Patient

Il y a un autre changement important : l'ajout de l'Extension BirthPlace créée dans la ressource Patient. Modifiez la définition de profil MyProfile dans la ressource Patient générée automatiquement à l'origine comme suit : les modifications apportées au paramètre Cardinality de l'élément Name ont été commentées.

Profile: MyPatient
Parent: Patient
Description: "An example profile of the Patient resource."
//* name 1..* MS
* extension contains BirthPlace named birthPlace 0..1

L'Extension nommée "BirthPlace" qui a été ajoutée précédemment est ajoutée dans la ressource Patient avec le nom birthPlace dans le paramètre Cardinality 0..1.

Création de ressources pour des tests en plus de ce qui précède

SUSHI vous permet également de créer des Instances de ressources qui peuvent être utilisées à des fins d'illustration ou autres. Vous pouvez également les utiliser à des fins de test. Vous pouvez également y inclure l'extension que vous venez de définir.

Instance: KamiExample
InstanceOf: MyPatient
Description: "Exemples de ressources Patient "
* nom.family = "Yamada"
* extension[BirthPlace].valueString = "Kagoshima"

Vous verrez quel type de données a été produit dans le test final.

Essayons SUSHI !

Le fichier FSH est prêt ! Maintenant, utilisons la commande SUSHI pour générer chaque fichier de définition à partir du fichier fsh ! Exécutez la commande sushi et elle est réussie si deux Profils (Patient et Extension étendus) et deux Instances (SearchParameter et ressource de modèle) sont générés comme suit.

C:\Users\kaminaka\Documents\Work\FHIR\SUSHI\TestProject\MyProfileProject>sushi .
info  Running SUSHI v2.1.1 (implements FHIR Shorthand specification v1.2.0)
info  Arguments:
info    C:\Users\kaminaka\Documents\Work\FHIR\SUSHI\TestProject\MyProfileProject
info  No output path specified. Output to .
info  Using configuration file: C:\Users\kaminaka\Documents\Work\FHIR\SUSHI\TestProject\MyProfileProject\sushi-config.yaml
info  Importing FSH text...
info  Preprocessed 1 documents with 0 aliases.
info  Imported 2 definitions and 2 instances.
info  Checking local cache for hl7.fhir.r4.core#4.0.1...
info  Found hl7.fhir.r4.core#4.0.1 in local cache.
info  Loaded package hl7.fhir.r4.core#4.0.1
(node:27132) Warning: Accessing non-existent property 'INVALID_ALT_NUMBER' of module exports inside circular dependency
(Use `node --trace-warnings ...` to show where the warning was created)
(node:27132) Warning: Accessing non-existent property 'INVALID_ALT_NUMBER' of module exports inside circular dependency
info  Converting FSH to FHIR resources...
info  Converted 2 FHIR StructureDefinitions.
info  Converted 2 FHIR instances.
info  Exporting FHIR resources as JSON...
info  Exported 4 FHIR resources as JSON.
info  Assembling Implementation Guide sources...
info  Generated ImplementationGuide-myprofileproject.json
info  Assembled Implementation Guide sources; ready for IG Publisher.

╔════════════════════════ SUSHI RESULTS ══════════════════════════╗
║ ╭───────────────┬──────────────┬──────────────┬───────────────╮ ║
║ │    Profiles   │  Extensions  │   Logicals   │   Resources   │ ║
║ ├───────────────┼──────────────┼──────────────┼───────────────┤ ║
║ │       1       │      1       │      0       │       0       │ ║
║ ╰───────────────┴──────────────┴──────────────┴───────────────╯ ║
║ ╭────────────────────┬───────────────────┬────────────────────╮ ║
║ │      ValueSets     │    CodeSystems    │     Instances      │ ║
║ ├────────────────────┼───────────────────┼────────────────────┤ ║
║ │         0          │         0         │         2          │ ║
║ ╰────────────────────┴───────────────────┴────────────────────╯ ║
║                                                                 ║
╠═════════════════════════════════════════════════════════════════╣
║ FSHing for compliments? Super job!     0 Errors      0 Warnings ║
╚═════════════════════════════════════════════════════════════════╝

C:\Users\kaminaka\Documents\Work\FHIR\SUSHI\TestProject\MyProfileProject>

Les artefacts suivants ont été créés dans le dossier fsh-generated\resource.

Importation et test du profil FHIR dans IRIS for Health

Application d'IRIS for Health au référentiel FHIR

Dans l'article précédent, nous avons exécuté _updatePublisher pour générer un groupe de fichiers IG. Dans cet article, nous allons voir comment le fichier StructureDefinitino/SearchParameter peut être importé dans le référentiel FHIR d'IRIS for Health et faire l'objet d'une recherche avec le nouveau SearchParameter.

Pour plus d'informations sur l'importation des profils FHIR, etc., veuillez vous référer à l'article de la communauté des développeurs sur les profils FHIR. Vous pouvez également vous référer à cet article pour plus d'informations sur la façon de construire un référentiel FHIR.

L'importation est ciblée sur les cinq fichiers qui viennent d'être générés.

• StructureDefinition-MyPatient.json
• StructureDefinition-birthPlace.json
• SearchParameter-BirthPlaceSearchParameter.json Il y a trois fichiers. Copiez-les dans un autre dossier, et préparez également un fichier package.json pour gérer l'ensemble des informations du paquet.

package.json

{
  "name": "SUSHI Demo",
  "title": "SUSHI Demo",
  "version": "0.0.1",
  "author": {
    "name": "ISC"
  },
  "fhirVersions": [
    "4.0.1"
  ],
  "bundleDependencies": false,
  "date": "20201208205547",
  "dependencies": {
    "hl7.fhir.r4.core": "4.0.1"
  },
  "deprecated": false
}

Vous pouvez modifier le nom, le titre, l'auteur, la date et d'autres éléments comme vous le souhaitez. (Remarque : lorsque chaque profil est modifié et réimporté dans IRIS, la version doit être modifiée (augmentée) en conséquence. （La version actuelle 2021.1 du référentiel FHIR n'a pas de fonction de suppression des profils, il faut donc veiller à ce que le nombre de profils n'augmente pas trop dans l'environnement de production, etc., en vérifiant le bon fonctionnement dans l'environnement de test et en ne les appliquant ensuite qu'un nombre minimum de fois dans l'environnement de production.)

À partir du portail de gestion IRIS, allez Health -> FHIR Configuration -> Package Configuration et sélectionnez le dossier contenant les quatre fichiers ci-dessus dans Import Package, et vous verrez l'écran suivant.

Cliquez sur Import pour terminer l'importation dans IRIS.

Ensuite, créez un nouveau référentiel FHIR sur l'écran de configuration du serveur Server Configuration. (Vous pouvez également ajouter à un référentiel FHIR existant).

Test de POSTMAN

POSTEZ la ressource de test qui vient d'être générée par SUSHI. À des fins de vérification, il peut être préférable de générer des données qui incluent d'autres valeurs de birthPlace, ou une ressource Patient qui n'inclut pas de birthPlace en premier lieu.

Si birthPlace a été correctement ajouté au SearchParameter dans le référentiel FHIR, la requête GET suivante devrait permettre de récupérer ces informations sur le patient !

GET http://localhost:52785/csp/healthshare/sushi/fhir/r4/Patient?birthPlace=Kagoshima

Obtenez-vous maintenant les bons résultats ? Si le nouveau SearchParameter, birthPlace, n'a pas été ajouté correctement, la première réponse à la requête GET contiendra la ressource OperationOutcome suivante qui contient les informations d'erreur suivantes : "Le paramètre birthPlace n'a pas été reconnu. Vérifiez le message de réponse pour ce message.

              {
            "resource": {
                "resourceType": "OperationOutcome",
                "issue": [
                    {
                        "severity": "error",
                        "code": "invalid",
                        "diagnostics": "<HSFHIRErr>ParameterNotSupported",
                        "details": {
                            "text": "Unrecognized parameter 'birthPlace'. 鹿児島"
                        }
                    }
                ]
            },
            "search": {
                "mode": "outcome"
            }
        },

Résumé

Vous avez vu le processus de création d'un profil (StructureDefinition/SearchParameter) pour FHIR à l'aide de SUSHI et son importation dans le référentiel FHIR d'IRIS for Health pour étendre ses fonctionnalités. Dans ce cas, les éléments ajoutés à Extension ont été ajoutés à SearchParameter, mais il est également possible d'ajouter SearchParameter à des éléments qui existent dans la spécification standard FHIR mais qui ne sont pas encore des SearchParameters.

Bien que le développement très flexible de FHIR permette d'étendre les fonctionnalités de cette manière, il est également important de partager des informations sur le type d'extensions réalisées pour assurer l'interopérabilité, c'est-à-dire de créer des guides de mise en œuvre, etc. Comme nous l'avons vu dans les parties 1 et 2 de cette série, SUSHI est un outil open source très unique et puissant qui couvre les deux côtés de la question.

On espère que ces outils seront combinés avec IRIS for Health pour créer une nouvelle solution FHIR.

Le fichier fsh SUSHI utilisé dans cet article et les fichiers modèles StructureDefinition/SearchParameter générés sont disponibles ici.

Bonjour, chers développeurs !

Dans cette série, je ne vous montrerai pas comment utiliser IRIS for Health, mais plutôt comment utiliser SUSHI, un outil de création de profils FHIR, en tant que technologie associée.

Quand on a les outils adéquats, les informations du profil (spécifications, limitations, extensions, etc.) d'un projet FHIR peuvent être bien organisées et publiées.

Avant de commencer, qu'est-ce que le SUSHI ? Je vais l'expliquer brièvement.

Qu'est-ce que le SUSHI ?

FHIR est un acronyme pour Fast Healthcare Interoperability Resources et est défini comme une norme pour l'l'échange de dossiers médicaux électroniques qui peut être mise en œuvre dans un court délai. REST est une technologie standard de communication web permettant d'échanger un ensemble de données (ressources) au format JSON/XML, très lisible et facile à manipuler.

En simplifiant, l'idée est d'utiliser un format commun pour représenter les données médicales afin de faciliter le transfert et l'échange d'informations entre les systèmes et les établissements.

Il existe plusieurs ressources définies dans FHIR. Par exemple, les informations sur les patients ont une définition appelée Ressource Patient, qui représente les informations sur les patients.

Il existe de nombreux modèles sur le site officiel de FHIR, j'ai donc pensé que je pourrais en extraire quelques-uns.

Par exemple, les données sont exprimées au format JSON de la manière suivante. Le numéro du patient (identifiant), son nom, son sexe, etc. sont représenté.

{
  "resourceType": "Patient",
  "id": "pat1",
  "texte": {
    "statut": "généré",
    "div": "<div xmlns=\"http://www.w3.org/1999/xhtml\">\n      \n      <p>Patient Donald DUCK @ Acme Healthcare, Inc. MR = 654321</p>\n    \n    </div>"
  },
  "identifiant": [
    {
      "utilisation": "commune",
      "type": {
        "codage": [
          {
            "système": "http://terminology.hl7.org/CodeSystem/v2-0203",
            "code": "MR"
          }
        ]
      },
      "système": "urn:oid:0.1.2.3.4.5.6.7",
      "valeur": "654321"
    }
  ],
  "active": true,
  "nom": [
    {
      "utilisation": "officiel",
      "nom de famille": "Donald",
      "prénom": [
        "Duck"
      ]
    }
  ],
  "sex": "masculin",
  "* snip *"
}

Qu'est-ce que le profil FHIR ?

Dans FHIR, il existe des formats de représentation JSON et XML et des règles concernant les informations à répertorier avec le nom de clé JSON, le type de code à utiliser et le type de structure à utiliser. C'est ce qu'on appelle le Profile FHIR.

Le profil est un terme utilisé de différentes manières.

Au sens le plus large :

Un ensemble de définitions pour les contraintes sur les ressources FHIR et les serveurs FHIR. Un artefact qui le représente.

Au sens plus restreint :

Au sens plus restreint, une ressource de conformité est une ressource à laquelle des contraintes spécifiques ont été appliquées.

Dans ce cas, un profil existe pour chaque ressource (par exemple, Profil de Patient, Profil d'observation)..

Pour plus de détails, veuillez regarder la vidéo du [Sommet virtuel japonais 2021] (https://youtu.be/B-B6ge_0nHg) sur les profils FHIR ici. (environ 20 minutes).

Bien que le site officiel FHIR fournisse des spécifications par défaut pour chaque ressource, le degré de liberté dans l'utilisation de chaque ressource est considérable. Malheureusement, le degré de liberté dans l'utilisation de chaque ressource est très important. Il est difficile de réaliser des échanges de données interopérables avec les ressources telles qu'elles sont. Il est donc important de définir de nouvelles règles pour la description des ressources sur la base de l'"accord" préalable. Cet "accord" et ces "règles" sont équivalents au Guide de mise en œuvre et au Profil.

Les directives de mise en œuvre sont pour la plupart rédigées en texte à l'aide de Word, Excel, HTML, etc. L'une des caractéristiques de FHIR est que le profil FHIR lui-même peut également être exprimé à l'aide de ressources FHIR. Par exemple, il est possible d'exprimer les spécifications au format JSON afin que des produits tels que IRIS for Health puissent intégrer les définitions et étendre les fonctions. D'autre part, le profil est écrit au format JSON, qui peut être traité à l'aide de la ressource StructureDefinition de FHIR.

L'Association HL7 des États-Unis a publié IG Publisher, qui génère automatiquement des directives de mise en œuvre à partir de profils. Grâce à cet outil, vous pouvez générer des fichiers HTML de directives de mise en œuvre au format publié par l'Association HL7. La seconde partie de cet article vous montrera comment procéder.

À titre d'exemple, il s'agit d'une ressource appelée "StructureDefinition" qui représente les conventions de notation pour les Ressources Patient suggérées pour une utilisation standard aux États-Unis, appelée US Core. (Référence)

{
  "resourceType" : "StructureDefinition",
  "id" : "us-core-patient",
  "texte" : {
    "statut" : "extensions",
    "div" : "(snip)"
  },
  "url" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient",
  "version" : "3.1.1",
  "nom" : "USCorePatientProfile",
  "titre" : "Profil du patient de base aux États-Unis",
  "statut" : "active",
  "expérimental" : false,
  "date" : "2020-06-27",
  "éditeur" : "Comité de pilotage HL7 US Realm",
  "contact" : [
    {
      "telecom" : [
        {
          "systéme" : "url",
          "valeur" : "http://www.healthit.gov"
        }
      ]
    }
  ],
  "(snip)"

Il existe également de nombreuses autres ressources qui décrivent le profil FHIR, comme l' [ImplementationGuide] (http://hl7.org/fhir/implementationguide.html) et le [CapabilityStatement] (http://hl7.org/fhir/capabilitystatement.html) qui résume la série de fonctions du serveur FHIR

Qu'est-ce que FHIR Shorthand?

Pour créer un profil FHIR, il suffit de compléter la structure JSON présentée ci-dessus ! Cependant, il serait difficile et fastidieux de le faire manuellement. Je ferais probablement une erreur.

Il existe des applications et des outils pour faciliter ce processus, notamment plusieurs produits commerciaux et des options à code source ouvert. Voir [cette] (https://confluence.hl7.org/pages/viewpage.action?pageId=35718864#ProfileTooling-Editing&AuthoringProfiles) page.

Un exemple est célèbre Forge de Firely aux Pays-Bas, bien que, plus récemment, une ** langue spécifique au domaine pour définir les artefacts FHIR** appelée FHIR Shorthand (lien) soit également devenue largement utilisée.

FHIR Shorthand est une langue qui vous permet de créer un profil FHIR tout en créant un fichier de définition = fichier FSH(fish) (exemple)

Un exemple de fichier FSH est présenté ci-dessous. Le paramètre quote contient le nom de ce profil (Profil : Cance.

Alias: LNC = http://loinc.org
Alias: SCT = http://snomed.info/sct

Profil:  CancerDiseaseStatus
Parent:   Observation
Id:       mcode-cancer-disease-status
Titre:    "Statut de la maladie cancéreuse"
Description: ""Le jugement qualitatif d'un clinicien sur la tendance actuelle du cancer, par exemple, s'il est stable, s'il s'aggrave (progression) ou s'il s'améliore (répond)."
* ^statut = #ébauche
* l'extension contient un EvidenceType nommé evidenceType 0..*
* extension[evidenceType].valueCodeableConcept de CancerDiseaseStatusEvidenceTypeVS (requis)
* statut et code et sujet et effectif[x] et valeurCodeableConcept MS
* bodySite 0..0
* modèle 0..0
* device 0..0
* referenceRange 0..0
* hasMember 0..0
* composant 0..0
* interprétation 0..1
* sujet 1..1
* basé sur la seule référence (ServiceRequest ou MedicationRequest)
 (snip)

Qu'est-ce que SUSHI?

Après avoir expliqué le profil FHIR/FHIR/FHIR Shorthand, il est temps d'expliquer SUSHI.

SUSHI (acronyme de "SUSHI Unshortens SHorthand Inputs") (4) est une implémentation de référence d'un compilateur FSH qui traduit FSH en artefacts FHIR tels que des profils, des extensions et des ensembles de valeurs. SUSHI est installé sur votre propre ordinateur et s'exécute localement à partir de la ligne de commande (Reference)

En bref, lorsque SUSHI traite le fichier FSH(fish) décrivant le FHIR Shorthand mentionné précédemment, des fichiers tels que StructureDefinition seront générés

Voici une illustration, à la fois évidente et quelque peu obscure, montrant comment cela fonctionne ! (Citation) (Dans cette image, il est décrit le processus (c'est-à-dire la compilation) de traitement du poisson pour faire du sushi, mais le compilateur SUSHI fait la compilation, et le produit fini est constitué d'artefacts FHIR tels que des profils, ce qui est un peu différent.)

J'espère qu'après cette introduction, vous comprenez mieux en quoi consiste le SUSHI.

Allons à l'école FSH

Au lieu d'expliquer ici comment installer et utiliser fondamentalement SUSHI, je vous recommande de visiter le site officiel où vous trouverez une introduction très précise. Le site s'appelle [École FSH] (https://fshschool.org/).

Les ressources (fichiers JSON) telles que StructureDefinition sont générées en utilisant SUSHI, et en utilisant l'outil "IG Publisher" également présenté sur ce site, vous pouvez générer la source HTML qui les combine. Vous pouvez également utiliser l'outil "IG Publisher", également présenté sur ce site, pour générer la source HTML pour l'ensemble d'entre eux.

Tout d'abord, nous vous recommandons de suivre le contenu de ce [Tutoriel SUSHI] (https://fshschool.org/docs/tutorials/basic/) pour vérifier les fonctions de base.

Si vous avez des problèmes, vous pouvez vous référer au répertoire FishExampleComplete, qui est la version complète du FSH Tank( !) inclus dans le dossier téléchargeable.

Je l'ai testé dans un environnement Windows, et comme je n'avais pas installé Node.js, j'ai utilisé les informations du site pour m'aider ! De plus, comme le stipule le tutoriel ci-dessous, vous aurez besoin d'un outil appelé Jekyll pour produire des fichiers HTML à l'aide d'IG Publisher.

Avertissement

Avant de passer à la commande suivante : Si vous n'avez jamais exécuté l'IG Publisher, il vous faudra peut-être d'abord installer Jekyll. Consultez la section Installation d'IG Publisher pour plus de détails.

Vous pouvez vous procurer le kit Jekyll sur le site.

Exemple d'exécution de SUSHI

Voici les résultats de l'exécution de la commande SUSHI en utilisant la version complète du tutoriel dans mon environnement. Pour plus d'informations sur la commande, etc., veuillez consulter ce site (Running SUSHI).

>sushi .
info  Running SUSHI v1.2.0 (implémentation de la spécification FHIR Shorthand v1.1.0)
info  Arguments:
info    C:\Users\kaminaka\Documents\Work\FHIR\SUSHI\fsh-tutorial-master\FishExampleComplete
info  Aucune route de sortie spécifiée. Sortie vers .
info  Utilisation du fichier de configuration : C:\Users\kaminaka\Documents\Work\FHIR\SUSHI\fsh-tutorial-master\FishExampleComplete\sushi-config.yaml
info  Importation du texte FSH...
info  Prétraitement de 2 documents avec 3 alias.
info  Importation de 4 définitions et 1 instance.
info  Vérification du cache local pour hl7.fhir.r4.core#4.0.1...
info  Trouver hl7.fhir.r4.core#4.0.1 dans le cache local
info  Paquet téléchargé hl7.fhir.r4.core#4.0.1
(node:26584) Avertissement : Accès à une propriété inexistante 'INVALID_ALT_NUMBER' des exportations du module à l'intérieur d'une dépendance circulaire
(Utilisez `node --trace-warnings ...` pour montrer où l'avertissement a été créé)
(node:26584) Avertissement : Accès à une propriété inexistante 'INVALID_ALT_NUMBER' des exportations du module à l'intérieur d'une dépendance circulaire
info  Conversion des ressources FSH en ressources FHIR...
info  Conversion de 3 StructureDefinitions FHIR.
info  Conversion de 1 ValueSets FHIR.
info  Conversion de 1 instance FHIR
info  Exportation des ressources FHIR en JSON...
info  Exportation de 5 ressources FHIR en JSON.
info  Assemblage des sources du Guide de mise en œuvre...
info  Génération d' ImplementationGuide-fish.json
info  Sources du guide de mise en œuvre assemblées ; prêtes pour l'IG Editeur.

╔════════════════════════ RÉSULTATS DE SUSHI ══════════════════════════╗
║ ╭──────────┬────────────┬───────────┬─────────────┬───────────╮ ║
║ │ Profils │ Extensions │ ValueSets │ CodeSystems │ Instances │ ║
║ ├──────────┼────────────┼───────────┼─────────────┼───────────┤ ║
║ │    2     │     1      │     1     │      0      │     1     │ ║
║ ╰──────────┴────────────┴───────────┴─────────────┴───────────╯ ║
║                                                                 ║
╠═════════════════════════════════════════════════════════════════╣
║ Il n'y a pas mieux que ça !    0 Erreurs      0 Avertissements ║
╚═════════════════════════════════════════════════════════════════╝

Une fois exécuté, il compilera le fichier FSH et affichera le nombre de profils et d'extensions générés au cours du processus. Si tout va bien, seul "info" sera imprimé, sinon " Avertissement et erreur " sera affiché. Les messages d'erreur sont relativement simples et permettent de déterminer facilement l'origine du problème.

Après son exécution, vous pouvez confirmer que le fichier JSON de StructureDefinition a été généré avec succès dans le dossier fsh-generated du dossier du projet.

Ensuite, essayons d'obtenir l'outil IG Publisher à l'aide de la commande "_updatePublisher", de lancer IG Publisher à l'aide de la commande "_genonce", et aussi de générer un groupe de fichiers HTML. Comme le journal d'exécution est long, je vais le sauter.

Après l'exécution, vérifiez le dossier de sortie dans le même dossier de projet, et vous verrez que de nombreux fichiers ont été générés. Et si vous ouvrez le fichier index.html, vous verrez que la page suivante a été développée.

Les pages de description des ressources que vous avez l'habitude de voir sur le site officiel de FHIR sont également générées automatiquement.

Rédigeons un guide de mise en œuvre

Bien que je ne travaille avec cet ensemble d'outils que depuis peu, je voudrais vous montrer comment rédiger un guide de mise en œuvre pour commencer.

Pour plus de détails sur la façon de les utiliser, veuillez vous reporter aux informations figurant sur le site Web de l'école FSH. Les [images FHIR DevDays et autres informations] (https://fshschool.org/downloads/) peuvent également vous être très utiles.

Pour commencer, utilisez la commande sushi --init pour créer un modèle pour la structure de votre projet.

C:\Users\kaminaka\Documents\Work\FHIR\SUSHI\TestProject>sushi --init

╭───────────────────────────────────────────────────────────╮
│ Cet outil interactif utilisera vos réponses pour créer    │
│ un projet SUSHI fonctionnel configuré avec les            │
│ informations de base de votre projet.                     │
╰───────────────────────────────────────────────────────────╯

Nom (par défaut : ExampleIG) : MonPremierProjetSUSHIP
Id (Par default: fhir.example): myfirstsushi
Canoniquel (Par default: http://example.org): http://example.org/myfirstsushi
Statut (Par default: ébauche):
Version (Par default: 0.1.0):
Initialiser le projet SUSHI en C :\Users\kaminaka\Documents\Work\FHIR\SUSHI\TestProject\MyFirstSUSHIProject? [y/n]: y
Téléchargement des scripts de l'éditeur à partir de https://github.com/HL7/ig-publisher-scripts
(node:13972) Avertissement : Accès à une propriété inexistante 'INVALID_ALT_NUMBER' des exportations du module à l'intérieur d'une dépendance circulaire.
(Utilisez `node --trace-warnings ...` pour montrer où l'avertissement a été créé)
(node:13972) Avertissement : Accès à une propriété inexistante 'INVALID_ALT_NUMBER' des exportations du module à l'intérieur d'une dépendance circulaire.

╭───────────────────────────────────────────────────────────╮
│ Le projet a été initialisé à : ./MyFirstSUSHIProject      │
├───────────────────────────────────────────────────────────┤
│ Maintenant, essayez ceci :                                │
│                                                           │
│ > cd MyFirstSUSHIProject                                  │
│ > sushi .                                                 │
│                                                           │
│ Pour des conseils sur la structure et la configuration    │
│ du projet, passez à la documentation SUSHI :              │
│ https://fshschool.org/docs/sushi                          │
╰───────────────────────────────────────────────────────────╯

Après l'avoir exécuté, il générera le minimum de fichiers de configuration et de FSH requis. Maintenant, apportons quelques modifications.

Ensuite, apportons quelques modifications.

Avant cela, je voudrais présenter l'éditeur ; je recommande d'utiliser Visual Studio Code, car il y a une [extension] (https://marketplace.visualstudio.com/items?itemName=kmahalingam.vscode-language-fsh) disponible pour modifier les fichiers fsh.

Puisque c'est ce que je vais faire, j'aimerais entrer quelques informations japonaises et voir comment elles sont reflétées.

Tout d'abord, modifiez sushi-config.yaml.

Le titre du guide d'implémentation est ajouté, l'écran de menu est changé en japonais, et la page de la liste des contenus (tuc.html) et la page personnalisée (mycustompage.html) sont ajoutées.

sushi-config.yaml

# ╭──────────────────────────────────────Guide d'implémentation────────────────────────────────────╮
# │  Les propriétés ci-dessous sont utilisées pour créer la ressource ImplementationGuide. Pour une│
# │  liste des propriétés prises en charge, consultez : https://fshschool.org/sushi/configuration/ │
# ╰────────────────────────────────────────────────────────────────────────────────────────────────╯
id: myfirstsushi
canonique: http://example.org/myfirstsushi
nom: MyFirstSUSHIProject
# Ajoutez un titre qui sera affiché en haut de la page.
Titre: ○○FHIR Guide d'implémentation du projet
statut: ébauche
publisher: InterSystems Japan/S.Kaminaka
description: Il s'agit d'un exemple de guide d'implémentation pour le projet FHIR utilisant SUSHI.
version: 0.1.0
fhirVersion: 4.0.1
copyrightYear: 2021+
releaseLabel: ci-build

# ╭────────────────────────────────────────────menu.xml────────────────────────────────────────────────╮
# │  Pour utiliser un fichier input/includes/menu.xml fourni, supprimez la propriété "menu" ci-dessous.│
# ╰────────────────────────────────────────────────────────────────────────────────────────────────────╯
# Configurez le menu pour qu'il s'affiche en japonais.
menu:
  Guide d'implémentation Accueil: index.html
  Liste de contenu: toc.html
  Résumé des artefacts FHIR: artifacts.html
  Page personnalisée: mycustompage.html

Les pages d'index et les pages personnalisées peuvent être écrites en markdown :

index.md

# MyFirstSUSHIProject

N'hésitez pas à modifier cette page d'index avec votre propre contenu !

### Historique du projet

pagecontent/index.md
Vous pouvez modifier le fichier pour changer la description dans le fichier html.

Pour décrire une page, vous pouvez utiliser la notation markdown.

### Liens vers des informations de référence
 (omission)

mycustompage.md

## C'est une page personnalisée.

Si vous fournissez un fichier markdown, un fichier html sera généré.

Des pages spécifiques au projet peuvent être produites et incluses dans le guide d'implémentation.

Enfin, nous allons modifier le fichier FSH le plus essentiel. Ce modèle contient le fichier FSH pour le profil Patient, nous l'avons donc modifié légèrement.

patient.fsh

// Voici un exemple simple d'un fichier FSH.
// Ce fichier peut être renommé, et des fichiers FSH supplémentaires peuvent être ajoutés.
// SUSHI recherchera les définitions dans tout fichier utilisant la terminaison .fsh.
Profil: MyPatient
Parent: Patient
Titre: "Profil du patient pour le projet ○○"
* nom 1..* MS
// La partie descriptive de la liste peut être modifiée en changeant le ^short.
* name ^short = "Contient le nom du patient.。"
* name ^definition = "Élément permettant de stocker le nom du patient. Kanji et Katakana basés sur NeXEHRS JP CORE"

Exécutez maintenant la commande suivante pour voir la page du guide d'implémentation générée.

sushi.

_updatePublisher

_genonce

Vous pouvez facilement générer une page qui contient les informations suivantes.

Il génère également des fichiers JSON tels que StructureDefinition et ImplementationGuide.

Résumé

Les résultats vous ont-ils satisfait ?

Cet outil génère des fichiers JSON de profils FHIR et peut créer des fichiers HTML. Ainsi, si cet outil est bien utilisé, il sera facile de créer un contenu capable de communiquer les spécifications FHIR d'une manière facile à comprendre.

Bien que cet outil ne soit pas directement lié à InterSystems, nous avons pensé qu'il serait utile de le présenter à la communauté des développeurs pour échanger des informations sur le projet FHIR.

Pour ceux d'entre vous qui l'ont essayé après avoir lu cet article, ou qui le connaissent déjà, je serais heureux d'entendre vos réflexions sur la façon de l'utiliser, ainsi que toute fonctionnalité ou syntaxe utile que vous souhaiteriez partager.

Dans l'article suivant de cette série, je voudrais étendre les paramètres de recherche en lisant le fichier de définition du paramètre de recherche généré par SUSHI dans IRIS for Health.

(2021/4/20 Nous avons corrigé la partie ambiguë de l'explication, notamment en ce qui concerne le profil. Merci de nous l'avoir signalé.)

Dans ce GitHub nous recueillons des informations à partir d'un csv, nous utilisons une DataTransformation pour les transformer en un objet FHIR, puis nous sauvegardons ces informations sur un serveur FHIR, et tout cela en utilisant uniquement Python.

The objective is to show how easy it is to manipulate data into the output we want, here a FHIR Bundle, in the IRIS full Python framework.

1. Fhir-orga-dt

• 1. Fhir-orga-dt
• 2. Préalables
• 3. Installation
  • 3.1. Installation pour le dévelopment
  • 3.2. Portail de gestion et VSCode
  • 3.3. Avoir le dossier ouvert à l'intérieur du conteneur
• 4. Serveur FHIR
• 5. Présentation pas à pas
  • 5.1. Messages et objets
  • 5.2. Service aux entreprises
  • 5.3. Processus d'entreprise
  • 5.4. Opération d'un entreprise
  • 5.5. Conclusion de la présentation
• 6. Création d'une nouvelle DataTransformation
• 7. Ce qu'il y a dans le référentiel
  • 7.1. Dockerfile
  • 7.2. .vscode/settings.json
  • 7.3. .vscode/launch.json

2. Préalables

Assurez-vous que git et Docker desktop sont installé.

Si vous travaillez à l'intérieur du conteneur, comme il est montré dans 3.3., vous n'avez pas besoin d'installer fhirpy et fhir.resources.

Si vous n'êtes pas dans le conteneur, vous pouvez utiliser pip pour installer fhirpy et fhir.resources.
Vérifiez fhirpy et fhir.resources pour plus d'information.

3. Installation

3.1. Installation pour le développement

Clone/git tire le repo dans n'importe quel répertoire local, par exemple comme indiqué ci-dessous :

git clone https://github.com/LucasEnard/fhir-client-python.git

Ouvrez le terminal dans ce répertoire et lancez :

docker build .

3.2. Portail de gestion et VSCode

Ce référentiel est prêt pour VS Code.

Ouvrez le dossier fhir-client-python cloné localement dans VS Code.

Si vous y êtes invité (coin inférieur droit), installez les extensions recommandées.

3.3. Avoir le dossier ouvert à l'intérieur du conteneur

Vous pouvez être à l'intérieur du conteneur avant de coder si vous le souhaitez.
Pour cela, il faut que docker soit activé avant d'ouvrir VSCode.
Ensuite, dans VSCode, lorsque vous y êtes invité ( coin inférieur droit ), rouvrez le dossier à l'intérieur du conteneur afin de pouvoir utiliser les composants python qu'il contient.
La première fois que vous effectuez cette opération, cela peut prendre plusieurs minutes, le temps que le conteneur soit préparé.

Si vous n'avez pas cette option, vous pouvez cliquer dans le coin inférieur gauche et cliquer sur Ouvrir à nouveau dans le conteneur puis sélectionner De Dockerfile

Plus d'informations ici

En ouvrant le dossier à distance, vous permettez à VS Code et à tous les terminaux que vous ouvrez dans ce dossier d'utiliser les composants python dans le conteneur.

4. Serveur FHIR

Pour compléter cette présentation, nous allons utiliser un serveur fhir.
Ce serveur fhir était déjà intégré lorsque vous avez cloné et construit le conteneur.

L'url est localhost:52773/fhir/r4

5. Présentation pas à pas

Présentation complète de la réalisation d'IRIS en Python.

5.1. Messages and objects

Les objets et les messages contiennent les informations entre nos services, nos processus et nos opérations.

Dans le fichier obj.py nous devons créer une classe de données qui correspond au csv, ceci sera utilisé pour garder l'information avant de faire la DataTransformation.
Dans notre exemple, le csv organisation.csv ressemble à ceci,

active;name;city;country;system;value
true;Name1;city1;country1;phone;050678504
false;Name2;city2;country2;phone;123456789

Par conséquent, l'objet ressemblera à ceci,

@dataclass
# > Cette classe représente une organisation simple
class BaseOrganization:
    active:bool = None
    name:str = None
    city:str = None
    country:str = None
    system:str = None
    value:str = None

Dans le fichier msg.py, nous aurons deux types de requêtes, la première contenant les informations d'une organisation avant la DataTransformation et la seconde contenant les informations de l'organisation après la DataTransformation.

5.2. Service aux entreprises

Dans le fichier bs.py, nous avons le code qui nous permet de lire le csv et pour chaque ligne du csv (donc pour chaque organisation), le mapper dans un objet que nous avons créé plus tôt. Ensuite, pour chacune de ces lignes (organisation), nous créons une requête et l'envoyons à notre processus pour effectuer la DataTransformation.

# Nous ouvrons le fichier
with open(self.path + self.filename,encoding="utf-8") as csv:
    # Nous le lisons et le mappons en utilisant l'objet BaseOrganization précédemment utilisé
    reader = DataclassReader(csv, self.fhir_type ,delimiter=";")
    # Pour chacune de ces organisations, nous pouvons créer une requête et l'envoyer au processus
    for row in reader:
        msg = OrgaRequest()
        msg.organization = row
        self.send_request_sync('Python.ProcessCSV',msg)

5.3. Service aux entreprises

Dans le fichier bp.py, nous avons la DataTransformation, qui convertit un simple objet python contenant peu d'informations en un objet FHIR R4

Voici les étapes pour effectuer une DataTransformation en utilisant du python embarqué sur notre organisation simple,

# Création de l'objet Organisation
organisation = Organisation()

# Mappage des informations de la demande à l'objet Organisation
organization.name = base_orga.name

organization.active = base_orga.active

## Création de l'objet Adresse et mappage des informations
## de la demande à l'objet Addresse
adresse = Addresse()
adress.country = base_orga.country
adress.city = base_orga.city

### Configuration de l'adresse de notre organisation à celle que nous avons créée
organization.address = [adress]

## Création de l'objet ContactPoint et mise en correspondance
## des informations de la demande avec l'objet ContactPoint
telecom = ContactPoint()
telecom.value = base_orga.value
telecom.system = base_orga.system

### Configuration de la télécommunication de notre organisation à celle que nous avons créée
organization.telecom = [telecom]

# Maintenant, notre DT est achevé, nous avons une organisation d'objets qui est
# un objet FHIR R4 et qui contient toutes nos informations csv.

Après cela, notre mappage est terminé et notre DT fonctionne.
Maintenant, nous pouvons envoyer cette ressource FHIR R4 nouvellement créée à notre FhirClient qui est notre opération.

5.4. Opération d'un entreprise

Dans le fichier bo.py nous avons le FhirClient, ce client crée une connexion à un serveur fhir qui contiendra les informations recueillies par le csv.

Dans cet exemple, nous utilisons un serveur fhir local qui n'a pas besoin d'une clé api pour se connecter.
Pour s'y connecter, nous devons utiliser la fonction on_init,

if not hasattr(self,'url'):
    self.url = 'localhost:52773/fhir/r4'

self.client = SyncFHIRClient(url=self.url)

Maintenant, lorsque nous recevons un message/demande, nous pouvons, en trouvant le type de ressource de la ressource que nous envoyons avec notre demande au client, créer un objet lisible par le client, puis le sauvegarder sur le serveur fhir.

# Obtenez le type de ressource de la demande ( ici "Organisation" )
resource_type = request.resource["resource_type"]

# Créer une ressource de ce type en utilisant les données de la demande
resource = construct_fhir_element(resource_type, request.resource)

# Sauvegarder la ressource sur le serveur FHIR en utilisant le client
self.client.resource(resource_type,**json.loads(resource.json())).save()

Il est à noter que le client fhir fonctionne avec n'importe quelle ressource de FHIR R4 et pour utiliser et modifier notre exemple, nous devons seulement changer la DataTransformation et l'objet qui contient les informations csv.

5.5. Conclusion de la présentation

Si vous avez suivi ce parcours, vous savez maintenant exactement comment lire un csv d'une représentation d'une ressource FHIR R4, utiliser une DataTransformation pour le transformer en un véritable objet FHIR R4 et le sauvegarder sur un serveur.

6. Création d'une nouvelle DataTransformation

Ce référentiel est prêt à être codé en VSCode avec les plugins InterSystems. Ouvrez /src/python pour commencer à coder ou utiliser l'autocomplétion.

Étapes pour créer une nouvelle transformation
Pour ajouter une nouvelle transformation et l'utiliser, la seule chose que vous devez faire est d'ajouter votre csv nommé Patient.csv (par exemple) dans le dossier src/python/csv.
Ensuite, créez un objet dans src/python/obj.py appelé BasePatient qui met en correspondance votre csv.
Maintenant, créez une requête dans src/python/msg.py appelée PatientRequest qui a une variable resource de type BasePatient.
L'étape finale est la DataTransformation, pour cela, allez dans src/python/bp.py et ajoutez votre DT. Ajoutez d'abord if isinstance(request, PatientRequest): puis mappez votre ressource de requête à une fhir.resource Patient.
Maintenant si vous allez dans le portail de gestion et changez le paramètre du ServiceCSV pour ajouter filename=Patient.csv vous pouvez juste démarrer la réalisation et voir votre transformation se dérouler et votre client envoyer les informations au serveur.

Étapes détaillées pour créer une nouvelle transformation
Si vous n'êtes pas sûr de ce qu'il faut faire ou de la manière de le faire, voici une création étape par étape d'une nouvelle transformation :

Créez le fichier Patient.csv and le dossier src/python/csv pour les remplir avec le suivant:

family;given;system;value
FamilyName1;GivenName1;phone;555789675
FamilyName2;GivenName2;phone;023020202

Notre CSV contient un nom de famille, un prénom et un numéro de téléphone pour deux patients.

Dans src/python/obj.py écrivez :

@dataclass
class BasePatient:
    family:str = None
    given:str = None
    system:str = None
    value:str = None

Dans src/python/msg.py écrivez :

from obj import BasePatient
@dataclass
class PatientRequest(Message):
    resource:BasePatient = None

Dans src/python/bp.py écrivez :

from msg import PatientRequest
from fhir.resources.patient import Patient
from fhir.resources.humanname import HumanName

Dans src/python/bp.py dans la fonction on_request écrivez :

if isinstance(request,PatientRequest):
    base_patient = request.resource

    patient = Patient()

    name = HumanName()
    name.family = base_patient.family
    name.given = [base_patient.given]
    patient.name = [name]

    telecom = ContactPoint()
    telecom.value = base_patient.value
    telecom.system = base_patient.system
    patient.telecom = [telecom]

    msg = FhirRequest()
    msg.resource = patient

    self.send_request_sync("Python.FhirClient", msg)

Maintenant si vous allez dans le portail de gestion et changez le paramètre du ServiceCSV pour ajouter filename=Patient.csv vous pouvez juste arrêter et redémarrer la production et voir votre transformation se dérouler et votre client envoyer les informations au serveur.

7. Ce qu'il y a dans le référentiel

7.1. Dockerfile

Le dockerfile le plus simple pour démarrer un conteneur Python.
Utilisez docker build . pour construire et rouvrir votre fichier dans le conteneur pour travailler à l'intérieur de celui-ci.

7.2. .vscode/settings.json

Fichier de paramètres.

7.3. .vscode/launch.json

Fichier de configuration si vous voulez déboguer.

Nous sommes présent au rendez Meetup FHIR #11 : API Mon Espace Santé - Paris & Online

Welcome de Nicolas :

BIENVENUE par Nicolas RISS

Meetup FHIR #11 : API Mon Espace Santé - Paris & Online

https://esante.gouv.fr/produits-services/ci-sis

Hela Ghariani (DNS)
Mon espace santé et le catalogue de services

Service Iris Healthtoolkit

Utilisation facile de HL7v2 vers FHIR, CDA vers FHIR, FHIR vers HL7v2 en tant que service.

L'objectif de ce projet est de fournir une API REST capable de convertir facilement divers formats de santé. Publiez le format souhaité dans le corps REST, obtenez la réponse dans le nouveau format.

• Version officielle : https://aws.amazon.com/marketplace/pp/prodview-q7ryewpz75cq2 :fire:

• Vidéo : https://youtu.be/lr2B7zSFkds :tv:

Installation

Clonez ce référentiel

git clone https://github.com/grongierisc/iris-healthtoolkit-service.git

Docker

docker-compose up --build -d

Utilisation

• Atteignez : http://localhost:32783/swagger-ui/index.html

Détails de l'Api

HL7 vers FHIR

POST http://localhost:32783/api/hl7/fhir

Exemple

Saisie

MSH|^~\&||^^NPI|||20211105165829+0000||ADT^A01|66053,61109.396628|P|2.5.1|||AL|AL|||||PH_SS-Ack^SS Sender^2.16.840.1.114222.4.10.3^ISO
EVN||202111051658|||||^^NPI
PID|1||060a6bd5-5146-4b08-a916-009858997bd3^^^https://github.com/synthetichealth/synthea^~060a6bd5-5146-4b08-a916-009858997bd3^^^http://hospital.smarthealthit.org^MR~999-97-4582^^^&^SS~S99986284^^^&^DL~X84330364X^^^&^PPN||Masson^Livia^^^Mrs.^^||19920820|F|Simon^Livia^^||615 Avenue Lemaire^^Lyon^Auvergne-Rhone-Alpes^63000||^PRN^PH^^^555^286|||||||||||||||||||||
PV1|1|O||424441002|||||||||||||||1^^^&&^VN|||||||||||||||||||||||||200812312325|20090101044004
PV2|||72892002^Grossesse normale^SCT
OBX|1||8302-2^Taille du corps^LN||20101014002504^^|cm^^UCUM|||||F|||20101014
OBX|2||72514-3^Gravite de la douleur - 0-10 evaluation numerique verbale [Score] - Signaleee^LN||20101014002504^^|{score}^^UCUM|||||F|||20101014
OBX|3||29463-7^Poids corporel^LN||20101014002504^^|kg^^UCUM|||||F|||20101014
OBX|4||39156-5^Indice de masse corporelle^LN||20101014002504^^|kg/m2^^UCUM|||||F|||20101014
OBX|5||72166-2^Statut du tabagisme^LN||20171026002504^Ancien fumeur^SCT^^^^^^Ancien fumeur||||||F|||20171026

Sortie

{
"typeDeRessource": "Paquet",
"type": "transaction",
"saisie": [
  {
    "demande": {
      "méthode": "POST",
      "url": "Organisation"
    },
    "UrlComplète": "urn:uuid:347a0c88-e7fa-11ec-9601-0242ac1a0002",
    "ressource": {
      "typeDeRessource": "Organisation",
      "identifiant": [
        {
          "valeur": "https://github.com/synthetichealth/synthea"
        }
      ]
    }
  },
  {
    "demande": {
      "méthode": "POST",
      "url": "Organisation"
    },
    "UrlComplète": "urn:uuid:34d03d1a-e7fa-11ec-9601-0242ac1a0002",
    "ressource": {
      "typeDeRessource": "Organisation",
      "identifiant": [
        {
          "valeur": "http://hospital.smarthealthit.org"
        }
      ]
    }
  },
  {
    "demande": {
      "méthode": "POST",
      "url": "Patient"
    },
    "UrlComplète": "urn:uuid:36dd6e2a-e7fa-11ec-9601-0242ac1a0002",
    "ressource": {
      "typeDeRessource": "Patient",
      "adresse": [
        {
          "ville": "Lyon",
          "ligne": [
            "615 Avenue Lemaire"
          ],
          "codePostal": "63000",
          "région": "Auvergne-Rhone-Alpes"
        }
      ],
      "dateDeNaissance": "1992-08-20",
      "sex": "femme",
      "identifiant": [
        {
          "assigner": {
            "référence": "urn:uuid:347a0c88-e7fa-11ec-9601-0242ac1a0002"
          },
          "système": "https://github.com/synthetichealth/synthea",
          "valeur": "060a6bd5-5146-4b08-a916-009858997bd3"
        },
        {
          "assigner": {
            "référence": "urn:uuid:34d03d1a-e7fa-11ec-9601-0242ac1a0002"
          },
          "système": "http://hospital.smarthealthit.org",
          "type": {
            "codage": [
              {
                "code": "MR",
                "système": "http://terminology.hl7.org/CodeSystem/v2-0203"
              }
            ],
            "texte": "MRN"
          },
          "valeur": "060a6bd5-5146-4b08-a916-009858997bd3"
        },
        {
          "extension": [
            {
              "url": "http://intersystems.com/fhir/extn/sda3/lib/patient-number-i-s-o-assigning-authority",
              "valeurDeLigne": "&"
            }
          ],
          "type": {
            "codage": [
              {
                "code": "SS"
              }
            ],
            "texte": "SS"
          },
          "valeur": "999-97-4582"
        },
        {
          "extension": [
            {
              "url": "http://intersystems.com/fhir/extn/sda3/lib/patient-number-i-s-o-assigning-authority",
              "valeurDeLigne": "&"
            }
          ],
          "type": {
            "codage": [
              {
                "code": "DL",
                "système": "http://terminology.hl7.org/CodeSystem/v2-0203"
              }
            ],
            "texte": "DL"
          },
          "valeur": "S99986284"
        },
        {
          "extension": [
            {
              "url": "http://intersystems.com/fhir/extn/sda3/lib/patient-number-i-s-o-assigning-authority",
              "valeurDeLigne": "&"
            }
          ],
          "type": {
            "codage": [
              {
                "code": "PPN",
                "système": "http://terminology.hl7.org/CodeSystem/v2-0203"
              }
            ],
            "texte": "PPN"
          },
          "valeur": "X84330364X"
        }
      ],
      "nom": [
        {
          "famille": "Simon",
          "prénom": [
            "Livia"
          ],
          "texte": "Livia Simon"
        },
        {
          "famille": "Masson",
          "prénom": [
            "Livia"
          ],
          "préfixe": [
            "Mrs."
          ],
          "texte": "Mrs. Livia Masson",
          "utilisation": "officiel"
        }
      ],
      "telecom": [
        {
          "système": "téléphone",
          "utilisation": "domicile",
          "valeur": "(555) 286"
        }
      ]
    }
  },
  {
    "demande": {
      "méthode": "POST",
      "url": "Visite"
    },
    "UrlComplète": "urn:uuid:38cf2d40-e7fa-11ec-9601-0242ac1a0002",
    "ressource": {
      "typeDeRessource": "Visite",
      "class": {
        "code": "AMB",
        "système": "http://terminology.hl7.org/CodeSystem/v3-ActCode"
      },
      "extension": [
        {
          "url": "http://intersystems.com/fhir/extn/sda3/lib/encounter-encounter-type",
          "valeurDeLigne": "O"
        },
        {
          "url": "http://intersystems.com/fhir/extn/sda3/lib/encounter-entered-on",
          "valeurDateHeur": "2008-12-31T23:25:00+00:00"
        },
        {
          "url": "http://intersystems.com/fhir/extn/sda3/lib/encounter-to-time",
          "valeurDateHeur": "2009-01-01T04:40:04+00:00"
        }
      ],
      "identifiant": [
        {
          "type": {
            "texte": "NuméroDeVisite"
          },
          "utilisation": "officiel",
          "valeur": "1"
        }
      ],
      "période": {
        "lancement": "2008-12-31T23:25:00+00:00"
      },
      "reasonCode": [
        {
          "codage": [
            {
              "code": "72892002",
              "affichage": "Grossesse normale",
              "système": "http://snomed.info/sct"
            }
          ]
        }
      ],
      "état": "inconnu",
      "sujet": {
        "référence": "urn:uuid:36dd6e2a-e7fa-11ec-9601-0242ac1a0002"
      },
      "type": [
        {
          "codage": [
            {
              "code": "424441002"
            }
          ]
        }
      ]
    }
  },
  {
    "demande": {
      "méthode": "POST",
      "url": "Observation"
    },
    "UrlComplète": "urn:uuid:3a13745e-e7fa-11ec-9601-0242ac1a0002",
    "ressource": {
      "typeDeRessource": "Observation",
      "code": {
        "codage": [
          {
            "code": "72166-2",
            "affichage": "Statut du tabagisme",
            "système": "http://loinc.org"
          }
        ]
      },
      "effectiveDateHeure": "2017-10-26T00:00:00+00:00",
      "visite": {
        "référence": "urn:uuid:38cf2d40-e7fa-11ec-9601-0242ac1a0002"
      },
      "extension": [
        {
          "url": "http://intersystems.com/fhir/extn/sda3/lib/observation-encounter-number",
          "valeurDeLigne": "1"
        },
        {
          "url": "http://intersystems.com/fhir/extn/sda3/lib/observation-observation-coded-value",
          "valeurConceptCodifiable": {
            "codage": [
              {
                "code": "20171026002504",
                "affichage": "Ancien fumeur",
                "système": "http://snomed.info/sct"
              }
            ],
            "texte": "Ancien fumeur"
          }
        }
      ],
      "état": "final",
      "sujet": {
        "référence": "urn:uuid:36dd6e2a-e7fa-11ec-9601-0242ac1a0002"
      },
      "valeurDeLigne": "Ancien fumeur"
    }
  },
  {
    "demande": {
      "méthode": "POST",
      "url": "Observation"
    },
    "UrlComplète": "urn:uuid:3b6212fc-e7fa-11ec-9601-0242ac1a0002",
    "ressource": {
      "typeDeRessource": "Observation",
      "category": [
        {
          "codage": [
            {
              "code": "Signes-vitaux",
              "affichage": "Signes vitaux",
              "système": "http://terminology.hl7.org/CodeSystem/observation-category"
            }
          ],
          "texte": "Signes vitaux"
        }
      ],
      "code": {
        "codage": [
          {
            "code": "8302-2",
            "affichage": "Taille du corps",
            "système": "http://loinc.org"
          }
        ],
        "extension": [
          {
            "url": "http://intersystems.com/fhir/extn/sda3/lib/code-table-detail-observation-observation-value-units",
            "valeurConceptCodifiable": {
              "codage": [
                {
                  "code": "cm",
                  "système": "http://unitsofmeasure.org"
                }
              ]
            }
          }
        ]
      },
      "effectiveDateHeure": "2010-10-14T00:00:00+00:00",
      "visite": {
        "référence": "urn:uuid:38cf2d40-e7fa-11ec-9601-0242ac1a0002"
      },
      "extension": [
        {
          "url": "http://intersystems.com/fhir/extn/sda3/lib/observation-encounter-number",
          "valeurDeLigne": "1"
        }
      ],
      "état": "final",
      "sujet": {
        "référence": "urn:uuid:36dd6e2a-e7fa-11ec-9601-0242ac1a0002"
      },
      "valeurConceptCodifiable": {
        "codage": [
          {
            "code": "20101014002504"
          }
        ]
      }
    }
  },
  {
    "demande": {
      "méthode": "POST",
      "url": "Observation"
    },
    "UrlComplète": "urn:uuid:3c8aba30-e7fa-11ec-9601-0242ac1a0002",
    "ressource": {
      "typeDeRessource": "Observation",
      "code": {
        "codage": [
          {
            "code": "72514-3",
            "affichage": "Gravite de la douleur - 0-10 evaluation numerique verbale [Score] - Signaleee",
            "système": "http://loinc.org"
          }
        ],
        "extension": [
          {
            "url": "http://intersystems.com/fhir/extn/sda3/lib/code-table-detail-observation-observation-value-units",
            "valeurConceptCodifiable": {
              "codage": [
                {
                  "code": "{score}",
                  "système": "http://unitsofmeasure.org"
                }
              ]
            }
          }
        ]
      },
      "effectiveDateHeure": "2010-10-14T00:00:00+00:00",
      "visite": {
        "référence": "urn:uuid:38cf2d40-e7fa-11ec-9601-0242ac1a0002"
      },
      "extension": [
        {
          "url": "http://intersystems.com/fhir/extn/sda3/lib/observation-encounter-number",
          "valeurDeLigne": "1"
        }
      ],
      "état": "final",
      "sujet": {
        "référence": "urn:uuid:36dd6e2a-e7fa-11ec-9601-0242ac1a0002"
      },
      "valeurConceptCodifiable": {
        "codage": [
          {
            "code": "20101014002504"
          }
        ]
      }
    }
  },
  {
    "demande": {
      "méthode": "POST",
      "url": "Observation"
    },
    "UrlComplète": "urn:uuid:3de455d0-e7fa-11ec-9601-0242ac1a0002",
    "ressource": {
      "typeDeRessource": "Observation",
      "category": [
        {
          "codage": [
            {
              "code": "signes -vitaux",
              "affichage": "Signes vitaux",
              "système": "http://terminology.hl7.org/CodeSystem/observation-category"
            }
          ],
          "texte": "Signes vitaux"
        }
      ],
      "code": {
        "codage": [
          {
            "code": "29463-7",
            "affichage": "Poids corporel",
            "système": "http://loinc.org"
          }
        ],
        "extension": [
          {
            "url": "http://intersystems.com/fhir/extn/sda3/lib/code-table-detail-observation-observation-value-units",
            "valeurConceptCodifiable": {
              "codage": [
                {
                  "code": "kg",
                  "système": "http://unitsofmeasure.org"
                }
              ]
            }
          }
        ]
      },
      "effectiveDateHeure": "2010-10-14T00:00:00+00:00",
      "visite": {
        "référence": "urn:uuid:38cf2d40-e7fa-11ec-9601-0242ac1a0002"
      },
      "extension": [
        {
          "url": "http://intersystems.com/fhir/extn/sda3/lib/observation-encounter-number",
          "valeurDeLigne": "1"
        }
      ],
      "état": "final",
      "sujet": {
        "référence": "urn:uuid:36dd6e2a-e7fa-11ec-9601-0242ac1a0002"
      },
      "valeurConceptCodifiable": {
        "codage": [
          {
            "code": "20101014002504"
          }
        ]
      }
    }
  },
  {
    "demande": {
      "méthode": "POST",
      "url": "Observation"
    },
    "UrlComplète": "urn:uuid:3f501418-e7fa-11ec-9601-0242ac1a0002",
    "ressource": {
      "typeDeRessource": "Observation",
      "code": {
        "codage": [
          {
            "code": "39156-5",
            "affichage": "Indice de masse corporelle",
            "système": "http://loinc.org"
          }
        ],
        "extension": [
          {
            "url": "http://intersystems.com/fhir/extn/sda3/lib/code-table-detail-observation-observation-value-units",
            "valeurConceptCodifiable": {
              "codage": [
                {
                  "code": "kg/m2",
                  "système": "http://unitsofmeasure.org"
                }
              ]
            }
          }
        ]
      },
      "effectiveDateHeure": "2010-10-14T00:00:00+00:00",
      "visite": {
        "référence": "urn:uuid:38cf2d40-e7fa-11ec-9601-0242ac1a0002"
      },
      "extension": [
        {
          "url": "http://intersystems.com/fhir/extn/sda3/lib/observation-encounter-number",
          "valeurDeLigne": "1"
        }
      ],
      "état": "final",
      "sujet": {
        "référence": "urn:uuid:36dd6e2a-e7fa-11ec-9601-0242ac1a0002"
      },
      "valeurConceptCodifiable": {
        "codage": [
          {
            "code": "20101014002504"
          }
        ]
      }
    }
  }
]
}

FHIR vers HL7 ADT

POST http://localhost:32783/api/fhir/hl7/adt

Exemple

{
"typeDeRessource": "Paquet",
"type": "transaction",
"saisie": [
  {
    "demande": {
      "méthode": "POST",
      "url": "Organisation"
    },
    "UrlComplète": "urn:uuid:347a0c88-e7fa-11ec-9601-0242ac1a0002",
    "ressource": {
      "typeDeRessource": "Organisation",
      "identifiant": [
        {
          "valeur": "https://github.com/synthetichealth/synthea"
        }
      ]
    }
  },
  {
    "demande": {
      "méthode": "POST",
      "url": "Organisation"
    },
    "UrlComplète": "urn:uuid:34d03d1a-e7fa-11ec-9601-0242ac1a0002",
    "ressource": {
      "typeDeRessource": "Organisation",
      "identifiant": [
        {
          "valeur": "http://hospital.smarthealthit.org"
        }
      ]
    }
  },
  {
    "demande": {
      "méthode": "POST",
      "url": "Patient"
    },
    "UrlComplète": "urn:uuid:36dd6e2a-e7fa-11ec-9601-0242ac1a0002",
    "ressource": {
      "typeDeRessource": "Patient",
      "adresse": [
        {
          "ville": "Lyon",
          "ligne": [
            "615 Avenue Lemaire"
          ],
          "codePostal": "63000",
          "région": "Auvergne-Rhone-Alpes"
        }
      ],
      "dateDeNaissance": "1992-08-20",
      "sex": "femme",
      "identifiant": [
        {
          "assigner": {
            "référence": "urn:uuid:347a0c88-e7fa-11ec-9601-0242ac1a0002"
          },
          "système": "https://github.com/synthetichealth/synthea",
          "valeur": "060a6bd5-5146-4b08-a916-009858997bd3"
        },
        {
          "assigner": {
            "référence": "urn:uuid:34d03d1a-e7fa-11ec-9601-0242ac1a0002"
          },
          "système": "http://hospital.smarthealthit.org",
          "type": {
            "codage": [
              {
                "code": "MR",
                "système": "http://terminology.hl7.org/CodeSystem/v2-0203"
              }
            ],
            "texte": "MRN"
          },
          "valeur": "060a6bd5-5146-4b08-a916-009858997bd3"
        },
        {
          "extension": [
            {
              "url": "http://intersystems.com/fhir/extn/sda3/lib/patient-number-i-s-o-assigning-authority",
              "valeurDeLigne": "&"
            }
          ],
          "type": {
            "codage": [
              {
                "code": "SS"
              }
            ],
            "texte": "SS"
          },
          "valeur": "999-97-4582"
        },
        {
          "extension": [
            {
              "url": "http://intersystems.com/fhir/extn/sda3/lib/patient-number-i-s-o-assigning-authority",
              "valeurDeLigne": "&"
            }
          ],
          "type": {
            "codage": [
              {
                "code": "DL",
                "système": "http://terminology.hl7.org/CodeSystem/v2-0203"
              }
            ],
            "texte": "DL"
          },
          "valeur": "S99986284"
        },
        {
          "extension": [
            {
              "url": "http://intersystems.com/fhir/extn/sda3/lib/patient-number-i-s-o-assigning-authority",
              "valeurDeLigne": "&"
            }
          ],
          "type": {
            "codage": [
              {
                "code": "PPN",
                "système": "http://terminology.hl7.org/CodeSystem/v2-0203"
              }
            ],
            "texte": "PPN"
          },
          "valeur": "X84330364X"
        }
      ],
      "nom": [
        {
          "famille": "Simon",
          "prénom": [
            "Livia"
          ],
          "texte": "Livia Simon"
        },
        {
          "famille": "Masson",
          "prénom": [
            "Livia"
          ],
          "préfixe": [
            "Mrs."
          ],
          "texte": "Mrs. Livia Masson",
          "utilisation": "officiel"
        }
      ],
      "telecom": [
        {
          "système": "téléphone",
          "utilisation": "domicile",
          "valeur": "(555) 286"
        }
      ]
    }
  },
  {
    "demande": {
      "méthode": "POST",
      "url": "visite"
    },
    "UrlComplète": "urn:uuid:38cf2d40-e7fa-11ec-9601-0242ac1a0002",
    "ressource": {
      "typeDeRessource": "visite",
      "class": {
        "code": "AMB",
        "système": "http://terminology.hl7.org/CodeSystem/v3-ActCode"
      },
      "extension": [
        {
          "url": "http://intersystems.com/fhir/extn/sda3/lib/encounter-encounter-type",
          "valeurDeLigne": "O"
        },
        {
          "url": "http://intersystems.com/fhir/extn/sda3/lib/encounter-entered-on",
          "valeurDateHeur": "2008-12-31T23:25:00+00:00"
        },
        {
          "url": "http://intersystems.com/fhir/extn/sda3/lib/encounter-to-time",
          "valeurDateHeur": "2009-01-01T04:40:04+00:00"
        }
      ],
      "identifiant": [
        {
          "type": {
            "texte": "EncounterNumber"
          },
          "utilisation": "officiel",
          "valeur": "1"
        }
      ],
      "période": {
        "lancement": "2008-12-31T23:25:00+00:00"
      },
      "reasonCode": [
        {
          "codage": [
            {
              "code": "72892002",
              "affichage": "Grossesse normale",
              "système": "http://snomed.info/sct"
            }
          ]
        }
      ],
      "état": "inconnu",
      "sujet": {
        "référence": "urn:uuid:36dd6e2a-e7fa-11ec-9601-0242ac1a0002"
      },
      "type": [
        {
          "codage": [
            {
              "code": "424441002"
            }
          ]
        }
      ]
    }
  },
  {
    "demande": {
      "méthode": "POST",
      "url": "Observation"
    },
    "UrlComplète": "urn:uuid:3a13745e-e7fa-11ec-9601-0242ac1a0002",
    "ressource": {
      "typeDeRessource": "Observation",
      "code": {
        "codage": [
          {
            "code": "72166-2",
            "affichage": "Statut du tabagisme",
            "système": "http://loinc.org"
          }
        ]
      },
      "effectiveDateHeure": "2017-10-26T00:00:00+00:00",
      "visite": {
        "référence": "urn:uuid:38cf2d40-e7fa-11ec-9601-0242ac1a0002"
      },
      "extension": [
        {
          "url": "http://intersystems.com/fhir/extn/sda3/lib/observation-encounter-number",
          "valeurDeLigne": "1"
        },
        {
          "url": "http://intersystems.com/fhir/extn/sda3/lib/observation-observation-coded-value",
          "valeurConceptCodifiable": {
            "codage": [
              {
                "code": "20171026002504",
                "affichage": "Ancien fumeur",
                "système": "http://snomed.info/sct"
              }
            ],
            "texte": "Ancien fumeur"
          }
        }
      ],
      "état": "final",
      "sujet": {
        "référence": "urn:uuid:36dd6e2a-e7fa-11ec-9601-0242ac1a0002"
      },
      "valeurDeLigne": "Ancien fumeur"
    }
  },
  {
    "demande": {
      "méthode": "POST",
      "url": "Observation"
    },
    "UrlComplète": "urn:uuid:3b6212fc-e7fa-11ec-9601-0242ac1a0002",
    "ressource": {
      "typeDeRessource": "Observation",
      "category": [
        {
          "codage": [
            {
              "code": "signes-vitaux",
              "affichage": "Signes vitaux",
              "système": "http://terminology.hl7.org/CodeSystem/observation-category"
            }
          ],
          "texte": "Signes vitaux"
        }
      ],
      "code": {
        "codage": [
          {
            "code": "8302-2",
            "affichage": "Taille du corps",
            "système": "http://loinc.org"
          }
        ],
        "extension": [
          {
            "url": "http://intersystems.com/fhir/extn/sda3/lib/code-table-detail-observation-observation-value-units",
            "valeurConceptCodifiable": {
              "codage": [
                {
                  "code": "cm",
                  "système": "http://unitsofmeasure.org"
                }
              ]
            }
          }
        ]
      },
      "effectiveDateHeure": "2010-10-14T00:00:00+00:00",
      "visite": {
        "référence": "urn:uuid:38cf2d40-e7fa-11ec-9601-0242ac1a0002"
      },
      "extension": [
        {
          "url": "http://intersystems.com/fhir/extn/sda3/lib/observation-encounter-number",
          "valeurDeLigne": "1"
        }
      ],
      "état": "final",
      "sujet": {
        "référence": "urn:uuid:36dd6e2a-e7fa-11ec-9601-0242ac1a0002"
      },
      "valeurConceptCodifiable": {
        "codage": [
          {
            "code": "20101014002504"
          }
        ]
      }
    }
  },
  {
    "demande": {
      "méthode": "POST",
      "url": "Observation"
    },
    "UrlComplète": "urn:uuid:3c8aba30-e7fa-11ec-9601-0242ac1a0002",
    "ressource": {
      "typeDeRessource": "Observation",
      "code": {
        "codage": [
          {
            "code": "72514-3",
            "affichage": "Gravite de la douleur - 0-10 evaluation numerique verbale [Score] - Signaleee",
            "système": "http://loinc.org"
          }
        ],
        "extension": [
          {
            "url": "http://intersystems.com/fhir/extn/sda3/lib/code-table-detail-observation-observation-value-units",
            "valeurConceptCodifiable": {
              "codage": [
                {
                  "code": "{score}",
                  "système": "http://unitsofmeasure.org"
                }
              ]
            }
          }
        ]
      },
      "effectiveDateHeure": "2010-10-14T00:00:00+00:00",
      "visite": {
        "référence": "urn:uuid:38cf2d40-e7fa-11ec-9601-0242ac1a0002"
      },
      "extension": [
        {
          "url": "http://intersystems.com/fhir/extn/sda3/lib/observation-encounter-number",
          "valeurDeLigne": "1"
        }
      ],
      "état": "final",
      "sujet": {
        "référence": "urn:uuid:36dd6e2a-e7fa-11ec-9601-0242ac1a0002"
      },
      "valeurConceptCodifiable": {
        "codage": [
          {
            "code": "20101014002504"
          }
        ]
      }
    }
  },
  {
    "demande": {
      "méthode": "POST",
      "url": "Observation"
    },
    "UrlComplète": "urn:uuid:3de455d0-e7fa-11ec-9601-0242ac1a0002",
    "ressource": {
      "typeDeRessource": "Observation",
      "category": [
        {
          "codage": [
            {
              "code": "signes-vitaux",
              "affichage": "Signes vitaux",
              "système": "http://terminology.hl7.org/CodeSystem/observation-category"
            }
          ],
          "texte": "Signes vitaux"
        }
      ],
      "code": {
        "codage": [
          {
            "code": "29463-7",
            "affichage": "Poids corporel",
            "système": "http://loinc.org"
          }
        ],
        "extension": [
          {
            "url": "http://intersystems.com/fhir/extn/sda3/lib/code-table-detail-observation-observation-value-units",
            "valeurConceptCodifiable": {
              "codage": [
                {
                  "code": "kg",
                  "système": "http://unitsofmeasure.org"
                }
              ]
            }
          }
        ]
      },
      "effectiveDateHeure": "2010-10-14T00:00:00+00:00",
      "visite": {
        "référence": "urn:uuid:38cf2d40-e7fa-11ec-9601-0242ac1a0002"
      },
      "extension": [
        {
          "url": "http://intersystems.com/fhir/extn/sda3/lib/observation-encounter-number",
          "valeurDeLigne": "1"
        }
      ],
      "état": "final",
      "sujet": {
        "référence": "urn:uuid:36dd6e2a-e7fa-11ec-9601-0242ac1a0002"
      },
      "valeurConceptCodifiable": {
        "codage": [
          {
            "code": "20101014002504"
          }
        ]
      }
    }
  },
  {
    "demande": {
      "méthode": "POST",
      "url": "Observation"
    },
    "UrlComplète": "urn:uuid:3f501418-e7fa-11ec-9601-0242ac1a0002",
    "ressource": {
      "typeDeRessource": "Observation",
      "code": {
        "codage": [
          {
            "code": "39156-5",
            "affichage": "Indice de masse corporelle",
            "système": "http://loinc.org"
          }
        ],
        "extension": [
          {
            "url": "http://intersystems.com/fhir/extn/sda3/lib/code-table-detail-observation-observation-value-units",
            "valeurConceptCodifiable": {
              "codage": [
                {
                  "code": "kg/m2",
                  "système": "http://unitsofmeasure.org"
                }
              ]
            }
          }
        ]
      },
      "effectiveDateHeure": "2010-10-14T00:00:00+00:00",
      "visite": {
        "référence": "urn:uuid:38cf2d40-e7fa-11ec-9601-0242ac1a0002"
      },
      "extension": [
        {
          "url": "http://intersystems.com/fhir/extn/sda3/lib/observation-encounter-number",
          "valeurDeLigne": "1"
        }
      ],
      "état": "final",
      "sujet": {
        "référence": "urn:uuid:36dd6e2a-e7fa-11ec-9601-0242ac1a0002"
      },
      "valeurConceptCodifiable": {
        "codage": [
          {
            "code": "20101014002504"
          }
        ]
      }
    }
  }
]
}

MSH|^~\&||^^NPI|||20220609134903+0000||^|66269,49743.388133779|P|2.5.1|||AL|AL|||||PH_SS-Ack^SS Sender^2.16.840.1.114222.4.10.3^ISO
EVN||202206091349|||||^^NPI
PID|1||060a6bd5-5146-4b08-a916-009858997bd3^^^https://github.com/s&&ISO^~060a6bd5-5146-4b08-a916-009858997bd3^^^http://hospital.smar&&ISO^MR~999-97-4582^^^&^SS~S99986284^^^&^DL~X84330364X^^^&^PPN||Masson^Livia^^^Mrs.^^||19920820|F|Simon^Livia^^||615 Avenue Lemaire^^^^||^PRN^PH^^^555^286|||||||||||||||||||||
PV1|1|O||424441002|||||||||||||||1^^^&&^VN|||||||||||||||||||||||||200812312325|
PV2|||72892002^Grossesse normale^SCT
OBX|1||72166-2^Statut du tabagisme^LN||^^||||||F|||20171026
OBX|2||8302-2^Taille du corps^LN||^^||||||F|||20101014
OBX|3||72514-3^Gravite de la douleur - 0-10 evaluation numerique verbale [Score] - Signaleee^LN||^^||||||F|||20101014
OBX|4||29463-7^Poids corporel^LN||^^||||||F|||20101014
OBX|5||39156-5^Indice de masse corporelle^LN||^^||||||F|||20101014

FHIR vers HL7 ORU

POST http://localhost:32783/api/fhir/hl7/oru

FHIR vers HL7 vxu

POST http://localhost:32783/api/fhir/hl7/vxu

CDA vers FHIR

POST http://localhost:32783/api/cda/fhir

Exemple

Dépôt FHIR

GET http://localhost:32783/api/fhir/metadata

Format d'entrée HL7 pris en charge :

• ADT_A01, ADT_A02, ADT_A03, ADT_A04, ADT_A05, ADT_A06, ADT_A07, ADT_A08, ADT_A09, ADT_A10, ADT_A11, ADT_A12, ADT_A13, ADT_A17, ADT_A18, ADT_A23, ADT_A25, ADT_A27, ADT_A28, ADT_A29, ADT_A30, ADT_A31, ADT_A34, ADT_A36, ADT_A39, ADT_A40, ADT_A41, ADT_A45, ADT_A47, ADT_A49, ADT_A50, ADT_A51, ADT_A60

• BAR_P12

• MDM_T02, MDM_T04, MDM_T08, MDM_T11

• OMP_O09

• ORM_O01

• ORU_R01

• PPR_PC1, PPR_PC2, PPR_PC3

• RDE_O11

• SIU_S12, SIU_S13, SIU_S14, SIU_S15, SIU_S16, SIU_S17, SIU_S26

• VXU_V04

Comment ça marche

Ce projet fonctionne avec le diagramme pivot : SDA.

Le SDA (Summary Document Architecture, Architecture du document de synthèse) est le format de données cliniques d'InterSystems.

Les correspondances SDA <-> FHIR peuvent être consultées ici, et celles de la CDA -> SDA ici.