|
1 Gestion de formulaires |
|
2 ====================== |
|
3 |
|
4 Contrôle de la génération automatique de formulaire pour les entités manipulée |
|
5 ------------------------------------------------------------------------------ |
|
6 XXX FILLME |
|
7 |
|
8 * les formulaires 'edition' et 'creation' |
|
9 |
|
10 Le formulaire généré par défaut ne vous convient pas ? Vous êtes peut-être pas |
|
11 obligé de le refaire à la main ! :) |
|
12 |
|
13 * rtags primary, secondary, generated, generic, |
|
14 `Entity.relation_category(rtype, x='subject')` |
|
15 * inline_view (now a rtag?) |
|
16 * spécification widget |
|
17 |
|
18 |
|
19 Fonctionnement du contrôleur d'édition par défaut (id: 'edit') |
|
20 -------------------------------------------------------------- |
|
21 |
|
22 Contrôle de l'édition |
|
23 ````````````````````` |
|
24 Prérequis: les paramètres liés aux entités à éditer sont spécifiés de la forme :: |
|
25 |
|
26 <nom de champ>:<eid de l'entité> |
|
27 |
|
28 où l'eid de l'entité pourra être une lettre dans le cas d'une entité à créer. On |
|
29 dénommera ces paramètres comme *qualifié*. |
|
30 |
|
31 1. récupération des entités à éditer en cherchant les paramètres de formulaire |
|
32 commençant par 'eid:' ayant également un paramètre '__type' associé |
|
33 (également *qualifié* par l'eid évidemment) |
|
34 |
|
35 2. pour tous les attributs et relations de chaque entité à éditer |
|
36 |
|
37 1. recherche d'un paramètre 'edits-<nom relation>' ou 'edito-<nom relation>' |
|
38 qualifié dans le cas d'une relation dont l'entité est objet |
|
39 2. si trouvé, la valeur récupérée est considérée comme la valeur originale |
|
40 pour cette relation, et on cherche la (ou les) nouvelle(s) valeur(s) dans |
|
41 le paramètre <nom relation> (qualifié) |
|
42 3. si la valeur est différente de l'originale, une requête de modification en |
|
43 base est effectuée |
|
44 |
|
45 3. pour chaque entité à éditer |
|
46 |
|
47 1. si un paramètre `__linkto` qualifié est spécifié, sa valeur doit être une |
|
48 chaine (ou une liste de chaine) de la forme : :: |
|
49 |
|
50 <relation type>:<eids>:<target> |
|
51 |
|
52 où <target> vaut 'subject' ou 'object' et chaque eid peut-être séparé d'un |
|
53 autre par un '_'. Target spécifie *l'entité éditée* est sujet ou objet de la |
|
54 relation et chaque relation ainsi spécifiée sera insérée. |
|
55 |
|
56 2. si un paramètre `__cloned_eid` qualifié est spécifié pour une entité, les |
|
57 relations de l'entité spécifiée en valeur de cette argument sont copiées sur |
|
58 l'entité éditée |
|
59 |
|
60 |
|
61 3. si un paramètre `__delete` qualifié est spécifié, sa valeur doit être une |
|
62 chaine (ou une liste de chaine) de la forme : :: |
|
63 |
|
64 <subject eids>:<relation type>:<object eids> |
|
65 |
|
66 où chaque eid sujet ou objet peut-être séparé d'un autre par un '_'. Chaque |
|
67 relation ainsi spécifiée sera supprimée. |
|
68 |
|
69 4. si un paramètre `__insert` qualifié est spécifié, sa valeur doit être de |
|
70 même format que pour `__delete`, mais chaque relation ainsi spécifiée sera |
|
71 insérée. |
|
72 |
|
73 4. si les paramètres `__insert` et/ou `__delete` sont trouvés non qualifiés, |
|
74 ils sont interprétés comme décrit ci-dessus (quelque soit le nombre d'entité |
|
75 édité) |
|
76 |
|
77 5. si aucune entité n'est éditée mais que le formulaire contient les paramètres |
|
78 `__linkto` et `eid`, celui-ci est interprété en prenant la valeur spécifié |
|
79 par le paramètre `eid` pour désigner l'entité sur laquelle ajouter les |
|
80 relations |
|
81 |
|
82 |
|
83 A noter que : |
|
84 |
|
85 * si le paramètre `__action_delete` est trouvé, toutes les entités comme |
|
86 spécifiées à éditer seront supprimées |
|
87 |
|
88 * si le paramètre `__action_cancel` est trouvé, aucune action n'est effectuée |
|
89 |
|
90 * si le paramètre `__action_apply` est trouvé, l'édition est effectuée |
|
91 normalement mais la redirection sera effectuée sur le formulaire (cf `Contrôle |
|
92 de la redirection`_) |
|
93 |
|
94 * le paramètre `__method` est également supporté comme sur le template principal |
|
95 (XXX not very consistent, maybe __method should be dealed in the view controller) |
|
96 |
|
97 * si aucune entité à éditer n'est trouvée et qu'il n'y a pas de paramètre |
|
98 `__action_delete`, `__action_cancel`, `__linkto`, `__delete` ou `__insert`, |
|
99 une erreur est levée |
|
100 |
|
101 * placer dans le formulaire le paramètre `__message` permettra d'utiliser la |
|
102 valeur de ce paramètre comme message d'information à l'utilisateur une fois |
|
103 l'édition effectuée. |
|
104 |
|
105 |
|
106 Contrôle de la redirection |
|
107 `````````````````````````` |
|
108 Une fois que l'édition s'est bien passé, reste un problème : c'est bien beau |
|
109 tout ça, mais où qu'on va maintenant ?? Si rien n'est spécifié, le controlleur |
|
110 se débrouille, mais comme il fait pas toujours ce qu'on voudrait, on peut |
|
111 controller ça en utilisant les paramètres suivant : |
|
112 |
|
113 * `__redirectpath`: chemin de l'url (relatif à la racine du site, sans paramètre |
|
114 de formulaire |
|
115 |
|
116 * `__redirectparams`: paramètres de formulaires à ajouter au chemin |
|
117 |
|
118 * `__redirectrql`: requête RQL de redirection |
|
119 |
|
120 * `__redirectvid`: identifiant de vue de redirection |
|
121 |
|
122 * `__errorurl`: url du formulaire original, utilisé pour la redirection en cas |
|
123 d'erreur de validation pendant l'édition. Si celui-ci n'est pas spécifié, une |
|
124 page d'erreur sera présentée plutot qu'un retour sur le formulaire (qui est le |
|
125 cas échéant responsable d'afficher les erreurs) |
|
126 |
|
127 * `__form_id`: identifiant de vue du formulaire original, utilisée si |
|
128 `__action_apply` est trouvé |
|
129 |
|
130 En général on utilise soit `__redirectpath et `__redirectparams` soit |
|
131 `__redirectrql` et `__redirectvid`. |