def test_url_tag_override(self):
# we should be setting HOST_OVERRIDE_URL_TAG to True
# but that doesn't really work since that setting is read only
# on setup time so we have to fake it by manually setting the stage.
try:
from django.template.base import add_to_builtins
except ImportError: # Django 1.9+
add_to_builtins = None
if add_to_builtins:
add_to_builtins('django_hosts.templatetags.hosts_override')
self.assertRender("{% url 'simple-direct' host 'www' %}",
'//www.example.com/simple/')
self.assertRender("{% url 'simple-direct' host 'www' as "
"simple_direct_url %}{{ simple_direct_url }}",
'//www.example.com/simple/')
else:
with self.settings(
TEMPLATES=[{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'OPTIONS': {
'builtins': [
'django_hosts.templatetags.hosts_override',
],
},
}]
):
self.assertRender("{% url 'simple-direct' host 'www' %}",
'//www.example.com/simple/')
self.assertRender("{% url 'simple-direct' host 'www' as "
"simple_direct_url %}{{ simple_direct_url }}",
'//www.example.com/simple/')
def setUpClass(cls):
super(TagParserTests, cls).setUpClass()
if add_to_builtins is not None:
# Django 1.8 and below.
# Make it easier to run tests without needing to change INSTALLED_APPS
add_to_builtins(
"tag_parser.tests.templatetags.tag_parser_test_tags")
def test_url_tag_override(self):
# we should be setting HOST_OVERRIDE_URL_TAG to True
# but that doesn't really work since that setting is read only
# on setup time so we have to fake it by manually setting the stage.
try:
from django.template.base import add_to_builtins
except ImportError: # Django 1.9+
add_to_builtins = None
if add_to_builtins:
add_to_builtins('django_hosts.templatetags.hosts_override')
self.assertRender("{% url 'simple-direct' host 'www' %}",
'//www.example.com/simple/')
self.assertRender(
"{% url 'simple-direct' host 'www' as "
"simple_direct_url %}{{ simple_direct_url }}",
'//www.example.com/simple/')
else:
with self.settings(TEMPLATES=[{
'BACKEND':
'django.template.backends.django.DjangoTemplates',
'OPTIONS': {
'builtins': [
'django_hosts.templatetags.hosts_override',
],
},
}]):
self.assertRender("{% url 'simple-direct' host 'www' %}",
'//www.example.com/simple/')
self.assertRender(
"{% url 'simple-direct' host 'www' as "
"simple_direct_url %}{{ simple_direct_url }}",
'//www.example.com/simple/')
def add_to_builtins_compat(name):
if django.VERSION < (1, 9):
from django.template.base import add_to_builtins
add_to_builtins(name)
else:
from django.template import engines
engines['django'].engine.builtins.append(name)
def add_to_builtins_compat(name):
if django.VERSION < (1, 9):
from django.template.base import add_to_builtins
add_to_builtins(name)
else:
from django.template import engines
engines['django'].engine.builtins.append(name)
def ready(self):
register()(check_template_settings)
if DJANGO_VERSION < (1, 9):
# add_to_builtins was removed in 1.9 and replaced with a
# documented public API configured by the TEMPLATES setting.
from django.template.base import add_to_builtins
add_to_builtins("mezzanine.template.loader_tags")
def handle(self, *args, **options):
from django.conf import settings
style = color_style()
template_dirs = set(settings.TEMPLATE_DIRS)
template_dirs |= set(options.get('includes', []))
template_dirs |= set(
getattr(settings, 'VALIDATE_TEMPLATES_EXTRA_TEMPLATE_DIRS', []))
# Load in Templates from 1.8
if hasattr(settings, 'TEMPLATES'):
for template_engine in settings.TEMPLATES:
if 'DIRS' in template_engine:
template_dirs |= set(template_engine['DIRS'])
settings.TEMPLATE_DIRS = list(template_dirs)
settings.TEMPLATE_DEBUG = True
verbosity = int(options.get('verbosity', 1))
errors = 0
# Replace built in template tags with our own validating versions
if options.get('check_urls', False):
add_to_builtins('django_extensions.utils.validatingtemplatetags')
for template_dir in template_dirs:
for root, dirs, filenames in os.walk(template_dir):
for filename in filenames:
if filename.endswith(".swp"):
continue
if filename.endswith("~"):
continue
filepath = os.path.join(root, filename)
if verbosity > 1:
print(filepath)
validatingtemplatetags.before_new_template(
options.get('force_new_urls', False))
try:
get_template(filename, [root])
except Exception as e:
errors += 1
print("%s: %s" %
(filepath,
style.ERROR("%s %s" %
(e.__class__.__name__, str(e)))))
template_errors = validatingtemplatetags.get_template_errors(
)
for origin, line, message in template_errors:
errors += 1
print("%s(%s): %s" %
(origin, line, style.ERROR(message)))
if errors and options.get('break', False):
raise CommandError("Errors found")
if errors:
raise CommandError("%s errors found" % errors)
print("%s errors found" % errors)
def ready(self):
super(YepesConfig, self).ready()
from django import VERSION as DJANGO_VERSION
if DJANGO_VERSION < (1, 9):
from django.template.base import add_to_builtins
add_to_builtins('yepes.defaultfilters')
add_to_builtins('yepes.defaulttags')
else:
from django.template.engine import Engine
Engine.default_builtins.append('yepes.defaultfilters')
Engine.default_builtins.append('yepes.defaulttags')
def handle(self, *args, **options):
from django.conf import settings
style = color_style()
template_dirs = set(settings.TEMPLATE_DIRS)
template_dirs |= set(options.get('includes', []))
template_dirs |= set(
getattr(
settings,
'VALIDATE_TEMPLATES_EXTRA_TEMPLATE_DIRS',
[]))
settings.TEMPLATE_DIRS = list(template_dirs)
settings.TEMPLATE_DEBUG = True
verbosity = int(options.get('verbosity', 1))
errors = 0
template_loader = Loader()
# Replace built in template tags with our own validating versions
if options.get('check_urls', False):
add_to_builtins('django_extensions.utils.validatingtemplatetags')
for template_dir in template_dirs:
for root, dirs, filenames in os.walk(template_dir):
for filename in filenames:
if filename.endswith(".swp"):
continue
if filename.endswith("~"):
continue
filepath = os.path.join(root, filename)
if verbosity > 1:
print(filepath)
validatingtemplatetags.before_new_template(
options.get('force_new_urls', False))
try:
template_loader.load_template(filename, [root])
except Exception as e:
errors += 1
print(
"%s: %s" %
(filepath, style.ERROR(
"%s %s" %
(e.__class__.__name__, str(e)))))
template_errors = validatingtemplatetags.get_template_errors()
for origin, line, message in template_errors:
errors += 1
print(
"%s(%s): %s" %
(origin, line, style.ERROR(message)))
if errors and options.get('break', False):
raise CommandError("Errors found")
if errors:
raise CommandError("%s errors found" % errors)
print("%s errors found" % errors)
def ready(self):
checks.register(check_root_hostconf)
checks.register(check_default_host)
if getattr(settings, 'HOST_OVERRIDE_URL_TAG', False):
if add_to_builtins:
add_to_builtins('django_hosts.templatetags.hosts_override')
else:
raise ImproperlyConfigured(
"On Django 1.9+, you must add "
"'django_hosts.templatetags.hosts_override' to the "
"TEMPLATES['OPTIONS']['builtins'] list instead of using "
"the HOST_OVERRIDE_URL_TAG setting.")
def ready(self):
checks.register(check_root_hostconf)
checks.register(check_default_host)
if getattr(settings, 'HOST_OVERRIDE_URL_TAG', False):
if add_to_builtins:
add_to_builtins('django_hosts.templatetags.hosts_override')
else:
raise ImproperlyConfigured(
"On Django 1.9+, you must add "
"'django_hosts.templatetags.hosts_override' to the "
"TEMPLATES['OPTIONS']['builtins'] list instead of using "
"the HOST_OVERRIDE_URL_TAG setting."
)
def preload_templatetags():
from django.conf import settings
#from django.template.loader import add_to_builtins
from django.template.base import add_to_builtins
import django.template.loader
try:
for lib in settings.TEMPLATE_TAGS:
add_to_builtins(lib)
except AttributeError:
pass
def test_url_tag_override(self):
# we should be setting HOST_OVERRIDE_URL_TAG to True
# but that doesn't really work since that setting is read only
# on import time for Django < 1.7 and on setup time for >= 1.7
# so we have to fake it by manually setting the stage
try:
from django.template.base import add_to_builtins
except ImportError: # Django < 1.8
from django.template import add_to_builtins
add_to_builtins("django_hosts.templatetags.hosts_override")
self.assertRender("{% url 'simple-direct' host 'www' %}", "//www.example.com/simple/")
self.assertRender(
"{% url 'simple-direct' host 'www' as " "simple_direct_url %}{{ simple_direct_url }}",
"//www.example.com/simple/",
)
def test_url_tag_override(self):
# we should be setting HOST_OVERRIDE_URL_TAG to True
# but that doesn't really work since that setting is read only
# on import time for Django < 1.7 and on setup time for >= 1.7
# so we have to fake it by manually setting the stage
try:
from django.template.base import add_to_builtins
except ImportError: # Django < 1.8
from django.template import add_to_builtins
add_to_builtins('django_hosts.templatetags.hosts_override')
self.assertRender("{% url 'simple-direct' host 'www' %}",
'//www.example.com/simple/')
self.assertRender("{% url 'simple-direct' host 'www' as "
"simple_direct_url %}{{ simple_direct_url }}",
'//www.example.com/simple/')
def test_include_chart_jscss_tag_custom_dirs(self):
add_to_builtins('django_nvd3.templatetags.nvd3_tags')
rendered = self.render_template(
"{% include_chart_jscss css_dir='css' js_dir='js' %}")
# Not only does this test the output of the template tag,
# but also the order of including the static files - mainly
# d3 and nvd3 js files which should be in that order.
expected = ('<link media="all" href="/static/css/nv.d3.min.css" '
'type="text/css" rel="stylesheet" />\n'
'<script src="/static/js/d3.min.js" '
'type="text/javascript" charset="utf-8"></script>\n'
'<script src="/static/js/nv.d3.min.js" '
'type="text/javascript" charset="utf-8"></script>\n\n')
self.assertEqual(rendered, expected)
def test_include_chart_jscss_tag_custom_dirs(self):
add_to_builtins('django_nvd3.templatetags.nvd3_tags')
rendered = self.render_template(
"{% include_chart_jscss css_dir='css' js_dir='js' %}"
)
# Not only does this test the output of the template tag,
# but also the order of including the static files - mainly
# d3 and nvd3 js files which should be in that order.
expected = (
'<link media="all" href="/static/css/nv.d3.min.css" '
'type="text/css" rel="stylesheet" />\n'
'<script src="/static/js/d3.min.js" '
'type="text/javascript" charset="utf-8"></script>\n'
'<script src="/static/js/nv.d3.min.js" '
'type="text/javascript" charset="utf-8"></script>\n\n'
)
self.assertEqual(rendered, expected)
def define_table(columns):
from django.template.base import add_to_builtins
add_to_builtins('silo.templatetags.underscoretags')
"""
Dynamically builds a django-tables2 table without specifying the column names
It is important to build the django-tables2 dynamically because each time a silo
is loaded from MongoDB, it is not known what columns heading it has or how mnay columns it has
"""
EDIT_DEL_TEMPLATE = '''
<a class="btn btn-default btn-xs" role="button" href="/value_edit/{{ record|get:'_id'|get:'$oid' }}">Edit</a>
<a class="btn btn-danger btn-xs btn-del" style="color: #FFF;" role="button" href="/value_delete/{{ record|get:'_id'|get:'$oid' }}" title="Are you sure you want to delete this record?">Delete</a>
'''
#add the operations to the table first then append the dynamic table columns
attrs = {}
attrs['Operation'] = tables.TemplateColumn(EDIT_DEL_TEMPLATE)
attrs.update(dict((c, tables.Column()) for c in columns))
attrs['Meta'] = type('Meta', (), dict(exclude=["_id", "edit_date", "create_date"], attrs={"class":"paleblue", "orderable":"True", "width":"100%"}) )
klass = type('DynamicTable', (tables.Table,), attrs)
return klass
def init():
# Our eventual aim is to patch the render() method on the Node objects
# corresponding to custom template tags. However we have to jump through
# a number of hoops in order to get access to the object.
#
# 1. Add ourselves to the set of built in template tags
# This allows us to replace the 'load' template tag which controls
# the loading of custom template tags
# 2. Delegate to default load with replaced parser
# We provide our own parser class so we can catch and intercept
# calls to add_library.
# 3. add_library receives a library of template tags
# It iterates through each template tag, wrapping its compile function
# 4. compile is called as part of compiling the template
# Our wrapper is called instead of the original templatetag compile
# function. We delegate to the original function, but then modify
# the resulting object by wrapping its render() function. This
# render() function is what ends up being timed and appearing in the
# tree.
add_to_builtins('speedbar.modules.templates')
@trace_method(Template)
def __init__(self, *args, **kwargs):
name = args[2] if len(args) >= 3 else '<Unknown Template>'
return ('TEMPLATE_COMPILE', 'Compile template: ' + name, {})
@trace_method(Template)
def render(self, *args, **kwargs):
name = self.name if self.name is not None else '<Unknown Template>'
return ('TEMPLATE_RENDER', 'Render template: ' + name, {})
@trace_method(BlockNode)
def render(self, *args, **kwargs):
return ('BLOCK_RENDER', 'Render block: ' + self.name, {})
@trace_method(TemplateResponse)
def resolve_context(self, *args, **kwargs):
return ('TEMPLATE_CONTEXT', 'Resolve context', {})
def configure(self, settings_module=None, overrides=None):
"""
"""
if self._wrapped is not empty:
raise RuntimeError('Settings already configured.')
from django.conf import ENVIRONMENT_VARIABLE, settings as django_settings
from django import setup
from django.template.base import add_to_builtins
if not django_settings.configured:
settings_module = settings_module or 'instance.defaults'
os.environ.setdefault(ENVIRONMENT_VARIABLE, settings_module)
setup()
add_to_builtins("instance.templatetags.loader_tags")
env = django_settings._wrapped.__dict__
if overrides:
env.update(overrides)
self._configure_data_root(env)
self._configure_database(env)
self._configure_defaults(env)
self._wrapped = Environment(env) #shallow copy
self._site_cache = {}
def ready(self):
# The following enables legacy ARCUtils behavior by adding a
# bunch of default template tags. It would be better to add the
# relevant {% load xxx %} in the templates that use these tags.
# Django 1.9 has a new setting that "officially" enables adding
# default tags, so we could leave this until we upgrade to 1.9.
from django.template.base import add_to_builtins
add_to_builtins('django.contrib.staticfiles.templatetags.staticfiles')
add_to_builtins('bootstrapform.templatetags.bootstrap')
add_to_builtins('arcutils.templatetags.arc')
def ready(self):
"""
Do a bunch of monkey patching based on the ARCUTILS_FEATURES setting
"""
from django.conf import settings
ARCUTILS_FEATURES = getattr(settings, 'ARCUTILS_FEATURES', DEFAULT_FEATURES)
# monkey patch the PasswordResetForm so it indicates if a user does not exist
if ARCUTILS_FEATURES.get('warn_on_invalid_email_during_password_reset'):
from django.contrib.auth.forms import PasswordResetForm
original_clean_email = getattr(PasswordResetForm, "clean_email", lambda self: self.cleaned_data['email'])
def _clean_email(self):
from django.contrib.auth import get_user_model
email = self.cleaned_data['email']
UserModel = get_user_model()
if not UserModel.objects.filter(email=email, is_active=True).exists():
raise forms.ValidationError("A user with that email address does not exist!")
return original_clean_email(self)
PasswordResetForm.clean_email = _clean_email
# hook up the session clearer
CLEAR_EXPIRED_SESSIONS_AFTER_N_REQUESTS = getattr(settings, 'CLEAR_EXPIRED_SESSIONS_AFTER_N_REQUESTS', 100)
CLEAR_EXPIRED_SESSIONS_ENABLED = is_installed('django.contrib.sessions') and CLEAR_EXPIRED_SESSIONS_AFTER_N_REQUESTS is not None
if ARCUTILS_FEATURES.get('clear_expired_sessions') and CLEAR_EXPIRED_SESSIONS_ENABLED:
from .sessions import patch_sessions
patch_sessions(CLEAR_EXPIRED_SESSIONS_AFTER_N_REQUESTS)
# add all the templatetag libraries we want available by default
if ARCUTILS_FEATURES.get('templatetags'):
from django.template.base import add_to_builtins
add_to_builtins('django.contrib.staticfiles.templatetags.staticfiles')
# add the arc template tags to the builtin tags, and the bootstrap tag
add_to_builtins('arcutils.templatetags.arc')
add_to_builtins('arcutils.templatetags.bootstrap')
# make the `required_css_class` attribute for forms and fields
# "required" by default
if ARCUTILS_FEATURES.get('add_css_classes_to_forms'):
from django.forms.fields import Field
from django import forms
forms.Form.required_css_class = "required"
forms.ModelForm.required_css_class = "required"
Field.required_css_class = "required"
def send_mail(self, lang, subject, text, recipient):
"""
This method will send an email to given recipient with attached cv pdf
:param lang: The language of sending CV
:type lang: str
:param subject: The subject of sending email
:type subject: str
:param text: The body of sending email
:type text: str
:param recipient: The target email
:type recipient: str
"""
pdf = self.translations.filter(language_code=lang).first().pdf
pdf_content = urllib2.urlopen('http://buildcv.org' + pdf).read()
pdf_name = '%s_%s_CV_%s-%s.pdf' % (
self.human.nume(), self.human.prenume(), self.title, lang)
message = EmailMessage(subject,
text,
'*****@*****.**', [recipient], [],
reply_to=[self.human.email])
message.attach(pdf_name, pdf_content, 'application/pdf')
message.send()
return {'success': True, 'message': 'The email was sent'}
admin.site.register(CV)
add_to_builtins('udata.templatetags.syns')
from django import http
from django.contrib import messages
from django.core.urlresolvers import reverse
from django.contrib.auth.decorators import login_required
from django.shortcuts import get_object_or_404, get_list_or_404, render
from django.template.base import add_to_builtins
from .models import League, Game, RosterStats, Preference, PickerResultException
from . import utils
from . import forms
from .decorators import management_user_required
datetime_now = utils.datetime_now
add_to_builtins('picker.templatetags.picker_tags')
#-------------------------------------------------------------------------------
def picker_adapter(view):
@functools.wraps(view)
def view_wrapper(request, *args, **kws):
league = League.get(kws.pop('league'))
result = view(request, league, *args, **kws)
if isinstance(result, http.HttpResponse):
return result
tmpl, ctx = (result, {}) if isinstance(result, basestring) else result
tmpls = utils.get_templates(league, tmpl)
data = {
'league': league,
from __future__ import unicode_literals
try:
# Django 1.6
from django.template.base import add_to_builtins
# This will add the localsite tags as built-in tags, and override the
# existing {% url %} tag in Django.
add_to_builtins(__name__ + '.localsite')
except ImportError:
# This is instead handled in the TEMPLATES settings.
pass
if not code.buffer:
codeTag = code.val.strip().split(' ', 1)[0]
if codeTag in self.autocloseCode:
self.buf.append('{%% end%s %%}' % codeTag)
def attributes(self, attrs):
return "{%% __pypugjs_attrs %s %%}" % attrs
try:
try:
from django.template.base import add_to_builtins
except ImportError: # Django < 1.8
from django.template import add_to_builtins
add_to_builtins('pypugjs.ext.django.templatetags')
except ImportError:
# Django 1.9 removed add_to_builtins and instead
# provides a setting to specify builtins:
# TEMPLATES['OPTIONS']['builtins'] = ['pypugjs.ext.django.templatetags']
pass
try:
from django.utils.encoding import force_text as to_text
except ImportError:
from django.utils.encoding import force_unicode as to_text
def decorate_templatize(func):
def templatize(src, origin=None):
src = to_text(src, settings.FILE_CHARSET)
def set_dynamic_settings(s):
"""
Called at the end of the project's settings module, and is passed
its globals dict for updating with some final tweaks for settings
that generally aren't specified, but can be given some better
defaults based on other settings that have been specified. Broken
out into its own function so that the code need not be replicated
in the settings modules of other project-based apps that leverage
Mezzanine's settings module.
"""
# Moves an existing list setting value to a different position.
move = lambda n, k, i: s[n].insert(i, s[n].pop(s[n].index(k)))
# Add a value to the end of a list setting if not in the list.
append = lambda n, k: s[n].append(k) if k not in s[n] else None
# Add a value to the start of a list setting if not in the list.
prepend = lambda n, k: s[n].insert(0, k) if k not in s[n] else None
# Remove a value from a list setting if in the list.
remove = lambda n, k: s[n].remove(k) if k in s[n] else None
s["TEMPLATE_DEBUG"] = s.get("TEMPLATE_DEBUG", s.get("DEBUG", False))
add_to_builtins("mezzanine.template.loader_tags")
if not s.get("ALLOWED_HOSTS", []):
warn("You haven't defined the ALLOWED_HOSTS settings, which "
"Django 1.5 requires. Will fall back to the domains "
"configured as sites.")
s["ALLOWED_HOSTS"] = SitesAllowedHosts()
if s.get("TIME_ZONE", None) is None:
tz = get_best_local_timezone()
s["TIME_ZONE"] = tz
warn("TIME_ZONE setting is not set, using closest match: %s" % tz)
# Define some settings based on management command being run.
management_command = sys.argv[1] if len(sys.argv) > 1 else ""
# Some kind of testing is running via test or testserver.
s["TESTING"] = management_command in ("test", "testserver")
# Some kind of development server is running via runserver,
# runserver_plus or harvest (lettuce)
s["DEV_SERVER"] = management_command.startswith(("runserver", "harvest"))
# Change tuple settings to lists for easier manipulation.
s.setdefault("AUTHENTICATION_BACKENDS", defaults.AUTHENTICATION_BACKENDS)
s.setdefault("STATICFILES_FINDERS", defaults.STATICFILES_FINDERS)
tuple_list_settings = ["AUTHENTICATION_BACKENDS", "INSTALLED_APPS",
"MIDDLEWARE_CLASSES", "STATICFILES_FINDERS",
"LANGUAGES"]
for setting in tuple_list_settings[:]:
if not isinstance(s.get(setting, []), list):
s[setting] = list(s[setting])
else:
# Setting is already a list, so we'll exclude it from
# the list of settings we'll revert back to tuples.
tuple_list_settings.remove(setting)
# Set up cookie messaging if none defined.
storage = "django.contrib.messages.storage.cookie.CookieStorage"
s.setdefault("MESSAGE_STORAGE", storage)
if s["TESTING"]:
# Following bits are work-arounds for some assumptions that
# Django 1.5's tests make.
# contrib.auth tests fail without its own auth backend installed.
append("AUTHENTICATION_BACKENDS",
"django.contrib.auth.backends.ModelBackend")
# Tests in contrib.redirects simply don't work with a
# catch-all urlpattern such as Mezzanine's pages app.
remove("INSTALLED_APPS", "django.contrib.redirects")
remove("MIDDLEWARE_CLASSES",
"django.contrib.redirects.middleware.RedirectFallbackMiddleware")
else:
# Setup for optional apps.
optional = list(s.get("OPTIONAL_APPS", []))
if s.get("USE_SOUTH"):
optional.append("south")
elif not s.get("USE_SOUTH", True) and "south" in s["INSTALLED_APPS"]:
s["INSTALLED_APPS"].remove("south")
for app in optional:
if app not in s["INSTALLED_APPS"]:
try:
__import__(app)
except ImportError:
pass
else:
s["INSTALLED_APPS"].append(app)
if "debug_toolbar" in s["INSTALLED_APPS"]:
debug_mw = "debug_toolbar.middleware.DebugToolbarMiddleware"
append("MIDDLEWARE_CLASSES", debug_mw)
# If compressor installed, ensure it's configured and make
# Mezzanine's settings available to its offline context,
# since jQuery is configured via a setting.
if "compressor" in s["INSTALLED_APPS"]:
append("STATICFILES_FINDERS", "compressor.finders.CompressorFinder")
s.setdefault("COMPRESS_OFFLINE_CONTEXT", {
"MEDIA_URL": s.get("MEDIA_URL", ""),
"STATIC_URL": s.get("STATIC_URL", ""),
})
def mezzanine_settings():
from mezzanine.conf import settings
return settings
s["COMPRESS_OFFLINE_CONTEXT"]["settings"] = mezzanine_settings
# Ensure the Mezzanine auth backend is enabled if
# mezzanine.accounts is being used.
if "mezzanine.accounts" in s["INSTALLED_APPS"]:
auth_backend = "mezzanine.core.auth_backends.MezzanineBackend"
s.setdefault("AUTHENTICATION_BACKENDS", [])
prepend("AUTHENTICATION_BACKENDS", auth_backend)
# Ensure Grappelli is after Mezzanine in app order so that
# admin templates are loaded in the correct order.
grappelli_name = s.get("PACKAGE_NAME_GRAPPELLI")
try:
move("INSTALLED_APPS", grappelli_name, len(s["INSTALLED_APPS"]))
except ValueError:
s["GRAPPELLI_INSTALLED"] = False
else:
s["GRAPPELLI_INSTALLED"] = True
# Ensure admin is last in the app order so that admin templates
# are loaded in the correct order.
move("INSTALLED_APPS", "django.contrib.admin", len(s["INSTALLED_APPS"]))
# Ensure we have a test runner (removed in Django 1.6)
s.setdefault("TEST_RUNNER", "django.test.simple.DjangoTestSuiteRunner")
# Add missing apps if existing apps depend on them.
if "mezzanine.blog" in s["INSTALLED_APPS"]:
append("INSTALLED_APPS", "mezzanine.generic")
if "mezzanine.generic" in s["INSTALLED_APPS"]:
s.setdefault("COMMENTS_APP", "mezzanine.generic")
append("INSTALLED_APPS", "django.contrib.comments")
# Ensure mezzanine.boot is first.
try:
move("INSTALLED_APPS", "mezzanine.boot", 0)
except ValueError:
pass
# Remove caching middleware if no backend defined.
if not (s.get("CACHE_BACKEND") or s.get("CACHES")):
s["MIDDLEWARE_CLASSES"] = [mw for mw in s["MIDDLEWARE_CLASSES"] if not
(mw.endswith("UpdateCacheMiddleware") or
mw.endswith("FetchFromCacheMiddleware"))]
# If only LANGUAGE_CODE has been defined, ensure the other required
# settings for translations are configured.
if (s.get("LANGUAGE_CODE") and len(s.get("LANGUAGES", [])) == 1 and
s["LANGUAGE_CODE"] != s["LANGUAGES"][0][0]):
s["USE_I18N"] = True
s["LANGUAGES"] = [(s["LANGUAGE_CODE"], "")]
# Revert tuple settings back to tuples.
for setting in tuple_list_settings:
s[setting] = tuple(s[setting])
# Some settings tweaks for different DB engines.
for (key, db) in s["DATABASES"].items():
shortname = db["ENGINE"].split(".")[-1]
if shortname == "sqlite3" and os.sep not in db["NAME"]:
# If the Sqlite DB name doesn't contain a path, assume
# it's in the project directory and add the path to it.
db_path = os.path.join(s.get("PROJECT_ROOT", ""), db["NAME"])
s["DATABASES"][key]["NAME"] = db_path
elif shortname == "mysql":
# Required MySQL collation for tests.
s["DATABASES"][key]["TEST_COLLATION"] = "utf8_general_ci"
import django
from django.conf import settings
from django.core import urlresolvers
from django.template import base
# To load docutils extensions somewhere
from missing import admindocs
if django.VERSION < (1, 9):
# To be able to force use of "contextblock" tag immediately after "extends" tag, we add it to built-in tags
base.add_to_builtins('missing.templatetags.context_tags')
# NoReverseMatch exceptions are silent (replaced by TEMPLATE_STRING_IF_INVALID setting), but we
# disable this behavior here
if getattr(settings, 'TEMPLATE_URL_RESOLVERS_DEBUG', False) and getattr(settings, 'TEMPLATE_DEBUG', False):
urlresolvers.NoReverseMatch.silent_variable_failure = False
from django.template.base import add_to_builtins
add_to_builtins('support.templatetags.support_tags')
add_to_builtins('support.templatetags.form_tags')
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
#
#
# Copyright (c) 2008-2011 University of Dundee.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
# Author: Aleksandra Tarkowska <A(dot)Tarkowska(at)dundee(dot)ac(dot)uk>, 2012.
#
from django.template.base import add_to_builtins
add_to_builtins('omeroweb.webgateway.templatetags.defaulttags')
def child_behavior(self):
if self.child_listings is None:
return ListingHandler.ALL if self._instance.tree_parent_id else ListingHandler.NONE
return self.child_listings
app_registry.register('ella', EllaAppDataContainer, Category)
# connect redis listing handler signals
connect_signals()
# connect cache invalidation signals
connect_invalidation_signals()
try:
# django < 1.9
from django.template.base import add_to_builtins
except ImportError:
pass
else:
# add core templatetags to builtin so that you don't have to invoke {% load core %} in every template
add_to_builtins('ella.core.templatetags.core')
# keep this here for backwards compatibility
add_to_builtins('ella.core.templatetags.related')
# and custom urls
add_to_builtins('ella.core.templatetags.custom_urls_tags')
# and the same for i18n
add_to_builtins('django.templatetags.i18n')
# and photos are always useful
add_to_builtins('ella.photos.templatetags.photos')
# License along with this program. If not, see <http://www.gnu.org/licenses/>.
#
from django.core.signals import request_finished
from django.db.models import signals, get_models
from django.db import DEFAULT_DB_ALIAS
from django.contrib.auth.models import Permission
from django.contrib.contenttypes.models import ContentType
from django.template.base import add_to_builtins
from freppledb.common import models as common_models
from freppledb.common.middleware import resetRequest
# Make our tags built-in, so we don't have to load them any more in our
# templates with a 'load' tag.
add_to_builtins('freppledb.common.templatetags.base_utils')
def removeModelPermissions(app, model, db=DEFAULT_DB_ALIAS):
Permission.objects.all().using(db).filter(
content_type__app_label=app, content_type__model=model).delete()
def createViewPermissions(app,
created_models,
verbosity,
db=DEFAULT_DB_ALIAS,
**kwargs):
if db != DEFAULT_DB_ALIAS:
return
# Create model read permissions
from django.template.base import add_to_builtins
add_to_builtins('commenting.templatetags.ajax')
add_to_builtins('commenting.templatetags.custom_tags')
ROOT_URLCONF = 'tests.urls'
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(BASE_DIR, 'db.sqlite3')
}
}
# Internationalization
# https://docs.djangoproject.com/en/dev/topics/i18n/
LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'UTC'
USE_I18N = True
USE_L10N = True
USE_TZ = False
# Static files (CSS, JavaScript, Images)
STATIC_URL = '/static/'
TEMPLATE_DIRS = (os.path.join(BASE_DIR, 'tests/templates'), )
# shortcut for in form templates
from django.template.base import add_to_builtins
add_to_builtins('viewform.templatetags.viewform')
try:
from deploy.local_settings import * # NOQA
except ImportError:
pass
# following PEP 440
__version__ = "1.7.3"
VERSION = (1, 7, 3)
import django
if django.VERSION < (1, 9):
# Make sure the ``{% print %}`` is always available, even without a {% load debugtools_tags %} call.
# This feature is no longer available in Django 1.9, which adds an explicit configuration for it:
# see: https://docs.djangoproject.com/en/1.9/releases/1.9/#django-template-base-add-to-builtins-is-removed
#
# This function is used here because the {% print %} tag is a debugging aid,
# and not a tag that should remain permanently in your templates. Convenience is preferred here.
#
from django.template.base import add_to_builtins
add_to_builtins("debugtools.templatetags.debugtools_tags")
d(**defaults)
try:
from django.template.base import add_to_builtins
except ImportError:
from django.template.loader import add_to_builtins
from django.core.management import get_commands
try:
import importlib
except ImportError:
from django.utils import importlib
add_to_builtins("djangothis.templatetags.raw")
def context(request):
return {
"settings": d.settings
}
try:
import views
except ImportError:
pass
else:
views
try:
"""
dictionary = dictionary or {}
if isinstance(template_name, (list, tuple)):
t = select_template(template_name)
else:
t = get_template(template_name)
if not context_instance:
return t.render(Context(dictionary))
# Add the dictionary to the context stack, ensuring it gets removed again
# to keep the context_instance in the same state it started in.
context_instance.update(dictionary)
try:
return t.render(context_instance)
finally:
context_instance.pop()
def select_template(template_name_list):
"Given a list of template names, returns the first that can be loaded."
not_found = []
for template_name in template_name_list:
try:
return get_template(template_name)
except TemplateDoesNotExist, e:
if e.args[0] not in not_found:
not_found.append(e.args[0])
continue
# If we get here, none of the templates could be loaded
raise TemplateDoesNotExist(', '.join(not_found))
add_to_builtins('django.template.loader_tags')
def set_dynamic_settings(s):
"""
Called at the end of the project's settings module, and is passed
its globals dict for updating with some final tweaks for settings
that generally aren't specified, but can be given some better
defaults based on other settings that have been specified. Broken
out into its own function so that the code need not be replicated
in the settings modules of other project-based apps that leverage
Mezzanine's settings module.
"""
# Moves an existing list setting value to a different position.
move = lambda n, k, i: s[n].insert(i, s[n].pop(s[n].index(k)))
# Add a value to the end of a list setting if not in the list.
append = lambda n, k: s[n].append(k) if k not in s[n] else None
# Add a value to the start of a list setting if not in the list.
prepend = lambda n, k: s[n].insert(0, k) if k not in s[n] else None
# Remove a value from a list setting if in the list.
remove = lambda n, k: s[n].remove(k) if k in s[n] else None
s["TEMPLATE_DEBUG"] = s.get("TEMPLATE_DEBUG", s.get("DEBUG", False))
add_to_builtins("mezzanine.template.loader_tags")
if not s.get("ALLOWED_HOSTS", []):
warn("You haven't defined the ALLOWED_HOSTS settings, which "
"Django requires. Will fall back to the domains "
"configured as sites.")
s["ALLOWED_HOSTS"] = SitesAllowedHosts()
if s.get("TIME_ZONE", None) is None:
tz = get_best_local_timezone()
s["TIME_ZONE"] = tz
warn("TIME_ZONE setting is not set, using closest match: %s" % tz)
# Define some settings based on management command being run.
management_command = sys.argv[1] if len(sys.argv) > 1 else ""
# Some kind of testing is running via test or testserver.
s["TESTING"] = management_command in ("test", "testserver")
# Some kind of development server is running via runserver,
# runserver_plus or harvest (lettuce)
s["DEV_SERVER"] = management_command.startswith(("runserver", "harvest"))
# Change tuple settings to lists for easier manipulation.
s.setdefault("AUTHENTICATION_BACKENDS", defaults.AUTHENTICATION_BACKENDS)
s.setdefault("STATICFILES_FINDERS", defaults.STATICFILES_FINDERS)
tuple_list_settings = [
"AUTHENTICATION_BACKENDS", "INSTALLED_APPS", "MIDDLEWARE_CLASSES",
"STATICFILES_FINDERS", "LANGUAGES", "TEMPLATE_CONTEXT_PROCESSORS"
]
for setting in tuple_list_settings[:]:
if not isinstance(s.get(setting, []), list):
s[setting] = list(s[setting])
else:
# Setting is already a list, so we'll exclude it from
# the list of settings we'll revert back to tuples.
tuple_list_settings.remove(setting)
# From Mezzanine 3.1.2 and onward we added the context processor
# for handling the page variable in templates - here we help
# upgrading by adding it if missing, with a warning. This helper
# can go away eventually.
cp = "mezzanine.pages.context_processors.page"
if ("mezzanine.pages" in s["INSTALLED_APPS"]
and cp not in s["TEMPLATE_CONTEXT_PROCESSORS"]):
warn("%s is required in the TEMPLATE_CONTEXT_PROCESSORS setting. "
"Adding it now, but you should update settings.py to "
"explicitly include it." % cp)
append("TEMPLATE_CONTEXT_PROCESSORS", cp)
# Set up cookie messaging if none defined.
storage = "django.contrib.messages.storage.cookie.CookieStorage"
s.setdefault("MESSAGE_STORAGE", storage)
# If required, add django-modeltranslation for both tests and deployment
if not s.get("USE_MODELTRANSLATION", False):
remove("INSTALLED_APPS", "modeltranslation")
else:
try:
__import__("modeltranslation")
except ImportError:
# django-modeltranslation is not installed, remove setting so
# admin won't try to import it
s["USE_MODELTRANSLATION"] = False
remove("INSTALLED_APPS", "modeltranslation")
warn("USE_MODETRANSLATION setting is set to True but django-"
"modeltranslation is not installed. Disabling it.")
else:
# Force i18n so we are assured that modeltranslation is active
s["USE_I18N"] = True
append("INSTALLED_APPS", "modeltranslation")
# Setup for optional apps.
optional = list(s.get("OPTIONAL_APPS", []))
for app in optional:
if app not in s["INSTALLED_APPS"]:
try:
__import__(app)
except ImportError:
pass
else:
s["INSTALLED_APPS"].append(app)
if s["TESTING"]:
# Triggers interactive superuser creation and some pyc/pyo tests
# fail with standard permissions.
remove("INSTALLED_APPS", "django_extensions")
if "debug_toolbar" in s["INSTALLED_APPS"]:
debug_mw = "debug_toolbar.middleware.DebugToolbarMiddleware"
append("MIDDLEWARE_CLASSES", debug_mw)
# Ensure debug_toolbar is before modeltranslation to avoid
# races for configuration.
move("INSTALLED_APPS", "debug_toolbar", 0)
# If compressor installed, ensure it's configured and make
# Mezzanine's settings available to its offline context,
# since jQuery is configured via a setting.
if "compressor" in s["INSTALLED_APPS"]:
append("STATICFILES_FINDERS", "compressor.finders.CompressorFinder")
s.setdefault(
"COMPRESS_OFFLINE_CONTEXT", {
"MEDIA_URL": s.get("MEDIA_URL", ""),
"STATIC_URL": s.get("STATIC_URL", ""),
})
def mezzanine_settings():
from mezzanine.conf import settings
return settings
s["COMPRESS_OFFLINE_CONTEXT"]["settings"] = mezzanine_settings
# Ensure the Mezzanine auth backend is enabled if
# mezzanine.accounts is being used.
if "mezzanine.accounts" in s["INSTALLED_APPS"]:
auth_backend = "mezzanine.core.auth_backends.MezzanineBackend"
s.setdefault("AUTHENTICATION_BACKENDS", [])
prepend("AUTHENTICATION_BACKENDS", auth_backend)
# Ensure Grappelli is after Mezzanine in app order so that
# admin templates are loaded in the correct order.
grappelli_name = s.get("PACKAGE_NAME_GRAPPELLI")
try:
move("INSTALLED_APPS", grappelli_name, len(s["INSTALLED_APPS"]))
except ValueError:
s["GRAPPELLI_INSTALLED"] = False
else:
s["GRAPPELLI_INSTALLED"] = True
# Ensure admin is at the bottom of the app order so that admin
# templates are loaded in the correct order, and that staticfiles
# is also at the end so its runserver can be overridden.
for app in ["django.contrib.admin", "django.contrib.staticfiles"]:
try:
move("INSTALLED_APPS", app, len(s["INSTALLED_APPS"]))
except ValueError:
pass
# Add missing apps if existing apps depend on them.
if "mezzanine.blog" in s["INSTALLED_APPS"]:
append("INSTALLED_APPS", "mezzanine.generic")
if "mezzanine.generic" in s["INSTALLED_APPS"]:
s.setdefault("COMMENTS_APP", "mezzanine.generic")
append("INSTALLED_APPS", "django_comments")
# Ensure mezzanine.boot is first.
try:
move("INSTALLED_APPS", "mezzanine.boot", 0)
except ValueError:
pass
# Remove caching middleware if no backend defined.
if not (s.get("CACHE_BACKEND") or s.get("CACHES")):
s["MIDDLEWARE_CLASSES"] = [
mw for mw in s["MIDDLEWARE_CLASSES"]
if not (mw.endswith("UpdateCacheMiddleware")
or mw.endswith("FetchFromCacheMiddleware"))
]
# If only LANGUAGE_CODE has been defined, ensure the other required
# settings for translations are configured.
if (s.get("LANGUAGE_CODE") and len(s.get("LANGUAGES", [])) == 1
and s["LANGUAGE_CODE"] != s["LANGUAGES"][0][0]):
s["USE_I18N"] = True
s["LANGUAGES"] = [(s["LANGUAGE_CODE"], "")]
# Revert tuple settings back to tuples.
for setting in tuple_list_settings:
s[setting] = tuple(s[setting])
# Some settings tweaks for different DB engines.
for (key, db) in s["DATABASES"].items():
shortname = db["ENGINE"].split(".")[-1]
if shortname == "sqlite3":
# If the Sqlite DB name doesn't contain a path, assume
# it's in the project directory and add the path to it.
if "NAME" in db and os.sep not in db["NAME"]:
db_path = os.path.join(s.get("PROJECT_ROOT", ""), db["NAME"])
s["DATABASES"][key]["NAME"] = db_path
elif shortname == "mysql":
# Required MySQL collation for tests.
s["DATABASES"][key]["TEST_COLLATION"] = "utf8_general_ci"
def set_dynamic_settings(s):
"""
Called at the end of the project's settings module, and is passed
its globals dict for updating with some final tweaks for settings
that generally aren't specified, but can be given some better
defaults based on other settings that have been specified. Broken
out into its own function so that the code need not be replicated
in the settings modules of other project-based apps that leverage
Mezzanine's settings module.
"""
# Moves an existing list setting value to a different position.
move = lambda n, k, i: s[n].insert(i, s[n].pop(s[n].index(k)))
# Add a value to the end of a list setting if not in the list.
append = lambda n, k: s[n].append(k) if k not in s[n] else None
# Add a value to the start of a list setting if not in the list.
prepend = lambda n, k: s[n].insert(0, k) if k not in s[n] else None
# Remove a value from a list setting if in the list.
remove = lambda n, k: s[n].remove(k) if k in s[n] else None
s["TEMPLATE_DEBUG"] = s.get("TEMPLATE_DEBUG", s.get("DEBUG", False))
add_to_builtins("mezzanine.template.loader_tags")
if not s.get("ALLOWED_HOSTS", []):
warn("You haven't defined the ALLOWED_HOSTS settings, which "
"Django 1.5 requires. Will fall back to the domains "
"configured as sites.")
s["ALLOWED_HOSTS"] = SitesAllowedHosts()
if s.get("TIME_ZONE", None) is None:
tz = get_best_local_timezone()
s["TIME_ZONE"] = tz
warn("TIME_ZONE setting is not set, using closest match: %s" % tz)
# Define some settings based on management command being run.
management_command = sys.argv[1] if len(sys.argv) > 1 else ""
# Some kind of testing is running via test or testserver.
s["TESTING"] = management_command in ("test", "testserver")
# Some kind of development server is running via runserver,
# runserver_plus or harvest (lettuce)
s["DEV_SERVER"] = management_command.startswith(("runserver", "harvest"))
# Change tuple settings to lists for easier manipulation.
s.setdefault("AUTHENTICATION_BACKENDS", defaults.AUTHENTICATION_BACKENDS)
s.setdefault("STATICFILES_FINDERS", defaults.STATICFILES_FINDERS)
tuple_list_settings = ["AUTHENTICATION_BACKENDS", "INSTALLED_APPS",
"MIDDLEWARE_CLASSES", "STATICFILES_FINDERS",
"LANGUAGES", "TEMPLATE_CONTEXT_PROCESSORS"]
for setting in tuple_list_settings[:]:
if not isinstance(s.get(setting, []), list):
s[setting] = list(s[setting])
else:
# Setting is already a list, so we'll exclude it from
# the list of settings we'll revert back to tuples.
tuple_list_settings.remove(setting)
# From Mezzanine 3.1.2 and onward we added the context processor
# for handling the page variable in templates - here we help
# upgrading by adding it if missing, with a warning. This helper
# can go away eventually.
cp = "mezzanine.pages.context_processors.page"
if ("mezzanine.pages" in s["INSTALLED_APPS"] and
cp not in s["TEMPLATE_CONTEXT_PROCESSORS"]):
warn("%s is required in the TEMPLATE_CONTEXT_PROCESSORS setting. "
"Adding it now, but you should update settings.py to "
"explicitly include it." % cp)
append("TEMPLATE_CONTEXT_PROCESSORS", cp)
# Set up cookie messaging if none defined.
storage = "django.contrib.messages.storage.cookie.CookieStorage"
s.setdefault("MESSAGE_STORAGE", storage)
# If required, add django-modeltranslation for both tests and deployment
if not s.get("USE_MODELTRANSLATION", False):
remove("INSTALLED_APPS", "modeltranslation")
else:
try:
__import__("modeltranslation")
except ImportError:
pass
else:
# Force i18n so we are assured that modeltranslation is active
s["USE_I18N"] = True
append("INSTALLED_APPS", "modeltranslation")
if s["TESTING"]:
# Following bits are work-arounds for some assumptions that
# Django 1.5's tests make.
# contrib.auth tests fail without its own auth backend installed.
append("AUTHENTICATION_BACKENDS",
"django.contrib.auth.backends.ModelBackend")
# Tests in contrib.redirects simply don't work with a
# catch-all urlpattern such as Mezzanine's pages app.
remove("INSTALLED_APPS", "django.contrib.redirects")
remove("MIDDLEWARE_CLASSES",
"django.contrib.redirects.middleware.RedirectFallbackMiddleware")
else:
# Setup for optional apps.
optional = list(s.get("OPTIONAL_APPS", []))
if s.get("USE_SOUTH"):
optional.append("south")
elif not s.get("USE_SOUTH", True) and "south" in s["INSTALLED_APPS"]:
s["INSTALLED_APPS"].remove("south")
for app in optional:
if app not in s["INSTALLED_APPS"]:
try:
__import__(app)
except ImportError:
pass
else:
s["INSTALLED_APPS"].append(app)
if "debug_toolbar" in s["INSTALLED_APPS"]:
debug_mw = "debug_toolbar.middleware.DebugToolbarMiddleware"
append("MIDDLEWARE_CLASSES", debug_mw)
# Ensure debug_toolbar is before modeltranslation to avoid
# races for configuration.
move("INSTALLED_APPS", "debug_toolbar", 0)
# If compressor installed, ensure it's configured and make
# Mezzanine's settings available to its offline context,
# since jQuery is configured via a setting.
if "compressor" in s["INSTALLED_APPS"]:
append("STATICFILES_FINDERS", "compressor.finders.CompressorFinder")
s.setdefault("COMPRESS_OFFLINE_CONTEXT", {
"MEDIA_URL": s.get("MEDIA_URL", ""),
"STATIC_URL": s.get("STATIC_URL", ""),
})
def mezzanine_settings():
from mezzanine.conf import settings
return settings
s["COMPRESS_OFFLINE_CONTEXT"]["settings"] = mezzanine_settings
# Ensure the Mezzanine auth backend is enabled if
# mezzanine.accounts is being used.
if "mezzanine.accounts" in s["INSTALLED_APPS"]:
auth_backend = "mezzanine.core.auth_backends.MezzanineBackend"
s.setdefault("AUTHENTICATION_BACKENDS", [])
prepend("AUTHENTICATION_BACKENDS", auth_backend)
# Ensure Grappelli is after Mezzanine in app order so that
# admin templates are loaded in the correct order.
grappelli_name = s.get("PACKAGE_NAME_GRAPPELLI")
if s["TESTING"]:
# Optional apps aren't installed when testing, but we need
# grappelli to perform some admin tests for certain HTML.
try:
__import__(grappelli_name)
except ImportError:
pass
else:
append("INSTALLED_APPS", grappelli_name)
try:
move("INSTALLED_APPS", grappelli_name, len(s["INSTALLED_APPS"]))
except ValueError:
s["GRAPPELLI_INSTALLED"] = False
else:
s["GRAPPELLI_INSTALLED"] = True
# Ensure admin is last in the app order so that admin templates
# are loaded in the correct order.
move("INSTALLED_APPS", "django.contrib.admin", len(s["INSTALLED_APPS"]))
# Ensure we have a test runner (removed in Django 1.6)
s.setdefault("TEST_RUNNER", "django.test.simple.DjangoTestSuiteRunner")
# Add missing apps if existing apps depend on them.
if "mezzanine.blog" in s["INSTALLED_APPS"]:
append("INSTALLED_APPS", "mezzanine.generic")
if "mezzanine.generic" in s["INSTALLED_APPS"]:
s.setdefault("COMMENTS_APP", "mezzanine.generic")
append("INSTALLED_APPS", "django.contrib.comments")
# Ensure mezzanine.boot is first.
try:
move("INSTALLED_APPS", "mezzanine.boot", 0)
except ValueError:
pass
# Remove caching middleware if no backend defined.
if not (s.get("CACHE_BACKEND") or s.get("CACHES")):
s["MIDDLEWARE_CLASSES"] = [mw for mw in s["MIDDLEWARE_CLASSES"] if not
(mw.endswith("UpdateCacheMiddleware") or
mw.endswith("FetchFromCacheMiddleware"))]
# If only LANGUAGE_CODE has been defined, ensure the other required
# settings for translations are configured.
if (s.get("LANGUAGE_CODE") and len(s.get("LANGUAGES", [])) == 1 and
s["LANGUAGE_CODE"] != s["LANGUAGES"][0][0]):
s["USE_I18N"] = True
s["LANGUAGES"] = [(s["LANGUAGE_CODE"], "")]
# Revert tuple settings back to tuples.
for setting in tuple_list_settings:
s[setting] = tuple(s[setting])
# Some settings tweaks for different DB engines.
for (key, db) in s["DATABASES"].items():
shortname = db["ENGINE"].split(".")[-1]
if shortname == "sqlite3" and os.sep not in db["NAME"]:
# If the Sqlite DB name doesn't contain a path, assume
# it's in the project directory and add the path to it.
db_path = os.path.join(s.get("PROJECT_ROOT", ""), db["NAME"])
s["DATABASES"][key]["NAME"] = db_path
elif shortname == "mysql":
# Required MySQL collation for tests.
s["DATABASES"][key]["TEST_COLLATION"] = "utf8_general_ci"
# following PEP 386
__version__ = "1.2.1"
VERSION = (1, 2, 1)
# Make sure the ``{% print %}`` is always available, even without a {% load debug_tags %} call.
# **NOTE** this uses the undocumented, unofficial add_to_builtins() call. It's not promoted
# by Django developers because it's better to be explicit with a {% load .. %} in the templates.
#
# This function is used here nevertheless because the {% print %} tag is a debugging aid,
# and not a tag that should remain permanently in your templates. Convenience is preferred here.
#
from django.template.base import add_to_builtins
add_to_builtins("debugtools.templatetags.debug_tags")
def set_dynamic_settings(s):
"""
Called at the end of the project's settings module, and is passed
its globals dict for updating with some final tweaks for settings
that generally aren't specified, but can be given some better
defaults based on other settings that have been specified. Broken
out into its own function so that the code need not be replicated
in the settings modules of other project-based apps that leverage
Mezzanine's settings module.
"""
# Moves an existing list setting value to a different position.
move = lambda n, k, i: s[n].insert(i, s[n].pop(s[n].index(k)))
# Add a value to the end of a list setting if not in the list.
append = lambda n, k: s[n].append(k) if k not in s[n] else None
# Add a value to the start of a list setting if not in the list.
prepend = lambda n, k: s[n].insert(0, k) if k not in s[n] else None
# Remove a value from a list setting if in the list.
remove = lambda n, k: s[n].remove(k) if k in s[n] else None
s["TEMPLATE_DEBUG"] = s.get("TEMPLATE_DEBUG", s.get("DEBUG", False))
add_to_builtins("mezzanine.template.loader_tags")
if not s.get("ALLOWED_HOSTS", []):
warn("You haven't defined the ALLOWED_HOSTS settings, which "
"Django requires. Will fall back to the domains "
"configured as sites.")
s["ALLOWED_HOSTS"] = SitesAllowedHosts()
if s.get("TIME_ZONE", None) is None:
tz = get_best_local_timezone()
s["TIME_ZONE"] = tz
warn("TIME_ZONE setting is not set, using closest match: %s" % tz)
# Define some settings based on management command being run.
management_command = sys.argv[1] if len(sys.argv) > 1 else ""
# Some kind of testing is running via test or testserver.
s["TESTING"] = management_command in ("test", "testserver")
# Some kind of development server is running via runserver,
# runserver_plus or harvest (lettuce)
s["DEV_SERVER"] = management_command.startswith(("runserver", "harvest"))
# Change tuple settings to lists for easier manipulation.
s.setdefault("AUTHENTICATION_BACKENDS", defaults.AUTHENTICATION_BACKENDS)
s.setdefault("STATICFILES_FINDERS", defaults.STATICFILES_FINDERS)
tuple_list_settings = ["AUTHENTICATION_BACKENDS", "INSTALLED_APPS",
"MIDDLEWARE_CLASSES", "STATICFILES_FINDERS",
"LANGUAGES", "TEMPLATE_CONTEXT_PROCESSORS"]
for setting in tuple_list_settings[:]:
if not isinstance(s.get(setting, []), list):
s[setting] = list(s[setting])
else:
# Setting is already a list, so we'll exclude it from
# the list of settings we'll revert back to tuples.
tuple_list_settings.remove(setting)
# From Mezzanine 3.1.2 and onward we added the context processor
# for handling the page variable in templates - here we help
# upgrading by adding it if missing, with a warning. This helper
# can go away eventually.
cp = "mezzanine.pages.context_processors.page"
if ("mezzanine.pages" in s["INSTALLED_APPS"] and
cp not in s["TEMPLATE_CONTEXT_PROCESSORS"]):
warn("%s is required in the TEMPLATE_CONTEXT_PROCESSORS setting. "
"Adding it now, but you should update settings.py to "
"explicitly include it." % cp)
append("TEMPLATE_CONTEXT_PROCESSORS", cp)
# Set up cookie messaging if none defined.
storage = "django.contrib.messages.storage.cookie.CookieStorage"
s.setdefault("MESSAGE_STORAGE", storage)
# If required, add django-modeltranslation for both tests and deployment
if not s.get("USE_MODELTRANSLATION", False):
remove("INSTALLED_APPS", "modeltranslation")
else:
try:
__import__("modeltranslation")
except ImportError:
# django-modeltranslation is not installed, remove setting so
# admin won't try to import it
s["USE_MODELTRANSLATION"] = False
remove("INSTALLED_APPS", "modeltranslation")
warn("USE_MODETRANSLATION setting is set to True but django-"
"modeltranslation is not installed. Disabling it.")
else:
# Force i18n so we are assured that modeltranslation is active
s["USE_I18N"] = True
append("INSTALLED_APPS", "modeltranslation")
# Ensure mezzanine.pages falls before any apps that subclass the
# Page model, otherwise modeltranslation doesn't work.
get_pos = lambda n, k: s[n].index(k) if k in s[n] else len(s[n])
page_pos = get_pos("INSTALLED_APPS", "mezzanine.pages")
subclass_pos = min([get_pos("INSTALLED_APPS", app) for app in
("mezzanine.forms", "mezzanine.gallery", "cartridge.shop")])
if page_pos > subclass_pos:
move("INSTALLED_APPS", "mezzanine.pages", subclass_pos)
# Setup for optional apps.
optional = list(s.get("OPTIONAL_APPS", []))
if s.get("USE_SOUTH") and VERSION < (1, 7):
optional.append("south")
elif not s.get("USE_SOUTH", True) and "south" in s["INSTALLED_APPS"]:
s["INSTALLED_APPS"].remove("south")
for app in optional:
if app not in s["INSTALLED_APPS"]:
try:
__import__(app)
except ImportError:
pass
else:
s["INSTALLED_APPS"].append(app)
if s["TESTING"]:
# Following bits are work-arounds for some assumptions that
# Django 1.5's tests make.
# Triggers interactive superuser creation and some pyc/pyo tests
# fail with standard permissions.
remove("INSTALLED_APPS", "django_extensions")
# To support migrations for both Django 1.7 and South, South's old
# migrations for each app were moved into "app.migrations.south"
# packages. Here we assign each of these to SOUTH_MIGRATION_MODULES
# allowing South to find them.
if "south" in s["INSTALLED_APPS"]:
s.setdefault("SOUTH_MIGRATION_MODULES", {})
for app in s["INSTALLED_APPS"]:
# We need to verify the path to the custom migrations
# package exists for each app. We can't simply try
# and import it, for some apps this causes side effects,
# so we need to import something higher up to get at its
# filesystem path - this can't be the actual app either,
# side effects again, but we can generally import the
# top-level package for apps that are contained within
# one, which covers Mezzanine, Cartridge, Drum.
if "." not in app:
continue
migrations = "%s.migrations.south" % app
parts = migrations.split(".", 1)
root = path_for_import(parts[0])
other = parts[1].replace(".", os.sep)
if os.path.exists(os.path.join(root, other)):
s["SOUTH_MIGRATION_MODULES"][app.split(".")[-1]] = migrations
if "debug_toolbar" in s["INSTALLED_APPS"]:
debug_mw = "debug_toolbar.middleware.DebugToolbarMiddleware"
append("MIDDLEWARE_CLASSES", debug_mw)
# Ensure debug_toolbar is before modeltranslation to avoid
# races for configuration.
move("INSTALLED_APPS", "debug_toolbar", 0)
# If compressor installed, ensure it's configured and make
# Mezzanine's settings available to its offline context,
# since jQuery is configured via a setting.
if "compressor" in s["INSTALLED_APPS"]:
append("STATICFILES_FINDERS", "compressor.finders.CompressorFinder")
s.setdefault("COMPRESS_OFFLINE_CONTEXT", {
"MEDIA_URL": s.get("MEDIA_URL", ""),
"STATIC_URL": s.get("STATIC_URL", ""),
})
def mezzanine_settings():
from mezzanine.conf import settings
return settings
s["COMPRESS_OFFLINE_CONTEXT"]["settings"] = mezzanine_settings
# Ensure the Mezzanine auth backend is enabled if
# mezzanine.accounts is being used.
if "mezzanine.accounts" in s["INSTALLED_APPS"]:
auth_backend = "mezzanine.core.auth_backends.MezzanineBackend"
s.setdefault("AUTHENTICATION_BACKENDS", [])
prepend("AUTHENTICATION_BACKENDS", auth_backend)
# Ensure Grappelli is after Mezzanine in app order so that
# admin templates are loaded in the correct order.
grappelli_name = s.get("PACKAGE_NAME_GRAPPELLI")
try:
move("INSTALLED_APPS", grappelli_name, len(s["INSTALLED_APPS"]))
except ValueError:
s["GRAPPELLI_INSTALLED"] = False
else:
s["GRAPPELLI_INSTALLED"] = True
# Ensure admin is at the bottom of the app order so that admin
# templates are loaded in the correct order, and that staticfiles
# is also at the end so its runserver can be overridden.
apps = ["django.contrib.admin"]
if VERSION >= (1, 7):
apps += ["django.contrib.staticfiles"]
for app in apps:
try:
move("INSTALLED_APPS", app, len(s["INSTALLED_APPS"]))
except ValueError:
pass
# Add missing apps if existing apps depend on them.
if "mezzanine.blog" in s["INSTALLED_APPS"]:
append("INSTALLED_APPS", "mezzanine.generic")
if "mezzanine.generic" in s["INSTALLED_APPS"]:
s.setdefault("COMMENTS_APP", "mezzanine.generic")
append("INSTALLED_APPS", "django_comments")
# Ensure mezzanine.boot is first.
try:
move("INSTALLED_APPS", "mezzanine.boot", 0)
except ValueError:
pass
# Remove caching middleware if no backend defined.
if not (s.get("CACHE_BACKEND") or s.get("CACHES")):
s["MIDDLEWARE_CLASSES"] = [mw for mw in s["MIDDLEWARE_CLASSES"] if not
(mw.endswith("UpdateCacheMiddleware") or
mw.endswith("FetchFromCacheMiddleware"))]
# If only LANGUAGE_CODE has been defined, ensure the other required
# settings for translations are configured.
if (s.get("LANGUAGE_CODE") and len(s.get("LANGUAGES", [])) == 1 and
s["LANGUAGE_CODE"] != s["LANGUAGES"][0][0]):
s["USE_I18N"] = True
s["LANGUAGES"] = [(s["LANGUAGE_CODE"], "")]
# Revert tuple settings back to tuples.
for setting in tuple_list_settings:
s[setting] = tuple(s[setting])
# Some settings tweaks for different DB engines.
for (key, db) in s["DATABASES"].items():
shortname = db["ENGINE"].split(".")[-1]
if shortname == "sqlite3":
# If the Sqlite DB name doesn't contain a path, assume
# it's in the project directory and add the path to it.
if "NAME" in db and os.sep not in db["NAME"]:
db_path = os.path.join(s.get("PROJECT_ROOT", ""), db["NAME"])
s["DATABASES"][key]["NAME"] = db_path
elif shortname == "mysql":
# Required MySQL collation for tests.
s["DATABASES"][key]["TEST_COLLATION"] = "utf8_general_ci"
limitations under the License"""
import django
from django.conf import settings
from django.conf.urls import patterns, include, url
from django.contrib import admin
if django.VERSION < (1, 8): # add_to_builtins removed in Django 1.9
try:
from django.template.base import add_to_builtins
except ImportError: # Django < 1.7
from django.template.loader import add_to_builtins
if django.VERSION < (1, 5) and django.VERSION > (1, 8): # load the "future" {% url %} tag
add_to_builtins('django.templatetags.future')
if django.VERSION < (1, 7):
# Django doing autodiscover automatically:
# https://docs.djangoproject.com/en/dev/releases/1.7/#app-loading-refactor
admin.autodiscover()
graphite_urls = patterns(
'',
('^admin/', include(admin.site.urls)),
('^render/?', include('graphite.render.urls')),
('^composer/?', include('graphite.composer.urls')),
('^metrics/?', include('graphite.metrics.urls')),
('^browser/?', include('graphite.browser.urls')),
('^account/', include('graphite.account.urls')),
('^dashboard/?', include('graphite.dashboard.urls')),
# UNIFI CONFIGURATION #
#################################################
from unifi_settings import *
from unifi_secret import *
INSTALLED_APPS += UNIFI_INSTALLED_APPS
LOGIN_URL = UNIFI_LOGIN_URL
LOGIN_REDIRECT_URL = UNIFI_LOGIN_REDIRECT_URL
TEMPLATES[0]['OPTIONS'][
'context_processors'] += UNIFI_TEMPLATE_CONTEXT_PROCESSORS
# shortcut for in form templates
try:
# shortcut for in form templates
from django.template.base import add_to_builtins
add_to_builtins(UNIFI_TEMPLATE_BUILTINS)
except ImportError:
"""
Django 1.9.
"""
TEMPLATES[0]['OPTIONS']['builtins'] = [
UNIFI_TEMPLATE_BUILTINS,
]
AUTHENTICATION_BACKENDS = UNIFI_AUTHENTICATION_BACKENDS
SOCIAL_AUTH_PIPELINE = UNIFI_SOCIAL_AUTH_PIPELINE
#When DEBUG = True Social Auth exception handling to redirected url is disabled
SOCIAL_AUTH_LOGIN_ERROR_URL = '/guest/s/default/'
def ready(self):
add_to_builtins('django.templatetags.i18n')
add_to_builtins('django.templatetags.tz')
for d in ('./', './template_set', './_layouts', './_includes'):
dd = os.path.join(PROJECT_ROOT_PATH, d)
if os.path.exists(dd):
DIR_TEMPLATES.append(dd)
DIR_TEMPLATES.append(DEFAULT_TEMPLATES)
TEMPLATES = [
{ 'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': DIR_TEMPLATES,
},
]
MIDDLEWARE_CLASSES = []
add_to_builtins('actionkit_templates.templatetags.actionkit_tags')
def _get_context_data(request, name, page, use_referer=False):
from actionkit_templates.contexts.page_contexts import contexts
port = '4000'
hostport = request.get_host().split(':')
if len(hostport) > 1:
port = hostport[1]
if use_referer:
paths = urlparse.urlparse(request.META['HTTP_REFERER']).path.split('/')
if paths and len(paths) > 1:
name = paths[1]
if len(paths) > 2:
page = paths[2]
d(**defaults)
try:
from django.template.base import add_to_builtins
except ImportError:
from django.template.loader import add_to_builtins
from django.core.management import get_commands
try:
import importlib
except ImportError:
from django.utils import importlib
add_to_builtins("djangothis.templatetags.raw")
def context(request):
return {"settings": d.settings}
try:
import views
except ImportError:
pass
else:
views
try:
import forms
default_app_config = 'material.frontend.apps.ModulesDiscoverConfig'
if getattr(settings, 'MATERIAL_FRONTEND_AUTOREGISTER', True):
# Register middleware
if 'material.frontend.middleware.SmoothNavigationMiddleware' not in settings.MIDDLEWARE_CLASSES:
settings.MIDDLEWARE_CLASSES += ('material.frontend.middleware.SmoothNavigationMiddleware',)
if 'material.frontend.middleware.UnpjaxMiddleware' not in settings.MIDDLEWARE_CLASSES:
settings.MIDDLEWARE_CLASSES += ('material.frontend.middleware.UnpjaxMiddleware',)
# Register pjax template tag
try:
from django.template.base import add_to_builtins
add_to_builtins("material.frontend.templatetags.pjax_tags")
except ImportError:
"""
Django 1.9
"""
for engine in settings.TEMPLATES:
if engine['BACKEND'] == 'django.template.backends.django.DjangoTemplates':
if 'OPTIONS' not in engine:
engine['OPTIONS'] = {}
if 'builtins' not in engine['OPTIONS']:
engine['OPTIONS']['builtins'] = []
if "material.frontend.templatetags.pjax_tags" not in engine['OPTIONS']['builtins']:
engine['OPTIONS']['builtins'].append("material.frontend.templatetags.pjax_tags")
# Context processors
for engine in settings.TEMPLATES:
from django.db import transaction
from django.http import HttpResponse, Http404
from django.shortcuts import render, redirect
from django.template.base import add_to_builtins
from appliances.api import json_response
from appliances.models import (
Provider, AppliancePool, Appliance, Group, Template, MismatchVersionMailer, User)
from appliances.tasks import (appliance_power_on, appliance_power_off, appliance_suspend,
anyvm_power_on, anyvm_power_off, anyvm_suspend, anyvm_delete, delete_template_from_provider,
appliance_rename, wait_appliance_ready, mark_appliance_ready, appliance_reboot)
from sprout.log import create_logger
from utils.providers import get_mgmt
add_to_builtins('appliances.templatetags.appliances_extras')
def go_home(request):
return redirect(index)
def go_back_or_home(request):
ref = request.META.get('HTTP_REFERER')
if ref:
return redirect(ref)
else:
return go_home(request)
def index(request):
if getattr(settings, 'MATERIAL_FRONTEND_AUTOREGISTER', True):
settings.LOGIN_REDIRECT_URL = '/'
# Register middleware
if 'material.frontend.middleware.SmoothNavigationMiddleware' not in settings.MIDDLEWARE_CLASSES:
settings.MIDDLEWARE_CLASSES += (
'material.frontend.middleware.SmoothNavigationMiddleware', )
if 'material.frontend.middleware.UnpjaxMiddleware' not in settings.MIDDLEWARE_CLASSES:
settings.MIDDLEWARE_CLASSES += (
'material.frontend.middleware.UnpjaxMiddleware', )
# Register pjax template tag
try:
from django.template.base import add_to_builtins
add_to_builtins("material.frontend.templatetags.pjax_tags")
except ImportError:
"""
Django 1.9
"""
for engine in settings.TEMPLATES:
if engine[
'BACKEND'] == 'django.template.backends.django.DjangoTemplates':
if 'OPTIONS' not in engine:
engine['OPTIONS'] = {}
if 'builtins' not in engine['OPTIONS']:
engine['OPTIONS']['builtins'] = []
if "material.frontend.templatetags.pjax_tags" not in engine[
'OPTIONS']['builtins']:
engine['OPTIONS']['builtins'].append(
"material.frontend.templatetags.pjax_tags")
from django.shortcuts import render, redirect
from django.contrib.auth import login, authenticate, logout
from django.contrib.auth.models import User
from django.template.base import add_to_builtins
from .forms import AuthenticateForm, UserCreateForm, UserEditForm, AuthorForm, PublisherForm, LendPeriodForm, BookForm
from .models import Book, LendPeriods, QuotationFromBook, Author, Publisher, UserProfile
from .tables import BookTable, FriendTable, BookTableUser, AuthorTable, PublisherTable, PeriodsTable
from django_tables2 import RequestConfig
from django.contrib import messages
from django.utils import timezone
from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
from .decorators.group_required import group_required
from django.db.models.base import ObjectDoesNotExist
from fandjango.decorators import facebook_authorization_required
add_to_builtins('library_app.templatetags.xextends')
add_to_builtins('library_app.templatetags.has_group')
@facebook_authorization_required
def fb_sign_up(request, what=None):
"""
Responsible for sign in and sign up using facebook.
:param what: string that determines whether it is sign in or sign up
:type what: `string`
"""
if request.method == 'POST':
if what.__str__() == "sign_up":
init_data = {
'first_name':
SESSION_ENGINE = "django.contrib.sessions.backends.signed_cookies"
# Django debug toolbar
# http://django-debug-toolbar.readthedocs.io/en/1.4/configuration.html
DEBUG_TOOLBAR_CONFIG = {
'DISABLE_PANELS': {
'debug_toolbar.panels.templates.TemplatesPanel',
'debug_toolbar.panels.redirects.RedirectsPanel',
},
}
# shortcut for in form templates
try:
# shortcut for in form templates
from django.template.base import add_to_builtins
add_to_builtins('material.templatetags.material_form')
add_to_builtins('template_debug.templatetags.debug_tags')
except ImportError:
"""
Django 1.9.
"""
TEMPLATES[0]['OPTIONS']['builtins'] = [
'material.templatetags.material_form',
'template_debug.templatetags.debug_tags'
]
STATIC_ROOT = os.path.join(BASE_DIR, 'deploy', 'static')
MEDIA_ROOT = os.path.join(BASE_DIR, 'deploy', 'media')
EMAIL_USE_TLS = True
EMAIL_HOST = 'smtp.gmail.com'
if not code.buffer:
codeTag = code.val.strip().split(' ',1)[0]
if codeTag in self.autocloseCode:
self.buf.append('{%% end%s %%}'%codeTag)
def attributes(self,attrs):
return "{%% __pyjade_attrs %s %%}"%attrs
try:
try:
from django.template.base import add_to_builtins
except ImportError: # Django < 1.8
from django.template import add_to_builtins
add_to_builtins('pyjade.ext.django.templatetags')
except ImportError:
# Django 1.9 removed add_to_builtins and instead
# provides a setting to specify builtins:
# TEMPLATES['OPTIONS']['builtins'] = ['pyjade.ext.django.templatetags']
pass
from django.utils.translation import trans_real
try:
from django.utils.encoding import force_text as to_text
except ImportError:
from django.utils.encoding import force_unicode as to_text
def decorate_templatize(func):
def templatize(src, origin=None):
dictionary = dictionary or {}
if isinstance(template_name, (list, tuple)):
t = select_template(template_name)
else:
t = get_template(template_name)
if not context_instance:
return t.render(Context(dictionary))
# Add the dictionary to the context stack, ensuring it gets removed again
# to keep the context_instance in the same state it started in.
with context_instance.push(dictionary):
return t.render(context_instance)
def select_template(template_name_list):
"Given a list of template names, returns the first that can be loaded."
if not template_name_list:
raise TemplateDoesNotExist("No template names provided")
not_found = []
for template_name in template_name_list:
try:
return get_template(template_name)
except TemplateDoesNotExist as e:
if e.args[0] not in not_found:
not_found.append(e.args[0])
continue
# If we get here, none of the templates could be loaded
raise TemplateDoesNotExist(', '.join(not_found))
add_to_builtins('django.template.loader_tags')
#!/usr/bin/env python
#
#
#
# Copyright (c) 2008-2011 University of Dundee.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
# Author: Aleksandra Tarkowska <A(dot)Tarkowska(at)dundee(dot)ac(dot)uk>, 2012.
#
from django.template.base import add_to_builtins
add_to_builtins('omeroweb.webgateway.templatetags.defaulttags')
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/1.7/howto/static-files/
STATIC_URL = '/static/'
STATICFILES_DIRS = (
os.path.join(BASE_DIR, "tests/static"),
)
SESSION_ENGINE = "django.contrib.sessions.backends.signed_cookies"
# shortcut for in form templates
from django.template.base import add_to_builtins
add_to_builtins('material.templatetags.material_form')
add_to_builtins('template_debug.templatetags.debug_tags')
STATIC_ROOT = os.path.join(BASE_DIR, 'deploy/static')
EMAIL_USE_TLS = True
EMAIL_HOST = 'smtp.gmail.com'
EMAIL_HOST_USER = os.environ.get('EMAIL')
EMAIL_HOST_PASSWORD = os.environ.get('EMAIL_PASSWORD')
EMAIL_PORT = 587
try:
from deploy.local_settings import * # NOQA
except ImportError:
import datetime
from django.test import TestCase
from django import template
from django.template.base import add_to_builtins
import ttag
from ttag.tests.setup import tags, models
add_to_builtins(tags.__name__)
def render(contents, extra_context=None):
return template.Template(contents).render(template.Context(extra_context))
class TagExecutionTests(TestCase):
def test_default(self):
"""
A tag with named arguments works with or without the argument as long
as a default value is set.
"""
self.assertEqual(render('{% named_arg %}'),
'The limit is %d' %
tags.NamedArg._meta.args['limit'].default)
# Reset the limit tag to have no default (and be required, which is set
# to False if a default was given.
tags.NamedArg._meta.args['limit'].default = None
tags.NamedArg._meta.args['limit'].required = True
