Mezzanine Documentation

Mezzanine supports multiple sites within a single running instance by leveraging Django's sites app. Unlike standard Django, which typically uses the SITE_ID setting to bind a project to one site, Mezzanine uses a priority-based pipeline to determine the active site for a request. This allows true multi-tenancy where different domains (or subdomains) can serve different content from the same process.

The site determination pipeline follows this order:

1. Session variable site_id: Used by the admin to allow users to switch between sites.
2. Host matching: The domain of the current HTTP request is compared against the domain names in the Site records.
3. Environment variable MEZZANINE_SITE_ID: Used for contexts outside of HTTP requests (e.g., management commands). Mezzanine's custom manage.py handles the --site=ID argument.
4. SITE_ID setting: The fallback if no other method identifies a site.

Mezzanine includes a wide range of built-in features for content management and site administration:

• Content Management: Hierarchical page navigation, save as draft/preview, scheduled publishing, drag-and-drop page ordering, and WYSIWYG editing.
• Site Customization: In-line page editing, custom templates per page/post, and configurable dashboard widgets.
• Forms & SEO: Drag-and-drop HTML5 forms builder (with CSV export) and SEO-friendly URLs/meta data.
• E-commerce: Includes the Cartridge shopping cart module.
• Communication & Social: Multi-lingual site support, social sharing (Facebook/Twitter), and integration with Disqus, Gravatar, and Google Analytics.
• Extensibility: API for custom content types, search engine and API, and seamless integration with third-party Django apps.
• Other: Blog engine, tagging, Akismet spam filtering, and bit.ly integration.

Mezzanine content is built using abstract models from mezzanine.core and mezzanine.pages. The two primary models for building custom content types are:

• mezzanine.core.models.Displayable: An abstract model for content that has a URL (slug) but is not part of the site's navigation (e.g., blog posts, calendar events). It provides metadata, auto-generated slugs, publishing status, and searchability.
• mezzanine.pages.models.Page: A concrete model that extends Displayable and implements a hierarchical navigation tree. This is the foundation for most site content.

Key abstract building blocks include:

• SiteRelated: Adds a django.contrib.sites.models.Site field.
• Slugged: Implements title and slug.
• MetaData: Provides SEO fields (title, description, keywords).
• TimeStamped: Provides created and updated timestamps.
• Ownable: Adds a related user field for authorship.
• RichText: Provides a WYSIWYG editable field.
• Orderable: Enables drag/drop ordering.

Since all :class:.Pageinstances are handled by the singlemezzanine.pages.views.page` view, you cannot create custom views for specific page types. Instead, use Page Processors.

Page Processors are functions associated with a custom :class:.Page model that are called during the view process. They receive two arguments: request and the page instance.

Return values:

• A dictionary: The keys/values are added to the template context.
• An HttpResponse (or subclass): This overrides the default mezzanine.pages.views.page view entirely (useful for handling form submissions via redirects).

Setup:

1. Create a module named page_processors.py inside one of your INSTALLED_APPS.
2. Use the @processor_for(Model) decorator to associate the function with a specific model.
3. Alternatively, use @processor_for(slug='your-slug') to run the processor only when a specific page slug is matched.

from django import forms
from django.http import HttpResponseRedirect
from mezzanine.pages.page_processors import processor_for
from .models import Author

class AuthorForm(forms.Form):
    name = forms.CharField()
    email = forms.EmailField()

@processor_for(Author)
def author_form(request, page):
    form = AuthorForm()
    if request.method == "POST":
        form = AuthorForm(request.POST)
        if form.is_valid():
            # Form processing goes here.
            redirect = request.path + "?submitted=true"
            return HttpResponseRedirect(redirect)
    return {"form": form}