Plone pour les développeurs

Plone pour les développeurs
Version 1.0.0
plone-fr
17-April-2017

Table des matières
1 Rappel sur Python 3
1.1 Définition ............................................... 3
1.2 Savoir ................................................. 3
1.3 Aide intégrée à Python ........................................ 3
1.4 Attributs par défaut d’une classe ................................... 4
1.5 set ................................................... 4
1.6 Le __call__ d’une classe ....................................... 4
1.7 Manipulation de chaines ....................................... 5
1.8 Différence entre unicode et string .................................. 5
1.9 Comprehensive list et generator ................................... 5
1.10 Decorateur .............................................. 6
1.11 Methode de classe .......................................... 7
1.12 Property ............................................... 7
1.13 Template ............................................... 7
1.14 Debogueur pdb ............................................ 8
1.15 Profiler ................................................ 8
1.16 Ressources .............................................. 8
1.17 Exercice ............................................... 9
2 Presentation de Python 11
2.1 Introduction ............................................. 11
2.2 Installation .............................................. 15
2.3 La console Python .......................................... 15
2.4 Le contrôle du flux d’instructions .................................. 30
2.5 Les conteneurs standard ....................................... 36
2.6 Fonctions et espaces de noms .................................... 48
2.7 Modules et packages ......................................... 54
2.8 La programmation Orientée Objet .................................. 59
2.9 Quelques Techniques avancées de programmation ......................... 67
3 ZODB - Une Base de données objet native pour python 77
3.1 Avertissement ............................................ 77
3.2 Licence ................................................ 77
3.3 Résumé ................................................ 77
3.4 Documentation ............................................ 78
3.5 Téléchargements ........................................... 87
3.6 Communauté et contribution ..................................... 88
i

4 Le guide complet de l’Architecture de Composants de Zope 89
4.1 Mise en route ............................................. 89
4.2 Un exemple .............................................. 93
4.3 Interfaces ............................................... 96
4.4 Adaptateurs ..............................................100
4.5 Utilitaires ...............................................104
4.6 Adaptateurs avancés .........................................106
4.7 Usage de la ZCA dans Zope .....................................110
4.8 Étude de cas .............................................114
4.9 Reference ...............................................125
5 Le langage ZCML 163
5.1 Introduction au ZCML ........................................163
5.2 Traitement des fichiers ZCML ....................................164
5.3 Les directives ZCML .........................................166
5.4 Pour aller plus loin ..........................................168
6 Utiliser la ZCA avec Grok 173
6.1 Introduction .............................................173
6.2 Installation de five.grok .......................................173
6.3 Utiliser Grok .............................................174
6.4 Ressources ..............................................175
7 Modélisation UML 177
7.1 Objectifs ...............................................177
7.2 Savoir .................................................177
7.3 Qu’est ce qu’UML ..........................................177
7.4 Les éléments .............................................178
7.5 Les relations .............................................183
7.6 Les diagrammes que nous utiliserons ................................184
8 Génerer un composant Plone avec ArgoUML et ArchgenXML 189
8.1 Définition ...............................................189
8.2 Savoir .................................................189
8.3 Installation d’ArgoUML .......................................189
8.4 Installation de ArchGenXML ....................................189
8.5 Configuration d’ArgoUML pour utiliser le profil d’ArchGenXML .................190
8.6 Création du buildout de notre module ................................192
8.7 Création du plan documentaire ....................................192
8.8 Création des workflows .......................................199
8.9 exercice ................................................212
9 Nouvelles fonctionnalités de ArchGenXML 213
9.1 Définition ...............................................213
9.2 Savoir .................................................213
9.3 Modélisation d’un portlet ......................................213
9.4 Modélisation de vue zope 3 .....................................213
9.5 Exercice ...............................................214
10 Création d’un thème Plone 215
10.1 Installation de Gloworm .......................................215
10.2 Création d’un theme .........................................215
10.3 Exercice 1 ..............................................216
10.4 Exercice 2 : Création d’une viewlet .................................216
10.5 Portlets ................................................217
10.6 GenericSetup .............................................219
11 Les viewlets 221
11.1 Introduction .............................................221
ii

11.2 Gestion interactive des viewlets ...................................222
11.3 L’enregistrement en ZCML .....................................223
11.4 Le step GenericSetup .........................................226
11.5 Exemple ...............................................227
11.6 Pour aller plus loin ..........................................228
12 Les portlets 231
12.1 Personnalisation ...........................................231
12.2 Portlets disponibles en standard ...................................232
12.3 Retour sur le paramétrage d’une portlet ...............................234
12.4 Habillage graphique .........................................234
12.5 Export/Import Generic setup du paramétrage des portlets ......................234
12.6 Création d’une portlet personnelle ..................................234
12.7 Et le résultat... ............................................237
12.8 Créer votre propre portlet ......................................239
12.9 Pour aller plus loin ..........................................239
13 Les vues standard 241
13.1 Qu’est-ce que c’est ? .........................................241
13.2 Pourquoi utiliser ces vues ? .....................................241
13.3 Quelles vues sont proposées ? ....................................241
13.4 Accéder aux ressources des vues ...................................242
14 Internationalisation d’un composant 249
14.1 Exemples de la formation ......................................249
14.2 Internationaliser un composant ....................................250
14.3 Localiser un composant .......................................253
14.4 La syntaxe des po en quelques mots .................................254
14.5 Modifier les traductions de Plone ..................................254
14.6 Mise à jour des traductions ......................................255
14.7 Ressources ..............................................255
15 Gestion des utilisateurs avec PlonePAS 257
15.1 Présentation .............................................257
15.2 Architecture fonctionnelle ......................................258
15.3 PlonePAS en ZMI ..........................................259
15.4 Les plugins standard .........................................264
15.5 Les plugins de tierce partie ......................................264
15.6 Votre plugin .............................................264
16 L’environnement de développement 265
16.1 Installation de Python 2.4 ......................................265
16.2 Configuration de l’éditeur vim ....................................265
16.3 Configuration de l’autocomplétion dans Python ...........................265
16.4 Activation de la recherche dans l’historique .............................266
16.5 Installation de ArgoUML et ArchGenXML .............................266
16.6 Checkout svn.zope.org ........................................267
17 La gestion des sources avec subversion 269
17.1 Savoir .................................................269
17.2 Création d’un dépôt via Apache ...................................269
17.3 Installation du client subversion ...................................270
17.4 Administration d’un dépôt subversion ................................270
17.5 Mettre à jour la branche de production ................................270
18 Migration des composants développés pour Plone 2.5 273
18.1 Définition ...............................................273
18.2 Savoir .................................................273
18.3 Outils .................................................273
iii