Accès aux Antécédents

Le but de cet article est d’expliquer comment accéder aux nouveau module des Antécédents d’ Easily à partir d’un formulaire et de pouvoir y exporter une sélection d’antécédents.

Dans le formulaire

Ajouter un groupe avec entête personnalisée afin d’y ajouter un bouton permettant l’accès aux antécédents.

Dans la propriété Image du bouton récupérer une image de téléchargement (image attachée à cet article) qui aura été préalablement ajoutée en tant qu’image dans l’arborescence du projet :

Propriété du bouton pour associer l’image d’accès aux antécédents :

Dans le modèle de données du formulaire

Dans l’onglet Données :

Il est nécessaire de déclarer les variables utiles à l’ouverture des antécédents à savoir :

• Un identifiant unique : pour la fenêtre en cours, permet au module antécédents de savoir dans quelle fenêtre Dominho envoyer les données exportées
• Un répertoire : permet de signifier quels sont les antécédents à ouvrir

 

Dans l’onglet Logique :

Déclarer une fonction locale “OuvrirATCD” permettant l’appel au module Antécédents  pour cela dans FormsStudio choisir l’action « Ouvrir un module easily » et positionner  les paramètres d’ouverture d’une url via l’action de FormsStudio « Paramètre d’ouverture d’une url » suivants :

• Code du CR
• Identifiant patient
• Répertoire
• Identifiant fenêtre

Pour affecter les variables à chaque paramètre accéder à l’éditeur d’expression FormsStudio dans la propriété Valeur du paramètre.

Dans l’éditeur d’expression, les valeurs proviennent :

soit de l’onglet “Modèle” tel est le cas pour les paramètres :

• Code du CR
• Répertoire
• Identifiant fenêtre
• Antécédents à importer

Soit de l’onglet “Contexte” tel est le cas pour les paramètres :

• Code du CR
• Identifiant patient

Exemple pour le code du CR :

Déclarer une fonction distante “OuvrirATCDDistant” pour le passage du répertoire qui indiquera au module Antécédents quel est la partie à ouvrir dans le cas présent les ANTECEDENTS :

Dans le code c# on aura pour la fonction “OuvrirATCDDistant”:
protected override void OuvrirATCDDistant(IExecutionContext context, string param_folder)
{
this.folder.Value = param_folder;
}
Lancement du module Antécédents :

Dans la propriété du bouton d’ouverture des antécédents sous l’action “Onclick”  faire appel à la fonction “OuvrirATCDDistant” et paramétrer dans le paramètre « param_folder » le texte « ANTECEDENTS » afin d’indiquer qu’on souhaite lancer les antécédents :

Il est également possible d’ouvrir les autres vues du module antécédents en utilisant l’un des paramètres suivants :

• SYNTHESE,
• ANTECEDENTS,
• TRAITEMENT DE FOND,
• FACTEURS DE RISQUE,
• VACCIN,
• RISQUES SANITAIRES,
• DPC

Sur la propriété Callback de la fonction distante “OuvrirATCDDistant” faire appel à la fonction “OuvrirATCD” :

Après avoir publié le formulaire, le clic du bouton Antécédents permet d’afficher les antécédents :

Export des données antécédents dans le formulaire :

Préparation du formulaire :

Pour pouvoir renseigner le formulaire avec les données du module antécédents, il est nécessaire de déclarer une inclusion dans le formulaire.

Dans l’arborescence du formulaire ajouter une inclusion « incl_antecedents » :

Dans le modèle de données de l’inclusion ajouter les éléments suivants :

• id : identifiant de l’antécédent,
• date_antecedent : date de l’antécédent,
• type_antecedent : type de l’antécédent,
• libelle_antecedent : libellé de l’antécédent,
• commentaire_antecedent : commentaire de l’antécédent.

Dans le modèle du formulaire, dans l’onglet Données ajouter une inclusion multiple à laquelle est associée l’inclusion décrite précédemment :

Dans le formulaire, ajouter une inclusion de type inclusion multiple en tableau dans le groupe Antécédenst, étiré le composant de sorte qu’il prenne toute la largeur du formulaire via la propriété Positionnement, Alignement.

Ajouter quatre entêtes et les nommer de la façon suivante : Date, Type, Commentaire et une entête vierge, ajouter 3 libellés générés qui pointeront sur les champs de l’inclusion «antecedents » accessible par l’éditeur d’expression et un bouton pour suppression de l’antécédent ajouter.

Programmation du bouton supprimer :

Dans l’onglet logique du modèle de l’inclusion « incl_antecedents » ajouter une fonction locale « SuppressionATCD ». Dans l’arborescence du formulaire ajouter un évènement « SupprimerATCD » avec un paramètre entier nommé Index qui correspondra à l’index de l’élément à supprimer.

Dans la fonction « SuppressionATCD » ajouter l’action “Emettre un évènement” et associer l’ évènement précédemment déclaré avec comme paramètre index, l’index courant de l’inclusion.

Dans le modèle « incl_antecedents » dans l’onglet logique on aura :

Afin de pouvoir intercepter la suppression de l’élément sur le clic du bouton suppression dans le formulaire, il est nécessaire d’ajouter dans le modèle de données du formulaire un gestionnaire d’ événement. Dans l’onglet logique du modèle de données ATCD ajouter l’action « Gestionnaire d’ événement » nommé « SuppressionLigneATCD ».

Ajouter dans le modèle de données une fonction locale avec en paramètre l’index à supprimer pour suppression d’un élément d’inclusion. Nommer la fonction « SupprimerEltATCD », ajouter l’action « Supprimer un élément », et déclarer le champ d’insertion à supprimer soit « antecedents » et l’index à supprimer soit « index_supp ».

La fonction sera de la forme :

Dans le gestionnaire d’ événement programmer l’ événement « SupprimerATCD » et la fonction à appeler « SupprimerEltATCD » de tel sorte :

Le gestionnaire d’ événement sera de la forme :

Sous le bouton de suppression dans la propriété Actions-OnClick faire appel à la fonction « SuppressionATCD ».

Préparation du modèle de données

Dans le modèle de données ajouter une variable pour récupération des données du module Antécédents soit la valeur texte « atcd_import ».

Modifier la fonction distante « OuvrirATCDDistant » en ajoutant un paramètre pour pouvoir renseigner l’inclusion du formulaire.

Dans l’appel de la fonction distante dans le Onclick du bouton renseigner l’inclusion « incl_antecedents » :

Dans la fonction locale « OuvrirATCD » ajouter un paramètre d’ouverture (VsmActdImport) d’url pour la donnée « atcd_import ».

Dans la partie c#

Renseigner une classe dans le global.cs de la sorte :
using System.Collections.Generic;
using System;
using System.Linq;

namespace Forms.Modules.TEST_MODULE
{
}

public class ExportATCD
{
/// <summary>
/// Type
/// </summary>
public string type;

/// <summary>
/// Liste des identifiants des antécédents exportés depuis le module antécédents
/// </summary>
public List<int> list = new List<int>();
}
Compléter la fonction distante « OuvrirATCDDistante » afin de pouvoir récupérer les antécédents sélectionner par l’utilisateur de la sorte:
protected override void OuvrirATCDDistant(IExecutionContext context, string param_folder, string param_inclusion_cible)
{
this.folder.Value = param_folder;
this.actd_import.Value = null;
MultipleInsertModelFieldEditor<Inclusions.Model_incl_antecedents> incl_cible = null;

incl_cible = this.antecedents;

if (incl_cible != null && incl_cible.Items.Count > 0)
{
List<ExportATCD> listeImport = new List<ExportATCD>();
ExportATCD importAntecedent = new ExportATCD() { type = “antecedent” };
ExportATCD importAllergies = new ExportATCD() { type = “allergie” };
ExportATCD importPsychiatrie = new ExportATCD() { type = “psychologie” };
foreach (var atcd in incl_cible.Items)
{
if (atcd.type_antecedent.Value != “ALL” && atcd.type_antecedent.Value != “PSY”)
{
importAntecedent.list.Add(atcd.id.Value.Value);
}
else if (atcd.type_antecedent.Value == “PSY”)
{
importPsychiatrie.list.Add(atcd.id.Value.Value);
}
else if (atcd.type_antecedent.Value == “ALL”)
{
importAllergies.list.Add(atcd.id.Value.Value);
}
}

if (importAntecedent.list.Any())
{
listeImport.Add(importAntecedent);
}

if (importAllergies.list.Any())
{
listeImport.Add(importAllergies);
}

if (importPsychiatrie.list.Any())
{
listeImport.Add(importPsychiatrie);
}

this.actd_import.Value = new System.Web.Script.Serialization.JavaScriptSerializer().Serialize(listeImport);
}
}
Pour la sérialisation, une bibliothèque est nécessaire et doit être ajouté dans le répertoire Bibliothèques externes de l’arborescence FormsStudio :

La bibliothèque est lié à cet article. 

Passage des antécédents dans le formulaire

Afin de pouvoir renseigner les antécédents dans le formulaire à partir de la fenêtre du module Antécédents, il faut déclarer dans le modèle de données du formulaire un post Message et une fonction distante.

Dans le modèle de données du formulaire ajouter la fonction distante « ExportATCD » avec un paramètre de type Texte :

Dans le modèle de données du formulaire ajouter le gestionnaire de post message et le nommer « sendATCD » accessible dans la boite à outil FormsStudio dans Gestionnaire d’ événement, ajouter l’appel à la fonction « ExportATCD ».

 

Dans le c# programmer la fonction “ExportATCD” de la sorte :
private string ObtenirTypeAntecedent(int antecedentId)
{
string typeAntecedent = string.Empty;

switch (antecedentId)
{
case 1:
typeAntecedent = “MED”;
break;
case 2:
typeAntecedent = “CHIR”;
break;
case 3:
typeAntecedent = “GYN”;
break;
case 4:
typeAntecedent = “FAM”;
break;
case 5:
typeAntecedent = “ALL”;
break;
}
return typeAntecedent;
}

protected override void ExportATCD(IExecutionContext context, string PARAMETERS)
{
this.antecedents.Items.Clear();

this.erreur_recup_antecedent.Value = string.Empty;
//enum typeAntecendet {
//1 med, 2 chir, 3 gyn, 4 fam,5 all}

try
{
List<ExportATCD> listExportATCD = new System.Web.Script.Serialization.JavaScriptSerializer().Deserialize<List<ExportATCD>>(PARAMETERS);

if (listExportATCD.Count > 0)
{
#region Traitements des antécédents exportés
ExportATCD exportAntecedent = listExportATCD.Where(e => e.type == “antecedent”).FirstOrDefault();
if (exportAntecedent != null)
{
var antecedentsListe = ModuleAPI.VSMService.GetAntecedentByIds(exportAntecedent.list, EditionContext.ContextData.UserId);

if (antecedentsListe.Count >= 1)
{
foreach (var atcd in antecedentsListe.OrderBy(a => a.TypeAntecedentId))
{
var item = new Inclusions.Model_incl_antecedents(EditionContext);
item.id.Value = atcd.Id;
item.date_antecedent.Value = atcd.DateSaisieForEditing;
item.libelle_antecedent.Value = atcd.Code + ” ” + atcd.Libelle;
item.type_antecedent.Value = ObtenirTypeAntecedent(atcd.TypeAntecedentId);
item.commentaire_antecedent.Value = atcd.Commentaire;

this.antecedents.Items.Add(item);
}
}
}
#endregion

#region Traitements des allergies exportées
ExportATCD exportAllergies = listExportATCD.Where(e => e.type == “allergie”).FirstOrDefault();
if (exportAllergies != null)
{
var listeAllergies = ModuleAPI.VSMService.GetAllergieByIds(exportAllergies.list, EditionContext.ContextData.UserId);

if (listeAllergies.Count >= 1)
{
foreach (var allergie in listeAllergies.OrderBy(a => a.TypeAntecedentId))
{
var item = new Inclusions.Model_incl_antecedents(EditionContext);
item.id.Value = allergie.Id;
item.date_antecedent.Value = allergie.DateSaisie.ToShortDateString();
item.libelle_antecedent.Value = allergie.Code + ” ” + allergie.Libelle;
item.commentaire_antecedent.Value = allergie.Manifestation;
item.type_antecedent.Value = “ALL”;

this.antecedents.Items.Add(item);
}
}
}
#endregion

#region Traitements des antécédents psychiatriques exportés
ExportATCD exportPsy = listExportATCD.Where(e => e.type == “psychiatrie”).FirstOrDefault();
if (exportPsy != null)
{
var listePsy = ModuleAPI.VSMService.RecupererTroublePsyParIds(exportPsy.list);

if (listePsy.Count >= 1)
{
foreach (var antecedentPsy in listePsy)
{
var item = new Inclusions.Model_incl_antecedents(EditionContext);
item.id.Value = antecedentPsy.Id;
item.date_antecedent.Value = antecedentPsy.DateSaisie.HasValue && antecedentPsy.DateSaisie.Value != DateTime.MinValue ? antecedentPsy.DateSaisie.Value.ToString(“d”) : null;
item.libelle_antecedent.Value = antecedentPsy.CodeCim + ” ” + antecedentPsy.Libelle;
item.commentaire_antecedent.Value = antecedentPsy.Commentaire;
item.type_antecedent.Value = “PSY”;

this.antecedents.Items.Add(item);
}
}
}
#endregion

}
}
catch (Exception ex)
{
if (string.IsNullOrEmpty(this.erreur_recup_antecedent.Value))
{
this.erreur_recup_antecedent.Value = “Une erreur est survenue lors de la récupération des antécédents depuis le module Antécédent médicale”;
ModuleAPI.LoggerService.Error(new LogOptions()
{
Message = “Une erreur est survenue lors de la récupération des antécédents depuis le module Antécédent médicale”,
Exception = ex
});
}
}
}
Dans le formulaire, seuls les éléments antécédents cochés dans le module Antécédents remontent :