--- myst: html_meta: "description": "" "property=og:description": "" "property=og:title": "" "keywords": "" --- (intro-what-is-plone-label)= # What is Plone? Plone is an open source Content Management System (CMS) built in Python. A CMS lets non-technical people create and maintain information for a public website or an intranet using only a web browser. - Open Source Enterprise `CMS` - Written in `Python` - `Plone` 5.2 supports `Python` 3 and 2 - `Plone` 6 supports `Python` 3 - {doc}`plone6docs:plone.restapi/docs/source/index` - `Volto`: `React` based frontend and editor - Based on the web framework {term}`Zope` - Database: `Zope Object Database` {term}`ZODB` or `ORM` & `SQL`/`Postgres`/`Oracle` - Runs on Linux, macOS, BSD, Solaris, NixOS and Windows Plone has a multitude of powerful features, is easily accessible to editors but also fun for programmers. - Workflow-driven, collaborative management of content - Industrial Strength Security and Access-Control - Limitless Extensibility The modular and open component architecture of Plone allows you to change or extend Plone in every respect! ```{seealso} - [What Is Plone?](https://5.docs.plone.org/intro/index.html) - [Conceptual Overview](https://5.docs.plone.org/working-with-content/introduction/conceptual-overview.html) ``` ## Core concepts Here are the technical concepts that Plone uses. They make Plone special and distinguish it from most other systems. ### Traversal - Plone uses [Traversal](https://5.docs.plone.org/develop/plone/serving/traversing.html) (portal/folder/document) instead of URL dispatch. - Python objects exists in a object tree that looks like a huge nested dictionary: ```python {'site': {'folder': {'page': page_object}}} ``` - Objects can be accessed like walking through a file-system: ```python root['site']['folder']['page'] ``` ```python >>> from plone import api >>> portal = api.portal.get() >>> portal.keys() ['folder1', 'document1'] >>> portal['folder1'] ``` ### Object publishing Objects can be called and return a representation of itself - usually HTML. ```python >>> obj = portal['folder1']['a-newsitem'] >>> obj >>> obj() '\n\n\n - ``` ```` ### CMF - `CMF` was an add-on for Zope to build Content Management Systems (like Plone). - It provides libraries for building content management applications together with the Zope Application Server. ### Plone (the backend) This is the backend of the CMS. This is what we are extending and using during this training. ### Rest API {doc}`plone6docs:plone.restapi/docs/source/index` is a hypermedia API to access Plone content using REST (Representational State Transfer). It is used to connect the Volto frontend with Plone. (volto-basics-label)= ### Volto Frontend [Volto](https://github.com/plone/volto) is the default frontend for Plone 6 written in ReactJS. It uses the Rest API to communicate with the backend and offers a modern editing experience. Here are some basics that you need to understand if you are new to Volto: - All data is stored in Plone backend. The Volto frontend comes in to display and edit the content. - Volto is built in [ReactJS](https://www.reactjs.dev), a modern Javascript Framework. - Volto uses {doc}`plone6docs:plone.restapi/docs/source/index` to communicate with the Plone backend. - Volto is installed separately from the Plone backend. See chapter {ref}`instructions-install-frontend-label` for instructions. - Volto runs in a different process than the Plone backend. By default Volto runs on port 3000. If you start Volto with `yarn start` you can see the frontend on . The Plone backend runs by default on - You create a new Plone instance in an already set up Zope environment via the backend. This is by now not possible in Volto. - Volto takes advantage of [Semantic UI React components](https://react.semantic-ui.com/) to compose most of the views. For example the component [Image](https://react.semantic-ui.com/elements/image/) is used to render images. - The Volto default theme is based on Semantic UI theme and is called [Pastanaga](https://www.youtube.com/watch?v=wW9mTl1Tavc&t=133s). - Same as Plone Classic, Volto is highly extendable with add-ons for further features. - Existing Volto components are customizable with a technology similar to `z3c.jbot` called {ref}`volto-overrides-componentshadowing-label`. - Volto provides server side rendering (SSR), important for SEO-purposes. - Volto aims to provide 100% of the features of the current Plone backend. Not all features of Plone are implemented in Volto yet. - Volto provides additional functionality that Plone does not have. - For example Volto features the Pastanaga Editor, allowing you to visually compose a page using blocks. This feature is enabled for content types that have the behavior `volto.blocks` enabled. - Using the `Volto` editor, the content you add in blocks and the arrangement of blocks is stored as JSON in the schema fields `blocks` and `blocks_layout` provided by the dexterity behavior `volto.blocks`. Additionally you can edit all fields of the content type schema in a sidebar. - If you do not use the behavior `volto.blocks`, the fields from a content-type schema are edited and stored exactly like previously in Plone Classic. ### Classic Frontend A stable alternative to the `React` frontend Volto is the classic frontend of Plone that uses server-side rendered HTML. Plone ships with a default theme called Barceloneta. Since Plone 6 it uses [Bootstrap 5](https://getbootstrap.com/). The Plone Classic frontend uses the template-engine [Chameleon](https://chameleon.readthedocs.io/en/latest/) to create html. ```{note} Choosing the right frontend Here are some pointers that may help you decide: - The new Plone 6 frontend is recommended for new projects. - Existing projects that are updated to Plone 6 can decide which frontend to use. If a lot of customizations were done and you don't want to reimplement a lot of custom templates and features in Volto, it is a good idea to use Plone Classic. - For a selection of awesome Volto add-ons see - There are a growing ecosystem of add-ons for the React frontend. Be aware that a Plone Classic add-on may not have value for your project, if it has a theming component or anything that concerns the UI. That could be for example a backend add-on that implements the logic and storage of bookmarks. The UI needs to be implemented in React, be it an open source add-on or your custom add-on. Both, frontend and backend, communicate via REST API. - Most existing add-ons for Plone will have to be adapted to Volto if they touch the UI (e.g. templates for content types, control panels or viewlets). - Ask the community for advice if you are not certain what to choose. ```