# cs_dynamicpages

A new addon for Plone to create web-based dynamic pages.

[Full Documentation](https://codesyntax.github.io/cs_dynamicpages/)

The concept is pretty similar that of Volto blocks:

- You can build a page using reusable items.
- Each item can have different fields
- Each item can have different views

## Provided Content Types

- DynamicPageFolder: this content type will be created in a given folder, and will be the container
  where all the rows will be added.

- DynamicPageRow: this content type will be the one that will be rendered in a separate row in the view

- DynamicPageRowFeatured: this content type can be used to save static information that can be shown in a
  row. For instance: each of the items of a slider need a title, a description or an image. They can be added
  using this content-type

## Provided View

There is just one view `dynamic_view` registered for Folders and Naviation roots. You can register it for your own content-types also.

### Different fields

To provide different fields, you should register standard `behaviors` to the `DynamicPageRow`
content type.

### Custom views

To provide different views, you should register standard views (using `zcml`).

Those views must be registered for implementers of `cs_dynamicpages.content.dynamic_page_row.IDynamicPageRow`
and their name _must_ start by `cs_dynamicpages-`.

### Restrict fields in the row edit view

You may register several behaviors for `DynamicPageRow` objects but only use some of the fields
provided by them in a given view.

You can restrict which fields are shown in the edit form of the `DynamicPageRow` going to the
Dynamic Pages Controlpanel, and setting there the list of fields that will be shown when editing
each of the row types.

To ease installation of such views and field configuration in your products, `cs_dynamicpages.utils` contains 2 utility functions:

- `add_custom_view`: function to add a given view to the list of available row types
- `enable_behavior`: function to enable the given behavior in the `DynamicPageRow` content type

## Templates

The product lets the end-user save a given dynamic page as a "Template". This means that a reference to the rows setup of a given page will be saved and then can be used as an starting point when creating a new dynamic page.

Templates are saved in a JSON field of a behavior called `cs_dynamicpages.templates` in a content object. This behavior is applied, by default, to the `Plone Site` object. But can be applied to any other object.

The template manager goes up in the contentree from the context object where you are setting the template until it finds a content object that implements the said behavior, and saves the template information there.

This means that you can configure different templates in different parts of your site, provided that you set the said behavior to a given content-type. Think, for instance, that you could set the behavior to Subsites of your site, or to Language Root Folders in multilingual sites.

A template management screen is also available to view and delete such templates.

## Installation

Install cs_dynamicpages with `pip`:

```shell
pip install cs_dynamicpages
```

And to create the Plone site:

```shell
make create-site
```

## Contribute 🤝

- [Issue tracker](https://github.com/codesyntax/cs_dynamicpages/issues)
- [Source code](https://github.com/codesyntax/cs_dynamicpages/)
- [Documentation](https://codesyntax.github.io/cs_dynamicpages/)

Please, clone this repo, do your developments in a specific branch, and create a pull request from it.

### Prerequisites ✅

- An [operating system](https://6.docs.plone.org/install/create-project-cookieplone.html#prerequisites-for-installation) that runs all the requirements mentioned.
- [uv](https://6.docs.plone.org/install/create-project-cookieplone.html#uv)
- [Make](https://6.docs.plone.org/install/create-project-cookieplone.html#make)
- [Git](https://6.docs.plone.org/install/create-project-cookieplone.html#git)
- [Docker](https://docs.docker.com/get-started/get-docker/) (optional)

### Installation 🔧

1.  Clone this repository, then change your working directory.

    ```shell
    git clone git@github.com:codesyntax/cs_dynamicpages.git
    cd cs_dynamicpages
    ```

2.  Install this code base.

    ```shell
    make install
    ```

### Add features using `plonecli` or `bobtemplates.plone`

This package provides markers as strings (`<!-- extra stuff goes here -->`) that are compatible with [`plonecli`](https://github.com/plone/plonecli) and [`bobtemplates.plone`](https://github.com/plone/bobtemplates.plone).
These markers act as hooks to add all kinds of subtemplates, including behaviors, control panels, upgrade steps, or other subtemplates from `plonecli`.

To run `plonecli` with configuration to target this package, run the following command.

```shell
make add <template_name>
```

For example, you can add a content type to your package with the following command.

```shell
make add content_type
```

You can add a behavior with the following command.

```shell
make add behavior
```

```{seealso}
You can check the list of available subtemplates in the [`bobtemplates.plone` `README.md` file](https://github.com/plone/bobtemplates.plone/?tab=readme-ov-file#provided-subtemplates).
See also the documentation of [Mockup and Patternslib](https://6.docs.plone.org/classic-ui/mockup.html) for how to build the UI toolkit for Classic UI.
```

## License

The project is licensed under GPLv2.

## Credits and acknowledgements 🙏

Generated using [Cookieplone (0.9.7)](https://github.com/plone/cookieplone) and [cookieplone-templates (4d55553)](https://github.com/plone/cookieplone-templates/commit/4d55553d61416df56b3360914b398d675b3f72a6) on 2025-07-17 11:59:12.982862. A special thanks to all contributors and supporters!
