Overview

I have evaluated and worked with many CMS's during my lifetime. Vignette, Documentum, Wordpress, Sitecore, Apostrophy, DjangoCMS etc. I always wondered why there were so many. The short answer is that there is no one solution that fits every case. Even with all the solutions I have worked with, none of them were designed to help developers; every one was designed to eliminate the developer and allow non-technical people to maintain and develop website pages. There is nothing wrong with this if you need it, however, there are significant trade-offs. Responsive design, SEO, speed, efficiency, complexity and flexibility. I wanted a CMS that helps me do my job more efficiently and easily.

First, and foremost docrootCMS is a Django application and can use any django features. Django is an outstanding framework for writing web applications. I wanted to leverage it as much as possible. However, anyone who has used django to develop and maintain a website knows that a couple of the frameworks features do not extend well to websites. Lets review the basic Django framework and discuss how docrootCMS differs. The basic Django framework to render a web page is to define application urls in urls.py and map each url to a view. The view performs logic and, in most cases, renders a template using data placed in a context. Templates are identified by defining the template directories in settings.py and separating them from static files, also defined in the application settings file.

docrootCMS uses the more traditional webserver rules much like PHP for defining urls and delivering pages

-- urls.py not required

The Django framework works great for an application and allows developers to know where to start in order to trace down a problem, however, creating urls and views for every page on your website quickly grows out of control and becomes extremely difficult to maintain.

From the very beginning, webservers have used directories and files to accomplish this same task. A specific directory (known as the docroot or document root) is defined and is accessed by the root slash. Every other directory becomes a path and all files are sent to the browser as pages. docrootCMS allows developers to place files and directories inside of the document root (docroot/files/) instead of having to define them in urls.py.

docrootCMS combines static files and dynamic templates much like PHP

-- combined static files

Many times, Developing a website requires explicit control on where static files are placed relative to the pages. For example, if you buy a theme from themes.getbootstrap.com you have to place css files in /css not /static/css/ or things will not work without you having to do a lot of modifications to the authors code; this is a maintenance nightmare.

While you can still use the static template tag and include static files you can also use static files placed in the docroot without any additional template tags. The developer has a choice. However, much like PHP, since templates and static files are mixed you must use an extension to identify templates. docrootCMS uses .dt to identify a file as a Django template.

docrootCMS dynamically injects context from a data.py file if found

-- views.py not required

Regardless if you use function based views or class based views having a view definition for each page becomes very difficult to follow and maintain.

By following a simple rule you can inject a data context into a template. If you create a page like index.dt and then create an index.data.py file, the data from the data file will be injected into the template for you. This is much simpler to maintain since the data file always lives in the same location as the template with the same name.