Les solutions Open Exchange de la plateforme de données InterSystems sont une galerie de solutions logicielles, d'outils et de frameworks qui ont été développés avec la plateforme de données InterSystems (Caché, Ensemble, HealthShare, InterSystems IRIS, InterSystems IRIS for Health) ou qui sont destinés à aider au développement, au déploiement et à la prise en charge des solutions conçues avec la plateforme de données InterSystems.
Vous pouvez utiliser n'importe quelle ressource publiée ou publier votre propre outil, exemple technologique ou solution.
Salut la communauté !
Nous aimerions vous inviter à participer à notre prochain concours pour partager vos connaissances de FHIR :
🏆 Concours InterSystems IRIS for Health : FHIR pour la santé des femmes 🏆
Soumettez une application qui utilise InterSystems FHIR ou InterSystems Healthcare Interoperability !
Durée: 14 novembre - 4 décembre 2022
Prix: $13,500!
>> Téléchargez votre application ici <<
Salut la communauté,
Nous apprécions grandement tous vos commentaires sur le concours d'interopérabilité !
Veuillez répondre à une courte enquête et répondre à quelques questions pour nous aider à améliorer nos concours.
👉 Sondage rapide : Enquête sur le concours d'interopérabilité 2022
N'hésitez pas à partager également vos pensées dans les commentaires de cet article !
Salut la communauté,
Rencontrons-nous lors de la rencontre en ligne avec les gagnants du concours d'interopérabilité InterSystems – une excellente occasion d'avoir une discussion avec l'équipe d'experts InterSystems ainsi qu'avec nos participants.
Démo des gagnants incluse !
Date et heure : jeudi 22 septembre, 09h00 HAE
Bonjour la communauté,
Nous sommes ravis d'annoncer les gagnants du concours d'interopérabilité intersystèmes : créer des solutions durables !
Merci à tous d'avoir participé à notre concours de codage ! Sans plus tarder, les gagnants sont...
.png)
Ceci est un client fhir simple en c# pour s'exercer avec les ressources fhir et les requêtes CRUD vers un serveur fhir.
Notez que pour la majeure partie, l'autocomplétion est activée.
Assurez-vous que git et Docker desktop sont installé.
Si vous travaillez à l'intérieur du conteneur, ces modules sont déjà installés.
Si ce n'est pas le cas, utilisez nugget pour installer Hl7.Fhir.R4, nous allons utiliser Model et Rest à partir de celui-ci :
Hl7.Fhir.Model
Clone/git tire le repo dans n'importe quel répertoire local, par exemple comme indiqué ci-dessous :
git clone https://github.com/LucasEnard/fhir-client-net.git
Ouvrez le terminal dans ce répertoire et lancez :
docker build .
Ce référentiel est prêt pour VS Code.
Ouvrez le dossier fhir-client-net cloné localement dans VS Code.
Si vous y êtes invité (coin inférieur droit), installez les extensions recommandées.
Vous pouvez être à l'intérieur du conteneur avant de coder si vous le souhaitez.
Pour cela, il faut que docker soit activé avant d'ouvrir VSCode.
Ensuite, dans VSCode, lorsque vous y êtes invité ( coin inférieur droit ), rouvrez le dossier à l'intérieur du conteneur afin de pouvoir utiliser les composants python qu'il contient.
La première fois que vous effectuez cette opération, cela peut prendre plusieurs minutes, le temps que le conteneur soit préparé.
Si vous n'avez pas cette option, vous pouvez cliquer dans le coin inférieur gauche et cliquer sur press reopen in container puis sélectionner From Dockerfile
En ouvrant le dossier à distance, vous permettez à VS Code et à tous les terminaux que vous ouvrez dans ce dossier d'utiliser les composants c# dans le conteneur.
Si vous y êtes invité (coin inférieur droit), installez les extensions recommandées.
Pour réaliser cette présentation, vous aurez besoin d'un serveur FHIR.
Vous pouvez soit utiliser le vôtre, soit vous rendre sur le site InterSystems free FHIR trial et suivre les étapes suivantes pour le configurer.
En utilisant notre essai gratuit, il suffit de créer un compte et de commencer un déploiement, puis dans l'onglet Overview vous aurez accès à un endpoint comme https://fhir.000000000.static-test-account.isccloud.io que nous utiliserons plus tard.
Ensuite, en allant dans l'onglet d'informations d'identification Credentials, créez une clé api et enregistrez-la quelque part.
C'est maintenant terminé, vous avez votre propre serveur fhir pouvant contenir jusqu'à 20 Go de données avec une mémoire de 8 Go.
La présentation pas à pas du client se trouve à /Client.cs.
Le code est divisé en plusieurs parties, et nous allons couvrir chacune d'entre elles ci-dessous.
Dans cette partie, nous connectons notre client à notre serveur en utilisant Fhir.Rest.
// Partie 1
// Creation of an htpclient holding the api key of the server as an header
var httpClient = new HttpClient();
httpClient.DefaultRequestHeaders.Add("x-api-key", "api-key");
var settings = new FhirClientSettings
{
Timeout = 0,
PreferredFormat = ResourceFormat.Json,
VerifyFhirVersion = true,
// PreferredReturn can take Prefer.ReturnRepresentation or Prefer.ReturnMinimal to return the full resource or an empty payload
PreferredReturn = Prefer.ReturnRepresentation
};
// Création de notre client en utilisant une correcte url
var client = new FhirClient("url",httpClient,settings);
Afin de vous connecter à votre serveur, vous devez modifier la ligne :
httpClient.DefaultRequestHeaders.Add("x-api-key", "api-key");
Et cette ligne aussi :
var client = new FhirClient("url",httpClient,settings);
L'url' est un point de terminaison tandis que l'"api-key" est la clé d'api pour accéder à votre serveur.
Notez que si vous n'utilisez pas un serveur InterSystems, vous pouvez vérifier comment autoriser vos accès si nécessaire.
Comme ça, nous avons un client FHIR capable d'échanger directement avec notre serveur.
Dans cette partie, nous créons un Patient en utilisant Fhir.Model et nous le complétons avec un HumanName, en suivant la convention FHIR, use et family sont des chaînes et given est une liste de chaînes. De la même manière, un patient peut avoir plusieurs HumanNames, donc nous devons mettre notre HumanName dans une liste avant de le mettre dans notre patient nouvellement créé.
// Partie 2
// Building a new patient and setting the names
var patient0 = new Patient();
patient0.Name.Add(new HumanName().WithGiven("GivenName").AndFamily("FamilyName"));
// Creation of our client in the server
// It is to be noted that using SearchParams you can check if an equivalent resource already exists in the server
// For more information https://docs.fire.ly/projects/Firely-NET-SDK/client/crud.html
var created_pat = client.Create<Patient>(patient0);
Console.Write("Partie 2 : Identifiant du patient nouvellement créé : ");
Console.WriteLine(created_pat.Id);
Après cela, nous devons sauvegarder notre nouveau Patient sur notre serveur en utilisant notre client.
Notez que si vous lancez Client.cs plusieurs fois, plusieurs Patients ayant le nom que nous avons choisi seront créés.
C'est parce que, suivant la convention FHIR, vous pouvez avoir plusieurs Patients avec le même nom, seul l' id est unique sur le serveur.
Vérifier la documentation pour avoir plus d'information.
Il est à noter qu'en utilisant SearchParams vous pouvez vérifier si une ressource équivalente existe déjà sur le serveur avant de la créer.
Pour plus d'information https://docs.fire.ly/projects/Firely-NET-SDK/client/crud.html
Nous conseillons donc de commenter la ligne après le premier lancement.
Dans cette partie, nous avons un client qui recherche un patient nommé d'après celui que nous avons créé précédemment.
// Part 3
// This gets all the Patient having the exact name "FamilyName" and we take the first one
// Note that if you have multiple patients with the same name, you will get only the first one
// We advise to use the id, the names, and any other informations for the SearchParams to be sure to get the right patient
var q = new SearchParams().Where("name:exact=FamilyName");
Bundle bund = client.Search<Patient>(q);
patient0 = bund.Entry[0].Resource as Patient;
Console.Write("Part 3 : Name of the patient we found by searching : ");
Console.WriteLine(patient0.Name[0]);
// Creation of our patient telecom, here a phone number
patient0.Telecom.Add(new ContactPoint(new ContactPoint.ContactPointSystem(),new ContactPoint.ContactPointUse(),"1234567890"));
// Change the given name of our patient
patient0.Name[0].Given = new List<string>() { "AnotherGivenName" };
Console.Write("Part 3 : Name of the changed patient : ");
Console.WriteLine(patient0.Name[0]);
Console.Write("Part 3 : Phone of the changed patient : ");
Console.WriteLine(patient0.Telecom[0].Value);
// Update the patient
var update_pat = client.Update<Patient>(patient0);
Une fois que nous l'avons trouvé, nous ajoutons un numéro de téléphone à son profil et nous changeons son prénom en un autre.
Maintenant nous pouvons utiliser la fonction de mise à jour de notre client pour mettre à jour notre patient sur le serveur.
Dans cette section, nous voulons créer une observation pour notre patient. Pour ce faire, nous avons besoin de son identifiant, qui est son identifiant unique.
A partir de là, nous remplissons notre observation et ajoutons comme sujet, l'identifiant de notre Patient.
// Part 4
// Building of our new observation
Observation obsv = new Observation {
Value = new Quantity(70, "kg"),
Code = new CodeableConcept {
Coding = new List<Coding> {
new Coding {
System = "http://loinc.org",
Code = "29463-7",
Display = "Body weight"
}
}},
Category = new List<CodeableConcept> {
new CodeableConcept {
Coding = new List<Coding> {
new Coding {
System = "http://snomed.info/sct",
Code = "276327007",
Display = "Body weight"
}
}
}},
Status = new ObservationStatus {},
Subject = new ResourceReference {
Reference = "Patient/" + update_pat.Id}
};
// Creation of our observation in the server
var new_obsv = client.Create<Observation>(obsv);
Console.Write("Part 4 : Id of the observation : ");
Console.WriteLine(new_obsv.Id);
Ensuite, nous enregistrons notre observation à l'aide de la fonction create.
Si vous avez suivi ce parcours, vous savez maintenant exactement ce que fait Client.cs, vous pouvez le lancer et vérifier votre Patient et votre Observation nouvellement créés sur votre serveur.
Pour le lancer, ouvrez un terminal VSCode et entrez :
dotnet run
Vous devriez voir des informations sur le Patient créé et son observation.
Si vous utilisez un serveur Intersystems, allez à API Deployement, autorisez-vous avec la clé api et d'ici vous pouvez OBTENIR par id le patient et l'observation que nous venons de créer.
Ce référentiel est prêt à être codé dans VSCode avec les plugins InterSystems.
Ouvrez Client.cs pour commencer à coder ou utiliser l'autocomplétion.
Un dockerfile pour créer un dot net env pour que vous puissiez travailler.
Utilisez docker build . pour construire et rouvrir votre fichier dans le conteneur pour travailler à l'intérieur de celui-ci.
Fichier de paramètres
Fichier de configuration si vous voulez déboguer
Salut la communauté,
C'est l'heure de voter ! Soumettez vos votes pour les meilleures applications du concours d'interopérabilité : Créer des solutions durables
🔥 VOTEZ POUR LES MEILLEURES APPLICATIONS 🔥
.png)
Comment voter ? Détails ci-dessous.
Ceci est un client fhir simple en python pour s'exercer avec les ressources fhir et les requêtes CRUD vers un serveur FHIR.
Notez que pour la plupart, l'autocomplétion est activée, c'est la principale raison d'utiliser fhir.resources.
Assurez-vous que git et Docker desktop sont installé.
Si vous travaillez à l'intérieur du conteneur, comme il est montré dans 3.3., vous n'avez pas besoin d'installer fhirpy et fhir.resources.
Si vous n'êtes pas dans le conteneur, vous pouvez utiliser pip pour installer fhirpy et fhir.resources.
Vérifiez fhirpy et fhir.resources pour plus d'information.
Clone/git tire le repo dans n'importe quel répertoire local, par exemple comme indiqué ci-dessous :
git clone https://github.com/LucasEnard/fhir-client-python.git
Ouvrez le terminal dans ce répertoire et lancez :
docker build.
Ce référentiel est prêt pour VS Code.
Ouvrez le dossier fhir-client-python cloné localement dans VS Code.
Si vous y êtes invité (coin inférieur droit), installez les extensions recommandées.
Vous pouvez être à l'intérieur du conteneur avant de coder si vous le souhaitez.
Pour cela, il faut que docker soit activé avant d'ouvrir VSCode.
Ensuite, dans VSCode, lorsque vous y êtes invité ( coin inférieur droit ), rouvrez le dossier à l'intérieur du conteneur afin de pouvoir utiliser les composants python qu'il contient.
La première fois que vous effectuez cette opération, cela peut prendre plusieurs minutes, le temps que le conteneur soit préparé.
Si vous n'avez pas cette option, vous pouvez cliquer dans le coin inférieur gauche et cliquer sur Ouvrir à nouveau dans le conteneur puis sélectionner De Dockerfile
En ouvrant le dossier à distance, vous permettez à VS Code et à tous les terminaux que vous ouvrez dans ce dossier d'utiliser les composants python dans le conteneur.
Pour réaliser cette présentation, vous aurez besoin d'un serveur FHIR.
Vous pouvez soit utiliser le vôtre, soit vous rendre sur le site InterSystems free FHIR trial et suivre les étapes suivantes pour le configurer.
En utilisant notre essai gratuit, il suffit de créer un compte et de commencer un déploiement, puis dans l'onglet Overview vous aurez accès à un endpoint comme https://fhir.000000000.static-test-account.isccloud.io que nous utiliserons plus tard.
Ensuite, en allant dans l'onglet d'informations d'identification Credentials, créez une clé api et enregistrez-la quelque part.
C'est maintenant terminé, vous avez votre propre serveur fhir pouvant contenir jusqu'à 20 Go de données avec une mémoire de 8 Go.
La présentation pas à pas du client se trouve à src/client.py.
Le code est divisé en plusieurs parties, et nous allons couvrir chacune d'entre elles ci-dessous.
Dans cette partie, nous connectons notre client à notre serveur en utilisant fhirpy et nous obtenons nos ressources Patient à l'intérieur de la variable patients_resources.
A partir de cette variable nous pourrons fecth n'importe quel Patient et même les trier ou obtenir un Patient en utilisant certaines conditions.
#Partie 1----------------------------------------------------------------------------------------------------------------------------------------------------
#Créer notre client connecté à notre serveur
client = SyncFHIRClient(url='url', extra_headers={"x-api-key":"api-key"})
#Obtenir les ressources de notre patient dans lesquelles nous pourrons aller chercher et rechercher
patients_resources = client.resources('Patient')
Afin de vous connecter à votre serveur, vous devez modifier la ligne :
client = SyncFHIRClient(url='url', extra_headers={"x-api-key":"api-key"})
L'url' est un point de terminaison tandis que l'"api-key" est la clé d'api pour accéder à votre serveur.
Notez que si vous n'utilisez pas un serveur InterSystems, vous pouvez vérifier comment changer extra_headers={"x-api-key":"api-key"} en authorization = "api-key".
Comme ça, nous avons un client FHIR capable d'échanger directement avec notre serveur.
Dans cette partie, nous créons un Patient en utilisant Fhir.Model et nous le complétons avec un HumanName, en suivant la convention FHIR, use et family sont des chaînes et given est une liste de chaînes. e la même manière, un patient peut avoir plusieurs HumanNames, donc nous devons mettre notre HumanName dans une liste avant de le mettre dans notre patient nouvellement créé.
#Partie 2----------------------------------------------------------------------------------------------------------------------------------------------------
#Nous voulons créer un patient et l'enregistrer sur notre serveur
#Créer un nouveau patient en utilisant fhir.resources
patient0 = Patient()
#Créer un HumanName et le remplir avec les informations de notre patient
name = HumanName()
name.use = "official"
name.family = "familyname"
name.given = ["givenname1","givenname2"]
patient0.name = [name]
#Vérifier notre patient dans le terminal
print()
print("Our patient : ",patient0)
print()
#Sauvegarder (post) notre patient0, cela va le créer sur notre serveur
client.resource('Patient',**json.loads(patient0.json())).save()
Après cela, nous devons sauvegarder notre nouveau Patient sur notre serveur en utilisant notre client.
Notez que si vous lancez client.py plusieurs fois, plusieurs Patients ayant le nom que nous avons choisi seront créés.
C'est parce que, suivant la convention FHIR, vous pouvez avoir plusieurs Patients avec le même nom, seul l' id est unique sur le serveur.
Alors pourquoi n'avons-nous pas rempli notre Patient avec un id de la même façon que nous avons rempli son nom ?
Parce que si vous mettez un id à l'intérieur de la fonction save(), la sauvegarde agira comme une mise à jour avant d'agir comme un sauveur, et si l'id n'est en fait pas déjà sur le serveur, il le créera comme prévu ici. Mais comme nous avons déjà des patients sue notre serveur, ce n'est pas une bonne idée de créer un nouveau patient et d'allouer à la main un Identifiant puisque la fonction save() et le serveur sont faits pour le faire à votre place.
Nous conseillons donc de commenter la ligne après le premier lancement.
Dans cette partie, nous avons un client qui cherche dans nos patients_resources un patient nommé d'après celui que nous avons créé précédemment.
#Partie 3----------------------------------------------------------------------------------------------------------------------------------------------------
#Maintenant, nous voulons obtenir un certain patient et ajouter son numéro de téléphone et changer son nom avant de sauvegarder nos changements sur le serveur
#Obtenez le patient en tant que fhir.resources Patient de notre liste de ressources de patients qui a le bon nom, pour la commodité, nous allons utiliser le patient que nous avons créé avant
patient0 = Patient.parse_obj(patients_resources.search(family='familyname',given='givenname1').first().serialize())
#Créer le nouveau numéro de téléphone de notre patient
telecom = ContactPoint()
telecom.value = '555-748-7856'
telecom.system = 'phone'
telecom.use = 'home'
#Ajouter le téléphone de notre patient à son dossier
patient0.telecom = [telecom]
#Changer le deuxième prénom de notre patient en "un autre prénom"
patient0.name[0].given[1] = "anothergivenname"
#Vérifiez notre Patient dans le terminal
print()
print("Notre patient avec le numéro de téléphone et le nouveau prénom : ",patient0)
print()
#Sauvegarder (mettre) notre patient0, ceci sauvera le numéro de téléphone et le nouveau prénom au patient existant de notre serveur
client.resource('Patient',**json.loads(patient0.json())).save()
Une fois que nous l'avons trouvé, nous ajoutons un numéro de téléphone à son profil et nous changeons son prénom en un autre.
Maintenant nous pouvons utiliser la fonction de mise à jour de notre client pour mettre à jour notre patient sur le serveur.
Dans cette partie, nous voulons créer une observation pour notre patient précédent, pour ce faire, nous cherchons d'abord notre patients_resources pour notre patient, puis nous obtenons son identifiant, qui est son identificateur unique.
#Partie 4----------------------------------------------------------------------------------------------------------------------------------------------------
#Maintenant nous voulons créer une observation pour notre client
#Obtenir l'identifiant du patient auquel vous voulez attacher l'observation
id = Patient.parse_obj(patients_resources.search(family='familyname',given='givenname1').first().serialize()).id
print("id of our patient : ",id)
#Placer notre code dans notre observation, code qui contient des codages qui sont composés de système, code et affichage
coding = Coding()
coding.system = "https://loinc.org"
coding.code = "1920-8"
coding.display = "Aspartate aminotransférase [Activité enzymatique/volume] dans le sérum ou le plasma"
code = CodeableConcept()
code.coding = [coding]
code.text = "Aspartate aminotransférase [Activité enzymatique/volume] dans le sérum ou le plasma"
#Créer une nouvelle observation en utilisant fhir.resources, nous entrons le statut et le code dans le constructeur car ils sont nécessaires pour valider une observation
observation0 = Observation(status="final",code=code)
#Définir notre catégorie dans notre observation, catégorie qui détient les codages qui sont composés de système, code et affichage
coding = Coding()
coding.system = "https://terminology.hl7.org/CodeSystem/observation-category"
coding.code = "laboratoire"
coding.display = "laboratoire"
category = CodeableConcept()
category.coding = [coding]
observation0.category = [category]
#Définir l'heure de notre date effective dans notre observation
observation0.effectiveDateTime = "2012-05-10T11:59:49+00:00"
#Régler l'heure de notre date d'émission dans notre observation
observation0.issued = "2012-05-10T11:59:49.565+00:00"
#Définir notre valueQuantity dans notre observation, valueQuantity qui est composée d'un code, d'un unir, d'un système et d'une valeur
valueQuantity = Quantity()
valueQuantity.code = "U/L"
valueQuantity.unit = "U/L"
valueQuantity.system = "https://unitsofmeasure.org"
valueQuantity.value = 37.395
observation0.valueQuantity = valueQuantity
#Définir la référence à notre patient en utilisant son identifiant
reference = Reference()
reference.reference = f"Patient/{id}"
observation0.subject = reference
#Vérifiez notre observation dans le terminal
print()
print("Notre observation : ",observation0)
print()
#Sauvegarder (poster) notre observation0 en utilisant notre client
client.resource('Observation',**json.loads(observation0.json())).save()
Ensuite, nous enregistrons notre observation à l'aide de la fonction save().
Si vous avez suivi ce parcours, vous savez maintenant exactement ce que fait client.py, vous pouvez le lancer et vérifier votre Patient et votre Observation nouvellement créés sur votre serveur.
from fhirpy import SyncFHIRClient
from fhir.resources.patient import Patient
from fhir.resources.observation import Observation
from fhir.resources.humanname import HumanName
from fhir.resources.contactpoint import ContactPoint
import json
La première importation est le client, ce module va nous aider à nous connecter au serveur, à obtenir et exporter des ressources.
Le module fhir.resources nous aide à travailler avec nos ressources et nous permet, grâce à l'auto-complétion, de trouver les variables dont nous avons besoin.
La dernière importation est json, c'est un module nécessaire pour échanger des informations entre nos 2 modules.
client = SyncFHIRClient(url='url', extra_headers={"x-api-key":"api-key"})
L''url' est ce que nous avons appelé avant un point de terminaison tandis que l'"api-key"' est la clé que vous avez générée plus tôt.
Notez que si vous n'utilisez pas un serveur InterSystems, vous voudrez peut-être changer le extra_headers={"x-api-key" : "api-key"} en authorization = "api-key"
Comme ça, nous avons un client FHIR capable d'échanger directement avec notre serveur.
Par exemple, vous pouvez accéder à vos ressources Patient en faisant patients_resources = client.resources('Patient') , fà partir de là, vous pouvez soit obtenir vos patients directement en utilisant patients = patients_resources.fetch() ou en allant chercher après une opération, comme :patients_resources.search(family='familyname',given='givenname').first() cette ligne vous donnera le premier patient qui sort ayant pour nom de famille 'familyname' et pour nom donné 'givenname'.
Une fois que vous avez les ressources que vous voulez, vous pouvez les analyser dans une ressource fhir.resources.
Par exemple :
patient0 = Patient.parse_obj(patients_resources.search(family='familyname',given='givenname1').first().serialize())
patient0 est un patient de fhir.resources, pour l'obtenir nous avons utilisé nos patients_resources comme cela a été montré précédemment où nous avons sélectionné un certain nom de famille et un prénom, après cela nous avons pris le premier qui est apparu et l'avons sérialisé.
En mettant ce patient sérialisé à l'intérieur d'un Patient.parse_obj nous allons créer un patient de fhir.resources .
Maintenant, vous pouvez accéder directement à n'importe quelle information que vous voulez comme le nom, le numéro de téléphone ou toute autre information.
Pour ce faire, utilisez juste par exemple :
patient0.name
Cela renvoie une liste de HumanName composée chacune d'un attribut use un attribut family un attribut given
as the FHIR convention is asking.
Cela signifie que vous pouvez obtenir le nom de famille de quelqu'un en faisant :
patient0.name[0].family
Pour enregistrer toute modification de notre serveur effectuée sur un fhir.resources ou pour créer une nouvelle ressource serveur, nous devons utiliser à nouveau notre client.
client.resource('Patient',**json.loads(patient0.json())).save()
En faisant cela, nous créons une nouvelle ressource sur notre client, c'est-à-dire un patient, qui obtient ses informations de notre fhir.resources patient0. Ensuite, nous utilisons la fonction save() pour poster ou mettre notre patient sur le serveur.
Ce référentiel est prêt à être codé dans VSCode avec les plugins InterSystems.
Ouvrez /src/client.py pour commencer à coder ou utiliser l'autocomplétion.
Le dockerfile le plus simple pour démarrer un conteneur Python.
Utilisez docker build . pour construire et rouvrir votre fichier dans le conteneur pour travailler à l'intérieur de celui-ci.
Fichier de paramètres.
Fichier de configuration si vous voulez déboguer.
Ceci est un client fhir simple en java pour s'exercer avec les ressources fhir et les requêtes CRUD vers un serveur fhir.
Notez que pour la majeure partie, l'autocomplétion est activée.
Assurez-vous que git et Docker desktop sont installé.
Déjà installé dans le conteneur :
Hapi Fhir modèle et client
Clone/git tire le repo dans n'importe quel répertoire local, par exemple comme indiqué ci-dessous :
git clone https://github.com/LucasEnard/fhir-client-java.git
Ouvrez le terminal dans ce répertoire et exécutez :
docker build .
Ce référentiel est prêt pour CodeVS.
Ouvrez le dossier fhir-client-java cloné localement dans VS Code.
Si vous y êtes invité (coin inférieur droit), installez les extensions recommandées.
Vous pouvez être à l'intérieur du conteneur avant de coder si vous le souhaitez.
Pour cela, il faut que docker soit activé avant d'ouvrir VSCode.
Ensuite, dans VSCode, lorsque vous y êtes invité ( coin inférieur droit ), rouvrez le dossier à l'intérieur du conteneur afin de pouvoir utiliser les composants python qu'il contient.
La première fois que vous effectuez cette opération, cela peut prendre plusieurs minutes, le temps que le conteneur soit préparé.
Si vous n'avez pas cette option, vous pouvez cliquer dans le coin inférieur gauche et cliquer sur Ouvrir à nouveau dans le conteneur puis sélectionner De Dockerfile
En ouvrant le dossier à distance, vous permettez à VS Code et à tous les terminaux que vous ouvrez dans ce dossier d'utiliser les composants java dans le conteneur.
Pour réaliser cette présentation, vous aurez besoin d'un serveur FHIR.
Vous pouvez soit utiliser le vôtre, soit vous rendre sur le site Essai FHIR gratuit d'InterSystems et suivre les étapes suivantes pour le configurer.
En utilisant notre essai gratuit, il suffit de créer un compte et de commencer un déploiement, puis dans l'onglet Overview vous aurez accès à un endpoint comme https://fhir.000000000.static-test-account.isccloud.io que nous utiliserons plus tard.
Ensuite, en allant dans l'onglet d'informations d'identification Credentials, créez une clé api et enregistrez-la quelque part.
C'est maintenant terminé, vous avez votre propre serveur fhir pouvant contenir jusqu'à 20 Go de données avec une mémoire de 8 Go.
La présentation pas à pas du client se trouve à src/java/test/Client.java.
Le code est divisé en plusieurs parties, et nous allons couvrir chacune d'entre elles ci-dessous.
Dans cette partie, nous connectons notre client à notre serveur en utilisant Fhir.Rest.
// Partie 1
// Créer un contexte en utilisant FHIR R4
FhirContext ctx = FhirContext.forR4();
// créer un en-tête contenant la clé api pour le httpClient
Header header = new BasicHeader("x-api-key", "api-key");
ArrayList<Header> headers = new ArrayList<Header>();
headers.add(header);
// créer un constructeur httpClient et lui ajouter l'en-tête
HttpClientBuilder builder = HttpClientBuilder.create();
builder.setDefaultHeaders(headers);
// créer un httpClient à l'aide du constructeur
CloseableHttpClient httpClient = builder.build();
// Configurer le httpClient au contexte en utilisant la fabrique
ctx.getRestfulClientFactory().setHttpClient(httpClient);
// Créer un client
IGenericClient client = ctx.newRestfulGenericClient("url");
Afin de vous connecter à votre serveur, vous devez modifier la ligne :
Header header = new BasicHeader("x-api-key", "api-key");
Et cette ligne aussi :
IGenericClient client = ctx.newRestfulGenericClient("url");
L'url' est un point de terminaison tandis que l'"api-key" est la clé d'api pour accéder à votre serveur.
Notez que si vous n'utilisez pas un serveur InterSystems, vous pouvez vérifier comment autoriser vos accès si nécessaire.
Comme ça, nous avons un client FHIR capable d'échanger directement avec notre serveur.
Dans cette partie, nous créons un Patient en utilisant Fhir.Model et nous le complétons avec un HumanName, en suivant la convention FHIR, use et family sont des chaînes et given est une liste de chaînes. De la même manière, un patient peut avoir plusieurs HumanNames, donc nous devons mettre notre HumanName dans une liste avant de le mettre dans notre patient nouvellement créé.
// Partie 2
// Créer un patient et lui ajouter un nom
Patient patient = new Patient();
patient.addName()
.setFamily("FamilyName")
.addGiven("GivenName1")
.addGiven("GivenName2");
// Voir aussi patient.setGender ou setBirthDateElement
// Créer le patient ressource sur le serveur
MethodOutcome outcome = client.create()
.resource(patient)
.execute();
// Enregistrez l'ID que le serveur a attribué
IIdType id = outcome.getId();
System.out.println("");
System.out.println("Created patient, got ID: " + id);
System.out.println("");
Après cela, nous devons sauvegarder notre nouveau Patient sur notre serveur en utilisant notre client.
Notez que si vous lancez Client.java plusieurs fois, plusieurs Patients ayant le nom que nous avons choisi seront créés.
C'est parce que, suivant la convention FHIR, vous pouvez avoir plusieurs Patients avec le même nom, seul l' id est unique sur le serveur.
Vérifier the doc pour avoir plus d'information.
Nous conseillons donc de commenter la ligne après le premier lancement.
Dans cette partie, nous avons un client qui recherche un patient nommé d'après celui que nous avons créé précédemment.
// Partie 3
// Rechercher un patient unique avec le nom de famille exact "NomDeFamille" et le prénom exact "Prénom1"
patient = (Patient) client.search()
.forResource(Patient.class)
.where(Patient.FAMILY.matchesExactly().value("FamilyName"))
.and(Patient.GIVEN.matchesExactly().value("GivenName1"))
.returnBundle(Bundle.class)
.execute()
.getEntryFirstRep()
.getResource();
// Créer une télécommunication pour le patient
patient.addTelecom()
.setSystem(ContactPointSystem.PHONE)
.setUse(ContactPointUse.HOME)
.setValue("555-555-5555");
// Changer le prénom du patient en un autre
patient.getName().get(0).getGiven().set(0, new StringType("AnotherGivenName"));
// Mettre à jour le patient de ressource sur le serveur
MethodOutcome outcome2 = client.update()
.resource(patient)
.execute();
Une fois que nous l'avons trouvé, nous ajoutons un numéro de téléphone à son profil et nous changeons son prénom en un autre.
Maintenant nous pouvons utiliser la fonction de mise à jour de notre client pour mettre à jour notre patient sur le serveur.
Dans cette section, nous voulons créer une observation pour notre patient. Pour ce faire, nous avons besoin de son identifiant, qui est son identifiant unique.
A partir de là, nous remplissons notre observation et ajoutons comme sujet, l'identifiant de notre Patient.
// Partie 4
// Créer un CodeableConcept et le remplir
CodeableConcept codeableConcept = new CodeableConcept();
codeableConcept.addCoding()
.setSystem("http://snomed.info/sct")
.setCode("1234")
.setDisplay("CodeableConceptDisplay");
// Créer une quantité et la remplir
Quantity quantity = new Quantity();
quantity.setValue(1.0);
quantity.setUnit("kg");
// Créer une catégorie et la remplir
CodeableConcept category = new CodeableConcept();
category.addCoding()
.setSystem("http://snomed.info/sct")
.setCode("1234")
.setDisplay("CategoryDisplay");
// Créer une liste de CodeableConcepts et y placer des catégories
ArrayList<CodeableConcept> codeableConcepts = new ArrayList<CodeableConcept>();
codeableConcepts.add(category);
// Créer une observation
Observation observation = new Observation();
observation.setStatus(Observation.ObservationStatus.FINAL);
observation.setCode(codeableConcept);
observation.setSubject(new Reference().setReference("Patient/" + ((IIdType) outcome2.getId()).getIdPart()));
observation.setCategory(codeableConcepts);
observation.setValue(quantity);
System.out.println("");
System.out.println("Created observation, reference : " + observation.getSubject().getReference());
System.out.println("");
// Créer l'observation de ressource sur le serveur
MethodOutcome outcome3 = client.create()
.resource(observation)
.execute();
// Imprimer la réponse du serveur
System.out.println("");
System.out.println("Created observation, got ID: " + outcome3.getId());
System.out.println("");
Ensuite, nous enregistrons notre observation à l'aide de la fonction de création.
Si vous avez suivi ce parcours, vous savez maintenant exactement ce que fait Client.java, vous pouvez le lancer et vérifier votre Patient et votre Observation nouvellement créés sur votre serveur.
Pour le lancer, ouvrez un terminal VSCode et entrez :
dotnet run
Vous devriez voir des informations sur le Patient créé et son observation.
Si vous utilisez un serveur Intersystems, allez à API Deployement, autorisez-vous avec la clé api et d'ici vous pouvez OBTENIR par id le patient et l'observation que nous venons de créer.
Ce référentiel est prêt à être codé dans VSCode avec les plugins InterSystems.
Ouvrez Client.java pour commencer à coder ou utiliser l'autocomplétion.
Un dockerfile pour créer un dot net env pour que vous puissiez travailler.
Utilisez docker build . pour construire et rouvrir votre fichier dans le conteneur pour travailler à l'intérieur de celui-ci.
Fichier de paramètres.
Fichier de configuration si vous voulez déboguer
Dans ce premier article, un tutoriel simple vous a aidé à mettre en place votre déploiement FHIRaaS.
Maintenant, allons plus loin et présentons une bibliothèque JS pour accéder à la ressource FHIR.
À la fin, deux exemples d'utilisation de cette bibliothèque seront présentés, explorant le type de ressource FHIR Appointment pour les rendez-vous.
FHIR est une API REST, vous pouvez donc utiliser n'importe quel client HTTP pour l'utiliser. Mais c'est toujours une bonne idée d'avoir de l'aide.
En outre, il existe une initiative intéressante appelée SMART qui vise à fournir des normes pour un accès facile aux données de santé stockées dans des systèmes de santé. Cette API s'appuie sur FHIR comme couche de communication. C'est ce qu'on appelle les SMART sur les applications FHIR.
L'équipe SMART a développé une bibliothèque de client JS, qui nous aide à créer des applications compatibles avec les normes SMART. Par exemple, pour initier le flux de code d'autorisation OAuth2, vous avez juste besoin de ce code.
FHIR.oauth2.authorize({
"client_id": "<your-app-client-id>",
"clientSecret": "<your-app-client-secret>",
"scope": "openid profile user/*.*",
"redirect_uri": "http://localhost:64755/iris-on-fhir/index.html",
"iss": "https://fhirauth.lrwvcusn.static-test-account.isccloud.io/oauth2"
});
Remarque : ce code est fourni pour que vous le copiez et le copiez dans l'onglet OAuth 2.0 :
Afin de respecter la norme SMART, vous devez placer ce code dans une page appelée launch.html. Ainsi, un lanceur SMART sera capable de trouver le lanceur de votre application.
Notez que la méthode authorize() fait beaucoup de travail pour nous :
Une autre caractéristique intéressante de cette bibliothèque est qu'il suffit de fournir la ressource FHIR, et elle sélectionne automatiquement les chemins d'accès à l'API. Par exemple, pour obtenir des patients, il suffit d'utiliser la méthode request et de spécifier le type de ressource Patient :
FHIR.oauth2.ready()
.then(client => client.request("Patient/1223"))
.then(resource => console.log(resource))
.catch(console.error);
Cette commande récupère une ressource de type Patient. Ainsi, si vous modifiez cette ressource, vous pouvez l'éditer ou même en créer une autre à partir de ce patient, par les méthodes de mise à jour et d'édition, respectivement :
// enregistre les changements dans la ressource patient
FHIR.oauth2.ready()
.then(client => client.update(resource))
.then(() => console.log('patient updated'))
.catch(console.error);
// crée une nouvelle ressource patient
FHIR.oauth2.ready()
.then(client => client.create(resource))
.then(() => console.log('patient created'))
.catch(console.error);
Notez que vous n'avez pas spécifié de chemin d'accès à l'API FHIR, car la bibliothèque résout le chemin d'accès correct à l'API en fonction du type de la ressource.
Enfin, pour supprimer une ressource :
FHIR.oauth2.ready()
.then(client => client.delete(`Patient/1223`))
.then(() => console.log('patient deleted'))
.catch(console.error);
Afin de montrer l'utilisation d'une autre ressource, créons une simple application de rendez-vous en manipulant la ressource FHIR Appointment.
Veuillez noter qu'il s'agit d'un cas d'utilisation très simple de cette ressource, qui n'utilise que quelques-unes de ses propriétés. En outre, cette ressource est liée à d'autres, qui ne sont pas couvertes ici. Si vous souhaitez en savoir plus sur ces ressources et le flux de travail entre elles, vous devez vous reporter à la spécification HL7 FHIR.
Tout d'abord, un objet modèle est récupéré à partir de la ressource API Development for Appointment. Cet objet est utilisé pour fournir un prototype pour la création et l'édition de rendez-vous.
function getAppointmentTemplate() {
return {
"resourceType": "Appointment",
"id": "examplereq",
...
};
}
Ensuite, une fonction permettant de modifier le prototype est créée. Cette fonction reçoit le prototype de ressource Appointment de rendez-vous et une instance d'un événement de calendrier. Cet objet d'événement contient des propriétés remplies par l'utilisateur via un composant de calendrier, qui seront introduites dans le prototype de ressource.
function setEventDataToResoruce(resource, eventData) {
if (eventData.id) {
resource.id = eventData.id;
}
const patient = getSelectedPatientObject();
resource.participant[0].actor.reference = `Patient/${patient.id}`;
resource.participant[0].actor.display = patient.name[0].given[0];
resource.description = eventData.title;
resource.comment = eventData.extendedProps.description;
if (!resource.comment) {
delete resource.comment;
}
if (eventData.allDay) {
eventData.start = eventData.start.split(" ")[0];
eventData.end = eventData.end.split(" ")[0];
}
const hasTime = {
start: eventData.start.indexOf(" ") > -1,
end: eventData.end.indexOf(" ") > -1
}
if (hasTime.start || hasTime.end) {
resource.requestedPeriod[0].start = new Date(eventData.start).toISOString();
resource.requestedPeriod[0].end = new Date(eventData.end).toISOString();
} else {
resource.requestedPeriod[0].start = eventData.start;
resource.requestedPeriod[0].end = eventData.end;
}
return resource;
}
Grâce à ces deux fonctions, nous pouvons créer et remplir correctement une ressource Rendez-vous. Maintenant, nous devons utiliser la bibliothèque SMART pour effectuer les opérations CRUD sur cette ressource, finalisant ainsi notre application simple de rendez-vous :
function getAppointments(client) {
return client.request(`Appointment`);
}
function createAppointment(eventData) {
const resource = setEventDataToResoruce(
getAppointmentTemplate(), eventData
);
return getFHIRClient()
.then(client => {
return client.create(resource);
});
}
function updateAppointment(eventData) {
const resource = setEventDataToResoruce(
getAppointmentTemplate(), eventData
);
return getFHIRClient()
.then(client => {
return client.update(resource);
});
}
function deleteAppointment(id) {
return getFHIRClient()
.then(client => {
return client.delete(`Appointment/${id}`);
});
}
Voici un screencast de l'application en cours d'exécution :
N'oubliez pas que le code exposé ici est simplement l'essentiel pour comprendre l'application. Mais, si vous souhaitez plus de détails, veuillez consulter le code source.
Comme dernière démonstration de ce que vous pouvez faire de cool avec FHIRaaS, je voudrais montrer un bot Telegram très simple.
J'ai entièrement basé cette fonctionnalité sur les travaux de Nikolay Soloviev et Sergey Mikhailenko. Dans l'article de Nikolay, vous pouvez voir comment créer le robot dans Telegram. Consultez également l'application de Sergey Mikhailenko pour obtenir plus d'informations sur les bots Telegram.
Comme le plus gros du travail a déjà été fait par Nikolay et Serguey, j'ai juste ajouté une couche supplémentaire de code. Cette couche récupère l'identifiant du patient, ainsi que la date et l'heure du rendez-vous, auprès des utilisateurs de Telegram, dans le cadre d'une simple interaction de type chat, sans fonctionnalités NLP. Après avoir récupéré ces informations, un point de terminaison FHIRaaS est appelé pour afficher un nouveau rendez-vous.
Voici un screencast du bot en action :
Si vous souhaitez obtenir plus de détails sur la mise en œuvre, veuillez consulter le code de l'application.
Dans cet article, nous avons fait une présentation de la bibliothèque SMART on FHIR JavaScript Library et montré comment l'utiliser sur deux exemples basés sur le type de ressource FHIR Appointment.
Dans le prochain article, nous allons approfondir les autres fonctionnalités de l'application iris-on-fhir.
Salut la communauté,
Nous sommes ravis de partager avec vous une session spéciale du Global Summit 2022 ! Et c'est si spécial pour nous parce qu'il parle de nous et est avec nous ! Veuillez accueillir :
Salut la communauté,
Nous sommes heureux de vous inviter au prochain webinaire de lancement du concours d'interopérabilité : Créer des solutions durables ! Le sujet de ce webinaire est dédié au concours de programmation d'interopérabilité.
Pendant ce webinaire, nous vous montrerons des certains principes généraux et des problèmes de résolution des problèmes de développement durable, ainsi que quelques bonnes idées qui ont surgi lors des hackathons pour vous inspirer et les choses à faire et à ne pas faire.
De plus, nous discuterons et répondrons aux questions sur la façon de créer des solutions d'interopérabilité à l'aide d'InterSystems IRIS et IRIS for Health.
Date et heure: lundi 29 août – 09 h 00 HAE
Speakers:
🗣 Tomas Studenik, PDG d'Insane Business Ideas et co-fondateur de Caelestinus
🗣 @Dean Andrews, responsable des relations avec les développeurs
🗣 @Evgeny Shvarov, responsable de l'écosystème des développeurs InterSystems
Formation complète en full Python pour construire de zéro une production sur IRIS. Durée environ 30-45 minutes mais possibilité de tout copier coller ou d'acceder directement à la solution sur la branche solution du github.
Ce projet a vu le jour lorsque j'ai réfléchi à la manière de permettre au code Python de traiter naturellement le mécanisme de stockage évolutif et de récupération efficace fourni par les globales IRIS, par le biais de la technologie Embedded Python.
Mon idée initiale était de créer une sorte d'implémentation de dictionnaire Python en utilisant les globales, mais j'ai vite réalisé que je devais d'abord m'occuper de l'abstraction des objets.
J'ai donc commencé à créer des classes Python capables d'envelopper des objets Python, de stocker et de récupérer leurs données dans des globales, c'est-à-dire de sérialiser et de désérialiser des objets Python dans des globales IRIS.
Comme ObjectScript%DispatchGetProperty(), %DispatchSetProperty() et %DispatchMethod(), Python dispose de méthodes permettant de déléguer les appels aux propriétés et aux méthodes des objets.
Lorsque vous définissez ou récupérez une propriété d'objet, l'interpréteur Python vous permet d'intercepter cette opération par les méthodes __setattr__(self, name, value) et __getattr(self, name)__.
Regardez cet exemple de base :
>>> class Test:
... def __init(self, prop1):
... self.prop1 = prop1
... def __setattr__(self, name, value):
... print(f"setting property {name} to value {value}")
... def __getattr__(self, name):
... print(f"getting property {name}")
...
>>> obj = Test()
>>> obj.prop1 = "test"
setting property prop1 to value test
>>> obj.prop1
getting property prop1
>>> obj.prop2
getting property prop2
>>> obj.prop2
getting property prop2
>>>
Notez que les méthodes __setattr__() et __getattr()__ ont été appelées indirectement par les opérations set et get sur les objets de la classe Test - qui implémente ces méthodes. Même une propriété non déclarée, comme prop2 dans cet exemple, émet des appels vers elles.
Ce mécanisme est le cœur du test de sérialisation que j'ai essayé dans mon projet python-globales-convertisseur-exemple. Avec ce mécanisme, vous pouvez intercepter les opérations set/get et stocker/récupérer les données des globales IRIS.
Les globales offrent une structure hautement personnalisable. En utilisant leur modèle hiérarchique pour l'accès aux informations, qui est assez similaire aux objets JSON et aux dictionnaires Python, nous pouvons stocker les données des propriétés des objets et les métadonnées.
Voici comment j'ai utilisé une globale pour créer un modèle d'objet simple pour sérialiser des objets Python :
Pour chaque objet sérialisé, son nom de classe est sérialisé dans un nœud étiqueté "class" :
^test(1,"class")="<class 'employee.SalaryEmployee'>"
Le premier indice est un nombre incrémental qui est utilisé comme référence à cet objet dans le modèle. Ainsi, dans l'exemple ci-dessus, un objet de la classe employee.SalaryEmployee est stocké avec la valeur de référence 1.
Pour les propriétés de types de données primitives, leur type et leur valeur sont stockés. Par exemple :
^test(1,"name","type")="<class 'str'>"
^test(1,"name","value")="me"
Cette structure est interprétée comme l'objet référencé par l'index 1, a une propriété appelée name, avec une valeur égale à 'me'.
Pour les propriétés référençant des objets, le modèle est légèrement différent, car contrairement aux objets JSON ou aux dictionnaires Python, les globales sont destinés à stocker uniquement des données de type primitif. Donc un autre noeud "classe" est créé pour cet objet référencé, et son index de noeud (c'est-à-dire sa référence) est stocké dans le noeud de propriété :
^test(1,"company","oref")=2
^test(1,"company","type")="<class 'iris_global_object.IrisGlobalObject'>"
^test(2,"class")="<class 'employee.Company'>"
^test(2,"name","type")="<class 'str'>"
^test(2,"name","value")="Company ABC"
Ces structures signifient que l'objet 1 a une propriété appelée company, dont les valeurs sont stockées dans l'index 2 - notez la valeur de ^test(1, "company", "oref").
Lorsque vous créez un wrapper pour sérialiser ou désérialiser des objets Python, vous devez définir le nom de la globale qui stocke l'objet.
Ensuite, le processus de sérialisation est effectué lorsqu'une opération set est exécutée. La méthode __setattr__() définit la valeur et le type de la propriété dans la globale définie pour stocker l'objet, en utilisant le modèle d'objet simple expliqué précédemment.
Dans le sens inverse, une désérialisation est effectuée par la méthode __getattr__, lorsqu'une opération get est effectuée.
Pour les types de données primitifs, ce processus est simple : il suffit de récupérer la valeur stockée dans la globale et de la retourner.
Mais pour les objets, le processus doit instancier le type de données de leur classe et définir également toutes leurs propriétés. De cette façon, un objet Python restauré peut être utilisé, y compris les appels à ses méthodes.
Comme nous l'avons dit au début de cette entrée, ce projet est né comme une simplification d'une façon de laisser le code Python utiliser les globales comme un moteur de stockage naturel, et vise à être juste une preuve de concept.
La sérialisation/désérialisation d'objets n'est que le début de cet objectif. Il y a donc beaucoup d'efforts à faire pour que cette idée arrive à maturité.
J'espère que cette entrée vous permettra de comprendre le but de mon travail dans ce projet, et qu'elle pourra vous inspirer à réfléchir à de nouvelles façons d'utiliser les globales IRIS pour rapprocher Python d'IRIS.
Salut la communauté !
Rencontrons-nous lors de la réunion en ligne avec les gagnants du concours InterSystems Full Stack – une excellente occasion de discuter avec l'équipe d'experts InterSystems ainsi qu'avec nos participants. Démonstration des gagnants incluse !
Date et heure : Vendredi 22 juillet - 12h00 PM EDT
Salut la communauté,
Nous sommes très heureux d'annoncer les gagnants du concours InterSystems Full Stack 2022!
Merci à tous d'avoir participé à notre concours de codage ! Et les gagnants sont...
Salut la communauté,
C'est l'heure de voter ! Soumettez vos votes pour les meilleures applications du concours InterSystems Full Stack 2022:
🔥 VOTEZ POUR LES MEILLEURES APPLICATIONS 🔥
Comment voter ? Détails ci-dessous.
Bonjour la Communauté,
Nous avons le plaisir de vous inviter au prochain webinaire de lancement du concours Full Stack d'InterSystems sur le changement climatique ! Le sujet de ce webinaire est consacré au concours Full Stack.
Nous discuterons des principaux défis et problèmes posés par le changement climatique et le réchauffement de la planète et de la manière dont ils peuvent être résolus. Comme toujours, nos experts répondront aux questions sur la façon de développer, construire et déployer des solutions full-stack en utilisant InterSystems IRIS.
Date et heure : lundi 27 juin - 09h00 EDT
Intervenants :
🗣 Ainar Abdrakhmanov, expert en changement climatique, co-auteur du cours 4 vagues, co-fondateur, PDG à Longevica
🗣 @Timothy Leavitt, InterSystems Development Manager
🗣 @Evgeny Shvarov, InterSystems Developer Ecosystem Manager
Salut la communauté,
Retrouvons-nous lors de la rencontre en ligne avec les gagnants d'InterSystems Grand Prix contest!
Une belle occasion d'échanger avec nos Experts sur la technologie InterSystems. Démos de nos gagnants incluses !
Date et heure: vendredi 10 juin 2022 - 11h00 HAE
Salut la communauté,
Nous sommes ravis d'annoncer les gagnants d'InterSystems Grand Prix Programming contest.
Ce concours a été un franc succès ! Pour montrer notre appréciation à nos incroyables concurrents, nous avons doublé les prix pour les finalistes !
Alors rencontrons les gagnants...
Salut les développeurs !
Voici le score des bonus techniques pour les participants de l'InterSystems Grand Prix 2022 Contest!
Salut les développeurs,
Que la semaine du vote commence ! C'est le moment de voter pour les meilleures applications du Grand Prix Programming Contest!
🔥 C'est vous qui décidez : VOTEZ ICI 🔥
Comment voter ? Détails ci-dessous.
Salut les développeurs !
InterSystems Grand Prix réunit toutes les fonctionnalités clés des plateformes de données InterSystems !
Ainsi, nous vous invitons à utiliser les fonctionnalités suivantes et à collecter des bonus techniques supplémentaires qui vous aideront à gagner le prix !
Nous y voilà!
Salut la communauté,
Nous sommes ravis d'inviter tous les développeurs au prochain webinaire de lancement du concours InterSystems Grand Prix 2022!
Nous partagerons les détails de notre méga concours Grand Prix Contest 2022 et décrirons comment vous pouvez gagner jusqu'à 22 000 $ en prix ! Contrairement à nos autres concours InterSystems Developer Community, ce concours vous permet d'utiliser n'importe quel élément de notre plateforme de données - IntegratedML, Native API, multi-modèle, Analytics et NLP, Open API and Interoperability, IKO etc. - dans votre projet.
Dans ce webinaire, nous parlerons des sujets attendus des participants et vous montrerons comment développer, créer et déployer des applications sur la plate-forme de données InterSystems IRIS.
Date et heure: lundi 9 mai à 11:00 EDT
Haut-parleurs:
🗣 @Alex Woodhead, InterSystems Technical Specialist
🗣 @Bob Kuszewski, InterSystems Product Manager
🗣 @Jeff Fried, InterSystems Director of Product Management
🗣 @Dean Andrews, InterSystems Head of Developer Relations
🗣 @Evgeny Shvarov, InterSystems Developer Ecosystem Manager
Le concours annuel pour les développeurs d'InterSystems IRIS approche !
Nous sommes ravis de vous inviter tous à participer au concours Grand Prix pour la création de solutions open source à l'aide de la plate-forme de données InterSystems IRIS !
Les nouveaux développeurs sont bienvenus - créez un compte maintenant.
🏆Concours de programmation Grand Prix InterSystems 🏆
Les prix : plus de 22 000 $
La durée : du 9 au 29 mai 2022
Période de vote : 30 mai - 5 juin 2022
Le sujet
Le Grand Prix InterSystems est notre concours de programmation annuel pour trouver la meilleure application qui utilise InterSystems IRIS. Nous accueillons les candidatures sur n'importe quel sujet !
Présentez toute application qui utilise InterSystems IRIS comme backend (API ou base de données) avec n'importe quel type d'API InterSystems IRIS ou de modèle de données.
Vous êtes invités à améliorer vos applications que vous avez présentées dans la série de concours InterSystems l'année dernière et à les soumettre pour le Grand Prix. Et vous êtes invités à soumettre une nouvelle applications.
Exigences générales :
Prix du concours :
1. Nomination des experts – les gagnants seront sélectionnés par l'équipe d'experts d'InterSystems :
🥇 1ère place - $7,000
🥈 2e place - $5,000
🥉 3e place - $3,000
🌟 4-20ème place - $100
2. Gagnants de la communauté – candidatures qui recevront le plus de votes au total :
🥇 1ère place - $3,000
🥈 2e place - $2,000
🥉 3e place - $1,000
✨ Badges Global Masters pour tous les gagnants sont inclus !
Remarque : si plusieurs participants obtiennent le même nombre de votes, ils sont tous considérés comme gagnants et le prix est partagé entre les gagnants.
Délais importants :
🛠 Phase de développement et d'inscription de l'application :
✅ Période de vote:
Remarque : Les développeurs peuvent améliorer leurs applications tout au long de la période d'inscription et de vote.
Qui peut participer ?
Tout membre de la communauté de développeurs, à l'exception des employés d'InterSystems (sous-traitants ISC autorisés). Créer un compte !
Les développeurs peuvent s'associer pour créer une application collaborative. Autorisé de 2 à 5 développeurs dans une équipe.
N'oubliez pas de mettre en évidence les membres de votre équipe dans le README de votre application – profils d'utilisateurs DC.
Ressources utiles :
✓ Comment travailler avec InterSystems IRIS (pour les débutants) :
✓ Pour les débutants avec ObjectScript Package Manager (ZPM) :
✓ Comment soumettre votre application au concours :
✓ Exemples d'applications IRIS :
Besoin d'aide ?
Rejoignez la chaîne du concours sur le serveur Discord d'InterSystems ou discutez avec nous dans les commentaires de ce post.
Nous avons hâte de voir vos projets! Bonne chance 👍
En participant à ce concours, vous acceptez les conditions du concours énoncées ici. Veuillez les lire attentivement avant de continuer.
🎉 🎉 🎉
Merci à tous et à toutes qui partagent leurs applications !
Et bienvenue sur Open Exchange à tous ceux qui ne l'ont pas encore fait.
