Effacer le filtre
Annonce
Irène Mykhailova · Mars 30, 2022
Salut la communauté,
Veuillez accueillir @Lorenzo.Scalese en tant que nouveau modérateur français dans l'équipe de la Communauté des Développeurs ! 🎉
Saluons Lorenzo avec de grands applaudissements et regardons de plus près sa bio !!
@Lorenzo.Scalese est architecte de solutions chez Zorgi. > Zorgi est une entreprise spécialisée et leader du marché belge des solutions informatiques pour le secteur de la santé.
Quelques mots sur Lorenzo :
Il a débuté sa carrière en 2007 en tant que développeur et a travaillé sur de nombreux projets liés à l'industrie de la santé : logiciel d'enregistrement médical électronique (DME), logiciel de radiologie, connectivité avec RIS\PACS et modalités ionisantes, hub national d'échange de données médicales,...
Il travaille avec les technologies d'InterSystems depuis le début de sa carrière. De Caché 5.2 à IRIS aujourd'hui.
Aujourd'hui, son travail consiste principalement à définir l'architecture générale d'un logiciel EMR, à créer des outils de développement, des scripts de déploiement et à migrer des applications basées sur Caché\HealthShare vers IRIS à l'aide de conteneurs.
Quelques autres faits sur Lorenzo
Il est né en Belgique en 1984, ses parents sont italiens. Il vit dans un village de campagne, marié et père de 2 garçons (11 ans et 8 ans).
Ses passe-temps sont les technologies, le codage, les balades en VTT, le bricolage et les jeux vidéo.
BIENVENU!
Merci et félicitations @Lorenzo.Scalese👏🏼
Que la force DC Moderator soit avec toi ;) Bienvenue dans la Team @Lorenzo.Scalese
Article
Robert Bira · Déc 30, 2022
Early Access Program (EAP) est un moyen de fournir rapidement des fonctionnalités spécifiques à un groupe de personnes qui testeront et fourniront des commentaires sur cette fonctionnalité.
InterSystems a publié différentes versions (ou parties) de logiciels au cours des dernières années et amélioré les fonctionnalités avant leur sortie. Quelques exemples jusqu'ici : Columnar Storage, Python intégré, FHIRSQL et d'autres.
Mais l'une des caractéristiques de l'EAP est qu'il ne sont peut-être pas accessibles à tous. Vous devez vous inscrire au programme.
Dans le cas de l'arrêt de l'installation du serveur Web Apache (alias NoPWS), la manière de s'inscrire consiste à envoyer un e-mail à nopws@intersystems.com. Utilisez ce même e-mail pour les commentaires.
Une fois que vous aurez reçu un e-mail de confirmation, vous verrez les PAE auxquels vous avez accès sur le site Web des services d'évaluation. Vous devez vous connecter pour voir le contenu.
Ainsi, après connexion :
1) EAPs se trouvent dans la partie droite de l'écran :
Cliquez sur "Télécharger les programmes d'accès anticipé" et passez à l'écran suivant.
2) Sélectionnez l'EAP auquel vous êtes inscrit. En utilisant NoPWS comme exemple ici :
N'oubliez pas que vous ne pouvez voir que les EAPs auxquels vous avez accès.
3) Après avoir sélectionné un EAP, vous pourrez voir tous les documents et logiciels disponibles pour celui-ci :
Oui, vous devez accepter les conditions d'utilisation. Ensuite, le bouton Télécharger sera activé pour vous.
Et une dernière chose...
S'il vous plaît, donnez votre avis !
Article
Lorenzo Scalese · Mars 24
Je vais vous montrer comment vous pouvez installer très rapidement sur votre ordinateur un cluster de nœuds InterSystems IRIS en sharding. Dans cet article, mon objectif n'est pas de parler du sharding en détail, ni de définir une architecture de déploiement pour un cas réel, mais de vous montrer comment vous pouvez rapidement installer sur votre machine un cluster d'instances d'IRIS en sharding avec lequel vous pouvez jouer et faire des tests. Si vous souhaitez en savoir plus sur le sharding dans IRIS, vous pouvez consulter la documentation en cliquant ici: clicking here.
Disons dès le départ que la technologie de sharding d'IRIS va nous permettre de faire deux choses:
Définir, charger et consulter des tables fragmentées ou des shards, dont les données seront réparties de manière transparente entre les nœuds du cluster
Définir des tables fédérées, qui offrent une vue globale et composite des données appartenant à des tables différentes et qui, physiquement, sont stockées sur différents nœuds distribués
Donc, comme je l'ai dit, nous laissons le sujet du jeu avec des shards ou des tableaux fédérés pour d'autres articles, et nous nous concentrons maintenant sur l'étape précédente, c'est-à-dire sur la mise en place du cluster de nœuds en sharding.
Pour notre exemple, nous allons utiliser Docker Desktop (for Windows or MacOS) et nous appuyer sur la fonctionnalité d'IRIS: CPF Merge; ou fusion de fichier de configuration; qui nous permet d'utiliser un fichier texte brut dans lequel nous inclurons les sections et propriétés de configuration d'IRIS que nous voulons appliquer pour modifier la configuration actuelle de l'instance d'IRIS. Cette fichier se superpose au fichier iris.cpf qui définit la configuration par défaut de l'instance.
Ce merge est automatiquement « activé » lors de l'ajout de la variable d'environnement: ISC_CPF_MERGE_FILE à laquelle nous devons avoir attribué un chemin valide vers un fichier contenant les sections du fichier cpf que nous voulons modifier. Au démarrage, IRIS vérifie si on lui a demandé de faire une fusion (merge) (en gros, si cette variable d'environnement existe et pointe vers un fichier valide). Si c'est le cas, vous pouvez procéder à la fusion et démarrer.
Je ne fais pas plus de détours et je vous inclus le fichier docker-compose.yml qui fera la magie:
docker-compose.yml
services:
# iris container
irisnode1:
init: true
hostname: irishost1
image: shardnode:latest
container_name: irisnode1
build:
context: ./cluster
dockerfile: Dockerfile
ports:
- "9991:1972"
environment:
- ISC_DATA_DIRECTORY=/durable/irishost1
- ISC_CPF_MERGE_FILE=/iris-shared/merge_first_data-node.cpf
command:
--check-caps false --ISCAgent false --key /iris-shared/iris.key -a /iris-shared/configure_first_data-node.sh
volumes:
- ./cluster/iris-instance:/iris-shared:delegated
- ./DDBBs:/durable:delegated
irisnode2:
init: true
hostname: irishost2
image: shardnode:latest
container_name: irisnode2
build:
context: ./cluster
dockerfile: Dockerfile
ports:
- "9992:1972"
environment:
- ISC_DATA_DIRECTORY=/durable/irishost2
- ISC_CPF_MERGE_FILE=/iris-shared/merge_data-node.cpf
command:
--check-caps false --ISCAgent false --key /iris-shared/iris.key -a /iris-shared/configure_data-node.sh
volumes:
- ./cluster/iris-instance:/iris-shared
- ./DDBBs:/durable
depends_on:
irisnode1:
condition: service_healthy
# conteneur de passerelle web
webgateway:
image: containers.intersystems.com/intersystems/webgateway:latest-em
init: true
container_name: webgateway
hostname: webgateway
ports:
- 7772:80
- 7773:443
environment:
- ISC_CSP_CONF_FILE=/webgateway-shared/CSP.conf
- ISC_CSP_INI_FILE=/webgateway-shared/CSP.ini
volumes:
- ./webgateway/CSP.conf:/webgateway-shared/CSP.conf
- ./webgateway/CSP.ini:/webgateway-shared/CSP.ini
Dans ce cas, nous créons 3 services:
irisnode1 - Premier nœud du cluster, qui a un rôle spécial, et c'est pourquoi nous l'appelons spécifiquement node1
irisnode2 - Nœud de données supplémentaire du cluster, dont le rôle est data (nous pouvons en avoir autant que nous le voulons)
webgateway - Serveur web préconfiguré pour accéder aux instances IRIS (Apache + Webgateway)
Pour créer l'image shardnode:latest, j'ai utilisé le dockerfile suivant:
Dockerfile
FROM containers.intersystems.com/intersystems/irishealth:2024.3
#FROM containers.intersystems.com/intersystems/iris-community:latest-em
#FROM containers.intersystems.com/intersystems/irishealth-arm64:2024.3
USER root
WORKDIR /opt/irisapp
RUN chown -R irisowner:irisowner /opt/irisapp
USER irisowner
WORKDIR /opt/irisapp
COPY --chown=irisowner:irisowner src src
COPY --chown=irisowner:irisowner iris.script iris.script
RUN iris start IRIS \
&& iris session IRIS < iris.script \
&& iris stop IRIS quietly
Les fichiers utilisés pour effectuer la fusion (merge) pour nodo1 et d'autre cluster IRIS data nodes sont les suivants:
merge_first_data-node.cpf
# Premier nœud du cluster
# 2 GB 8k / 204 MB gmpheap / 64 nodos max
[config]
globals=0,0,2048,0,0,0
gmheap=204800
MaxServerConn=64
MaxServers=64
# Configuration du premier nœud du cluster de sharding. Création d'un point de terminaison REST de test
[Actions]
ConfigShardedCluster:ClusterURL=IRIS://irishost1:1972/IRISCLUSTER,Role=node1
CreateApplication:Name=/rest/testapp,MatchRoles=:%ALL,NameSpace=USER,DispatchClass=Test.RESTserver,AutheEnabled=64
merge_data-node.cpf
# Noeud de données supplémentaires
# 2 GB 8k / 204 MB gmpheap / 64 nodos max
[config]
globals=0,0,2048,0,0,0
gmheap=204800
MaxServerConn=64
MaxServers=64
# Définition d'un nœud de données et son ajout au cluster. Création d'un point de terminaison REST de test (optionnel)
[Actions]
ConfigShardedCluster:ClusterURL=IRIS://irishost1:1972/IRISCLUSTER,Role=data
# CreateApplication:Name=/rest/testapp,MatchRoles=:%ALL,NameSpace=USER,DispatchClass=Test.RESTserver,AutheEnabled=64
On pourrait avoir plus de nœuds de type data dans le cluster en ajoutant simplement plus de services avec la même définition que l' irisnode2 (en changeant le nom bien sûr)
D'autre part, pour que l'acheminement fonctionne correctement sur notre serveur web et que nous puissions accéder aux portails d'administration de chacune des instances, nous devons modifier le paramètre CSPConfigName dans chacune d'entre elles, et nous le faisons avec les fichiers: configure_first_data-node.sh y configure_data-node.sh; qui sont identiques dans cet exemple, mais que j'ai laissés différents car, à un moment donné, nous pourrions vouloir effectuer des actions différentes au démarrage de chaque instance d'IRIS, selon qu'il s'agit du node1 ou d'un nœud de type data du cluster.
configure_data-node.sh
cat << EOF | iris session iris
do ##class(%SYSTEM.CSP).SetConfig("CSPConfigName","$HOSTNAME")
halt
EOF
Je pense que c'est à peu près tout.
Les nœuds pourraient être définis à l'aide de l'API disponible dans la classe %SYSTEM.Cluster mais la possibilité d'introduire des actions conjointement avec la fonctionnalité CPF Merge simplifie grandement la tâche. Je vous recommande de consulter ce lien, en particulier la section relative à la rubrique the section [Actions].
Pour construire les images et déployer le cluster, nous pourrions construire notre image sharnode:latest et lancer le docker-compose from depuis VS Code. Alternativement, nous pourrions le faire dans notre ligne de commande, à partir du dossier dans lequel nous avons le fichier: docker-compose.yml, en exécutant ces commandes:
docker compose build
docker compose up
Cela prendra un peu de temps la première fois car l'instance marquée comme node1 doit être instanciée avant que tout autre nœud de type data du cluster ne démarre pour la première fois. Mais tout devrait fonctionner et être prêt en une minute ou moins.
Si tout s'est bien passé, vous devriez pouvoir accéder aux portail de gestion de chaque instance avec les URL ci-dessous:
Portail de gestion du nœud de cluster 1 node1: http://localhost:7772/irishost1/csp/sys/UtilHome.cspPortail de gestion du nœud de données data : http://localhost:7772/irishost2/csp/sys/UtilHome.cspAccès à la passerelle WebGateway: http://localhost:7772/csp/bin/Systems/Module.cxw
Et voilà! À partir de là, la limite en termes de volume de stockage de bases de données et de taille de tables est déjà fixée par votre hardware. Vous auriez un cluster de nœuds IRIS prêt à définir des tables en sharding ou des tables fédérées.
J'espère que cela vous sera utile!! À bientôt...
Article
Lorenzo Scalese · Sept 21, 2022
Bonjour la communauté,
Ce post est une introduction de mon application de messagerie pour iris-fhir-client iris-fhir-client .

iris-fhir-client peut se connecter à n'importe quel serveur FHIR public en utilisant Python intégré avec l'aide de la bibliothèque fhirpy.
Obtenez des informations sur les ressources via le terminal et l'application web CSP.
## Affichage et activation des serveurs enregistrés
Connexion au terminal IRIS
docker-compose exec iris iris session iris
L'application enregistrera le service d'accélérateur FHIR d'InterSystems Accelerator Service et le serveur public FHIR de SmartHealthIT par défaut et les deux sont prêts à être utilisés.
Utilisez la commande suivante pour obtenir la liste des serveurs enregistrés
do ##class(dc.FhirClient).ServerList()

Le service InterSystems FHIR Accelerator est actif. Afin de sélectionner le serveur public FHIR de SmartHealthIT, utilisez la fonction SetFhirServer de la classe dc.FhirClient en indiquant l'ID du serveur
do ##class(dc.FhirClient).SetFhirServer(2)
## Serveurs FHIR enregistrés
Pour enregistrer un nouveau serveur, utilisez la fonction RegisterServer() de la classe dc.FhirClient
class(dc.FhirClient).RegsterServer("Nom du serveur", "Point de terminaison", "ApiKey" [facultatif], "EndpointOAuth" [facultatif])
exécutez ##class(dc.FhirClient).RegisterServer("Serveur FHIR INTERSYSTEMS", "http://localhost:52773/csp/healthshare/samples/fhir/r4/","","")

## Obtention de ressources à partir des serveurs FHIR
Pour récupérer toutes les ressources du serveur actuel, utilisez la méthode ListResources() de la classe dc.FhirClient
exécutez ##class(dc.FhirClient).ListResources()

Afin d'afficher le nombre d'enregistrements de n'importe quelle ressource, utilisez la méthode CountResource() en passant la ressource de dc.FhirClient.
La commande ci-dessous permet d'obtenir le compteur de ressources patient par rapport au serveur FHIR actif
Définissez le nombre = ##class(dc.FhirClient).CountResource("Patient")
écrivez le nombre
Pour récupérer toutes les ressources créées avec leur nombre, il suffit de passer 1 à la fonction ListResource()
exécutez ##class(dc.FhirClient).ListResources(1)
##
Pour obtenir les détails de la ressource, utilisez GetResource() en passant la ressource de la classe dc.FhirClient
La commande ci-dessous récupère tous les patients du serveur FHIR actif
exécutez ##class(dc.FhirClient).GetResource("Patient")
##
#### La commande ci-dessous récupère toutes les observations du serveur FHIR actif
exécutez ##class(dc.FhirClient).GetResource("Observation")
##
##
## Obtention des ressources pour un patient particulier à partir des serveurs FHIR
La commande ci-dessous permet de récupérer les détails des observations pour l'identifiant Patinet ID 1 à partir du serveur FHIR actif
exécutez ##class(dc.FhirClient).GetPatientResources("Observation","1")

Affichez des informations du serveur FHIR à partir de l'application Web CSP
Naviguer vers http://localhost:55037/csp/fhirclient/index.cspLa page d'index affiche le nombre de patients, d'observations, de praticiens et de rencontres sur le serveur actif, ainsi que les détails sur les patients et les serveurs enregistrés
### La page d'index affichera la liste des serveurs FHIR avec le serveur actif sélectionné. Sélectionnez un autre serveur dans la liste pour afficher les détails du serveur sélectionné

### Passez la souris sur l'ID du Patient et sélectionnez pour obtenir des détails sur les Ressources Patient

### Cette page affichera le nombre de Ressources Patient ainsi que les détails des Observations des Patients

Si vous avez trouvé cette application utile, merci de voter pour mon application.
Merci!
Article
Sylvain Guilbaud · Mai 19, 2023
[Apache Superset](https://superset.apache.org/) est une plate-forme moderne d'exploration et de visualisation des données. Superset peut remplacer ou augmenter les outils de business intelligence propriétaires pour de nombreuses équipes. Superset s'intègre bien à une variété de sources de données.
Désormais, il est également possible de l'utiliser avec InterSystems IRIS.
Une [démo en ligne est disponible](https://superset.demo.community.intersystems.com/superset/dashboard/world_health/) et elle utilise SQL d'IRIS Cloud comme source de données.
.png)
Apache Superset fournit un certain nombre d'exemples, qui ont été chargés avec succès dans IRIS sans aucun problème, et affichés sur des tableaux de bord d'exemple.
Le support d'IRIS est implémenté avec un paquetage Python nommé [superset-iris](https://pypi.org/project/superset-iris/), qui peut être installé manuellement dans Superset.
Superset utilise SQLAlchemy comme moteur de base de données, tandis que le paquet superset-iris utilise [sqlalchemy-iris](https://pypi.org/project/sqlalchemy-iris/).
Lorsque le paquet est installé dans l'environnement Superset, il devient possible de sélectionner InterSystems IRIS dans la liste des bases de données prises en charge.
.png).png)
Pour se connecter à la base de données IRIS, il faut un URI SQLAlchemy sous la forme suivante: `iris://{login}:{password}@{hostname}:{port}/{namespace}`
La connexion de test doit vérifier la disponibilité du serveur. Cliquez ensuite sur Connecter pour terminer l'ajout de la base de données.
> Dans le même formulaire d'édition de base de données, dans l'onglet avancé Advanced Tab, et dans le bloc de sécurité Security, l'option nommée `Autoriser le téléchargement de fichiers vers la base de données`, qui permettra de télécharger des fichiers CSV et de construire des tableaux avec des données dans IRIS en se basant sur ces derniers.
Le Labo SQL, qui permet d'effectuer des requêtes SQL
.png)
Il permet également de collecter et d'afficher des renseignements sur les schémas et les tableaux existants, de prévisualiser ces tableaux et de proposer la construction d'une simple requête SQL avec toutes les colonnes.
.png)
Pour l'essayer localement, clonez le dépôt
git clone https://github.com/caretdev/superset-iris.git superset-iris
cd superset-iris
Lancez Superset avec Docker-Compose
docker-compose pull
docker-compose up -d
Lancez Superset avec Docker-Compose
Pendant le démarrage, il importe les données d'exemple dans la base de données IRIS, cela prendra un certain temps, pour attendre que ce soit fait, exécutez la commande suivante
docker-compose logs -f superset-init
Lorsque la commande ci-dessus a fini de fonctionner, allez à http://localhost:8088/dashboard/list/. Les panneaux de bord sont disponibles sans autorisation. Pour accéder au Labo SQL, utilisez admin/admin comme login et mot de passe.
Veuillez voter sur [le concours](https://openexchange.intersystems.com/contest/current)
Article
Lorenzo Scalese · Oct 10, 2022
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/.
.png)
.png)
**É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.
.png)
**É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
.png)
**É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
#.png)
Ajoutez le type de ressource Patient et tous les attributs liés à la ressource Patient vont apparaître dans l'IntelliSense.
.png)
**VS Code validera automatiquement la structure et la syntaxe de la ressource.**
.png)
Avec l'aide d'IntelliSense et de la fonction de complétion automatique, nous avons créé et validé notre ressource patient.
.png)
Step 5: Affichez la ressource créée dans le serveur FHIR d'InterSystems en utilisant l'API Rest à partir de postman
.png)
Récupérer la ressource patient créée en utilisant la méthode "Get"
.png)
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.
Article
Lorenzo Scalese · Déc 9, 2022
Une production simple qui permet de charger des paquets de transactions FHIR dans le serveur FHIR® d'InterSystems® via Box et Dropbox.  ; 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.  ; 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 !

Article
Irène Mykhailova · Juin 5, 2023
Salut la Communauté !
Comme vous le savez, le Global Summit a ouvert ses portes hier soir avec une grande soirée ! Cette année il se passe à Hollywood ensoleillé qui se trouve en Floride.
Et il y a beaucoup d'énormes reptiles qui courent partout
Mais votre fidèle équipe de la communauté française n'est pas là uniquement pour admirer la nature, mais pour faire de notre mieux pour attirer plus de membres pour notre communauté.
On a enfin réunis après une journée bien remplie lors d'une fête en soirée (@Lorenzo.Scalese, @Irène.Mykhailova et @Guillaume.Rongier7183)
Et si vous n'avez pas fait attention, sur le signe il y a des dates: 1978 et 2023. Ça signifie, qu'InterSystems a 45 ans cette année ! Bonne aniversaire !
Mais c'est pas tout ! Ce Global Summit et le 30me Summit ! Encore une anniversaire !
Cependant revenons-nous à la communauté. On a notre propre stand au Summit ou on peut se reunir et discuter de choses
MISE À JOUR 19H00
C'était une journée très chargée ! Elle a commencé par les keynotes dédié au healthcare réalisés par @Donald.Woodlock.
Après les keynotes, tout le monde s'est rendu aux ateliers, réunions et formations qu'ils avaient planifiés pour eux-mêmes. Et le choix était stupéfiant !
Sur le stand de la Communauté de Develppeurs il y avait toujurs qulque'un. Les moderateurs d'autres Communautés regionales sont venus. Par exemple (@Irène.Mykhailova, @Lorenzo.Scalese, @Dmitry.Maslennikov, @Francisco.López1549) :
Bien sûr, les sessions du Tech Exchange avaient lieu.
Et @Guillaume.Rongier7183 était à côté en train de discuter avec les participants.
A la fin de cette journée riche en communications intéressantes et utiles, on a eu un dîner avec des démos de projets
et des divertissements
C'est tout pour aujourd'hui. A demain !
Article
Irène Mykhailova · Juin 2, 2022
Étant donné que SELECT ... FOR UPDATE est implémenté dans de nombreux RDBMS en tant que méthode d'acquisition de lock de ligne explicite, vous utilisez probablement cette fonctionnalité dans de nombreux cas.
Cette syntaxe n'entraîne pas d'erreur dans les produits InterSystems, mais elle n'acquiert pas les locks de ligne attendus.
Cet article vous montrera comment obtenir la même fonctionnalité.
DECLARE CURSOR C1 IS
SELECT Name FROM Person WHERE Name LIKE 'A%' FOR UPDATE
OPEN C1
LOOP FETCH C1 INTO name
...afficher le nom...
...sortir de loop lorsque vous avez terminé...
END LOOP
CLOSE C1
L'instruction SQL ci-dessus peut être remplacée par l'instruction SQL suivante.
&SQL(START TRANSACTION ISOLATION LEVEL READ COMMITTED)
&SQL(UPDATE Person SET ID=ID Where Name like 'A%')
&SQL(DECLARE C1 CURSOR FOR SELECT ID,Name into :id,:name FROM Person Where Name like 'A%')
&SQL(OPEN C1)
&SQL(FETCH C1)
While (SQLCODE = 0) {
Write id, ": ", name,! &SQL(FETCH C1)
}
&SQL(CLOSE C1)&SQL(COMMIT)
Remarque : &SQL() est appelé Embedded SQL et est une méthode de description qui peut être utilisée lorsque vous souhaitez incorporer des instructions SQL dans la logique côté serveur. Veuillez vous référer au document pour plus de détails.
Article
Irène Mykhailova · Oct 31, 2022
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](https://docs.intersystems.com/irisforhealthlatest/csp/docbook/DocBook.UI.Page.cls?KEY=HXFHIR_fhir_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 !
Article
Irène Mykhailova · Mai 23
Après avoir déployé un nouveau conteneur basé sur containers.intersystems.com/intersystems/irishealth:2023.1 cette semaine, nous avons soudainement constaté que notre dépôt FHIR affichait une erreur 500. Ce problème est dû à des violations de PROTECT sur le nouvel espace de noms et la nouvelle base de données HSSYSLOCALTEMP utilisés par cette version des composants FHIR d'IRIS for Health. Pour résoudre ce problème, ajoutez « %DB_HSSYSLOCALTEMP » aux applications Web qui gèrent les requêtes FHIR. Vous pouvez créer un script pour cela en exécutant la méthode de classe suivante dans les espaces de noms qui définissent ces applications Web
do ##class(HS.HealthConnect.FHIRServer.Upgrade.MethodsV6).AddLOCALTEMPRoleToCSP()
Dans notre cas, cela n'était pas suffisant. Dans certains de nos codes personnalisés, nous avions besoin d'accéder au jeton porteur JWT envoyé par le client. Nous pouvions le récupérer depuis l'élément AdditionalInfo « USER:OAuthToken », qui n'est plus présent dans la version 2023.6.1.809, comme décrit dans https://docs.intersystems.com/upgrade/results?product=ifh&versionFrom=2023.1.0&versionTo=2023.1.6&categories=Business%20Intelligence,Cloud,Core,Development%20Tools,Driver%20Technologies,Embedded%20Python,External%20Languages,FHIR,Healthcare%20Interoperability,Interoperability,Machine%20Learning,Mirroring,Monitoring,Natural%20Language%20Processing,SQL,Security,Sharding,Web%20Applications&audience=All&changes=121 Nous avons contourné ce problème en ajoutant la logique suivante pour récupérer le jeton depuis le cache de jetons :
$$$ThrowOnError(##class(HS.HC.Util.InfoCache).GetTokenInfo(pInteropRequest.Request.AdditionalInfo.GetAt("USER:TokenId"), .pTokenInfo)) set OAuthToken = pTokenInfo("token_string")
Article
Irène Mykhailova · Avr 10, 2023
Voici mon introduction à une série d'articles expliquant comment créer un système d'apprentissage automatique de bout en bout.
## Un seul problème pour commencer
Notre communauté de développement d'IRIS a plusieurs messages sans balise ou mal balisés. Au fur et à mesure que le nombre de messages augmente, l'organisation de chaque balise et l'expérience d'un membre de la communauté qui parcourt les sujets tendent à diminuer.
## Les premières solutions envisagées
Nous pouvons envisager quelques solutions habituelles pour ce scénario, comme par exemple :
- Prendre un volontaire pour lire tous les messages et corriger les erreurs.
- Payer un entrepreneur pour corriger toutes les erreurs.
- Envoyez un courriel à chaque auteur de message pour qu'il revoie les textes du passé.
## Ma solution

## Et si nous pouvions apprendre à une machine à faire ce travail ?

Nous avons beaucoup d'exemples de dessins animés, d'anime ou de films pour nous rappeler ce qui peut se passer lorsqu'on enseigne à une machine...
## Apprentissage automatique
L'apprentissage automatique est un sujet très vaste et je vais faire de mon mieux pour expliquer ma vision du sujet. Revenons au problème que nous devons encore résoudre : Si l'on examine les solutions habituelles, elles prennent toutes en compte l'interprétation d'un texte. Comment apprendre à une machine à lire un texte, à comprendre la corrélation entre un texte et une balise ? Tout d'abord, nous devons explorer les données et en tirer des conclusions.
## Classification ? Régression ?
Lorsque vous commencez à étudier l'apprentissage automatique, les deux termes ci-dessus sont toujours utilisés. Mais comment savoir ce qu'il faut approfondir ?
-Classification : Un algorithme d'apprentissage automatique de classification prédit des valeurs discrètes.
-Régression : Un algorithme d'apprentissage automatique de régression prédit des valeurs continues.
Si l'on considère notre problème, nous devons prédire des valeurs discrètes (toutes les baises existent).
## C'est une question de données !
Toutes les données relatives aux articles ont été fournies [ici](https://community.intersystems.com/post/posts-and-tags-problem-intersystems-iris-ai-contest).
### Article
```
SELECT
id, Name, Tags, Text
FROM Community.Post
Where
not text is null
order by id
```
|id | Nom | Balises | Texte|
|--- | --- | --- | --- |
|1946| Introduction aux services web | Web Development,Web Services | Cette vidéo est une introduction aux services web. Elle explique ce que sont les services web, leur utilisation et comment les administrer. Les services web sont également connus sous le nom de "SOAP". Cette session comprend des informations sur la sécurité et la politique de sécurité.|
|1951| Les outils pour Caché | Caché | Cette astuce technique (Tech Tip) passe en revue les différents outils disponibles à partir du Caché dans la barre d'état système de Windows. Vous verrez comment accéder à Studio IDE, au terminal, au portail de gestion du système, à SQL, aux globales, à la documentation, à la référence de classe et à l'accès au système à distance.|
|1956| Démarrage avec Caché | Caché | Démarrage avec Caché présentera Caché et son architecture. Nous examinerons également les outils de développement, la documentation et les exemples disponibles.|
### Balises
|ID |Description|
|---|---|
|.NET |NET Framework (prononcé dot net) est un cadre logiciel développé par Microsoft qui fonctionne principalement sur Microsoft Windows. Site officiel. Support .NET dans InterSystems Data Platform.|
|.NET Experience |InterSystems .NET Experience révèle les possibilités d'interopérabilité entre .NET et InterSystems IRIS Data Platform. Pour plus de détails, cliquez ici. Site officiel de .NET|
|IA |L'intelligence artificielle (IA) est la simulation des processus de l'intelligence humaine par des machines, en particulier par des systèmes informatiques. Ces processus comprennent l'apprentissage (l'acquisition d'informations et de règles d'utilisation de ces informations), le raisonnement (l'utilisation de règles pour parvenir à des conclusions approximatives ou définitives) et l'autocorrection. Apprenez-en plus.|
|API |L'interface de programmation d'applications (API) est un ensemble de définitions de sous-programmes, de protocoles et d'outils permettant de créer des logiciels d'application. En termes généraux, il s'agit d'un ensemble de méthodes de communication clairement définies entre divers composants logiciels. Apprenez-en plus.|
Nous savons maintenant à quoi ressemblent les données. Mais il ne suffit pas de connaître la conception des données pour créer un modèle d'apprentissage automatique.
## Qu'est-ce qu'un modèle d'apprentissage automatique ?
Un modèle d'apprentissage automatique est une combinaison d'un algorithme d'apprentissage automatique et de données. Après avoir combiné une technique avec des données
un modèle peut commencer à prédire.
## Exactitude
Si vous pensez que les modèles ML ne font jamais d'erreurs, vous devriez mieux comprendre la précision du modèle. En quelques mots, la précision correspond
aux performances du modèle en matière de prédiction. En général, la précision est exprimée en pourcentage, sous forme de chiffres.
Ainsi, quelqu'un dira : "J'ai créé un modèle dont la précision est de 70 %". Cela signifie que pour 70 % des prédictions, le modèle prédit correctement.
Les 30 % restants seront des prédictions erronées.
## NLP - Traitement du langage naturel
Le NLP est un domaine de l'apprentissage automatique qui travaille sur la capacité d'un ordinateur à comprendre et à analyser le langage humain.
Et oui, notre problème peut être résolu grâce au NLP.
## Utilisation d'algorithmes d'apprentissage automatique
La plupart des algorithmes d'apprentissage automatique ont une chose en commun : ils utilisent en entrée des **NOMBRES**. Oui, je sais... c'est le point
le plus difficile à comprendre pour créer des modèles d'apprentissage automatique.
## Si tous les messages et les balises sont du texte, comment le modèle peut-il fonctionner ?
Une bonne partie du travail dans une solution de ML consiste à transformer les données en quelque chose qui peut être utilisé dans un algorithme.
Ce travail est appelé "ingénierie des fonctionnalités" (Feature Engineering). Dans ce cas, c'est plus compliqué car les données ne sont pas structurées. Mais voici une brève explication*:
J'ai transformé chaque mot du texte en un identifiant unique représenté par un nombre. SKLearn et d'autres librairies python devraient vous aider
de le faire facilement.
## Démonstration
J'ai déployé le modèle formé en tant que démonstration ici :
[http://iris-ml-suite.eastus.cloudapp.azure.com/](http://iris-ml-suite.eastus.cloudapp.azure.com/)
## Quelle est la suite ?
Dans mon prochain article, je montrerai le code et les moyens de faire toute la modélisation. A ne pas manquer !
### Si cet article vous a aidé ou si vous avez aimé son contenu, votez :
Cette application est au concours actuel sur l'échange ouvert, vous pouvez voter ici:
[https://openexchange.intersystems.com/contest/current](https://openexchange.intersystems.com/contest/current) ou dans mon application **iris-ml-suite**
Article
Irène Mykhailova · Mars 28, 2022
Lorsque je décris InterSystems IRIS à des personnes plus orientées vers la technique, je commence toujours par dire qu'il s'agit d'un DBMS (système de gestion de base de données) multi-modèle.
À mon avis, c'est son principal avantage (du côté du DBMS). Et les données ne sont stockées qu'une seule fois. Vous choisissez simplement l'API d'accès que vous voulez utiliser.
* Voulez-vous une sorte de résumé pour vos données ? Utilisez SQL !
* Souhaitez-vous travailler en profondeur avec un seul enregistrement ? Utilisez des objets !
* Voulez-vous accéder ou définir une valeur et vous connaissez la clé ? Utilisez les globales !
À première vue, c'est une belle histoire - courte et concrète, elle fait passer le message, mais lorsque les gens commencent vraiment à travailler avec InterSystems IRIS, les questions apparaissent. Comment les classes, les tables et les globales sont-ils liés ? Que sont-ils les uns pour les autres ? Comment les données sont-elles réellement stockées ?
Dans cet article, je vais essayer de répondre à ces questions et d'expliquer ce qui se passe réellement.
**Première partie. Le biais des modèles.**
Les personnes qui travaillent avec des données ont souvent un biais en faveur du modèle avec lequel elles travaillent.
Les développeurs pensent en objets. Pour eux, les bases de données et les tableaux sont des boîtes avec lesquelles vous interagissez via CRUD (Créer-Lire-Mettre à jour-Supprimer, de préférence via ORM), mais le modèle conceptuel sous-jacent est constitué d'objets (bien sûr, c'est surtout vrai pour les développeurs utilisant des langages orientés objet - donc la plupart d'entre nous).
D'autre part, pour avoir passé beaucoup de temps dans des DBMS relationnels, les DBA considèrent souvent les données comme des tables. Dans ce cas, les objets ne sont que des enveloppes sur les lignes.
Et avec InterSystems IRIS, une classe persistante est aussi un table, qui stocke les données en globale, donc une clarification est nécessaire.
**Deuxième partie. Un exemple.**
Disons que vous avez créé une classe Point :
```objectscript
Class try.Point Extends %Persistent [DDLAllowed]
{
Property X;
Property Y;
}
```
Vous pouvez également créer la même classe avec DDL/SQL :
```
CREATE Table try.Point (
X VARCHAR(50),
Y VARCHAR(50))
```
Après la compilation, notre nouvelle classe aurait généré automatiquement une structure de stockage qui fait correspondre les données qui sont nativement stockées dans les globaux aux colonnes (ou aux propriétés si vous êtes un penseur orienté objet) :
```
Storage Default
{
%%CLASSNAME
X
Y
^try.PointD
PointDefaultData
^try.PointD
^try.PointI
^try.PointS
%Library.CacheStorage
}
```
Qu'est-ce qui se passe ici ?
De bas en haut (les mots en **gras** sont importants, ignorez le reste) :
- Type : le type de stockage généré, dans notre cas le stockage par défaut pour les objets persistants
- StreamLocation - l'endroit où nous stockons les flux de données séquencé
- IndexLocation - la globale pour les indices
- IdLocation - la globale où nous stockons l'ID compteur autoincrémental
- **DefaultData** - l'élément XML de stockage qui fait correspondre la valeur globale aux colonnes/propriétés
- **DataLocation** - la globale dans lequel les données sont stockées
Maintenant notre "DefaultData" est `PointDefaultData` alors regardons de plus près sa structure. Essentiellement, cela dit que le noeud global a cette structure :
- 1 - %%CLASSNAME
- 2 - X
- 3 - Y
On peut donc s'attendre à ce que notre globale ressemble à ceci :
```
^try.PointD(id) = %%CLASSNAME, X, Y
```
Mais si nous imprimons notre globale, il sera vide car nous n'avons pas ajouté de données :
```
zw ^try.PointD
```
Ajoutons un objet :
```
set p = ##class(try.Point).%New()
set p.X = 1
set p.Y = 2
write p.%Save()
```
Et voici notre globale
```
zw ^try.PointD
^try.PointD=1
^try.PointD(1)=$lb("",1,2)
```
Comme vous le voyez, notre structure attendue %%CLASSNAME, X, Y est définie avec `$lb("",1,2)` qui correspond aux propriétés X et Y de notre objet (%%CLASSNAME est une propriété du système, ignorez-la).
Nous pouvons également ajouter une ligne via SQL :
```
INSERT INTO try.Point (X, Y) VALUES (3,4)
```
Maintenant, notre globale ressemble à ceci :
```
zw ^try.PointD
^try.PointD=2
^try.PointD(1)=$lb("",1,2)
^try.PointD(2)=$lb("",3,4)
```
Ainsi, les données que nous ajoutons par le biais d'objets ou de SQL sont stockées dans des globales en fonction des définitions de stockage (remarque : vous pouvez modifier manuellement la définition de stockage en remplaçant X et Y dans PointDefaultData - vérifiez ce qu'il arrive aux nouvelles données !)
Maintenant, que se passe-t-il lorsque nous voulons exécuter une requête SQL ?
```
SELECT * FROM try.Point
```
Elle est traduite en code ObjectScript qui itère sur la globale `^try.PointD` et remplit les colonnes en fonction de la définition du stockage - la partie `PointDefaultData` précisément.
Maintenant pour les modifications. Supprimons toutes les données du table :
```
DELETE FROM try.Point
```
Et voyons notre globale à ce stade :
```
zw ^try.PointD
^try.PointD=2
```
Notez que seul le compteur d'ID est laissé, donc le nouvel objet/ligne aura un ID=3. De même, notre classe et notre table continuent d'exister.
Mais que se passe-t-il quand on lance :
```
DROP TABLE try.Point
```
Il détruirait le table, la classe et supprimerait la globale.
```
zw ^try.PointD
```
Si vous avez suivi cet exemple, j'espère que vous comprenez maintenant mieux comment les globales, les classes et les tables s'intègrent et se complètent. L'utilisation de la bonne API pour le travail à effectuer permet un développement plus rapide, plus agile et moins bogué.
Article
Irène Mykhailova · Oct 7, 2022

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](https://nginx.org/en/) 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 ](https://portal.live.isccloud.io/account/signup)
- [ X] [Créez un déploiement de service InterSystems FHIR® Accelerator](https://portal.live.isccloud.io/deployments/create)

- [ ] [Créez une clé Api](https://portal.live.isccloud.io/deployments/create)

> 🖇 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](https://gitlab.com/isc_cloud/fhiraas-microservice-kubernetes/-/blob/main/k8s/fhiraas_k8s_deployment.yml#L1-6), afin de disposer d'un rayon d'explosion dans lequel jouer pour l'instant.
- [X] [Creez une ConfigMap](https://gitlab.com/isc_cloud/fhiraas-microservice-kubernetes/-/blob/main/k8s/fhiraas_k8s_deployment.yml#L7-29), 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](https://gitlab.com/isc_cloud/fhiraas-microservice-kubernetes/-/blob/main/k8s/fhiraas_k8s_deployment.yml#L24-26)
- [ X] [Créez un déploiement](https://gitlab.com/isc_cloud/fhiraas-microservice-kubernetes/-/blob/main/k8s/fhiraas_k8s_deployment.yml#L30-60), voici les conteneurs eux-mêmes, avec 3 modules pour le groupe de répliques de déploiement.
- [ X] [Créez un Service](https://gitlab.com/isc_cloud/fhiraas-microservice-kubernetes/-/blob/main/k8s/fhiraas_k8s_deployment.yml#L61-75), 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.
Article
Evgeny Shvarov · Juil 20, 2022
Salut la communauté !
@Joan.Pérez a publié une critique selon laquelle il n'est pas très clair quelles applications sont disponibles pour InterSystems Package Manager. Merci Joan ! En effet, cela mérite un article.
Il y a au moins deux façons que je connais pour les présenter :
1. Exécuter la commande find dans zpm :
IRISAPP>zpm
=============================================================================
|| Welcome to the Package Manager Shell (ZPM). ||
|| Enter q/quit to exit the shell. Enter ?/help to view available commands ||
=============================================================================
zpm:IRISAPP>find
registry https://pm.community.intersystems.com:
analytics-okr 1.0.0
analyzethis 1.2.4
aoc-2021-uvg 0.0.2
aoc2021-rcc 0.0.2
appmsw-dbdeploy 1.0.3
appmsw-docbook 1.0.5
appmsw-forbid-old-passwd 1.0.4
....
Ou find -d pour les lister avec des descriptions :
zpm:IRISAPP>find -d
registry https://pm.community.intersystems.com:
analytics-okr 1.0.0
analyzethis 1.2.4 Description: Module that helps to
generate cubes, pivots and
dashboards vs IRIS data
aoc-2021-uvg 0.0.2 Description: Advent of code 2021 in
COS classes
aoc2021-rcc 0.0.2 Description: AoC-2021 full Embedded
Python demo
appmsw-dbdeploy 1.0.3 Description: An example of deploying
solutions with prepared databases,
even without source code.
appmsw-docbook 1.0.5 Description: Importing docbook
...
2. La deuxième façon est de filtrer les OEX sur ZPM:
Partagez vos méthodes pour lister les paquets publics ?
Ceci était lié aux dépôts publics, bien sûr il y a beaucoup de dépôts privés et nous ne savons pas ce qu'ils contiennent. Comment exposez-vous les paquets ?