def auth(request):
username = request.POST.get('username', '')
password = request.POST.get('password', '')
user = auth.authenticate(username=username, password=password)
if user is not None:
auth.login(request, user)
return HttpResponseRedirect(url('home'))
else:
return HttpResponseRedirect(url('invalid'))
def make_notification(data):
"""
This function make a notify to user for that propouse receive data param that is a dictionary with the keys
user_id: Int pk of user to make the notify
text: String for the body of notify
level: Int to represent the level of importance of notify
:param data: Python dictionary
:return: None
"""
if not data or data is None:
return
user = User.objects.filter(pk=data["user_id"])
if not user or user is None:
return
n = Notify()
n.user = user.first()
n.level = data["level"] or 0
n.main_text = data["text"]
n.save()
"""
If the user of the notify have activated the flag to receive email when have a new notify, then try send and email
"""
if user.perfil_usuario.notificacion_email:
message_body = """
Te ha llegado una nueva notificación que se ha generado debido ha algún evento del sistema que te involucra,
puedes ver todas las notificaciones desde este enlace
""" + url("notifies")
send_mail(_("Tienes una nueva notificación"),
_(message_body),
settings.DEFAULT_FROM_EMAIL, [user.email],
fail_silently=False)
def absurl(parser, token, node_cls=AbsoluteURLNode):
"""Just like {% url %} but ads the domain of the current site."""
node_instance = url(parser, token)
return node_cls(view_name=node_instance.view_name,
args=node_instance.args,
kwargs=node_instance.kwargs,
asvar=node_instance.asvar)
def absurl(parser, token, node_cls=AbsoluteURLNode):
"""Just like {% url %} but ads the domain of the current site."""
node_instance = url(parser, token)
return node_cls(view_name=node_instance.view_name,
args=node_instance.args,
kwargs=node_instance.kwargs,
asvar=node_instance.asvar)
def sph_url2(*args, **kwargs):
try:
node = defaulttags.url(*args, **kwargs)
return SphURLNode(node.view_name, node.args, node.kwargs, node.asvar)
except TemplateSyntaxError:
log.error('Error while resolving url for %r / %r', args, kwargs, [str(x) for x in args])
return TextNode('')
def fullurl(parser, token):
"""Return an absolute URL (including the scheme and domain) matching the
given view with its parameters.
This is meant to be identical to the built-in tag `url`, except that it
always returns an absolute URL with the scheme and authority parts.
For example, take this `url` tag:
{% url "articles:article" slug="hello" %}
This could return:
/articles/hello
This is considered an absolute URL because it begins with a forward-slash,
however, it is not an absolute absolute URL, because it does not include
the scheme and authority parts.
Compare with this `fullurl` tag:
{% fullurl "articles:article" slug="hello" %}
This returns:
http://example.com/articles/hello
"""
return FullURLNode(defaulttags.url(parser, token))
def full_url(parser, token):
"""Spits out the full URL"""
url_node = url(parser, token)
f = url_node.render
url_node.render = lambda context: _get_host_from_context(context) + f(
context)
return url_node
def saneurl(parser, token):
"""
Allows variable/filters as view names in url tag.
{% saneurl some_variable %}
"""
return SaneURLNode(url(parser, token))
def absurl(parser, token):
node = url(parser, token)
return AbsoluteURLNode(
view_name=node.view_name,
args=node.args,
kwargs=node.kwargs,
asvar=node.asvar
)
def absurl(parser, token):
node = url(parser, token)
return AbsoluteURLNode(
view_name=node.view_name,
args=node.args,
kwargs=node.kwargs,
asvar=node.asvar
)
def render(self, context):
from django.template import TOKEN_BLOCK, Token
resolved_named_url = self.named_url.resolve(context)
contents = u'url ' + resolved_named_url
urlNode = url(self.parser, Token(token_type=TOKEN_BLOCK, contents=contents))
return urlNode.render(context)
def url_optional(parser, token):
"""
creates the default URLNode, then routes it to the Optional resolver with the same properties
by first creating the URLNode, the parsing stays in django core where it belongs.
"""
urlnode = url(parser, token)
return URLNodeOptional(urlnode.view_name, urlnode.args, urlnode.kwargs, urlnode.asvar)
def url_or_back(parser, token):
"""
Returns the result of the default tag ``url`` unless it is the same target
as the HTTP_REFERER header in which case a simple
'javascript:history.back()'
saves a useless hit to the server.
"""
return UrlOrBackNode(url(parser, token))
def transurl(parser, token):
"""
Returns an absolute URL matching given view with its parameters.
See django.templatetags.future.url and django.template.defaulttags.URLNode
"""
from django.template.defaulttags import url
return TransURLNode.from_urlnode(url(parser, token))
def sph_url2(*args, **kwargs):
try:
node = defaulttags.url(*args, **kwargs)
return SphURLNode(node.view_name, node.args, node.kwargs, node.asvar)
except TemplateSyntaxError:
log.error('Error while resolving url for %r / %r', args, kwargs,
[str(x) for x in args])
return TextNode('')
def render(self, context):
from django.template import TOKEN_BLOCK, Token
resolved_named_url = self.named_url.resolve(context)
contents = u'url ' + resolved_named_url
urlNode = url(self.parser, Token(token_type=TOKEN_BLOCK, contents=contents))
return urlNode.render(context)
def disqus_url(parser, token):
url_instance = url(parser, token)
return DisqusURLNode(
view_name=url_instance.view_name,
args=url_instance.args,
kwargs=url_instance.kwargs,
asvar=url_instance.asvar
)
def absurl(parser, token):
"""Just like {% url %} but ads the domain of the current site."""
# invoke url setup just to parse the arguments.
node = url(parser, token)
# then pass the parsed args to the actual node instance
return AbsoluteURLNode(view_name=node.view_name,
args=node.args,
kwargs=node.kwargs,
asvar=node.asvar)
def abs_url(parser, token, node_cls=AbsoluteURLNode):
"""Just like {% url %} but creates an absolute URL."""
node_instance = url(parser, token)
return node_cls(
view_name=node_instance.view_name,
args=node_instance.args,
kwargs=node_instance.kwargs,
asvar=node_instance.asvar,
)
def menuitem(parser, token):
bullseye = '_bullseye'
head, sep, tail = token.contents.partition(bullseye)
token.contents = ' '.join([head.rstrip(), tail.lstrip()])
nodelist = parser.parse(('endmenuitem',))
parser.delete_first_token()
node = url(parser, token)
node.render = markup(node.render, nodelist, bool(sep))
return node
def absolute_url(parser, token, node_cls=AbsoluteURLNode):
"""
Just like {% url %} but adds the domain from settings.ABSOLUTE_HOST.
"""
node_instance = url(parser, token)
return node_cls(view_name=node_instance.view_name,
args=node_instance.args,
kwargs=node_instance.kwargs,
asvar=node_instance.asvar)
def render(self, context):
from django.template import TOKEN_BLOCK, Token
resolved_named_url = self.named_url.resolve(context)
if django.VERSION >= (1, 3):
contents = 'url "%s"' % resolved_named_url
else:
contents = 'url %s' % resolved_named_url
urlNode = url(self.parser, Token(token_type=TOKEN_BLOCK, contents=contents))
return urlNode.render(context)
def suburl(parser, token, node_cls=SubdomainAbsoluteURLNode):
"""Just like {% url %} but ads the domain of the current site."""
subdomain_context = token.split_contents()[2]
token.contents = token.contents.replace(subdomain_context, '')
node_instance = url(parser, token)
return node_cls(view_name=node_instance.view_name,
args=node_instance.args,
kwargs=node_instance.kwargs,
asvar=node_instance.asvar,
subdomain_context=subdomain_context)
def absolute(parser, token):
'''
Returns a full absolute URL based on the request host.
This template tag takes exactly the same paramters as url template tag.
'''
node = url(parser, token)
return AbsoluteUrlNode(view_name=node.view_name,
args=node.args,
kwargs=node.kwargs,
asvar=node.asvar)
def render(self, context):
from django.template import TOKEN_BLOCK, Token
resolved_named_url = self.named_url.resolve(context)
if django.VERSION >= (1, 3):
contents = 'url "%s"' % resolved_named_url
else:
contents = 'url %s' % resolved_named_url
urlNode = url(self.parser, Token(token_type=TOKEN_BLOCK, contents=contents))
return urlNode.render(context)
def breadcrumb_last_url(parser, token):
bits = token.split_contents()
if len(bits) == 2:
return breadcrumb(parser, token)
# Extract our extra title parameter
title = bits.pop(1)
token.contents = ' '.join(bits)
url_node = url(parser, token)
return UrlBreadcrumbNode(title, url_node, True)
def render(self, context):
from django.template import TOKEN_BLOCK, Token
resolved_named_url = self.named_url.resolve(context)
if django.VERSION >= (1, 3):
tokens = resolved_named_url.split(' ')
base = tokens[0]
args = tokens[1:]
contents = u'url "{0}" {1}'.format(base, ' '.join(args))
else:
contents = u'url {0}'.format(resolved_named_url)
urlNode = url(self.parser, Token(token_type=TOKEN_BLOCK, contents=contents))
return urlNode.render(context)
def blogurl(parser, token):
"""
Compatibility tag to allow django-fluent-blogs to operate stand-alone.
Either the app can be hooked in the URLconf directly, or it can be added as a pagetype of django-fluent-pages.
For the former, URL resolving works via the normal '{% url "viewname" arg1 arg2 %}' syntax.
For the latter, the URL resolving works via '{% appurl "viewname" arg1 arg2 %}' syntax.
"""
if HAS_APP_URLS:
from fluent_pages.templatetags.appurl_tags import appurl
return appurl(parser, token)
else:
from django.template.defaulttags import url
return url(parser, token)
def url_timeslot(parser, token):
"""
Wrapper around url templatetag which inserts a timeslot argument if a timeslot is present.
:param parser:
:param token:
:return:
"""
node = url(parser, token) # default url parser
ts = get_timeslot()
if ts:
node.args.append(FilterExpression(token=str(ts.pk), parser=parser))
return node
def ancestor(parser, token):
# If there is only one argument (2 including tag name)
# parse it as a variable
bits = token.split_contents()
if len(bits) == 2:
arg = parser.compile_filter(bits[1])
else:
arg = None
# Also pass all arguments to the original url tag
url_node = url(parser, token)
return AncestorNode(url_node, arg=arg)
def site(parser, token):
'''
Returns a full absolute URL based on the current site.
This template tag takes exactly the same paramters as url template tag.
'''
node = url(parser, token)
return SiteUrlNode(
view_name=node.view_name,
args=node.args,
kwargs=node.kwargs,
asvar=node.asvar
)
def ancestor(parser, token):
# If there is only one argument (2 including tag name)
# parse it as a variable
bits = token.split_contents()
if len(bits) == 2:
arg = parser.compile_filter(bits[1])
else:
arg = None
# Also pass all arguments to the original url tag
url_node = url(parser, token)
return AncestorNode(url_node, arg=arg)
def blogurl(parser, token):
"""
Compatibility tag to allow django-fluent-blogs to operate stand-alone.
Either the app can be hooked in the URLconf directly, or it can be added as a pagetype of django-fluent-pages.
For the former, URL resolving works via the normal '{% url "viewname" arg1 arg2 %}' syntax.
For the latter, the URL resolving works via '{% appurl "viewname" arg1 arg2 %}' syntax.
"""
if HAS_APP_URLS:
from fluent_pages.templatetags.appurl_tags import appurl
return appurl(parser, token)
else:
from django.template.defaulttags import url
return url(parser, token)
def old_style_url(parser, token):
global error_on_old_style_url_tag
bits = token.split_contents()
view = bits[1]
if error_on_old_style_url_tag:
_error("Old style url tag used (only reported once per file): {%% %s %%}" % (" ".join(bits)), token)
error_on_old_style_url_tag = False
if view[0] in "\"'" and view[0] == view[-1]:
_error("Old style url tag with quotes around view name: {%% %s %%}" % (" ".join(bits)), token)
return defaulttags.url(parser, token)
def render(self, context):
from django.template import TOKEN_BLOCK, Token
resolved_named_url = self.named_url.resolve(context)
# edit hts SpectralAngel
if django.VERSION >= (1, 3):
tokens = resolved_named_url.split(' ')
base = tokens[0]
args = tokens[1:]
contents = u'url "{0}" {1}'.format(base, ' '.join(args))
else:
contents = u'url {0}'.format(resolved_named_url)
## edit
urlNode = url(self.parser, Token(token_type=TOKEN_BLOCK, contents=contents))
return urlNode.render(context)
def relurl(parser, token, node_cls=RelativeURLNode):
"""Use like the url templatetag, but provide the request path as the first
argument and this templatetag will return a relative url."""
old_token = token
contents = old_token.split_contents()
request_path = contents.pop(1)
new_token = Token(old_token.token_type, ' '.join(contents))
node_instance = url(parser, new_token)
node_instance.request_path = request_path
node = node_cls(view_name=node_instance.view_name,
args=node_instance.args,
kwargs=node_instance.kwargs,
asvar=node_instance.asvar)
node.request_path = request_path
return node
def breadcrumb_url(parser, token):
"""
Render breadcrumbs in the form of:
{% breadcrumb 'Breadcrumb title' url args %}
"""
contents = token.split_contents()
if len(contents) == 2:
return breadcrumb(parser, token) # Shortcut to normal breadcrumbs
title = contents.pop(1)
token.contents = ' '.join(contents)
url = django_defaulttags.url(parser, token)
return UrlBreadcrumbNode(title, url)
def relurl(parser, token, node_cls=RelativeURLNode):
"""Use like the url templatetag, but provide the request path as the first
argument and this templatetag will return a relative url."""
old_token = token
contents = old_token.split_contents()
request_path = contents.pop(1)
new_token = Token(old_token.token_type, ' '.join(contents))
node_instance = url(parser, new_token)
node_instance.request_path = request_path
node = node_cls(view_name=node_instance.view_name,
args=node_instance.args,
kwargs=node_instance.kwargs,
asvar=node_instance.asvar)
node.request_path = request_path
return node
def group_url(parser, token):
"""
A proxy wrapper for the Django 'url' tag for URLs pointing to pages within a CosinnusGroup.
This tag is aware of which type of group is being pointed to and will automatically chose
the correct URL path specific for the group type, as configured with group_model_registry.py.
Otherwise this uses the django 'url' tag definition.
"""
urlnode = url(parser, token)
if not "group" in urlnode.kwargs:
raise TemplateSyntaxError("'group_url' tag requires a group kwarg!")
return GroupURLNode(urlnode.view_name, urlnode.args, urlnode.kwargs, urlnode.asvar)
def do_repo_url(parser, token):
func_name, view_name, token_parts = token.contents.split(' ', 2)
token_parts = token_parts.split(' ', 1)
if len(token_parts) > 1:
repo_obj_name = token_parts[0]
new_token = token_parts[1]
else:
repo_obj_name = token_parts[0]
new_token = ''
return url(
parser,
template.Token(
token.token_type, '%s %s %s.user.username %s.slug %s' %
(func_name, view_name, repo_obj_name, repo_obj_name, new_token)))
def url_fqdn(parser, token):
"""
Acts like 'url(), but returns with FQDN of current context. Takes optional 'sitedata' label to override.
Use like the following:
{% url_fqdn 'name-of-url' %}
{% url_fqdn 'name-of-url' sitedata='djangohunter' %}
"""
node = url(parser, token)
return SiteDataURLNode(
view_name=node.view_name,
args=node.args,
kwargs=node.kwargs,
asvar=node.asvar,
)
def locale_url(parser, token):
"""
Renders the url for the view with another locale prefix. The syntax is
like the 'url' tag, only with a locale before the view.
Examples:
{% locale_url "de" cal.views.day day %}
{% locale_url "nl" cal.views.home %}
{% locale_url "en-gb" cal.views.month month as month_url %}
"""
bits = token.split_contents()
if len(bits) < 3:
raise TemplateSyntaxError("'%s' takes at least two arguments:"
" the locale and a view" % bits[0])
urltoken = Token(token.token_type, bits[0] + ' ' + ' '.join(bits[2:]))
urlnode = defaulttags.url(parser, urltoken)
return LocaleURLNode(bits[1], urlnode)
def asset_url(parser, token, node_cls=AssetURLNode):
"""
Just like the "url" templatetag, except replaces the filename part of
the url path with the versioned filename pulled from the asset manifest
generated by webpack.
Example:
{% asset_url 'sentry-media' 'sentry' 'dist/sentry.css' %}
=> "/_static/sentry/dist/sentry.74d127b78dc7daf2c51f.css"
"""
node_instance = url(parser, token)
return node_cls(view_name=node_instance.view_name,
args=node_instance.args,
kwargs=node_instance.kwargs,
asvar=node_instance.asvar)
def locale_url(parser, token):
"""
Renders the url for the view with another locale prefix. The syntax is
like the 'url' tag, only with a locale before the view.
Examples:
{% locale_url "de" cal.views.day day %}
{% locale_url "nl" cal.views.home %}
{% locale_url "en-gb" cal.views.month month as month_url %}
"""
bits = token.split_contents()
if len(bits) < 3:
raise TemplateSyntaxError("'%s' takes at least two arguments:"
" the locale and a view" % bits[0])
urltoken = Token(token.token_type, bits[0] + ' ' + ' '.join(bits[2:]))
urlnode = defaulttags.url(parser, urltoken)
return LocaleURLNode(bits[1], urlnode)
def do_repo_url(parser, token):
func_name, view_name, token_parts = token.contents.split(' ', 2)
token_parts = token_parts.split(' ', 1)
if len(token_parts) > 1:
repo_obj_name = token_parts[0]
new_token = token_parts[1]
else:
repo_obj_name = token_parts[0]
new_token = ''
return url(parser, template.Token(token.token_type, '%s %s %s.user.username %s.slug %s' % (
func_name,
view_name,
repo_obj_name,
repo_obj_name,
new_token
)))
def active_urls_builder(parser, token): link_id = None query_params = [] bits = token.split_contents() if LINK_RX.match(bits[1]): link_id = bits[1] bits = [bits[0]] + bits[2:] if QUERY_PARAM_SEPARATOR in bits: query_params_start = bits.index(QUERY_PARAM_SEPARATOR) query_params = bits[query_params_start + 1:] bits = bits[:query_params_start] print '!!', token.contents, bits, ' '.join(bits) url_node = url(parser, Token(token.token_type, ' '.join(bits), token.position, token.lineno)) return ActiveUrlsBuilderNode(url_node, link_id, query_params)
def breadcrumb_url(parser, token):
"""
Same as breadcrumb
but instead of url context variable takes in all the
arguments URL tag takes.
{% breadcrumb "Title of breadcrumb" person_detail person.id %}
{% breadcrumb person.name person_detail person.id %}
"""
bits = token.split_contents()
if len(bits) == 2:
return breadcrumb(parser, token)
# Extract our extra title parameter
title = bits.pop(1)
token.contents = " ".join(bits)
url_node = url(parser, token)
return UrlBreadcrumbNode(title, url_node)
def facebook_url(parser, token):
"""
Works exactly like the default url tag, except the final url is replaced
with its facebook canvas equivalent if it's in the canvas app.
Refer to https://docs.djangoproject.com/en/1.3/ref/templates/builtins/#url
for more information on how to use this tag.
"""
# The {% url %} tag's function generates a URLNode. The URLNode's render
# function handles generating the proper url. We're going to move the
# the render method and replace it with a new render method. The new
# method will call the old one and then adjust the url before returning.
URLNode_obj = url(parser, token)
URLNode_obj.old_render = URLNode_obj.render
URLNode_obj.render = types.MethodType(
replacement_URLNode_render_method,
URLNode_obj,
URLNode)
return URLNode_obj
def ancestor(parser, token):
bits = token.split_contents()
exact = False
if len(bits) >= 2:
arg = parser.compile_filter(bits[1])
# check last bits for the exact=True|False
extra_context = token_kwargs(bits[-1:], parser, support_legacy=True)
if 'exact' in extra_context:
token.contents = u" ".join(bits[:-1])
exact = extra_context.get('exact', False)
else:
arg = None
# Also pass all arguments to the original url tag
url_node = url(parser, token)
return AncestorNode(url_node, arg=arg, exact=exact)
def breadcrumb_url(parser, token):
"""
Same as breadcrumb
but instead of url context variable takes in all the
arguments URL tag takes.
{% breadcrumb "Title of breadcrumb" person_detail person.id %}
{% breadcrumb person.name person_detail person.id %}
"""
bits = token.split_contents()
if len(bits)==2:
return breadcrumb(parser, token)
# Extract our extra title parameter
title = bits.pop(1)
token.contents = ' '.join(bits)
url_node = url(parser, token)
return UrlBreadcrumbNode(title, url_node)
def ifancestor(parser, token):
"""
Returns the contents of the tag if the provided path consitutes the
base of the current pages path.
There are two ways to provide arguments to this tag. Firstly one may
provide a single argument that starts with a forward slash. e.g.
{% ifancestor '/path/to/page' %}...{% endifancestor}
{% ifancestor path_variable %}...{% endifancestor}
In this case the provided path will be used directly.
Alternatively any arguments accepted by the standard "url" tag may
be provided. They will be passed to the url tag and the resultant
path will be used. e.g.
{% ifancestor 'core:model:detail' model.pk %}...{% endifancestor}
Ultimately the provided path is matched against the path of the
current page. If the provided path is found at the root of the current
path it will be considered an anscestor, and the contents of this tag
will be rendered.
"""
# Grab the contents between
contents = parser.parse(('endifancestor', ))
parser.delete_first_token()
# If there is only one argument (2 including tag name)
# parse it as a variable
bits = token.split_contents()
if len(bits) == 2:
arg = parser.compile_filter(bits[1])
else:
arg = None
# Also pass all arguments to the original url tag
url_node = url(parser, token)
return AncestorNode(url_node, arg=arg, contents=contents)
def ifancestor(parser, token):
"""
Returns the contents of the tag if the provided path consitutes the
base of the current pages path.
There are two ways to provide arguments to this tag. Firstly one may
provide a single argument that starts with a forward slash. e.g.
{% ifancestor '/path/to/page' %}...{% endifancestor}
{% ifancestor path_variable %}...{% endifancestor}
In this case the provided path will be used directly.
Alternatively any arguments accepted by the standard "url" tag may
be provided. They will be passed to the url tag and the resultant
path will be used. e.g.
{% ifancestor 'core:model:detail' model.pk %}...{% endifancestor}
Ultimately the provided path is matched against the path of the
current page. If the provided path is found at the root of the current
path it will be considered an anscestor, and the contents of this tag
will be rendered.
"""
# Grab the contents between
contents = parser.parse(('endifancestor',))
parser.delete_first_token()
# If there is only one argument (2 including tag name)
# parse it as a variable
bits = token.split_contents()
if len(bits) == 2:
arg = parser.compile_filter(bits[1])
else:
arg = None
# Also pass all arguments to the original url tag
url_node = url(parser, token)
return AncestorNode(url_node, arg=arg, contents=contents)
def ancestor(parser, token):
"""Checks whether a given URL is the "ancestor" of the current request's
path.
In other words, this tag is used the see whether the current page (the
current request's path) is a "child" of some other URL (in the URL
structure). This ability is useful for discovering whether a navigation
element is "selected" or not.
Usage:
{% load ancestor %}
If the argument to the ancestor tag matches the start of the current page's
URL, it outputs "selected":
Using a string as the URL path:
{% ancestor '/arbitrary/path/' %}
Or using variables, filters, etc.:
{% ancestor some_variable|somefilter %}
Or url reverse resolution:
{% ancestor 'core:model_detail' model.pk %}
Adapted from https://github.com/marcuswhybrow/django-lineage
"""
# If there is only one argument (2 including tag name), parse it as a
# variable
bits = token.split_contents()
if len(bits) == 2:
arg = parser.compile_filter(bits[1])
else:
arg = None
# Also pass all arguments to the original url tag
url_node = url(parser, token)
return AncestorNode(url_node, arg=arg)
def ancestor(parser, token):
"""Checks whether a given URL is the "ancestor" of the current request's
path.
In other words, this tag is used the see whether the current page (the
current request's path) is a "child" of some other URL (in the URL
structure). This ability is useful for discovering whether a navigation
element is "selected" or not.
Usage:
{% load ancestor %}
If the argument to the ancestor tag matches the start of the current page's
URL, it outputs "selected":
Using a string as the URL path:
{% ancestor '/arbitrary/path/' %}
Or using variables, filters, etc.:
{% ancestor some_variable|somefilter %}
Or url reverse resolution:
{% ancestor 'core:model_detail' model.pk %}
Adapted from https://github.com/marcuswhybrow/django-lineage
"""
# If there is only one argument (2 including tag name), parse it as a
# variable
bits = token.split_contents()
if len(bits) == 2:
arg = parser.compile_filter(bits[1])
else:
arg = None
# Also pass all arguments to the original url tag
url_node = url(parser, token)
return AncestorNode(url_node, arg=arg)
def t_url(parser, token):
exp = token.split_contents()
new_content = exp[0] + ' ' + exp[1]
args = {}
arg_names = {}
for i in range(len(exp) - 2):
argname = ''.join([random.choice('1234567890')
for j in range(10)]) # 'xp_tag_arg%d'% i
args[argname] = '<%= this.' + exp[i + 2] + ' %>'
arg_names[argname] = argname
new_content += ' ' + argname
token.contents = new_content
tagged = url(parser, token)
old_render = tagged.render
def new_render(context):
rendered = old_render(Context(arg_names))
for arg in args:
rendered = rendered.replace(arg, args[arg])
return rendered
tagged.render = new_render
return tagged
def site(parser, token):
'''
Returns a full absolute URL based on the current site.
This template tag takes exactly the same paramters as url template tag,
plus an optional "site" argument to force usage of a given Site object::
{% site "my_view" site my_site_obj %}
'''
bits = token.split_contents()
if len(bits) > 2 and bits[2] == 'site':
site = parser.compile_filter(bits[3])
token = Token(token.token_type, ' '.join(bits[:2] + bits[4:]),
token.position, token.lineno)
else:
site = None
node = url(parser, token)
return SiteUrlNode(site=site,
view_name=node.view_name,
args=node.args,
kwargs=node.kwargs,
asvar=node.asvar)
def noprefix_url(parser, token):
"""
Returns an absolute URL matching given view with its parameters, with any
path prefix from the WSGI request stripped.
"""
return NoPrefixURLNode(url(parser, token))