Professional Plone 4 Development


Professional Plone 4 Development
eBook: $35.99
Formats: PDF, PacktLib, ePub and Mobi formats
$30.59
save 15%!
Print + free eBook + free PacktLib access to the book: $95.98    Print cover: $59.99
$59.99
save 37%!
Free Shipping!
UK, US, Europe and selected countries in Asia.
Also available on:
Overview
Table of Contents
Author
Reviews
Support
Sample Chapters
  • The very first book on the newly released Plone version 4.
  • Learn how - and when - the professionals use Plone
  • Master the latest Plone technologies
  • Put theory into practice with a realistic case study built from chapter to chapter.
  • Written by Martin Aspeli, one of the Plone project’s most prolific core developers and responsible for several R&D efforts relating to Plone 4.0; and with a Foreword by Eric Steele, the Plone Release Manager.
  • Bonus chapter: Custom Content Types with Archetypes
  • Bonus chapter: KSS

Book Details

Language : English
Paperback : 516 pages [ 235mm x 191mm ]
Release Date : August 2011
ISBN : 1849514429
ISBN 13 : 9781849514422
Author(s) : Martin Aspeli
Topics and Technologies : All Books, CMS and eCommerce, Content Management (CMS), Open Source, Plone, Python

Table of Contents

Preface
Chapter 1: Plone in Context
Chapter 2: Introduction to the Case Study
Chapter 3: The Development Environment
Chapter 4: Basics of Customization
Chapter 5: Developing a Site Strategy
Chapter 6: Security and Workflow
Chapter 7: Using Add-ons
Chapter 8: Creating a Custom Theme
Chapter 9: Nine Core Concepts of Zope Programming
Chapter 10: Custom Content Types
Chapter 11: Standalone Views and Forms
Chapter 12: Relational Databases
Chapter 13: Users and their Permissions
Chapter 14: Dynamic User Interfaces with jQuery
Chapter 15: Summary and Potential Enhancements
Chapter 16: Zope on the Server
Chapter 17: Setting up a Production Server
Chapter 18: Authenticating with LDAP or Active Directory
Chapter 19: Looking to the Future
Index
  • Chapter 1: Plone in Context
    • A brief history of Plone
      • What is new in Plone 4?
    • Plone-the-application and Plone-the-framework
    • Additional considerations when deciding on Plone
      • Licensing
    • The Plone Community, and why you belong there
    • Summary
      • Chapter 3: The Development Environment
        • Installers
        • Glossary of terms
        • Prerequisites
          • Creating an isolated Python environment
        • A minimal buildout
        • Buildout basics
          • The buildout directory
          • Buildout defaults
          • Packages and distributions
        • The development buildout
          • Development tools
            • Development Zope instance
            • Test runner
            • Omelette
            • The zopepy interpreter
            • ZopeSkel
            • z3c.checkversions
            • jarn.mkrelease
            • Tools in the browser
        • Learning to help yourself
          • Find the documentation
          • Use the Source, Luke!
          • Become familiar with the debugger
          • Look at the logs
        • Summary
        • Chapter 4: Basics of Customization
          • Persistent settings and the ZODB
            • Where are persistent settings stored?
          • Using GenericSetup for configuration
            • GenericSetup and Plone's Add-ons Control Panel
          • Acquisition and skin layers
          • Overriding Component Architecture components
          • Customization best practices
            • Using source control
            • Writing tests
            • Considering migration requirements
          • Summary
          • Chapter 5: Developing a Site Strategy
            • Creating a policy package
              • Distribution details
              • Changes to setup.py
              • Changes to configure.zcml
            • Updating the buildout
              • Working sets and component configuration
            • Creating an extension profile
              • Writing tests for customizations
              • Making a change with the extension profile
            • Activating the package
            • Rebuildout, restart, reapply?
            • Summary
            • Chapter 6: Security and Workflow
              • Security primitives
                • Users and groups
                • Permissions
                • Roles
                • Manipulating permissions and roles programmatically
              • Keeping control with workflow
                • Interacting with workflow in code
              • Installing a custom workflow
                • Designing a workflow for Optilux Cinemas
                • Building the workflow
                  • Exporting
                • Amending the policy package
                  • Role and permission settings
                  • Workflow definition
                  • Mapping workflows to types
                  • Adding the Staff group
                  • Writing the tests
              • Protected and trusted code
                • Restricted Python
              • Summary
              • Chapter 7: Using Add-ons
                • Finding and evaluating add-ons
                • Playing it safe
                • Installing an add-on
                  • Amending the buildout and policy package
                  • Adding tests
                • Summary
                • Chapter 8: Creating a Custom Theme
                  • Background
                    • Diazo primer
                  • Creating a Diazo theme
                    • Creating a theme distribution
                    • Adding the theme distribution to the buildout
                      • Installing lxml in Mac OS X
                    • Adding the theme and rules
                      • Managing CSS and JavaScript resources
                      • Adding the rest of the rules
                      • Enabling the theme automatically
                    • Adding tests
                  • Variations on the theming approach
                    • Separate public and editing interfaces
                    • Reading the theme from a separate server
                    • Sharing a theme across multiple systems
                  • Overriding visual elements
                    • Registering a browser layer
                    • The layout policy view
                    • Overriding templates
                  • Summary
                  • Chapter 9: Nine Core Concepts of Zope Programming
                    • About the examples
                    • Object publishing and traversal
                      • Containment and URLs
                      • Acquisition chains
                      • Path traversal
                    • Persistence in the ZODB
                      • Transactions
                      • Object persistence
                      • ZODB BLOBs
                    • Searching for objects using the catalog
                    • Describing functionality with interfaces
                      • Using interfaces in catalog searches
                    • Component configuration with ZCML or Grokkers
                      • Python directives and grokkers
                    • Component registries using utilities
                      • Global utilities
                      • Named utilities
                      • Local utilities
                      • Tools
                    • Modelling component aspects with adapters
                      • Multi-adapters
                      • Named adapters
                      • Adapter factories
                    • Views and other presentation components
                      • Content providers and viewlets
                    • Synchronous events
                      • Object events
                    • Summary
                    • Chapter 10: Custom Content Types
                      • Content-centric design
                      • Choosing a content type framework
                      • Creating a distribution
                        • Contents of the distribution
                      • Using the Dexterity framework
                        • What is in a content type?
                        • Basic configuration
                        • Schemata and fields
                          • Form hints in the schema
                          • Validation
                          • Vocabularies
                          • Rich text fields
                          • Files, images, and BLOBs
                          • Content reference fields
                        • Unique content identifiers
                        • Indexers
                        • Content security
                          • Add permissions
                          • Schema permissions
                        • Views and browser resources
                          • Icons and stylesheets
                          • Main content views
                        • Installing and registering types
                          • Add permissions
                          • Adding catalog indexes and metadata columns
                          • Adding the stylesheet
                        • Integration tests
                      • Installation and configuration in the policy package
                        • Adjusting the security policy
                        • Adjusting navigation tree properties
                        • Enabling content object versioning
                        • Site policy tests
                      • Using the schema extender
                        • Adding the schema extender and registry
                        • Defining the registry settings
                        • Creating the schema extender, vocabulary, and indexer
                        • Adding tests
                      • Using portlets
                        • Creating a new portlet
                        • Configuring and registering new portlet types
                        • Assigning portlets automatically
                      • Summary
                      • Chapter 11: Standalone Views and Forms
                        • Pages without a specific context
                          • Templates in skin layers
                          • Views available on all objects
                          • Views on the navigation root
                          • Invoking standalone pages
                        • Writing custom forms
                          • Processing form actions
                            • Checking form submit buttons
                            • Performing redirects
                          • Form input converters
                        • Generating forms automatically
                        • Creating a control panel view
                        • The form controller tool
                        • Writing new viewlets
                        • Global template variables and helper views
                        • Functional testing of views
                        • Summary
                        • Chapter 12: Relational Databases
                          • Relational databases versus the ZODB
                          • Modeling screenings and reservations
                            • Screening query and reservation services
                          • Setting up the database
                          • Database connectivity in Zope
                            • SQLAlchemy basics
                          • Managing database connections
                          • Working with the database
                            • Mapping the database tables
                            • Querying the database
                            • Updating and inserting records
                            • Testing the database
                          • Adding the user interface
                            • Updating the Film and Cinema views
                            • Custom traversal
                              • Implementing the screening view
                              • Implementing the reservations form
                              • Tests
                          • Summary
                          • Chapter 13: Users and their Permissions
                            • Defining a membership policy
                              • Updating the site policy product
                              • Managing user metadata
                            • Collaborative workspaces
                            • The Pluggable Authentication Service
                              • Anatomy of a PAS plugin
                              • A Facebook authentication plugin
                                • Package configuration
                                • Facebook OAuth authentication
                                • Testing the plugin
                                • Installation
                              • Summary
                              • Chapter 15: Summary and Potential Enhancements
                                • What we have achieved
                                • Additional functionality
                                  • Additional reporting and analytics
                                  • More advanced ticketing
                                  • Internationalization
                                    • Translating content
                                    • Translating user interface strings
                                • Summary
                                • Chapter 16: Zope on the Server
                                  • Deployment checklist
                                  • Scaling Zope
                                    • Zope Enterprise Objects (ZEO)
                                    • RelStorage
                                  • A deployment buildout using RelStorage
                                  • Moving code, configuration, and data to a server
                                    • Releasing distributions
                                    • Source distributions from tags
                                    • Tagging the build
                                    • Deploying the build
                                    • Managing data
                                  • Managing Zope processes
                                    • Supervisor
                                    • Unix init scripts
                                    • Windows services
                                  • Backups and maintenance
                                    • Backups
                                    • ZODB packing
                                    • Log monitoring and rotation
                                  • Summary
                                  • Chapter 17: Setting up a Production Server
                                    • Server components
                                      • Virtual hosting
                                      • Web server
                                      • Caching reverse proxy
                                      • Load balancer
                                      • Other services
                                      • Common configurations
                                        • Deploying on UNIX with minimal configuration
                                        • Deploying on UNIX with SSL
                                        • Deploying on UNIX with maximum flexibility
                                        • Deploying on Windows
                                    • Hardware and operating system concerns
                                      • Hardware
                                      • Buildout or system packages
                                      • Operating system configuration
                                    • Caching and optimization
                                      • Application-level problems
                                      • Optimizing resources
                                        • Resource Registries resource merging
                                        • A crash course in caching
                                        • Caching configuration and rulesets
                                    • Testing and benchmarking
                                    • Summary

                                        Martin Aspeli

                                        Martin Aspeli is an experienced Plone consultant and a prolific Plone contributor. He served on the Framework Team for Plone 3.0, and is responsible for many new features such as the improved portlets infrastructure, the “content rules” engine, and several R&D efforts relating to Plone 4.0. He is a former leader of the Plone Documentation Team and has written a number of well-received tutorials available on plone.org. He is also the author of Professional Plone Development and was recognized in 2008 by Packt Publishing as one of the “Most Valuable People” in Open source Content Management Systems.

                                        Code Downloads

                                        Download the code and support files for this book.


                                        Submit Errata

                                        Please let us know if you have found any errors not listed on this list by completing our errata submission form. Our editors will check them and add them to this list. Thank you.


                                        Errata

                                        - 2 submitted: last submission 18 Jul 2013

                                        Errata type: Content | Page number: 235 | Errata date: 14 September 11

                                        In the information box providing the following information: "The first edition of this book covered Archetypes exclusively. The Archetypes chapter was updated for Plone 4 before it was decided that the book should cover Dexterity instead. You can find the (unedited) Archetypes draft online at https://www.packtpub.com/ professional-plone-4-development/book."

                                        The link provided for the unedited draft is no longer available as the book has been published.

                                         

                                        Errata type: Others | Page number: 68 | Errata date: 11 May 12

                                        navigation_properties in the last paragraph should be navtree_properties.

                                         

                                        Sample chapters

                                        You can view our sample chapters and prefaces of this title on PacktLib or download sample chapters in PDF format.

                                        Frequently bought together

                                        Professional Plone 4 Development +    Oracle JRockit: The Definitive Guide =
                                        50% Off
                                        the second eBook
                                        Price for both: $53.70

                                        Buy both these recommended eBooks together and get 50% off the cheapest eBook.

                                        What you will learn from this book

                                        • Setting up a productive development environment
                                        • Basics of Plone customisation and extension
                                        • Theming a Plone site using Diazo and plone.app.theming
                                        • Core concepts that underpin the workings of Zope and Plone
                                        • Creating custom content types using Dexterity
                                        • Building views and forms, including the use of z3c.form
                                        • Integrating with relational databases using SQLAlchemy
                                        • Customising the management of users and groups with PAS
                                        • Creating rich user interfaces with jQuery and jQuery Tools
                                        • Deploying and optimizing a production-ready Plone server
                                        • Integrating with LDAP and Active Directory

                                         

                                        In Detail

                                        Aspeli’s years of experience in Plone development and project management are combined with an approachable writing style to create an engaging and highly-informative guide to working with Plone. Professional Plone 4 Development stands as an excellent resource for developers of all levels.

                                        - Eric Steele, Plone Release Manager

                                        Plone is a web content management system that features among the top 2% of open source projects and is used by more than 300 solution providers in 57 countries. Its powerful workflow system, outstanding security track record, friendly user interface, elegant development model and vibrant community makes Plone a popular choice for building content-centric applications. By customising and extending the base platform, integrators can build unique solutions tailored to specific projects quickly and easily.

                                        If you want to create your own web applications and advanced websites using Plone 4, Professional Plone 4 Development is the book you need.

                                        The first edition of this book remains one of the most widely read and recommended Plone books. This second edition is completely revised and up-to-date for Plone 4.1, covering new topics such as Dexterity, Diazo, jQuery and z3c.form, as well as improved ways of working with existing technologies such as Buildout, SQLAlchemy and the Pluggable Authentication Service. It retains the writing style and comprehensive approach that made the first edition so popular.

                                        Built around a realistic case study, Professional Plone 4 Development will take you from an understanding of Plone’s central concepts, through basic customization, theming, and custom development, to deployment and optimization.

                                        The book is divided into four sections:

                                        1. First, you will be introduced to Plone and the case study, and learn how to set up a development environment.
                                        2. The second section covers basic customization, including theming a Plone site using Diazo.
                                        3. The third section focuses on custom development – building new content types and user interfaces, customizing security and integrating with external databases.
                                        4. The final chapters cover deployment and performance optimization.

                                        Approach

                                        Professional Plone 4 Development is written in a clear conversational easy-to-understand style. This book cuts short the preamble and gets straight to the point - building robust, content-rich web applications with Plone 4. Detailed real world examples are provided for each chapter.

                                        Who this book is for

                                        This book assumes that the reader is familiar with Plone from the point of view of an administrator or power user, has a basic understanding of web application development, and is comfortable with the Python programming language.

                                        Code Download and Errata
                                        Packt Anytime, Anywhere
                                        Register Books
                                        Print Upgrades
                                        eBook Downloads
                                        Video Support
                                        Contact Us
                                        Awards Voting Nominations Previous Winners
                                        Judges Open Source CMS Hall Of Fame CMS Most Promising Open Source Project Open Source E-Commerce Applications Open Source JavaScript Library Open Source Graphics Software
                                        Resources
                                        Open Source CMS Hall Of Fame CMS Most Promising Open Source Project Open Source E-Commerce Applications Open Source JavaScript Library Open Source Graphics Software