Des éléments d'expérience dans la technologie InterSystems qui résolvent un problème particulier de manière efficace ou inhabituelle.
Dans InterSystems IRIS, vous pouvez créer des tables liées à l'aide de commandes, au lieu d'utiliser System Explorer > SQL > Wizard > Linked Tables dans le Portail de gestion :
Pour créer une table liée, utilisez la méthode CreateLinkedTable de la classe %SYSTEM.SQL.Schema. Consultez la référence de la classe pour plus de détails.
Pour l'exécuter, procédez comme suit :
Certaines données, telles que les données du journal d'exécution, ne doivent pas être restaurées à leur état antérieur, même en cas de restauration lors d'une transaction. Pour ce faire, placez ces données dans la base de données IRISTEMP, qui ne sera pas restaurée.
Salut tout le monde! Ayant récemment rejoint InterSystems, je me suis rendu compte que, même en ayant la version communautaire de la Community Edition totalement gratuite et géniale, la manière d'y accéder n'était pas très claire. J'ai donc décidé de rédiger un guide présentant toutes les différentes façons d'accéder à la version communautaire de la Community Edition d'InterSystems IRIS:
L'utilisation d'une instance conteneurisée de la Community Edition est l'approche recommandée pour les personnes qui découvrent le développement sur InterSystems IRIS. À mon avis, c'est aussi la plus simple. La Community Edition d'InterSystems IRIS est disponible sur DockerHub; si vous avez un compte SSO InterSystems, vous pouvez également la trouver dans le registre de conteneurscan also find it in the InterSystems Container Registry.
Quel que soit le cas, vous devrez extraire l'image de votre choix à l'aide de l'interface CLI Docker:
docker pull intersystems/iris-community:latest-em
// or
docker pull containers.intersystems.com/intersystems/iris-community:latest-emEnsuite, vous devrez démarrer le conteneur: Afin d'interagir avec IRIS en dehors du conteneur (par exemple, pour utiliser le portail de gestion), vous devrez publier certains ports. La commande suivante exécutera le conteneur IRIS Community Edition avec les ports du superserveur et du serveur web publiés ; notez que vous ne pouvez rien avoir d'autre en cours d'exécution qui dépende des ports 1972 ou 52773!
docker run --name iris -d --publish 1972:1972 --publish 52773:52773 intersystems/iris-community:latest-emVous souhaitez peut-être éviter complètement le problème d'avoir à gérer une installation locale; et si tel est le cas, vous pouvez vous lancer avec un déploiement cloud de la Community Edition d'InterSystems IRIS. Tous les principaux fournisseurs de cloud sont pris en charge. Consultez notre page Cloud Partners page pour plus d'information. Dans cet exemple, nous allons nous concentrer sur le déploiement sur AWS.
Commencez par rechercher la Community Edition d'InterSystems IRIS sur AWS Marketplace:
Vous pouvez cliquer sur "View purchase options" (Afficher les options d'achat) et vous connecter à votre compte pour afficher la page d'abonnement:
En faisant défiler vers le bas, vous pouvez cliquer sur “Subscribe” (s'abonner), remplir l'information requise, puis cliquer sur “Deploy” (déployer) pour déployer la Community Edition d'InterSystems IRIS en tant que nœud cloud! Consultez notre documentation ici déploiement d'InterSystems IRIS dans le cloud pour plus de d'information.
Si vous préférez travailler avec InterSystems IRIS installé directement sur votre machine et que vous ne souhaitez pas utiliser de conteneurs, vous pouvez télécharger un kit d'installation pour votre système à partir du service InterSystems Evaluation Service. Pour télécharger un kit d'installation, vous devez avoir un identifiant SSO InterSystems. Bonne nouvelle: si vous avez un compte sur la Communauté de développeurs, vous en avez déjà un! Sinon, vous pouvez cliquer sur "Créer un nouveau compte" et suivre les étapes indiquées:
Une fois connecté, la page suivante devrait s'afficher. Cliquez sur "Télécharger la version Community Edition" pour commencer le téléchargement du kit d'installation:
Vous serez invité à fournir certaines information concernant la version exacte d'InterSystems IRIS dont vous avez besoin et la plate-forme sur laquelle vous allez l'installer:
Dans la plupart des cas, vous devrez sélectionner « InterSystems IRIS Community » et la version la plus récente disponible pour votre plateforme. Suivez les instructions d'installation fournies dans la documentation spécifique à votre plateforme, et le tour est joué!
Si vous souhaitez générer une erreur personnalisée arbitraire dans un bloc TRY, vous pouvez transmettre une exception avec un throw comme suit. Dans l'exemple suivant, une erreur personnalisée est générée si Stcount est inférieur à 1.
Par défaut, l'ordre des colonnes d'une table est déterminé automatiquement par le système. Pour modifier cet ordre, définissez explicitement l'ordre de chaque propriété à l'aide du mot-clé SqlColumnNumber lors de la définition de la classe.
Exemple :
Property Name As %String [SqlColumnNumber = 2];
Veuillez consulter la documentation ci-dessous.
Si vous souhaitez modifier le nom de la table SQL, spécifiez SqlTableName. Si vous souhaitez modifier le nom de la colonne (nom du champ), spécifiez SqlFieldName.
Bonjour,
Quels sont les avantages et les inconvénients d'avoir plusieurs namespaces par rapport à un seul?
J'aimerais bien savoir les aspects positifs et négatifs des deux cas de figures, par exemple 1 ou 4 espaces de nom pour un total de 20 flux.
Qu'en est t'il niveau sécurité, gestion serveur, gestion du code, autre?
En terme de performances, est-ce que trop d'items sur une seul production ralenti le serveur? Ou trop de namespaces augmente la consommation mémoire pour rien?
Comment évolue la consommation d'un namespace? Il y a un minimum?
Je vous remercie de vos réponses.
Corentin BLONDEAU
Le bon vieux temps
La classe %Library.DynamicObject existe dans IRIS depuis bien avant que IRIS ne devienne IRIS. Si vous l'utilisez depuis l'époque de Cache, vous souhaiterez peut-être vous familiariser avec certaines de ses modifications.
Dans Cache 2018, la méthode %Get n'avait qu'un seul argument. Il s'agissait de la clé permettant de récupérer les données dans le JSON. Ainsi, si votre objet JSON s'appelait myObj, cela ressemblerait à ceci:
{
“mybool”:true,
“mynum”:1234,
“mystring”:”Hello World!”
}L'exploitation de myObj.%Get(“mybool”) renverrait 1, myObj.%Get(“mynum”) renverrait 1234 et myObj.%Get("mystring") renverrait la chaîne "Hello World!"
La définition de ces paramètres, en revanche, nécessitait un peu plus de travail. Par exemple, l'attribution d'une propriété JSON à 0 pouvait signifier le nombre 0, une valeur booléenne signifiant faux ou une chaîne littérale "0". C'est pourquoi la méthode %Set avait toujours un troisième argument facultatif. Pour créer l'objet JSON mentionné ci-dessus, nous pouvions utiliser le code suivant:
set myObj = ##class(%Library.DynamicObject).%New()
do myObj.%Set(“mybool”,1,”boolean”)
do myObj.%Set(“mynum”,1234,”number”)
do myObj.%Set(“mystring”,”Hello World!”,”string”)Cependant, dans ce cas, nous pourrions également omettre le troisième argument des deux derniers. Ainsi, 1234 serait reconnu comme un nombre, car il n'est pas entre guillemets, tandis que "Hello World!" serait identifié comme une chaîne, car il est entre guillemets. Si nous voulions ajouter la valeur 1234 à l'objet en tant que chaîne, nous pourrions changer la chaîne en nombre. Nous pourrions également spécifier le type "null". Dans ce cas, la valeur doit être "". En pratique, cependant, nous ajoutons souvent ces valeurs à partir de variables dans notre code ObjectScript. Pour cette raison, il peut être préférable de spécifier cet argument, juste au cas où la variable serait une chaîne ou un nombre, afin de garantir que notre JSON arrive à destination correctement encodé.
Comment j'ai appris à ne plus m'inquiéter à propos de <MAXSTRING> et aimer JSON
Comme l'a dit un jour le sage Billy Joel, ""Le bon vieux temps n'était pas toujours bon, demain n'est pas aussi mauvais qu'il n'y paraît." La liste des types pour %Set s'est allongée, et la méthode %Get a acquis deux nouveaux arguments. Ce qui est crucial, c'est qu'elles prennent toutes deux en charge le type "stream". Si vous avez déjà traité de grandes quantités de données JSON, vous avez probablement déjà rencontré une erreur
try{
Set mydata = myObj.%Get(“mydata”,”N/A”)
}
catch ex{
if ex.Name = “<MAXSTRING>”{
set mydata = myObj.%Get(“mydata”,,”stream”)
}
}Il tentera de définir mydata à la valeur située à l'intérieur de "mydata" dans l'objet JSON. Si cet élément n'existe pas, il renverra "N/A" à la place. Si cet élément est trop long pour une chaîne, le système lèvera une exception vers le bloc catch. Nous devons vérifier le nom de cette exception, car si une exception différente s'est produite, il ne serait pas logique d'essayer d'obtenir les données sous forme de flux. Vous pouvez en savoir plus sur la gestion des exceptions ici. Si la valeur est
Si vous suivez l'approche décrite ci-dessus, vous ne saurez pas si mydata dans le code est une chaîne ou un flux. Cela signifie que vous devrez suivre le code similaire à celui ci-dessous:
if$ISOBJECT(mydata){
//Traitement des flux ici
}
else{
//Traitement des chaînes ici
}Vous pouvez également utiliser l'option stream chaque fois afin de vous assurer que vous avez toujours un flux à votre disposition. Cependant, cela entraînerait une utilisation inutile des ressources et alourdirait votre code.
Une autre option consiste à ajouter un flux à un objet dynamique à l'aide de %Set. Consultez l'exemple suivant:
set mystream = ##class(%Stream.FileBinary).%New()
do mystream.LinkToFile(“/path/to/your/file”)
do myObj.%Set(“mydata”,mystream,”stream”)Les données de votre fichier seront désormais enregistrées dans le champ mydata de votre objet dynamique.
%Set et %Get encodent et décodent également les chaînes à l'aide de l'encodage Base64.
Gardez toujours à l'esprit que l'encodage Base64 est un encodage et non un cryptage ! Il n'y a pas de clés secrètes ni de mots de passe pour décoder votre message, et il est facilement réversible. Par conséquent, vous devez toujours utiliser un protocole crypté, tel que TLS ou HTTPS, pour la transmission ! Base64 est utilisé pour transmettre des caractères non ASCII de manière à ce que les systèmes ASCII puissent les recevoir et les transmettre.
Maintenant que cette remarque importante est faite, nous pouvons enfin voir comment cela fonctionne. Si nous apportons une petite modification à l'exemple de code précédent, le contenu du flux de fichiers sera encodé en Base64.
set mystream = ##class(%Stream.FileBinary).%New()
do mystream.LinkToFile(“/path/to/your/file”)
do myObj.%Set(“mydata”,mystream,”stream>base64”)D'autre part, si les données du fichier étaient déjà encodées en Base64 et que nous voulions les convertir en données décodées, il suffirait de changer un seul caractère.
set mystream = ##class(%Stream.FileBinary).%New()
do mystream.LinkToFile(“/path/to/your/file”)
do myObj.%Set(“mydata”,mystream,”stream<base64”)Les signes " supérieur à" ou "inférieur à" indiquent toujours la direction dans laquelle la conversion a lieu. Si nous convertissons un flux non codé en une chaîne Base64, le signe pointera vers Base64. Si nous convertissons un flux codé en Base64 en un flux non codé, le signe pointera de Base64 vers le flux. La même fonctionnalité existe pour les chaînes lorsque string>base64 et string
set something = myObj.%Get(“something”,”NA”,”string>base64”)Si l'élément "quelque chose" existe, il sera renvoyé sous sa forme encodée en Base64. Cependant, s'il n'existe pas, "NA" sera renvoyé sans être encodé.
Il existe une restriction concernant l'option d'encodage Base64. Seuls les caractères dont le code est compris entre 0 et 255 peuvent être encodés en Base64. Les codes de caractères supérieurs à 255 entraîneront une exception <WIDE CHAR>. FPar exemple, la ligne suivante provoquera une telle exception:
set mychar = $C(256)
do myobj.%Set(“mychar”,mychar,”string>base64”)Alors, j'ai entendu dire que vous aimiez JSON . . .
Parfois, il y a du JSON à l'intérieur de votre JSON. La manière par défaut de gérer cette situation est généralement celle que vous choisiriez. Cependant, une autre option a été ajoutée à l'argument de type pour traiter un cas d'utilisation différent. Il s'agit du type "json". Regardez l'objet JSON suivant:
{
“mystring”:”Hello World!”,
“mynumber”:1234,
“myjson”:{
“subitem1”:”Hello Mars!”,
“subitem2”:”Hello Stars!”
}
}En règle générale, lorsque vous rencontrez ce problème, vous devez utiliser la méthode %Get avec la clé « myjson » pour obtenir un objet dynamique. Voici un exemple:
set myjson = myobj.%Get(“myjson”)
write myjson.%Get(“subitem1”)La ligne ci-dessus écrirait "Hello Mars!". C'est le cas le plus courant dans cette situation. Cependant, dans certains cas, vous préférerez peut-être obtenir le JSON réel contenu dans cet élément sous forme de chaîne. Dans ce cas, vous pouvez procéder comme suit:
set myjson = myobj.%Get(“myjson”,,”json”)
write myjsonLa chaîne JSON sera écrite exactement telle qu'elle est:
{“subitem1”:”Hello Mars!”,”subitem2”:”Hello Stars!”}Cela peut s'avérer utile dans les cas où nous voulons transmettre le JSON tel quel à un autre processus. Notez que, contrairement à tous les autres types nouveaux, celui-ci n'est pris en charge que pour la méthode %Get, et non pour la méthode %Set.
Hourra, hourra, les massives!
Jusqu'à présent, nous avons discuté de ces nouveaux objets dans le contexte de la classe %Library.DynamicObject, mais ils sont également pris en charge pour la classe %Library.DynamicArray. Dans cette classe, %Set et %Get prennent en charge les mêmes arguments de type que dans la classe %Library.DynamicObject. La classe de tableaux dynamiques dispose toutefois d'une méthode %Push supplémentaire. Elle prend en charge les mêmes types que %Set, à l'exception du type JSON.
Sans plus attendre, c'est probablement le bon moment pour revoir vos anciens codes et implémenter ces changements à votre avantage!
Les variables globales temporaires stockées dans les bases de données IRISTEMP/CACHETEMP sont utilisées lorsqu'un processus n'a pas besoin de stocker des données indéfiniment, mais requiert les performances élevées des variables globales. Les bases de données IRISTEMP/CACHETEMP ne sont pas journalisées ; leur utilisation ne crée donc pas de fichiers journaux.
Le système utilise les bases de données IRISTEMP/CACHETEMP pour le stockage temporaire et les utilisateurs peuvent y accéder à cette fin.
Depuis qu'InterSystems a récemment annoncé l'arrêt du support d'InterSystems Studio à partir de la version 2023.2 au profit du développement exclusif d'extensions pour l'IDE Visual Studio Code (VSC), estimant que ce dernier offre une expérience supérieure par rapport à Studio, beaucoup d'entre nous, développeurs, avons changé ou commencé à utiliser VSC. Beaucoup se sont peut-être demandé comment ouvrir le Terminal pour effectuer des opérations, car VSC n'a pas de panneau de sortie comme Studio, ni de fonctionnalité intégrée pour ouvrir le terminal IRIS, sauf en téléchargeant les plugins développés par InterSystems.
Je me suis lancé un défi : trouver un moyen de faire en sorte qu'une variable se surveille elle-même pour une certaine valeur et fasse quelque chose lorsqu'elle atteint cette valeur sans avoir à la vérifier à chaque fois que quelque chose la touche. En gros, un moyen de dire "à un moment donné pendant l'exécution de ce code, si x = 0 (ou quelle que soit la condition) faire ceci". La classe avec laquelle j'ai fini par surveiller un %Status :
Lors du dernier concours InterSystems "Bringing Ideas to Reality", j'ai parcouru le portail d'idées à la recherche de problèmes d'interface utilisateur à traiter.
<iframe allowfullscreen="" frameborder="0" height="360" src="https://www.youtube.com/embed/zw51X1JQhQ0" width="640"></iframe>
J'ai implémenté les idées suivantes dans l'extension de navigateur IRIS Whiz browser extension, so if you use the management portal to help with your day-to-day integration management this extension could be for you!
Iris a désormais une liste déroulante de rafraîchissement automatique pour la page des files d'attente (Queues). Cette option permet de rafraîchir la file d'attente à l'intervalle sélectionné. Cette fonctionnalité ne s'applique pas à Ensemble, qui en dispose déjà.
C'est utile si vous avez un concours de clics à venir et que vous avez besoin du repos de votre doigt de clic.
Implémenté à partir de l'idée: https://ideas.intersystems.com/ideas/DPI-I-487
Dans la page de la visionneuse de messages Message Viewer, vous pouvez cliquer sur le bouton Iris Whiz Export pour télécharger une copie CSV des données contenues actuellement dans votre table de recherche.
Utile si vous voulez faire une analyse rapide de vos données sans utiliser la nouvelle page Chart.JS que j'ai mis une éternité à créer (voir ici en action!).
Implémenté à partir de l'idée: https://ideas.intersystems.com/ideas/DPI-I-566
Ajout d'options de tri pour l'onglet "file d'attente" de la page de production. Le tri par défaut est le nombre d'erreurs. Cliquez sur l'en-tête d'un table pour passer de l'ordre de tri asc à l'ordre de tri desc. Utilisez la barre de recherche pour trouver rapidement des éléments.
Utile si vous ne voulez pas faire défiler sur l'écran pour accéder à la plus grande file d'attente.
Implémenté à partir de l'idée: https://ideas.intersystems.com/ideas/DPI-I-628
Permet de classer par ordre alphabétique la liste déroulante des catégories dans la page de production, quel que soit la casse. Sans cela, l'ordre est dépendant de la casse.
Utile si vous voulez trouver des choses dans la liste des catégories, sans avoir à tout recatégoriser dans la même casse pour y parvenir.
Implémenté à partir de l'idée: https://ideas.intersystems.com/ideas/DPI-I-625
Bonus!
Il existe également un taux de rafraîchissement dans l'onglet de la visionneuse de messages dans la page de production. Cela rafraîchira également votre onglet de file d'attente si vous sélectionnez un intervalle et naviguez vers l'onglet de la file d'attente.
Si l'une de ces idées vous plaît, téléchargez l'extension de navigateur et communiquez moi vos commentaires. Vous trouverez une vidéo d'installation sur la liste d'OpenExchange que je vous recommande de regarder car vous devrez en réaliser une partie pour que la plupart des fonctionnalités fonctionnent!
La possibilité de renvoyer facilement des messages a toujours été une caractéristique importante de nos capacités d'interopérabilité.
Avec la sortie de la version 2024.3, nous avons rendu cela encore plus facile !
Cet article a pour objectif de fournir au lecteur les informations suivantes:
Schéma de l'article:
Flux de travail de l'article:
Cette session de formation vise à fournir aux participants les compétences suivantes:
Pour installer l'environnement de formation, vous devez avoir installé Docker et Docker Compose sur votre machine.
Vous pouvez installer Docker et Docker Compose en suivant les instructions sur le site Docker website.
Une fois Docker et Docker Compose installés, vous pouvez cloner ce dépôt et exécuter la commande suivante:
docker-compose up -d
Cette commande démarre le conteneur "IRIS for Health" et le conteneur "Web Gateway" pour exposer le serveur FHIR via HTTPS.
Une fois les conteneurs démarrés, vous pouvez accéder au serveur FHIR à l'URL suivante:
https://localhost:4443/fhir/r5/
Vous pouvez accéder au portail de gestion InterSystems IRIS à l'adresse suivante:
http://localhost:8089/csp/sys/UtilHome.csp
Le nom d'utilisateur et le mot de passe par défaut sont "SuperUser" et "SYS" respectivement.
Pour configurer le serveur d'autorisation OAuth2, il faut se connecter au portail de gestion InterSystems IRIS et naviguer jusqu'à l'administration du système: System Administration > Security > OAuth 2.0 > Servers.
Ensuite, nous remplirons le formulaire pour créer un nouveau serveur d'autorisation OAuth2.
Nous commençons d'abord par l'onglet Généralités.
Les paramètres sont les suivants:
Ensuite, nous passons à l'onglet Périmètre.
Nous allons créer 3 périmètres:
Ensuite, nous passons à l'onglet JWT.
Ici, nous sélectionnons simplement l'algorithme à utiliser pour le JWT..
Nous utiliserons l'algorithme RS256.
Si nécessaire, nous pouvons sélectionner le cryptage pour le JWT. Nous n'utiliserons pas de cryptage pour cette session de formation.
Ensuite, nous passons à l'onglet Personnalisation.
Voici toutes les classes de personnalisation pour le serveur d'autorisation OAuth2.
Nous changeons les classes suivantes:
Nous pouvons maintenant enregistrer le serveur d'autorisation OAuth2.
Félicitations, nous avons maintenant configuré le serveur d'autorisation OAuth2. 🥳
Pour configurer le Client, il faut se connecter au portail de gestion InterSystems IRIS et naviguer jusqu'à l'administration du système: System Administration > Security > OAuth 2.0 > Client.
Pour créer un nouveau client, il faut d'abord enregistrer le serveur d'autorisation OAuth2.
Sur la page client, cliquez sur le bouton de création d'une description de serveur Create Server Description.
Dans le formulaire Description du serveur, nous devons remplir les paramètres suivants:
Cliquez sur le bouton Discover and Save (Découvrir et enregistrer).
Félicitations, nous avons maintenant enregistré le serveur d'autorisation OAuth2.
Ensuite, nous pouvons créer un nouveau client.
Sur la page client, nous avons un nouveau bouton Client Configuration (Configuration Client).
Cliquez sur le bouton de lien Client Configuration vers la description du serveur.
Nous pouvons maintenant créer un nouveau client..
Nous commençons d'abord par l'onglet Généralités.
Les paramètres sont les suivants:
Maintenant, nous pouvons cliquer sur le bouton Dynamic Registration (Enregistrement dynamique)..
Félicitations, nous avons maintenant créé le client. 🥳
Si nous allons dans l'onglet Client Credentials (Informations d'identification du client), nous pouvons voir les informations d'identification du client.
Notez que les informations d'identification du client sont Client ID et Client Secret (l'Identifiant du client et le Secret du client).
⚠️ AVERTISSEMENT ⚠️ : Assurez-vous d'être sur l'espace de noms FHIRSERVER.
Pour configurer le serveur FHIR, il faut se connecter au portail de gestion InterSystems IRIS et naviguer: Health > FHIR Configuration > Servers.
Ensuite, nous allons créer un nouveau serveur FHIR.
Cliquez sur le bouton Server Configuration (Configuration du Serveur).
Dans le formulaire Configuration du serveur, nous devons remplir les paramètres suivants:
FHIR.Python.InteractionsStrategy.Cliquer sur le bouton Add.
Cela peut prendre quelques minutes. 🕒 Allons prendre un café. ☕️
Félicitations, nous avons maintenant créé le serveur FHIR. 🥳
Sélectionnez le serveur FHIR et descendez jusqu'au bouton Edit (modifier).
Dans le formulaire Serveur FHIR , nous devons remplir les paramètres suivants:
Cliquez sur le bouton Save (sauvegarder).
Félicitations, nous avons maintenant lié le serveur FHIR au serveur d'autorisation OAuth2. 🥳
Pour tester le serveur FHIR, vous pouvez utiliser la commande suivante:
GET https://localhost:4443/fhir/r5/Patient
Sans l'en-tête Authorization, vous obtiendrez une réponse 401 Unauthorized.
Pour authentifier la demande, vous devez ajouter l'en-tête Authorization avec le jeton Bearer.
Pour ce faire, demandons un jeton au serveur d'autorisation OAuth2.
POST https://localhost:4443/oauth2/token
Content-Type: application/x-www-form-urlencoded
Authorization: Basic <client_id>:<client_secret>
grant_type=client_credentials&scope=user/Patient.read&aud=https://localhost:4443/fhir/r5
Vous obtiendrez une réponse 200 OK avec le jeton d'accès access_token et le type de jeton token_type.
Maintenant, vous pouvez utiliser jeton d'accès access_token pour authentifier la demande auprès du serveur FHIR.
GET https://localhost:4443/fhir/r5/Patient
Authorization: Bearer <access_token>
Accept: application/fhir+json
Félicitations, vous avez maintenant authentifié la demande sur le serveur FHIR. 🥳
Eh bien, nous aborderont maintenant un grand sujet.
Le but de ce sujet sera de mettre en place les capacités d'interopérabilité d'IRIS for Health entre le serveur FHIR et l'application cliente.
Ci-dessous, une vue macro de l'architecture:
Et voici le flux de travail:
Ce que nous remarquons ici, c'est que l'EAI (capacités d'interopérabilité d'IRIS for Health) servira de chemin d'accès pour les demandes entrantes vers le serveur FHIR.
Il filtrera la réponse du serveur FHIR en fonction des champs d'application et enverra la réponse filtrée à l'application cliente.
Avant d'aller plus loin, permettez-moi de vous présenter rapidement les capacités d'interopérabilité d'IRIS for Health.
Il s'agit du cadre IRIS Framework.
L'objectif de ce cadre est de fournir un moyen de relier différents systèmes entre eux.
Nous avons 4 composants principaux:
Pour cette session de formation, nous utiliserons les composants suivants:
Business Service pour recevoir la demande de l'application cliente.Business Process pour filtrer la réponse du serveur FHIR en fonction des péramètres.Business Operation pour envoyer les messages au serveur FHIR.Pour cette session de formation, nous utiliserons une production d'interopérabilité pré-construite.
Nous nous concentrerons uniquement sur le processus métier Business Process permettant de filtrer la réponse du serveur FHIR en fonction des périmètres.
Pour cette partie, nous utiliserons l'outil IoP. IoP signifie l'Interopérabilité sur Python..
Vous pouvez installer l'outil IoP en suivant les instructions du référentiel de l'IoP
L'outil IoP est pré-installé dans l'environnement de formation.
Connectez-vous au conteneur en cours d'exécution:
docker exec -it formation-fhir-python-iris-1 bash
Et exécutez la commande suivante:
iop --init
Ainsi l'IoP sera installée sur le conteneur IRIS for Health.
Toujours dans le conteneur, exécutez la commande suivante:
iop --migrate /irisdev/app/src/python/EAI/settings.py
Ainsi, la production d'interopérabilité sera créée.
Vous pouvez maintenant accéder à la production d'interopérabilité à l'adresse URL suivante:
http://localhost:8089/csp/healthshare/eai/EnsPortal.ProductionConfig.zen?$NAMESPACE=EAI&$NAMESPACE=EAI&
Vous pouvez maintenant lancer la production.
Félicitations, vous avez créé la production d'interopérabilité. 🥳
Obtenez un jeton du serveur d'autorisation OAuth2.
POST https://localhost:4443/oauth2/token
Content-Type: application/x-www-form-urlencoded
Authorization : Basic <client_id>:<client_secret>
grant_type=client_credentials&scope=user/Patient.read&aud=https://webgateway/fhir/r5
⚠️ AVERTISSEMENT ⚠️ : we change the aud parameter to the URL of the Web Gateway to expose the FHIR server over HTTPS.
Faites passer un patient par la production d'interopérabilité.
GET https://localhost:4443/fhir/Patient
Authorization : Bearer <Token>
Accept: application/fhir+json
Vous pouvez voir la trace de la requête dans la production d'interopérabilité.
http://localhost:8089/csp/healthshare/eai/EnsPortal.MessageViewer.zen?SOURCEORTARGET=Python.EAI.bp.MyBusinessProcess
Tout le code pour le processus métier Business Process se trouve dans le fichier suivant : https://github.com/grongierisc/formation-fhir-python/blob/main/src/python/EAI/bp.py
Pour cette session de formation, nous adopterons une approche de développement piloté par les tests, TTD (Test Driven Development)..
Tous les tests pour le processus métier Business Process se trouve dans le fichier suivant : https://github.com/grongierisc/formation-fhir-python/blob/main/src/python/tests/EAI/test_bp.py
Pour préparer votre environnement de développement, il faut créer un environnement virtuel.
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
Pour exécuter les tests, vous pouvez utiliser la commande suivante:
pytest
Les tests échouent.
Nous avons 4 fonctions à mettre en œuvre:
check_tokenon_fhir_requestfilter_patient_resourcefilter_resourcesVous pouvez mettre en œuvre le code dans https://github.com/grongierisc/formation-fhir-python/blob/main/src/python/EAI/bp.py file.
Cette fonction vérifie si le jeton est valide et si le champ d'application contient le périmètre VIP.
Si le jeton est valide et que le périmètre contient le périmètre VIP, la fonction renvoie True (vrai), sinon elle renvoie False (faux).
Nous utiliserons la bibliothèque jwt pour décoder le jeton.
def check_token(self, token:str) -> bool:
# décoder le jeton
try:
decoded_token= jwt.decode(token, options={"verify_signature": False})
except jwt.exceptions.DecodeError:
return False
# vérifier si le jeton est valide
if 'VIP' in decoded_token['scope']:
return True
else:
return False
Cette fonction filtrera la ressource patient.
Cela supprimera les champ name, address, telecom and birthdate (nom, adresse, télécom et date de naissance) de la ressource patient..
La fonction renverra la ressource patient filtrée sous forme de chaîne.
Nous utiliserons la bibliothèque fhir.resources pour analyser la ressource patient.
Notez la signature de la fonction.
La fonction prend une chaîne en entrée et renvoie une chaîne comme le résultat.
Nous devons donc analyser la chaîne d'entrée en un objet fhir.resources.patient.Patient, puis analyser l'objet fhir.resources.patient.Patient en une chaîne.
def filter_patient_resource(self, patient_str:str) -> str:
# filtrer le patient
p = patient.Patient(**json.loads(patient_str))
# supprimer le nom
p.name = []
# supprimer l'adresse
p.address = []
# supprimer le télécom
p.telecom = []
# supprimer la date de naissance
p.birthDate = None
return p.json()
Cette fonction filtrera les ressources.
Nous devons vérifier le type de ressource et filtrer la ressource en fonction du type de ressource.
Si le type de ressource est Bundle (Paquet), nous devons filtrer toutes les entrées du paquet qui sont de type Patient.
Si le type de ressource est Patient, nous devons filtrer la resource de type patient.
La fonction renverra la ressource filtrée sous forme de chaîne.
Nous utiliserons la bibliothèque fhir.resources pour analiser la ressource.
def filter_resources(self, resource_str:str) -> str:
# analyser le payload
payload_dict = json.loads(resource_str)
# quel est le type de ressource?
resource_type = payload_dict['resourceType'] if 'resourceType' in payload_dict else 'None'
self.log_info('Resource type: ' + resource_type)
# c'est un paquet?
if resource_type == 'Bundle':
obj = bundle.Bundle(**payload_dict)
# filtrer le paquet
for entry in obj.entry:
if entry.resource.resource_type == 'Patient':
self.log_info('Filtering a patient')
entry.resource = patient.Patient(**json.loads(self.filter_patient_resource(entry.resource.json())))
elif resource_type == 'Patient':
# filtrer le patient
obj = patient.Patient(**json.loads(self.filter_patient_resource(resource_str)))
else:
return resource_str
return obj.json()
Cette fonction sera le point d'entrée du processus métier Business Process.
Elle recevra la demande du service métier Business Service, vérifiera le jeton, filtrera la réponse du serveur FHIR en fonction des champs d'application et enverra la réponse filtrée au service métier Business Service.
La fonction renverra la réponse du serveur FHIR.
Nous utiliserons la bibliothèque iris pour envoyer la requête au serveur FHIR.
Le message sera un objet iris.HS.FHIRServer.Interop.Request.
Cet objet contient la requête au serveur FHIR.
Il consiste des composant suivants: Method, URL, Headers et Payload.
Pour vérifier le jeton, nous utiliserons la fonction check_token et pour obtenir un jeton, il faut utiliser l'en-tête USER:OAuthToken.
Pour filtrer la reponse, nous utiliserons la fonction filter_resources et pour lire la réponse du serveur FHIR, nous utiliserons QuickStream.
def on_fhir_request(self, request:'iris.HS.FHIRServer.Interop.Request'):
# Faire quelque chose avec la requête
self.log_info('Received a FHIR request')
# La passer à la cible
rsp = self.send_request_sync(self.target, request)
# Essayer d'obtenir le jeton de la requête
token = request.Request.AdditionalInfo.GetAt("USER:OAuthToken") or ""
# Faire quelque chose avec la réponse
if self.check_token(token):
self.log_info('Filtering the response')
# Filtrer la réponse
payload_str = self.quick_stream_to_string(rsp.QuickStreamId)
# Si le payload est vide, renvoyer la réponse
if payload_str == '':
return rsp
filtered_payload_string = self.filter_resources(payload_str)
if filtered_payload_string == '':
return rsp
# écrire la chaîne json dans un flux rapide
quick_stream = self.string_to_quick_stream(filtered_payload_string)
# renvoyer la réponse
rsp.QuickStreamId = quick_stream._Id()
return rsp
Pour exécuter les tests, vous pouvez utiliser la commande suivante:
pytest
Les tests passent. 🥳
Vous pouvez maintenant tester le processus métier Business Process avec la production d'interopérabilité.
Dernière partie de la session de formation. 🏁
Nous allons créer une opération personnalisée sur le serveur FHIR.
L'opération personnalisée sera opération de fusion de patients Patient et le résultat sera la différence entre les deux patients.
exemple:
POST https://localhost:4443/fhir/r5/Patient/1/$merge
Authorization : Bearer <Token>
Accept: application/fhir+json
Content-Type: application/fhir+json
{
"resourceType": "Patient",
"id": "2",
"meta": {
"versionId": "2"
}
}
La réponse sera la différence entre les 2 patients.
{
"values_changed": {
"root['address'][0]['city']": {
"new_value": "fdsfd",
"old_value": "Lynnfield"
},
"root['meta']['lastUpdated']": {
"new_value": "2024-02-24T09:11:00Z",
"old_value": "2024-02-28T13:50:27Z"
},
"root['meta']['versionId']": {
"new_value": "1",
"old_value": "2"
}
}
}
Avant de poursuivre, permettez-moi de présenter rapidement l'opération personnalisée sur le serveur FHIR..
L'opération de personnalisation se décline en trois types:
Pour cette session de formation, pour la création de l'opération personnalisée nous utiliserons l'Instance Operation.
Une opération personnalisée doit hériter de la classe OperationHandler à partir du module FhirInteraction.
Voici la signature de la classe OperationHandler:
class OperationHandler(object):
@abc.abstractmethod
def add_supported_operations(self,map:dict) -> dict:
"""
@API Enumerate the name and url of each Operation supported by this class
@Output map : A map of operation names to their corresponding URL.
Example:
return map.put("restart","http://hl7.org/fhir/OperationDefinition/System-restart")
"""
@abc.abstractmethod
def process_operation(
self,
operation_name:str,
operation_scope:str,
body:dict,
fhir_service:'iris.HS.FHIRServer.API.Service',
fhir_request:'iris.HS.FHIRServer.API.Data.Request',
fhir_response:'iris.HS.FHIRServer.API.Data.Response'
) -> 'iris.HS.FHIRServer.API.Data.Response':
"""
@API Process an Operation request.
@Input operation_name : The name of the Operation to process.
@Input operation_scope : The scope of the Operation to process.
@Input fhir_service : The FHIR Service object.
@Input fhir_request : The FHIR Request object.
@Input fhir_response : The FHIR Response object.
@Output : The FHIR Response object.
"""
Comme nous l'avons fait dans la partie précédente, nous utiliserons une approche TTD (Développement piloté par les tests).
Tous les tests pour le Processus d'Affaires sont dans ce fichier : https://github.com/grongierisc/formation-fhir-python/blob/main/src/python/tests/FhirInteraction/test_custom.py
Cette fonction ajoute l'opération de fusion de patients Patient aux opérations prises en charge.
La fonction retournera un dictionnaire avec le nom de l'opération et l'adresse URL de l'opération. Sachez que le dictionnaire d'entrée peut être vide.
Le résultat attendu est le suivant:
{
"resource":
{
"Patient":
[
{
"name": "merge",
"definition": "http://hl7.org/fhir/OperationDefinition/Patient-merge"
}
]
}
}
This json document will be added to the CapabilityStatement of the FHIR server.
def add_supported_operations(self,map:dict) -> dict:
"""
@API Enumerate the name and url of each Operation supported by this class
@Output map : A map of operation names to their corresponding URL.
Example:
return map.put("restart","http://hl7.org/fhir/OperationDefinition/System-restart")
"""
# verify the map has attribute resource
if not 'resource' in map:
map['resource'] = {}
# verify the map has attribute patient in the resource
if not 'Patient' in map['resource']:
map['resource']['Patient'] = []
# add the operation to the map
map['resource']['Patient'].append({"name": "merge" , "definition": "http://hl7.org/fhir/OperationDefinition/Patient-merge"})
return map
Cette fonction traitera l'opération de fusion Patient.
La fonction renverra la différence entre les 2 patients.
Nous allons utiliser la bibliothèque deepdiff pour obtenir la différence entre les 2 patients.
Les paramètres d'entrée sont les suivants:
operation_name: Le nom de l'opération à traiter.operation_scope: Le périmètre de l'opération à traiter.body: Le corps de l'operation.fhir_service: L'objet FHIR Service.
resource_type: Le type de la ressource à lire.resource_id: L'identifiant de la ressource à lire.%DynamicObjectfhir_request: L'objet de requête FHIR Request..
%DynamicObjectfhir_response: L'objet de réponse FHIR Response.
%DynamicObject.%DynamicObject est une classe permettant de manipuler des objets JSON.
C'est la même chose qu'un dictionnaire Python mais pour ObjectScript.
Téléchargement d'objet JSON:
json_str = fhir_request.Json._ToJSON()
json_obj = json.loads(json_str)
Définition d'objet JSON:
json_str = json.dumps(json_obj)
fhir_response.Json._FromJSON(json_str)
Assurez-vous que la fonction de traitement process_operation est appelée pour vérifier si operation_name est merge, operation_scope est Instance et RequestMethod est POST.
def process_operation(
self,
operation_name:str,
operation_scope:str,
body:dict,
fhir_service:'iris.HS.FHIRServer.API.Service',
fhir_request:'iris.HS.FHIRServer.API.Data.Request',
fhir_response:'iris.HS.FHIRServer.API.Data.Response'
) -> 'iris.HS.FHIRServer.API.Data.Response':
"""
@API Process an Operation request.
@Input operation_name : The name of the Operation to process.
@Input operation_scope : The scope of the Operation to process.
@Input fhir_service : The FHIR Service object.
@Input fhir_request : The FHIR Request object.
@Input fhir_response : The FHIR Response object.
@Output : The FHIR Response object.
"""
if operation_name == "merge" and operation_scope == "Instance" and fhir_request.RequestMethod == "POST":
# obtenir la ressource primaire
primary_resource = json.loads(fhir_service.interactions.Read(fhir_request.Type, fhir_request.Id)._ToJSON())
# obtenir la ressource secondaire
secondary_resource = json.loads(fhir_request.Json._ToJSON())
# retrouver la différence entre les deux ressources
# utiliser deepdiff pour obtenir la différence entre les deux ressources
diff = DeepDiff(primary_resource, secondary_resource, ignore_order=True).to_json()
# créer un nouvel %DynamicObject pour stocker le résultat
result = iris.cls('%DynamicObject')._FromJSON(diff)
# mettre le résultat dans la réponse
fhir_response.Json = result
return fhir_response
à tester :
POST https://localhost:4443/fhir/r5/Patient/1/$merge
Authorization : Bearer <Token>
Accept: application/fhir+json
{
"resourceType": "Patient",
"id": "2",
"meta": {
"versionId": "2"
}
}
Vous obtiendrez la différence entre les 2 patients.
{
"values_changed": {
"root['address'][0]['city']": {
"new_value": "fdsfd",
"old_value": "Lynnfield"
},
"root['meta']['lastUpdated']": {
"new_value": "2024-02-24T09:11:00Z",
"old_value": "2024-02-28T13:50:27Z"
},
"root['meta']['versionId']": {
"new_value": "1",
"old_value": "2"
}
}
}
Félicitations, vous avez créé l'opération personnalisée. 🥳
In %SYS
set ^%ISCLOG = 5
zw ^ISCLOG
from grongier.pex import BusinessProcess
import iris
import jwt
import json
from fhir.resources import patient, bundle
class MyBusinessProcess(BusinessProcess):
def on_init(self):
if not hasattr(self, 'target'):
self.target = 'HS.FHIRServer.Interop.HTTPOperation'
return
def on_fhir_request(self, request:'iris.HS.FHIRServer.Interop.Request'):
# Faire quelque chose avec la requête
self.log_info('Received a FHIR request')
# La passer à la cible
rsp = self.send_request_sync(self.target, request)
# Essayez d'obtenir le jeton de la requête
token = request.Request.AdditionalInfo.GetAt("USER:OAuthToken") or ""
# Faire quelque chose avec la réponse
if self.check_token(token):
self.log_info('Filtering the response')
# Filtrer la reponse
payload_str = self.quick_stream_to_string(rsp.QuickStreamId)
# si le payload est vide, renvoyer la réponse
if payload_str == '':
return rsp
filtered_payload_string = self.filter_resources(payload_str)
if filtered_payload_string == '':
return rsp
# écrire la chaîne json dans un flux rapide
quick_stream = self.string_to_quick_stream(filtered_payload_string)
# renvoyer la réponse
rsp.QuickStreamId = quick_stream._Id()
return rsp
def check_token(self, token:str) -> bool:
# décoder le jeton
decoded_token= jwt.decode(token, options={"verify_signature": False})
# vérifier si le jeton est valide
if 'VIP' in decoded_token['scope']:
return True
else:
return False
def quick_stream_to_string(self, quick_stream_id) -> str:
quick_stream = iris.cls('HS.SDA3.QuickStream')._OpenId(quick_stream_id)
json_payload = ''
while quick_stream.AtEnd == 0:
json_payload += quick_stream.Read()
return json_payload
def string_to_quick_stream(self, json_string:str):
quick_stream = iris.cls('HS.SDA3.QuickStream')._New()
# écrire la chaîne json dans le payload
n = 3000
chunks = [json_string[i:i+n] for i in range(0, len(json_string), n)]
for chunk in chunks:
quick_stream.Write(chunk)
return quick_stream
def filter_patient_resource(self, patient_str:str) -> str:
# filtrer le patient
p = patient.Patient(**json.loads(patient_str))
# supprimer le nom
p.name = []
# supprimer l'adresse
p.address = []
# supprimer le télécom
p.telecom = []
# supprimer la date de naissance
p.birthDate = None
return p.json()
def filter_resources(self, resource_str:str) -> str:
# analyser le payload
payload_dict = json.loads(resource_str)
# quel est le type de ressource?
resource_type = payload_dict['resourceType'] if 'resourceType' in payload_dict else 'None'
self.log_info('Resource type: ' + resource_type)
# c'est un paquet?
if resource_type == 'Bundle':
obj = bundle.Bundle(**payload_dict)
# filrer le paquet
for entry in obj.entry:
if entry.resource.resource_type == 'Patient':
self.log_info('Filtering a patient')
entry.resource = patient.Patient(**json.loads(self.filter_patient_resource(entry.resource.json())))
elif resource_type == 'Patient':
# filtrer le patient
obj = patient.Patient(**json.loads(self.filter_patient_resource(resource_str)))
else:
return resource_str
return obj.json()
Le type TIMESTAMP correspond au type de données %Library.TimeStamp (=%TimeStamp) dans les produits InterSystems, et le format est YYYY-MM-DD HH:MM:SS.nnnnnnnnn.
Si vous souhaitez modifier la précision après la virgule, définissez-la à l'aide de la méthode suivante.
1) Définir la précision à l'échelle du système
Portail de gestion : [Administration du système] > [Configuration] > [Paramètres SQL et objets] > [Paramètres SQL généraux]
Précision de l'heure par défaut pour GETDATE(), CURRENT_TIME, CURRENT_TIMESTAMP. Vous pouvez spécifier le nombre de chiffres entre 0 et 9.
Pour désactiver le délai d'attente, réglez le délai d'attente de la requête sur désactivé dans les paramètres DSN :
Panneau de configuration de Windows > Outils d'administration > Sources de données (ODBC) > Configuration DSN du système
Si vous cochez la case Désactiver le délai d'attente des requêtes, le délai d'attente sera désactivé.
Si vous souhaitez le modifier du côté de l'application, vous pouvez le définir au niveau de l'API ODBC.
La procédure de téléchargement à partir d'un serveur FTP est la suivante.
1. Télécharger le fichier image sur le serveur FTP
Vous pouvez utiliser la classe %IndexBuilder pour effectuer une reconstruction d'index à l'aide de plusieurs processus. L'exemple suivant a pour but de définir l'index standard HomeStateIdx pour la colonne Home_State (informations d'état de l'adresse de contact) de Sample.Person.
Les étapes sont les suivantes:
1. Masquez le nom de l'index à ajouter/reconstruire à partir de l'optimiseur de requêtes.
>write$system.SQL.SetMapSelectability("Sample.Person","HomeStateIdx",0)
1Si vous souhaitez exécuter un fichier exécutable du système d'exploitation, une commande ou un programme créé dans un produit InterSystems au démarrage de ce dernier, écrivez le traitement dans la routine SYSTEM^%ZSTART. (La routine %ZSTART est créée dans l'espace de noms %SYS).
Avant d'écrire du code dans la routine SYSTEM^%ZSTART, assurez-vous qu'il fonctionne correctement dans toutes les conditions.
Dans Studio, vous pouviez ouvrir une classe directement par son nom, sans avoir à parcourir l'arborescence du paquetage par de multiples clics jusqu'à ce que vous arriviez à la classe souhaitée.
Vous pouvez faire Ctrl + O ou (File -> Open) et taper simplement le nom de la classe, par exemple :
.png)
Appuyez sur la touche "Enter" et la classe est ouverte.
Comment y parvenir en VSCode ?
C'est assez facile en fait, il suffit d'appuyer sur Ctrl + T (pour Windows par exemple), ou Go -> Go to Symbol in Workspace..., tapez le nom de la classe et vous y êtes.
Par exemple :
.png)
Cette solution a été mentionnée par @Dmitry Maslennikov comme une suggestion pour le rapport de problème GitHub (désigné comme une demande d'amélioration) pour ces fonctionnalités - "Ouverture d'une classe par le nom à partir du serveur".
Voici un petit GIF pour la démonstration :
Aimeriez-vous avoir accès au terminal Web directement à partir de votre VSCode ?
.png)
Voici une nouvelle entrée dans la rubrique "Trucs et astuces de VSCode" - et elle ressemble beaucoup à la précédente à propos de l'assistant SOAP Wizard.
Même principe et même résultat, bien que le cas d'utilisation soit différent.
Supposons donc que vous désiriez ouvrir le Terminal Web (et pour ceux d'entre vous qui ne sont pas encore familiers avec cet excellent outil créé par l'incroyable @Nikita Savchenko consultez sapage d'accueil) à partir de VSCode - vous pouvez adopter une approche similaire à celle que j'ai décrite dans l'article précédent.
Je reprendrai les étapes -
Il se présentera comme suit -
.png)
Une fois que vous avez fait cela, vous pouvez trouver Web Terminal dans le menu en cliquant sur Connexion dans la barre d'état inférieure de VSCode.
Ceci est mentionné dans la discussion this VSCode ObjectScript's GitHub Issues (à propos de variables ${...} utilisées dans l'URL ci-dessus), par @John Murray
Voici un court GIF pour illustrer ce processus (en commençant par le menu standard et en terminant par l'option permettant de lancer le terminal Web). -
Another VSCode "Tips & Tricks" entry -
.png)
Do you want to see this option in VSCode?
This time we'll focus on how to get the SOAP Wizard as was available in Studio (to define a WSDL-based SOAP Web Service client (and Business Operation), or service).
If you work with Web Services you most probably used the SOAP Wizard in Studio. You would open it via Tools -> Add-Ins
.png)
And this opened a "Server Template" -
.png)
In VSCode you might be wondering how you can access this.
Well the basic fact you need to understand is that truly this Add-In or Wizard is simply a web page, displayed within Studio per above, and as such can also be accessed in a simple browser. VSCode facilitates the opening of such a browser with the desired content (ultimately constructing the correct URL with the right server name, port, web application, etc.).
The result would be the same as you see an option to open the Management Portal or the Class Reference (with relevant URLs) when you click on the Server Connection on the bottom Status Bar of VSCode, for example:
.png)
You will also see an entry for the SOAP Wizard.
You can achieve this by adding a 'links' entry in to your 'conn' object in your Settings JSON of your ObjectScript Extension, and specifying the desired URL (using the relevant variables).
This is mentioned in the VSCode ObjectScript's GitHub Issues discussion under a "SOAP Wizard" issue, with comments by @John Murray and @Ondřej Hoferek, and also referred to in this comment on a Community post by @Timothy Leavitt
The JSON value would be:
And this part would look like this:
.png)
Once you have this you will see an extra option when you click on the Connection -
And choosing that option will take you to the desired Wizard (opened in a Browser):
.png)
Here's a short GIF demonstrating this process (starting from the regular menu when clicking the Connection, and ending with the menu including the SOAP Wizard).
Note there are other Wizards (or Templates) you can add this way (like the XSD Wizard for example).
Salutations à toutes et à tous,
Faut-il connecter votre VSCode à un serveur d'InterSystems ?
Connaissez-vous déjè de cette option ?
.png)
Puisque beaucoup de gens commencent à utiliser VSCode comme IDE pour nos produits, j'ai pensé qu'il pourrait être bénéfique de fournir quelques petits trucs et astuces pour les aider à démarrer et à devenir plus productifs. C'est pourquoi je lance cette série de petits articles.
Quelques éclaircissements importants :
1. Il ne s'agit pas d'un tutoriel ou d'une ressource d'apprentissage formelle - si vous recherchez ce type de ressources, veuillez consulter cet excellent exercice en ligne, par exemple, ou examiner cette excellente session de notre dernier Sommet virtuel.
2. Ces "trucs et astuces" ne sont pas mes inventions - ils sont généralement déjà documentés ou mentionnés quelque part, je voulais simplement les rassembler et peut-être fournir quelques conseils ou exemples supplémentaires. J'essaierai de faire référence à la source le cas échéant.
3. Bien que j'aie déjà noté quelques idées et sujets à aborder dans cette "série", je ne sais pas à quelle vitesse je pourrai les mettre en place, et je ne peux donc pas m'engager sur la fréquence à laquelle ils apparaîtront...
Voici le premier -
Parmi les choses que vous devez faire en premier dans VSCode, il y a la définition de vos connexions au serveur. Vous pouvez le faire manuellement dans le fichier JSON Settings de l'extension InterSystems Server Manger, ou en appuyant sur le signe (+) lorsque vous essayez de vous connecter à un serveur (et en répondant aux invites), mais si vous êtes sous Windows, vous pouvez simplement importer vos définitions de serveur depuis le Registre Windows.
En fait, cela fait partie de la documentation de l'extension (dans la page VSCode Marketplace de l'extension, dans le GitHub Repository Readme, et dans la page Détails de l'extension dans VSCode lui-même - c'est en fait le même texte...) -
Import Servers from Registry à partir de Command Palette pour créer des entrées de connexion pour toutes les connexions que vous avez précédemment définies avec le gestionnaire de serveur InterSystems (InterSystems Server Manager).Lorsque vous installez une instance sur une machine Windows ou définissez des serveurs pour un client via l'outil Server Manger, le registre Windows est mis à jour.
Par exemple, j'ai eu un client avec 9 serveurs différents définis sur lesquels il pourrait vouloir se connecter (environnements Prod / Dev / Test, LAN vs. DMZ, etc.), tandis qu'un autre client en a encore plus (ou beaucoup plus). Faire cela un par un dans VSCode pourrait être fastidieux (et sujet à l'erreur humaine).
Supposons qu'il y ait par exemple la situation suivante sur ma machine, telle qu'elle est définie dans l'InterSystems Server Manager -
.png)
Je peux utiliser l'option "Importation de serveurs à partir du registre" de l'extension InterSystems Server Manager.
Ouvrez simplement la palette de commandes (View -> Command Palette... or Ctrl+Shift+P) et tapez après >le caractère "InterSystems", ainsi vous verrez l'option suivante -
.png)
[Ou une autre option dans le commentaire ci-dessous]
Ensuite, on vous demandera un nom d'utilisateur pour vous connecter à l'un des serveurs (vous n'êtes pas obligé de le saisir si vous ne voulez pas qu'il soit enregistré, mais il vous sera demandé à chaque fois que vous vous connecterez), puis un mot de passe, puis si vous voulez enregistrer le mot de passe pour tous les autres serveurs (vous n'êtes pas obligé d'enregistrer le mot de passe du tout si vous ne voulez pas) et enfin toutes les définitions de serveurs seront ajoutées.
Par exemple, voici ce à quoi ressembleront les paramètres JSON après l'importation, d'après l'image du Gestionnaire de serveur ci-dessus (et en supposant que j'ai fourni un nom d'utilisateur de SuperUtilisateur) -
.png)
Voici un petit GIF démontrant ce processus rapide (il commence par la définition des 3 connexions de serveur par défaut, et se termine avec les 5 serveurs supplémentaires selon l'exemple ci-dessus) :
Lorsque vous exécutez une routine dans le terminal et qu'une erreur se produit dans le programme, si vous n'avez pas défini correctement le piège à erreurs, le programme entrera en mode de débogage comme indiqué ci-dessous.
USER>do^error1
write A
^
a+2^error1 *A
USER 2d0>A partir de cet état, entrez la commandeQuit pour revenir à l'état précédant le démarrage de la routine.
USER 2d0>QuitSi une transaction est en cours de traitement dans la routine où l'erreur s'est produite, une invite similaire à celle ci-dessous s'affiche.
Dans le monde des affaires, chaque seconde compte, et il est essentiel de disposer d'applications performantes pour rationaliser nos processus commerciaux. Nous comprenons l'importance de concevoir des algorithmes efficaces, mesurables par la notation big O.Néanmoins, il existe de nombreuses stratégies pour augmenter la performance des systèmes construits sur la plate-forme de données IRIS. Ces stratégies sont tout aussi cruciales pour optimiser l'efficacité globale.Rejoignons le voyage pour un aperçu des astuces permettant d'améliorer le fonctionnement d'IRIS Data Platform, où chaque petite
La page de gestion de Web/CSP Gateway est généralement configurée de manière à ne pas être accessible à partir des machines clientes.
Pour y accéder depuis n'importe quel client, procédez comme suit :
Ici, nous présenterons un exemple de code pour l'enregistrement et le référencement des plannings de tâches.
①Exemple d'enregistrement du calendrier des tâches
*Créez une tâche à exécuter do ^TEST tous les jours à 1h00.
Record maps sont utilisés pour faire correspondre efficacement des fichiers contenant des enregistrements délimités ou des enregistrements de largeur fixe aux classes de messages utilisées par la fonction d'interopérabilité, et pour faire correspondre des fichiers de classes de messages de la fonction d'interopérabilité à des fichiers texte.
Le définitions de correspondace peuvent être créés à l'aide du portail de gestion, et nous fournissons également un assistant d'enregistrement CSV qui vous permet de définir tout en lisant un fichier CSV.
Les mappages globaux peuvent être enregistrés à l'aide de la classe système Config.MapGlobals.
La méthode pour mapper globalement ^Sample.PersonD dans une base de données SAMPLES autre que la base de données par défaut de l'espace de noms USER est la suivante (exemple exécuté dans un terminal).
USER>zn"%SYS"%SYS>set ns="USER"%SYS>set glo="Sample.PersonD"%SYS>set vals("Database")="SAMPLES"%SYS>set st=##class (Config.MapGlobals).Create(ns,glo,.vals)"Cela fait trente secondes que j'attends un service. C'est scandaleux ! Je m'en vais !"
"Je suis désolé d'entendre cela, monsieur. La prochaine fois, vous devriez peut-être réserver."
Si vous entendiez ce commentaire dans votre restaurant préféré, vous penseriez que la personne qui le fait est ridicule. Cependant, dans le contexte de votre API, ce commentaire est parfaitement logique. Tout comme votre restaurant préféré, votre API a des clients réguliers qui, comme vous le savez, viendront un jour ou l'autre. Il serait formidable de pouvoir faire une réservation permanente pour eux aussi.