How Do You Extend The Site Model In Django?

March 17, 2024 Post a Comment

What is the best approach to extending the Site model in django? Creating a new model and ForeignKey the Site or there another approach that allows me to subclass the Site model? I

Solution 1:

I just used my own subclass of Site and created a custom admin for it.

Basically, when you subclass a model in django it creates FK pointing to parent model and allows to access parent model's fields transparently- the same way you'd access parent class attributes in pyhon. Built in admin won't suffer in any way, but you'll have to un-register Sites ModelAdmin and register your own ModelAdmin.

Solution 2:

If you only want to change behaviour of the object, but not add any new fields, you should consider using a "proxy model" (new in Django 1.1). You can add extra Python methods to existing models, and more:

This is what proxy model inheritance is for: creating a proxy for the original model. You can create, delete and update instances of the proxy model and all the data will be saved as if you were using the original (non-proxied) model. The difference is that you can change things like the default model ordering or the default manager in the proxy, without having to alter the original.

Solution 3:

As of Django 2.2 there still no simple straight way to extend Site as can be done for User. Best way to do it now is to create new entity and put parameters there. This is the only way if you want to leverage existing sites support.

classSiteProfile(models.Model):
    title = models.TextField()
    site = models.OneToOneField(Site, on_delete=models.CASCADE)

You will have to create admin for SiteProfile. Then add some SiteProfile records with linked Site. Now you can use site.siteprofile.title anywhere where you have access to current site from model.

Solution 4:

You can have another model like SiteProfile which has a OneToOne relation with Site.

Solution 5:

It has been a long time since the question was asked, but I think there is not yet (Django 3.1) an easy solution for it like creating a custom user model. In this case, creating a custom user model inheriting from django.contrib.auth.models.AbstractUser model and changing AUTH_USER_MODEL (in settings) to the newly created custom user model solves the issue.

However, it can be achieved for also Site model with a long solution written below:

SOLUTION

Suppose that you have an app with the name core. Use that app for all of the code below, except the settings file.

Baca Juga

Create a SiteProfile model with a site field having an OneToOne relation with the Site model. I have also changed its app_label meta so it will be seen under the Sites app in the admin.

# in core.models

...
from django.contrib.sites.models import Site
from django.db import models

classSiteProfile(models.Model):
    """SiteProfile model is OneToOne related to Site model."""
    site = models.OneToOneField(
        Site, on_delete=models.CASCADE, primary_key=True,
        related_name='profiles', verbose_name='site')

    long_name = models.CharField(
        max_length=255, blank=True, null=True)
    meta_name = models.CharField(
        max_length=255, blank=True, null=True)

    def__str__(self):
        return self.site.name

    classMeta:
        app_label = 'sites'# make it under sites app (in admin)

...

What we did until now was good enough if you just want to create a site profile model. However, you will want the first profile to be created just after migration. Because the first site is created, but not the first profile related to it. If you don't want to create it by hand, you need the 3rd step.

Write below code in core.apps.py:

# in core.apps

...
from django.conf import settings
from django.db.models.signals import post_migrate

defcreate_default_site_profile(sender, **kwargs):
    """after migrations"""from django.contrib.sites.models import Site
    from core.models import SiteProfile

    site = Site.objects.get(id=getattr(settings, 'SITE_ID', 1))

    ifnot SiteProfile.objects.exists():
        SiteProfile.objects.create(site=site)

classCoreConfig(AppConfig):
    name = 'core'defready(self):
        post_migrate.connect(create_default_site_profile, sender=self)
        from .signals import (create_site_profile)  # now create the second signal

The function (create_default_site_profile) will automatically create the first profile related to the first site after migration, using the post_migrate signal. However, you will need another signal (post_save), the last row of the above code.

If you do this step, your SiteProfile model will have a full connection with the Site model. A SiteProfile object is automatically created/updated when any Site object is created/updated. The signal is called from apps.py with the last row.

# in core.signalsfrom django.contrib.sites.models import Site
from django.db.models.signals import post_save, post_migrate
from django.dispatch import receiver

from .models import SiteProfile


@receiver(post_save, sender=Site)defcreate_site_profile(sender, instance, **kwargs):
    """This signal creates/updates a SiteProfile object 
    after creating/updating a Site object.
    """
    siteprofile, created = SiteProfile.objects.update_or_create(
        site=instance
    )

    ifnot created:
        siteprofile.save()

Would you like to use it on templates? e.g. {{ site.name }}

Then you need the 5th and 6th steps.

Add the below code in settings.py > TEMPLATES > OPTIONS > context_processors 'core.context_processors.site_processor'

# in settings.pyTEMPLATES = [
    {
        # ...'OPTIONS': {
            'context_processors': [
                # ...# custom processor for getting the current site'core.context_processors.site_processor',
            ],
        },
    },
]

Create a context_processors.py file in the core app with the code below. A try-catch block is needed (catch part) to make it safer. If you delete all sites from the database you will have an error both in admin and on the front end pages. Error is Site matching query does not exist. So the catch block creates one if it is empty.

This solution may not be fully qualified if you have a second site and it is deleted. This solution only creates a site with id=1.

# in core.context_processorsfrom django.conf import settings
from django.contrib.sites.models import Site


defsite_processor(request):
    try:
        return {
            'site': Site.objects.get_current()
        }
    except:
        Site.objects.create(
            id=getattr(settings, 'SITE_ID', 1),
            domain='example.com', name='example.com')

You can now use the site name, domain, meta_name, long_name, or any field you added, in your templates.

# e.g.
{{ site.name }} 
{{ site.profiles.long_name }}

It normally adds two DB queries, one for File.objects and one for FileProfile.objects. However, as it is mentioned in the docs, Django is clever enough to cache the current site at the first request and it serves the cached data at the subsequent calls.

https://docs.djangoproject.com/en/3.1/ref/contrib/sites/#caching-the-current-site-object

Getting Started with Python