Django - Tutorial 050. Creating Dynamic Site Settings Using SingletonModel

SingletonModel, Model, Django, singleton

Let's say you create a site with CMS based on Django, which must have some kind of dynamic site settings that will be available to the user. For example, the name of the site, some specialized information, while you take into account the possibility of multilingualism. What then can be used for this? I got the idea to use a database.

To implement this, the following is required:

1. Creating a data model that will always contain only one object, that is, only one record. That is, it will be a Singleton Model.
2. Prohibit deleting this entry and creating new ones in the Django admin panel
3. The ability to use information from this model directly in the template, without loading the site settings in the view function.

Let's figure out in order how to implement this.

SingletonModel

I found on GitHub the code of the abstract SingletonModel, which was written back in 2012. Here is a link to gist .

Here is the code for this SingletonModel

class SingletonModel(models.Model):
    class Meta:
        abstract = True

    def save(self, *args, **kwargs):
        self.__class__.objects.exclude(id=self.id).delete()
        super(SingletonModel, self).save(*args, **kwargs)

    @classmethod
    def load(cls):
        try:
            return cls.objects.get()
        except cls.DoesNotExist:
            return cls()

The model in the save method automatically saves all the others when saving the object, which allows you to always keep only one instance of this model in the database.

The load method takes from the database the only settings object, if the object does not exist in the database, it returns a new instance of this model, which will need to be saved later.

Let's create a custom settings class to use it for our needs in the future.

# -*- coding: utf-8 -*-

from django.db import models
from django.utils.translation import ugettext_lazy as _

from my_app.singleton_model import SingletonModel


class SiteSettings(SingletonModel):
    site_url = models.URLField(verbose_name=_('Website url'), max_length=256)
    title = models.CharField(verbose_name=_('Title'), max_length=256)

    def __str__(self):
        return 'Configuration'

Setting up the administration panel

Now you need to prohibit deleting this entry and creating new ones in the Django admin panel.

# -*- coding: utf-8 -*-

from django.contrib import admin
from django.db.utils import ProgrammingError

from my_app.models import SiteSettings


class SiteSettingsAdmin(admin.ModelAdmin):
    # Create a default object on the first page of SiteSettingsAdmin with a list of settings
    def __init__(self, model, admin_site):
        super().__init__(model, admin_site)
        # be sure to wrap the loading and saving SiteSettings in a try catch,
        # so that you can create database migrations
        try:
            SiteSettings.load().save()
        except ProgrammingError:
            pass

    # prohibit adding new settings
    def has_add_permission(self, request, obj=None):
        return False

    # as well as deleting existing
    def has_delete_permission(self, request, obj=None):
        return False


admin.site.register(SiteSettings, SiteSettingsAdmin)

Now the settings can be used in Python code

Creating a context processor to load settings into a template

context_proccessors.py

# -*- coding: utf-8 -*-

from evileg_settings.models import SiteSettings


def load_settings(request):
    return {'site_settings': SiteSettings.load()}

settings.py

Then we connect load_settings

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
                # Загружаем наши настройки при каждом рендеринге шаблона с контекстом
                'my_app.context_processors.load_settings', 
            ],
        },
    },
]

Usage in the template

<h1>{{ site_settings.title }}</h1>

Conclusion

So quickly and simply, you can implement simple dynamic site settings in Django and then bind them to all the site parameters that interest us.
The advantage of this approach will be the ability to use foreign keys for some special data on the site, as well as the use of django modeltranslation, which means there will be no problems with multilingualism.