Développement de formulaires Web : Mode avancé

Aperçu

Le mode avancé est spécialement conçu pour les développeurs en offrant un contrôle total sur tous les aspects d'un formulaire Web. Cela permet une plus grande flexibilité et offre plus de possibilités pour les fonctions pouvant entrer dans le formulaire Web.

Création de l'application Web

Outils de développement suggérés

    Visual Web Developer Express 2015 ou version supérieure
    Visual Studio 2015 ou version supérieure

Répertoire d'installation des formulaires Web

Nous vous suggérons fortement de stocker tous vos formulaires Web dans le répertoire \wfgen\wfapps\webforms (p.ex. : \wfgen\wfapps\webforms\MonFormulaireWeb).
Notez que si vous modifiez votre processus WorkflowGen et que vous devez modifier le MonFormulaireWeb associé en raison de ces modifications, vous devez au préalable dupliquer MonFormulaireWeb, puis créer une autre application IIS. Sinon, les deux versions du processus utiliseront le même MonFormulaireWeb modifié.

Créez l'application dans IIS

L'application du formulaire Web doit être déclarée en tant qu'application dans IIS pour être reconnue en tant qu'application de formulaire Web .NET. Suivez ces instructions pour déclarer votre répertoire de formulaires Web en tant qu'application IIS :

Pour IIS 7 ou version ultérieure

    1.
    Ouvrez Gestionnaire IIS.
    2.
    Accédez à l'emplacement de votre formulaire Web, qui doit se trouver dans le nœud Site Web par défaut sous \wfgen\wfapps\webforms\MonFormulaireWeb.
    3.
    Faites un clic droit sur MonFormulaireWeb et choisissez Convertir en application.
    4.
    Sélectionnez le pool d'applications utilisé par votre site et un autre pool d'applications spécifique.
    5.
    Cliquez sur OK.

Création du projet avec Visual Studio

Créez le projet

    1.
    Ouvrez Visual Studio et sélectionnez Fichier > Nouveau site Web.
    2.
    Choisissez Site Web ASP.NET.
    3.
    Choisissez Système de fichiers dans la liste déroulante Emplacement.
    4.
    Cliquez sur Parcourir, puis choisissez l'emplacement de votre site Web ASP.NET.
    5.
    Cliquez sur OK.

Créez un DataSet typé

Vous devrez créer un nouvel élément DataSet dans votre projet et y ajouter un DataTable Table1. Suivez ces étapes afin d'ajouter un nouveau DataSet dans votre projet Web :
    1.
    Faites un clic droit sur votre projet et sélectionnez Ajouter un nouvel élément...
    2.
    Choisissez DataSet, puis cliquez sur Ajouter.
    3.
    Une fenêtre contextuelle apparaîtra vous demandant de choisir une connexion de données; cliquez sur Annuler car un DataSet ne peut pas être attaché à une source de données spécifique (il sera à la place envoyé dynamiquement lors de l'exécution).
    4.
    Faites un clic droit dans l'espace vide et sélectionnez Ajouter > DataTable.
    5.
    Renommez DataTable1 en Table1.
    6.
    Ajoutez tous vos noms de champ de formulaire et les paramètres IN, OUT et INOUT en tant que colonnes dans ce tableau.
    ✏️ Note : Il est nécessaire de reconstruire votre formulaire Web chaque fois que vous modifiez cette définition de DataSet.
    7.
    Ajoutez une variable DataSet à votre code Default.aspx.cs et instanciez-la dans le constructeur par défaut de votre classe. Si votre nom de classe est Form, le code ressemblera à ceci pour l'instant :
    1
    public partial class Form : WorkflowGen.My.Web.UI.WebForms.WorkflowPage
    2
    {
    3
    protected DataSet1 formData;
    4
    5
    public Form() : base()
    6
    {
    7
    formData = new DataSet1();
    8
    }
    Copied!

Obtenir des messages d'erreur détaillés

Par défaut, vous n'aurez aucun fichier web.config dans votre projet Web si vous utilisez C# comme langage de développement dans l'IDE de Microsoft Visual Studio. Pour afficher des messages d'erreur complets lorsque vous souhaitez déboguer, vous devez disposer d'un fichier web.config. Pour ajouter un fichier web.config par défaut à votre projet, procédez comme suit :
    1.
    Faites un clic droit sur le nom de votre projet, puis cliquez sur Ajouter un nouvel élément...
    2.
    Choisissez Fichier de configuration Web, puis cliquez sur OK.
Afin de pouvoir voir les messages d'erreur complets, modifiez les propriétés suivantes dans le fichier web.config :
    1.
    Assurez-vous que cette ligne est définie sur "true" :
    1
    <compilation debug="true" />
    Copied!
    2.
    Assurez-vous que le suivant n'est pas commenté et que la propriété mode est définie sur "Off" :
    1
    <customErrors mode="Off" defaultRedirect="GenericErrorPage.htm">
    2
    <error statusCode="403" redirect="NoAccess.htm" />
    3
    <error statusCode="404" redirect="FileNotFound.htm" />
    4
    </customErrors>
    Copied!

Implémentation de base

Référence

Vous devez ajouter une référence à WorkflowGen.My.dll dans votre projet Web, puis ajouter cette instruction au début de votre formulaire Web :
1
using WorkflowGen.My.Web.UI.WebForms;
Copied!

Héritage de classe

Votre formulaire Web doit hériter de la classe WorkflowPage contenue dans l'espace de noms WorfklowGen.My.Web.UI.WebForms.

Utilisation du mode avancé

Lorsque vous utilisez le mode avancé de WorkflowPage, vous devez spécifier que vous n'utilisez pas le mode simple. Utilisez le code suivant pour ce faire :
1
public partial class Form : WorkflowGen.My.Web.UI.WebForms.WorkflowPage
2
{
3
protected DataSet1 formData;
4
5
public Form() : base()
6
{
7
8
// Définissez la propriété SimpleMode sur False pour utiliser le mode avancé
9
IsSimpleMode = false;
10
formData = new DataSet1();
11
}
12
}
Copied!

Méthode Page_Load

La première chose à faire dans la méthode Page_Load est d'appeler la méthode FillFormData() pour remplir les données dans vos données de formulaire. La Page_Load est également l'endroit où apporter des modifications aux propriétés de WorkflowPage. Vous pouvez donner un DataSet ou un XmlDocument à la méthode FillFormData().
1
protected void Page_Load(object sender, System.EventArgs e)
2
{
3
// Remplissez vos données de formulaire ici
4
FillFormData(formData);
5
6
// Liez les données du formulaire aux champs du formulaire Web. (Ce n'est pas obligatoire,
7
// cela dépend de la manière dont vous souhaitez gérer les données de votre formulaire)
8
9
if (!Page.IsPostBack)
10
{
11
12
BindFormDataToFields(formData);
13
}
14
15
// Tout traitement supplémentaire ira ici
16
// ...
17
}
Copied!

Enregistrement des données de formulaire

Les données de formulaire doivent être enregistrées sur toute publication (« postback ») qui modifie les données du formulaire. Si vous ne l'enregistrez pas avant la fin de la publication, toutes les modifications seront perdues car la méthode FillFormData() dans l'événement Page_Load remplacera les modifications avec les anciennes données.
Pour enregistrer vos données de formulaire dans EFORMASPX, vous devez appeler la méthode SaveFormData() à partir de WorkflowPage. Vous pouvez attribuer un DataSet ou un XmlDocument à la méthode SaveFormData().
1
protected void AnyServerSideEventModifyingFormData(object sender, ...)
2
{
3
// Modifiez les données du formulaire ...
4
formData.Tables["TableExpense"].Rows.RemoveAt(e.Item.ItemIndex);
5
6
// Reliez le(s) contrôle(s) pour voir les modifications sur le formulaire Web
7
DataList1.DataBind();
8
9
// Enregistrez les données du formulaire
10
this.SaveFormData(formData);
11
}
Copied!

Mise à jour des données de formulaire avec les valeurs du formulaire Web

Vous souhaiterez généralement mettre à jour vos données de formulaire avec les valeurs du formulaire Web avant de soumettre les données du formulaire à WorkflowGen. Cela peut être fait pour tous les champs qui sont liés dans le Table1 de vos données de formulaire en appelant la méthode SaveFieldsData(DataSet). La méthode essaiera de trouver des contrôles dans la page qui ont les mêmes IDs que les colonnes Table1, et lorsqu'elle en trouve un, elle met à jour la valeur de la donnée de formulaire avec la valeur du contrôle.
1
protected void Submit_Click(object sender, System.EventArgs e)
2
{
3
// Mettre à jour automatiquement les données du formulaire avec les valeurs du formulaire Web
4
this.SaveFieldsData(formData);
5
}
Copied!
Cette méthode supporte uniquement les DataSet. Les champs qui sont mis à jour doivent se trouver dans une table nommée Table1.

Soumission au workflow

Une fois qu'il est temps de tout soumettre au workflow (via EFORMASPX), vous devez appeler la méthode WorkflowPageSubmitToWorkflow(). Cette méthode doit recevoir vos données de formulaire si vous souhaitez les enregistrer en même temps. Vous pouvez également séparer manuellement ces appels en appelant SubmitToWorkflow sans aucun paramètre; cependant, si vous faites cela, les données de votre formulaire ne seront pas mises à jour si vous n'appelez pas explicitement SaveFormData(formData) avant de soumettre.
1
protected void Submit_Click(object sender, System.EventArgs e)
2
{
3
4
// Tout traitement avant de soumettre va ici (p.ex. : validation,
5
// modification des données etc.)
6
// ...
7
8
// Soumet tout au workflow et crée l'archive de formulaire si
9
// nécessaire.
10
this.SubmitToWorkflow(formData);
11
}
Copied!

Gestion de la validation des champs

Aperçu

WorkflowPage crée automatiquement des contrôles RequiredFieldValidator dans votre page pour valider les champs qui ont été écrits dans le paramètre FORM_FIELDS_REQUIRED dans toutes vos actions EFORMASPX. Ces validations peuvent être placées sur l'un des types de contrôle suivants :
    TextBox
    RadioButtonList
    DropDownList
    ListBox
    FileUpload
    HtmlInputFile
Si vous souhaitez avoir un message personnalisé, vous devez modifier la propriété RequiredFieldsErrorMessage. Assurez-vous d'avoir le symbole {0} dans votre message personnalisé. Si vous ne placez pas de balise {0} quelque part dans votre message, une exception sera levée car il ne serait pas logique d'avoir une liste de champs obligatoires sans savoir quels champs doivent être remplis.
Les contrôles RequiredFieldValidator qui sont créés ont leurs propriétés ValidationGroup définies sur WFGENPage. Cela signifie que la validation de ces validateurs ne sera effectuée que si le contrôle qui déclenche la validation a sa propriété ValidationGroup définie sur la même valeur. Par défaut, si vous avez un contrôle bouton SubmitButton dans votre page, son ValidationGroup est automatiquement modifié. Si vous utilisez un autre identifiant pour le bouton de soumission, vous devez définir vous-même le ValidationGroup, sinon les champs obligatoires ne seront pas validés comme prévu lors de la soumission de la page.

Validation du type de données

Lorsque vous spécifiez le type de données d'un champ à l'aide de l'attribut FieldDataType, des validateurs sont automatiquement insérés dans votre page pour valider les types de données Date et Numeric.
    Les champs de type DATE sont validés à l'aide d'un RangeValidator avec la propriété MinimumValue définie sur DateTime.MinimumValue et la propriété MaximumValue définie sur DateTime.MaximumValue.
    Les champs de type NUMERIC sont validés à l'aide d'un RangeValidator avec la propriété MinimumValue définie sur Double.MinimumValue et la propriété MaximumValue définie sur Double.MaximumValue.
Les contrôles RangeValidator ont la convention d'affectation de noms suivante : WFGEN_RV_FIELD_ID.
Si vous créez vos propres contrôles RangeValidator pour valider les champs sur lesquels vous avez défini l'attribut FieldDataType, WorkflowPage ne crée pas automatiquement de RangeValidator pour ces champs.
Les contrôles RangeValidator qui sont créés ont leurs propriétés ValidationGroup définies sur WFGENPage. Cela signifie que la validation de ces validateurs ne sera effectuée que si le contrôle qui déclenche la validation a sa propriété ValidationGroup définie sur la même valeur. Par défaut, si vous avez un contrôle bouton SubmitButton dans votre page, son ValidationGroup est automatiquement modifié. Si vous utilisez un autre identifiant pour le bouton de soumission, vous devez définir vous-même le ValidationGroup, sinon les champs ne seront pas validés comme prévu lors de la soumission de la page.

Validation personnalisée

Si vous souhaitez effectuer vos propres validations personnalisées, vous pouvez toujours créer vos contrôles RequiredFieldValidator ou RangeValidator sur les champs où vous avez spécifié l'attribut FieldDataType, et WorkflowPage ne créera pas automatiquement des contrôles RequiredFieldValidator ou RangeValidator pour ces contrôles particuliers.
Si vous souhaitez effectuer plus de validations sur l'un de vos champs à l'aide d'autres validateurs .NET (tels que les contrôles CompareValidator, CustomValidator ou RegularExpressionValidator), vous devrez modifier les propriétés ValidationGroup de ces validateurs en WFGENPage, sinon la validation ne sera pas effectuée pour les contrôles ciblés lors de la soumission du formulaire.

📌 Exemple

1
<asp:RegularExpressionValidator ID="RegValidatorExample" runat="server"
2
ErrorMessage="Votre message d'erreur" ControlToValidate="VotreContrôle"
3
Display="Dynamic" ValidationGroup="WFGENPage" ValidationExpression="\w+([-
4
+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*">
5
</asp:RegularExpressionValidator>
Copied!

Champs en lecture seule

Aperçu

WorkflowPage peut automatiquement rendre certains champs en lecture seule ou désactivés (selon les types de contrôle) pour les champs du paramètre FORM_FIELDS_READONLY. Les types de contrôle suivants seront définis en lecture seule ou désactivés s'ils se trouvent dans FORM_FIELDS_READONLY :
    TextBox
    RadioButton
    RadioButtonList
    CheckBox
    CheckBoxList
    DropDownList
    ListBox
    FileUpload
    HtmlInputFile

Gestion de la colorisation des champs

Aperçu

WorkflowPage modifie automatiquement l'apparence des contrôles FORM_FIELDS_REQUIRED et FORM_FIELDS_READONLY en fonction de sa propriété FieldsColorization.
La propriété FieldsColorization est une instance d'une énumération qui peut avoir les valeurs suivantes :
    Automatic
    CSS
    None

Mode Automatic

Le mode Automatic utilise les propriétés suivantes pour coloriser les champs :
    RequiredFieldsBorderColor
    ReadOnlyFieldsBorderColor
Certains types de contrôle ont leurs bordures colorisées tandis que d'autres ont leurs couleurs de texte modifiées (pour des raisons esthétiques).
Les contrôles suivants verront leur couleur de texte (propriété ForeColor) modifiée si la couleur n'est pas Color.Empty dans leurs propriétés correspondantes :
    DropDownList
    CheckBoxList
    RadioButtonList
Les autres contrôles verront leurs couleurs de bordure modifiées si la couleur n'est pas Color.Empty dans leurs propriétés correspondantes.

Mode CSS

Au lieu de modifier directement le style, le mode CSS modifie les propriétés CssClass des contrôles comme indiqué dans l'exemple ci-dessous, ce qui vous donne beaucoup plus de flexibilité pour avoir l'apparence exacte que vous souhaitez dans votre formulaire Web.

📌 Exemple

    Si TextBox1 a sa propriété CssClass définie sur FieldValueCell et qu'il s'agit d'un champ obligatoire, CssClass1 sera remplacé par FieldValueCell-required.
    Si TextBox1 n'a pas de propriété CssClass, CssClass sera remplacé par Required.

Mode None

Le mode None ne modifiera la couleur ou le style des contrôles de votre formulaire Web. Ce mode désactive complètement la colorisation automatique ou la colorisation CSS.

Gestion de l'archive de formulaire

Feuille de style CSS

Vous pouvez personnaliser l'apparence de votre archive de formulaire à l'aide du fichier form_archive.css.
Vos styles CSS doivent être situés dans un sous-répertoire appelé \css et votre fichier de feuille de style d'archive de formulaire doit être appelé form_archive.css, car WorkflowPage recherchera cet emplacement particulier et ce nom de fichier pour le trouver, puis remplacera les styles d'archive de formulaire par les styles contenus dans ce fichier.
Si ces valeurs par défaut ne sont pas celles que vous souhaitez utiliser, vous pouvez toujours modifier la propriété FormArchiveCssPath, dont la valeur par défaut est \css\form_archive.css. Si aucun fichier form_archive.css n'est créé, l'archive de formulaire aura la même apparence que le formulaire Web, mais les champs seront tous définis en lecture seule ou désactivés.

Masquer les champs

Par défaut, le bouton dans votre page avec l'ID SubmitButton sera automatiquement masqué dans l'archive de formulaire.
Si vous souhaitez masquer d'autres champs dans l'archive de formulaire, utilisez le paramètre FORM_FIELDS_ARCHIVE_HIDDEN. Les contrôles répertoriés dans ce paramètre seront automatiquement masqués lors de la création de l'archive de formulaire.
Les contrôles qui ne sont pas runat=server dans votre formulaire Web ne seront pas masqués.
Vous voudrez parfois personnaliser la mise en page du formulaire archivé. Pour ce faire, vous devrez remplacer la méthode WorkflowPage ChangeFormArchiveLayout().
1
protected override void ChangeFormArchiveLayout()
2
{
3
// Effectuez des traitements personnalisés ici
4
// ...
5
6
// Assurez-vous d'appeler la base ChangeFormArchiveLayout si vous souhaitez
7
// que les champs soient automatiquement mis en lecture seule et masquer
8
// les champs répertoriés dans FORM_FIELDS_ARCHIVE_HIDDEN
9
base.ChangeFormArchiveLayout();
10
}
Copied!
Si vous voulez encore plus de flexibilité avec la création d'archives de formulaires, vous pouvez remplacer la méthode GetFormArchive(). Cette méthode doit renvoyer une chaîne contenant le HTML de l'archive de formulaire.
1
protected override string GetFormArchive()
2
{
3
// Construisez le html de l'archive de formulaire
4
5
// ...
6
7
// Renvoyer le résultat html
8
9
return htmlResult;
10
}
Copied!

Gestion des pièces jointes

Lorsque vous avez un contrôle FileUpload dans votre formulaire Web, vous souhaiterez utiliser la méthode SaveFileAttachment() dans WorkflowPage. Cette méthode est utilisée pour enregistrer le fichier dans le sous-répertoire \upload dans le chemin de stockage EFORMASPX et récupérer le nom de fichier du fichier publié.
1
protected void Submit_Click(object sender, System.EventArgs e)
2
{
3
// ...
4
5
// Enregistrez la pièce jointe dans EFORMASPX et mettez à jour
6
// le nom du fichier dans les données du formulaire
7
formData.Tables["Table1"].Rows[0]["TEST_UPLOAD"] =
8
SaveFileAttachment(TEST_UPLOAD.PostedFile);
9
10
// ...
11
}
Copied!
Si vous avez plusieurs pièces jointes en une seule action, vous devez envisager de renommer les fichiers publiés manuellement, car si l'utilisateur envoie deux fichiers différents portant le même nom, les fichiers se remplaceront. Pour enregistrer la pièce jointe avec un nom spécifié, utilisez la méthode surchargée SaveFileAttachment().
1
protected void Submit_Click(object sender, System.EventArgs e)
2
{
3
4
// ...
5
6
// Enregistrez la pièce jointe dans EFORMASPX et mettez à jour
7
// le nom du fichier dans les données du formulaire
8
formData.Tables["Table1"].Rows[0]["TEST_UPLOAD"] =
9
SaveFileAttachment(TEST_UPLOAD.PostedFile,
10
"NomDeFichierQueVousChoisissez.ext");
11
12
// ...
13
}
Copied!

Gestion des ressources

Ajouter des ressources à votre projet Web

    1.
    Faites un clic droit sur la racine de votre site Web, puis sélectionnez Ajouter un nouvel élément...
    2.
    Choisissez Fichier de ressources et entrez le nom souhaité pour votre fichier de ressources.
    3.
    Cliquez sur Ajouter. Ce fichier contiendra les ressources par défaut pour votre formulaire Web (en-US).
    4.
    Ajoutez un fichier de ressources pour chaque langue que vous souhaitez gérer pour votre formulaire Web. Le nom de fichier doit se terminer par culture-code.resx. 📌 Exemple : Strings.fr-FR.resx serait le nom de fichier de la langue française de France.
Lorsque vous souhaitez utiliser les ressources dans votre formulaire Web, il vous suffit d'utiliser l'espace de noms System.Resources, et toutes vos ressources seront automatiquement fortement typées. Cela signifie que vous pouvez accéder à tout le contenu de vos fichiers de ressources avec des propriétés d'objet.

Gestion du GridView

Aperçu

Cette section explique comment utiliser un GridView en mode avancé.

DataTable

La première chose que vous devez faire est d'ajouter un DataTable au DataSet de vos données de formulaire qui représente les données gérées du GridView.
Il est important que ce DataTable ait une clé primaire.

Objet métier

Vous devez maintenant concevoir un objet métier qui encapsulera les opérations possibles sur votre DataTable. Voici un exemple d'objet métier pour le DataTable PEOPLE_LIST :
1
public class PeopleListBusinessObject
2
{
3
// Référence au DataTable people_list
4
private FormData.PEOPLE_LISTDataTable peopleListTable;
5
6
/// <summary>
7
/// Constructeur qui affecte la référence de la table peopleListTable
8
/// </summary>
9
/// <param name="peopleListDataTable">The reference we need to populate our
10
/// business object</param>
11
public PeopleListBusinessObject(FormData.PEOPLE_LISTDataTable
12
peopleListDataTable)
13
{
14
peopleListTable = peopleListDataTable;
15
}
16
17
/// <summary>
18
/// Returns the PeopleListDataTable, will be used by the ObjectDataSource
19
/// </summary>
20
/// <returns>A PEOPLE_LISTDataTable</returns>
21
public FormData.PEOPLE_LISTDataTable GetPeopleList()
22
{
23
return peopleListTable;
24
}
25
26
/// <summary>
27
/// Inserts / updates data into the PEOPLE_LIST DataTable, will be used by the
28
/// ObjectDataSource
29
/// </summary>
30
/// <param name="ID">The Person ID</param>
31
/// <param name="firstName">First name of the person</param>
32
/// <param name="lastName">Last name of the person</param>
33
public void UpdateOrInsertPerson(int ID, string firstName, string lastName)
34
{
35
FormData.PEOPLE_LISTRow tempRow = peopleListTable.Rows.Find(ID) as FormData.PEOPLE_LISTRow;!
36
37
if (tempRow != null)
38
{
39
// we found a row, so we are updating it
40
tempRow.FIRSTNAME = firstName;
41
tempRow.LASTNAME = lastName;
42
}
43
else
44
{
45
// nous n'avons pas trouvé de ligne avec l'ID demandé, cela signifie que nous insérons
46
peopleListTable.Rows.Add(firstName, lastName);
47
}
48
}
49
50
/// <summary>
51
/// Supprime une personne de la table de données PEOPLE_LIST qui sera utilisée par le
52
/// ObjectDataSource
53
/// </summary>
54
/// <param name="ID"></param>
55
public void DeletePerson(int ID)
56
{
57
FormData.PEOPLE_LISTRow tempRow = peopleListTable.Rows.Find(ID) as FormData.PEOPLE_LISTRow;
58
peopleListTable.Rows.Remove(tempRow);
59
}
60
}
Copied!

ObjectDataSource

L'étape suivante consiste à placer un ObjectDataSource dans votre page et à le lier à votre objet métier. Pour ce faire :
    1.
    Glissez-déplacez l'ObjectDataSource sur votre formulaire Web en mode Création.
    2.
    Cliquez sur Configurer la source de données.
    3.
    Choisissez l'objet métier que vous avez créé précédemment.
    4.
    Sélectionnez la méthode appropriée pour chaque opération de données.​
    ​​
    ​​
    ✏️ Note : Le GridView n'a pas les fonctions intégrées pour supporter les opérations d'insertion, nous allons donc utiliser la section UPDATE afin d'insérer des éléments. Ne choisissez aucune méthode pour la section INSERT.
    5.
    Cliquez sur Terminer.
    6.
    Ajoutez l'événement ObjectCreating pour gérer la création de l'ObjectDataSource avec la classe de l'objet métier.
    1
    protected void PeopleListObjectDataSource_ObjectCreating(object sender, ObjectDataSourceEventArgs e)
    2
    {
    3
    // Attachez l'instance de PEOPLE_LIST à
    4
    // PeopleListObjectDataSource
    5
    e.ObjectInstance = new PeopleListBusinessObject(formData.PEOPLE_LIST);
    6
    }
    Copied!

GridView

    1.
    Glissez-déplacez un GridView sur le formulaire Web, choisissez l'ObjectDataSource que vous avez créé à l'étape précédente comme DataSource et vérifiez les opérations que vous souhaitez activer dans votre GridView. (Voir Activation de l'insertion dans le GridView ci-dessous pour des instructions sur comment activer l'insertion dans un GridView.)
    2.
    Définissez la propriété DataKeyNames si vous souhaitez activer la modification et l'insertion dans votre GridView.
    3.
    Il est recommandé de définir le champ ID en lecture seule en cliquant sur Modifier les colonnes... et en définissant la propriété ReadOnly du champ lié à l'ID sur True.

Activation de l'insertion dans le GridView

La solution de contournement pour l'insertion dans un GridView consiste à ajouter un bouton pour insérer manuellement une nouvelle ligne dans le DataTable PEOPLE_LIST lorsque quelqu'un clique dessus. Pour ce faire :
    1.
    Glissez-déplacez un LinkButton sous votre GridView, puis double-cliquez sur le LinkButton et ajoutez-y le code suivant:
    1
    protected void InsertPerson_Click(object sender, EventArgs e)
    2
    {
    3
    // Insérez une nouvelle ligne dans la table de données PEOPLE_LIST,
    4
    // changez le EditIndex afin que nous puissions remplir les informations
    5
    // de la nouvelle personne, puis reliez PEOPLE_LIST.
    6
    formData.PEOPLE_LIST.AddPEOPLE_LISTRow("", "");
    7
    PEOPLE_LIST.EditIndex = formData.PEOPLE_LIST.Rows.Count - 1;
    8
    PEOPLE_LIST.DataBind();
    9
    }
    Copied!
    2.
    Ce code ne supporte pas la pagination et le tri, vous devrez donc détecter vous-même le nouvel EditIndex si vous souhaitez activer la pagination et le tri dans votre GridView. Cela est dû au fait que le EditIndex n'est pas nécessairement le PEOPLE_LIST.Rows.Count - 1 lorsque vous utilisez ces fonctions.

Mise à jour des données de votre formulaire OnRowDeleted et OnRowUpdated

La dernière étape consiste à définir les événements OnRowDeleted et OnRowUpdated pour que GridView mette à jour vos données de formulaire à chaque modification. Pour ce faire, ajoutez le code suivant :
1
protected void PEOPLE_LIST_RowUpdated(object sender,
2
GridViewUpdatedEventArgs e)
3
{
4
// Lorsque nous mettons à jour une ligne,
5
// nous enregistrons les données
6
SaveFormData(formData);
7
}
8
protected void PEOPLE_LIST_RowDeleted(object sender,
9
GridViewDeletedEventArgs e)
10
{
11
// Lorsque nous supprimons une ligne,
12
// nous enregistrons les données
13
SaveFormData(formData);
14
}
Copied!

Personnalisation du schéma FormData et séparation des données de formulaire des paramètres de formulaire

Personnalisation du schéma FormData

Dans la section précédente, vous avez été invité à placer tous les paramètres et vos données de formulaire dans le même DataTable nommé Table1, mais vous pouvez toujours utiliser un autre nom de DataSet et un autre nom de DataTable si vous le souhaitez.
Notez, cependant, que si vous n'utilisez pas le nom Table1 pour le DataTable, vous devez utiliser le paramètre PARAMS_XPATH dans toutes vos actions pour indiquer à EFORMASPX et WorkflowPage où ils doivent localiser les paramètres et les données du formulaire. Ce paramètre est un XPath qui pointe vers cette table. Si vous nommez votre DataSet MyFormData et que vous nommez votre table par défaut MyParameters, le paramètre PARAMS_XPATH doit contenir MyFormData/MyParameters, sinon votre processus ne fonctionnera pas.
Lorsque vous définissez un schéma personnalisé de cette façon, vous devez également inclure un fichier modèle FORM_DATA dans votre projet avec le même schéma vide :
1
<?xml version="1.0" encoding="utf-8" ?>
2
<MyFormData>
3
<MyParameters>
4
</MyParameters>
5
</MyFormData>
Copied!

Séparation des données de formulaire des paramètres de formulaire

Vous pouvez séparer les paramètres d'action de vos données de formulaire, mais vous devrez utiliser l'emplacement XPath complet de vos données de formulaire comme nom de paramètre si vous souhaitez les utiliser comme paramètres d'action. Par exemple, si vous avez un champ nommé REQUEST_FIRSTNAME dans votre formulaire Web et que vous souhaitez placer ces données dans une autre table (p.ex. MyData), vous déclarez le paramètre avec le nom /MesDonnnéesFormulaire/MesDonnées/REQUEST_FIRSTNAME.
Notez que si vous utilisez des expressions XPath personnalisées pour vos noms de paramètres d'action, vous devrez également télécharger un FORM_DATA personnalisé dans votre processus qui contient des nœuds vides pour ces paramètres.
Voici un exemple complet d'action de processus qui utiliserait des DataTables séparés pour les paramètres et pour les données du formulaire :
1
<?xml version="1.0" encoding="utf-8" ?>
2
<MyFormData>
3
<MyParameters>
4
</MyParameters>
5
<MyData>
6
<REQUEST_NUMBER />
7
<REQUEST_FIRSTNAME />
8
<REQUEST_LASTNAME />
9
<REQUEST_DATE />
10
</MyData>
11
</MyFormData>
Copied!

Structure de DataSet

Paramètres d'action

Utilisation des UserControls Web dans les formulaires Web

Si vous prévoyez d'utiliser des UserControls pour encapsuler certaines parties de vos formulaires Web qui seront répétées d'un formulaire Web à un autre, vous pouvez les utiliser avec WorkflowGen.My.
Vous devez disposer des informations suivantes pour les utiliser correctement :
    Pour chaque contrôle présent dans le UserControl, WorkflowGen.My créera un nœud dans Table1 du jeu de donnée FormData, préfixé par l'ID du contrôle utilisateur dans la page. Par exemple, si vous avez un UserControl dans votre page avec l'ID HEADER_UC qui contient une zone de texte avec l'ID FIRST_NAME, le champ sera accessible via FormData avec le nom HEADER_UC.FIRST_NAME.
    Si vous souhaitez accéder à ce champ via un paramètre WorkflowGen, vous devrez utiliser cette convention pour accéder au champ. Si vous souhaitez utiliser une macro qui envoie le prénom de l'utilisateur dans le champ HEADER_UC.FIRST_NAME, vous devrez utiliser ce nom comme nom de paramètre dans le paramètre d'action WorkflowGen.
    Si vous souhaitez définir un champ situé dans un UserControl pour qu'il soit considéré comme requis par WorkflowGen.My, vous utilisez toujours la convention ci-dessus pour répertorier ce champ dans le paramètre FORM_FIELDS_REQUIRED.
Dernière mise à jour 9mo ago