Mastering Plone 6 Development

Mastering Plone Development is intended as a training to learn proven practices of Plone development. It's both, an online course and a sketch for an on-the-spot training.

The story of a conference platform provides a week-long training of several development topics that can be split in two trainings:

• A beginner training (2 to 3 days) covering the essentials of Plone and Plone Volto.

• An advanced training (3 to 5 days) with additional advanced topics.

Note

This is the Mastering Plone 6 Development Training.

Mastering Plone 6 Development Training supplements Mastering Plone 5 with known best practices for customizing and developing Plone 6: Plone Classic + frontend.

In chapters handling Volto React frontend is a link to a chapter that covers the corresponding tasks in Plone Classic, and vice versa.

Plone 6 is not yet released and thus the training is a work in-progress and there are still some rough edges.

Mastering Plone 6 Development

• 1. About Mastering Plone
  • 1.1. The beginning and the continuation
  • 1.2. Upcoming Trainings
  • 1.3. Previous Trainings
  • 1.4. Trainers
  • 1.5. License
  • 1.6. Using the documentation for a training
  • 1.7. Contributing
• 2. Watch the Training Video
• 3. Introduction
  • 3.1. Who are you?
  • 3.2. Classroom Protocol
  • 3.3. Documentation
  • 3.4. Further Reading
• 4. The Case Study
  • 4.1. Background
  • 4.2. Requirements
  • 4.3. Changing requirements
  • 4.4. Tasks
  • 4.5. What will we do?
  • 4.6. What will we not do?
• 5. What is Plone?
  • 5.1. Core concepts
• 6. Installation and Setup of Plone 6
  • 6.1. Installing Plone backend
  • 6.2. Installing Plone frontend
  • 6.3. Creating a Plone Website
  • 6.4. Hosting Plone
  • 6.5. Production Deployment
• 7. Installing Plone for the Training
  • 7.1. Technical set up to do before a training (as a trainer)
  • 7.2. Installing Plone without vagrant
  • 7.3. Installing Plone with Vagrant
• 8. The Features of Plone
  • 8.1. Starting and Stopping Plone
  • 8.2. Creating a Plone Site
  • 8.3. Starting and Stopping the frontend
  • 8.4. Walkthrough of the UI
  • 8.5. Users
  • 8.6. Configure a Mailserver
  • 8.7. The site structure
  • 8.8. Default content types
  • 8.9. Folders
  • 8.10. Collections
  • 8.11. Content Rules
  • 8.12. History
  • 8.13. Manage members and groups
  • 8.14. Workflows
  • 8.15. Working copy
  • 8.16. Placeful workflows
• 9. The Anatomy of Plone
  • 9.1. Database
  • 9.2. Zope
  • 9.3. Content Management Framework
  • 9.4. Zope Toolkit / Zope3
  • 9.5. Zope Component Architecture (ZCA)
  • 9.6. Pyramid
  • 9.7. Exercise
  • 9.8. Plone
  • 9.9. REST API
  • 9.10. Volto
• 10. What's New in Plone?
  • 10.1. Plone 5.0
  • 10.2. Plone 5.1
  • 10.3. Plone 5.2
  • 10.4. Plone 6
• 11. Plone 6 Basics
• 12. Configuring and Customizing Plone "Through The Web"
  • 12.1. The Control Panel
  • 12.2. Portlets
  • 12.3. Viewlets
  • 12.4. ZMI (Zope Management Interface)
  • 12.5. Summary
• 13. Customizing Volto Components
  • 13.1. Component shadowing
  • 13.2. The Logo
  • 13.3. The Footer
  • 13.4. The News Item View
  • 13.5. The Summary View
  • 13.6. The Listing Block
  • 13.7. Localization
  • 13.8. Summary
• 14. Semantic UI
• 15. Theming in Volto
• 16. Extending Plone
  • 16.1. Extension technologies
• 17. Extending Plone With Add-on Packages
  • 17.1. Some notable Plone add-ons for a classic Plone setup without Volto frontend
  • 17.2. How to find add-ons
  • 17.3. Installing Plone Add-ons
  • 17.4. collective.easyform
  • 17.5. Add page layout management with plone.app.mosaic
  • 17.6. Internationalization
  • 17.7. Summary classic Plone
• 18. Buildout I
  • 18.1. Minimal Example
  • 18.2. Syntax
  • 18.3. Recipes
  • 18.4. Variables and References
  • 18.5. A real life example
  • 18.6. Mr. Developer
  • 18.7. Extensible
  • 18.8. Be McGuyver
• 19. Write Your Own Python Add-On to Customize Plone
  • 19.1. Creating the package
  • 19.2. Volto Add-ons
  • 19.3. Eggs
  • 19.4. Inspecting the new package
  • 19.5. Including the package in Plone
  • 19.6. Exercises
  • 19.7. Summary
• 20. Dexterity I: Content types
  • 20.1. What is a content type?
  • 20.2. The makings of a Plone content type
  • 20.3. Schemas, Fields and Values
  • 20.4. Behaviors
  • 20.5. Modifying existing types
  • 20.6. Creating content types TTW
  • 20.7. Exercises
• 21. Dexterity II: Talks
  • 21.1. The type registration
  • 21.2. The FTI
  • 21.3. The schema
  • 21.4. The instance class
  • 21.5. Try the new type
  • 21.6. Summary
• 22. Dexterity: Reference
  • 22.1. Fields included in Plone
  • 22.2. How fields look like
  • 22.3. 3rd party fields
  • 22.4. Datagrid Field
  • 22.5. mixedfield
  • 22.6. Widgets
  • 22.7. Directives
• 23. Volto View Component: A Default View for a "Talk"
  • 23.1. Summary
• 24. Behaviors
  • 24.1. Dexterity Approach
  • 24.2. Names and Theory
  • 24.3. Practical example
  • 24.4. Adding it to our talk
  • 24.5. Add a index for the new field
  • 24.6. Add a metadata column for the new field
  • 24.7. Exercises
• 25. Creating a dynamic frontpage with Volto blocks
  • 25.1. Add Index as collection criteria
  • 25.2. Add a listing block to show the featured content
  • 25.3. Outlook: block variations
• 26. Volto View Components: A Listing View for Talks
  • 26.1. Register the view
  • 26.2. Using the search endpoint
  • 26.3. Search options
  • 26.4. Exercises
• 27. Programming Plone
  • 27.1. plone.api
  • 27.2. portal-tools
  • 27.3. Debugging
  • 27.4. Exercise
• 28. IDEs and Editors
• 29. Custom Search
  • 29.1. Custom Search in Volto
  • 29.2. Custom Search in Plone Classic
• 30. Turning Talks into Events
  • 30.1. Add date fields
  • 30.2. Display the dates
  • 30.3. Hiding fields from certain users
  • 30.4. Display the date in the listing
  • 30.5. Summary
• 31. Vocabularies, Registry-Settings and Control Panels
  • 31.1. Introduction
  • 31.2. The Registry
  • 31.3. Registry Records
  • 31.4. Accessing and modifying records in the registry
  • 31.5. Custom registry records
  • 31.6. Vocabularies
  • 31.7. Using vocabularies in a schema
  • 31.8. Summary
• 32. Upgrade-steps
  • 32.1. Upgrade steps
  • 32.2. Browserlayers
  • 32.3. Add catalog indexes
  • 32.4. Query for custom indexes
  • 32.5. Exercise 1
  • 32.6. Add collection criteria
  • 32.7. Add versioning through GenericSetup
  • 32.8. Summary
• 33. Testing in Plone
  • 33.1. Testing permissions, features and UI topics
  • 33.2. Testing the rendering of a component
• 34. Using Third-Party Behaviors
  • 34.1. Add Teaser With collective.behavior.banner
• 35. Dexterity Types III: Sponsors
  • 35.1. The Python schema
  • 35.2. The Factory Type Information, or FTI
  • 35.3. Summary
• 36. The Sponsors Component
  • 36.1. A React component
  • 36.2. The Sponsors Component
  • 36.3. Exercise
  • 36.4. Summary
• 37. Using Volto add-ons
  • 37.1. Volto Add-ons
  • 37.2. Complementing Volto with Plone add-ons
• 38. Rich Text Editor Settings
• 39. Custom Block
  • 39.1. Exercise
  • 39.2. Prospect
• 40. Extending Volto With Custom Add-on Package
  • 40.1. Enrich an existing project with your new released add-on
  • 40.2. Create a new project with your new released add-on
  • 40.3. Footnotes
• 41. Extending Volto With a FAQ Block Type
  • 41.1. Save your work to Github
• 42. Workflow, Roles and Permissions
  • 42.1. Self-registration
  • 42.2. Constrain types
  • 42.3. Grant local roles
  • 42.4. A custom workflow for talks
  • 42.5. Move the changes to the file system
• 43. Relations
  • 43.1. Creating relations in a schema
  • 43.2. Controlling what to relate to
  • 43.3. Configure the RelatedItemsFieldWidget
  • 43.4. Using the search mode of the Related Items Widget
  • 43.5. Using different widgets for relations
  • 43.6. Define Favorite Locations
  • 43.7. Accessing and displaying related items
  • 43.8. Inspecting relations
  • 43.9. Creating RelationFields through the web
  • 43.10. Interacting with relations and backrelations in code
  • 43.11. Relationfields without relations
  • 43.12. The stack
  • 43.13. RelationValues
• 44. Creating Reusable Packages
• 45. More Complex Behaviors
  • 45.1. Using Annotations
  • 45.2. Using Schema
  • 45.3. Writing Code
• 46. Endpoints
• 47. Volto Actions and Component State
  • 47.1. Fetching data from backend and displaying
  • 47.2. Writing to the backend…
  • 47.3. Component State
• 48. Making Our Package Reusable
  • 48.1. Adding permissions
  • 48.2. Using our permissions
  • 48.3. Provide defaults
• 49. Using starzel.votable_behavior in ploneconf.site
• 50. Releasing Your Code
• 51. Buildout II: Getting Ready for Deployment
  • 51.1. The Starzel buildout
  • 51.2. A deployment setup
  • 51.3. Other tools we use
• 52. Plone REST API
  • 52.1. Installing plone.restapi
  • 52.2. Explore the API
  • 52.3. Implementing the talklist
  • 52.4. Submit lightning talks
  • 52.5. Exercise
• 53. The Future of Plone
• 54. Optional
• 55. Using the code for the training
  • 55.1. The code-package
  • 55.2. Getting the code for a certain chapter
  • 55.3. Moving from chapter to chapter
  • 55.4. Tags
  • 55.5. Updating the code-package

Please note that this document is not complete without the spoken word of a trainer.

We attempt to include the most important parts of what we teach in the training. But reading it here can not be considered equal to attending a training.