mirror of
https://github.com/jazzband/django-dbtemplates.git
synced 2026-05-25 07:33:48 +00:00
94 lines
3.5 KiB
Python
94 lines
3.5 KiB
Python
from django.contrib.sites.models import Site
|
|
from django.db import router
|
|
from django.template import Origin, TemplateDoesNotExist
|
|
from django.template.loaders.base import Loader as BaseLoader
|
|
|
|
from dbtemplates.models import Template
|
|
from dbtemplates.utils.cache import (
|
|
cache,
|
|
get_cache_key,
|
|
set_and_return,
|
|
get_cache_notfound_key,
|
|
)
|
|
|
|
|
|
class Loader(BaseLoader):
|
|
"""
|
|
A custom template loader to load templates from the database.
|
|
|
|
Tries to load the template from the dbtemplates cache backend specified
|
|
by the DBTEMPLATES_CACHE_BACKEND setting. If it does not find a template
|
|
it falls back to query the database field ``name`` with the template path
|
|
and ``sites`` with the current site.
|
|
"""
|
|
|
|
is_usable = True
|
|
|
|
def get_template_sources(self, template_name, template_dirs=None):
|
|
yield Origin(
|
|
name=template_name,
|
|
template_name=template_name,
|
|
loader=self,
|
|
)
|
|
|
|
def get_contents(self, origin):
|
|
content, _ = self._load_template_source(origin.template_name)
|
|
return content
|
|
|
|
def _load_and_store_template(self, template_name, cache_key, site, **params):
|
|
template = Template.objects.get(name__exact=template_name, **params)
|
|
db = router.db_for_read(Template, instance=template)
|
|
display_name = f"dbtemplates:{db}:{template_name}:{site.domain}"
|
|
return set_and_return(cache_key, template.content, display_name)
|
|
|
|
def _load_template_source(self, template_name, template_dirs=None):
|
|
# The logic should work like this:
|
|
# * Try to find the template in the cache. If found, return it.
|
|
# * Now check the cache if a lookup for the given template
|
|
# has failed lately and hand over control to the next template
|
|
# loader waiting in line.
|
|
# * If this still did not fail we first try to find a site-specific
|
|
# template in the database.
|
|
# * On a failure from our last attempt we try to load the global
|
|
# template from the database.
|
|
# * If all of the above steps have failed we generate a new key
|
|
# in the cache indicating that queries failed, with the current
|
|
# timestamp.
|
|
site = Site.objects.get_current()
|
|
cache_key = get_cache_key(template_name)
|
|
# Not found in cache, move on.
|
|
cache_notfound_key = get_cache_notfound_key(template_name)
|
|
if cache:
|
|
try:
|
|
backend_template = cache.get(cache_key)
|
|
except Exception:
|
|
pass
|
|
else:
|
|
if backend_template:
|
|
return (backend_template, template_name)
|
|
|
|
try:
|
|
notfound = cache.get(cache_notfound_key)
|
|
except Exception:
|
|
raise TemplateDoesNotExist(template_name)
|
|
else:
|
|
if notfound:
|
|
raise TemplateDoesNotExist(template_name)
|
|
|
|
# Not marked as not-found, move on...
|
|
|
|
try:
|
|
return self._load_and_store_template(
|
|
template_name, cache_key, site, sites__in=[site.id]
|
|
)
|
|
except (Template.MultipleObjectsReturned, Template.DoesNotExist):
|
|
try:
|
|
return self._load_and_store_template(
|
|
template_name, cache_key, site, sites__isnull=True
|
|
)
|
|
except (Template.MultipleObjectsReturned, Template.DoesNotExist):
|
|
pass
|
|
|
|
# Mark as not-found in cache.
|
|
cache.set(cache_notfound_key, "1")
|
|
raise TemplateDoesNotExist(template_name)
|