def _get_object_navigation_links(context,
menu_name=None,
links_dict=object_navigation):
request = Variable('request').resolve(context)
current_path = request.META['PATH_INFO']
current_view = resolve_to_name(current_path)
context_links = []
# Don't fudge with the original global dictionary
links_dict = links_dict.copy()
# Preserve unicode data in URL query
previous_path = smart_unicode(
urllib.unquote_plus(
smart_str(request.get_full_path())
or smart_str(request.META.get('HTTP_REFERER', u'/'))))
query_string = urlparse.urlparse(previous_path).query
parsed_query_string = urlparse.parse_qs(query_string)
try:
"""
Override the navigation links dictionary with the provided
link list
"""
navigation_object_links = Variable('overrided_object_links').resolve(
context)
if navigation_object_links:
return [
link for link in
resolve_links(context, navigation_object_links, current_view,
current_path, parsed_query_string)
]
except VariableDoesNotExist:
pass
try:
"""
Check for and inject a temporary navigation dictionary
"""
temp_navigation_links = Variable('temporary_navigation_links').resolve(
context)
if temp_navigation_links:
links_dict.update(temp_navigation_links)
except VariableDoesNotExist:
pass
try:
links = links_dict[menu_name][current_view]['links']
for link in resolve_links(context, links, current_view, current_path,
parsed_query_string):
context_links.append(link)
except KeyError:
pass
obj, object_name = get_navigation_object(context)
try:
links = links_dict[menu_name][type(obj)]['links']
for link in resolve_links(context, links, current_view, current_path,
parsed_query_string):
context_links.append(link)
except KeyError:
pass
return context_links
def __init__(self, obj, context_var):
self.obj = Variable(obj)
self.context_var = context_var
def __init__(self, obj, var_name, with_feedback):
self.obj = Variable(obj)
self.var_name = var_name
self.with_feedback = with_feedback
def __init__(self, title, url_node):
self.title = Variable(title)
self.url_node = url_node
def __init__(self, *args, **kwargs):
self.args = [Variable(arg) for arg in args]
self.kwargs = dict([(k, Variable(arg)) for k, arg in kwargs.items()])
def __init__(self, actions, varname=None):
self.actions = Variable(actions)
self.varname = varname
def __init__(self, record, fieldset, crosslinks):
self.record = Variable(record)
self.fieldset = Variable(fieldset) if fieldset else None
self.crosslinks = Variable(crosslinks) if crosslinks else None
def __init__(self, user, event, context_var):
self.user = Variable(user)
self.event = Variable(event)
self.context_var = context_var
def render(self, context):
tags = u''
query = u''
user = AnonymousUser()
limit = 3
order = 'next_upcoming'
event_type = ''
group = u''
start_dt = u''
randomize = False
if 'start_dt' in self.kwargs:
try:
start_dt = datetime.strptime(
self.kwargs['start_dt'].replace('"', '').replace('"', ''),
'%m/%d/%Y-%H:%M')
except ValueError:
pass
if 'random' in self.kwargs:
randomize = bool(self.kwargs['random'])
if 'tags' in self.kwargs:
try:
tags = Variable(self.kwargs['tags'])
tags = str(tags.resolve(context))
except:
tags = self.kwargs['tags']
tags = tags.replace('"', '')
tags = tags.split(',')
if 'user' in self.kwargs:
try:
user = Variable(self.kwargs['user'])
user = user.resolve(context)
except:
user = self.kwargs['user']
if user == "anon" or user == "anonymous":
user = AnonymousUser()
else:
# check the context for an already existing user
# and see if it is really a user object
if 'user' in context:
if isinstance(context['user'], User):
user = context['user']
if 'limit' in self.kwargs:
try:
limit = Variable(self.kwargs['limit'])
limit = limit.resolve(context)
except:
limit = self.kwargs['limit']
limit = int(limit)
if 'query' in self.kwargs:
try:
query = Variable(self.kwargs['query'])
query = query.resolve(context)
except:
query = self.kwargs['query'] # context string
if 'order' in self.kwargs:
try:
order = Variable(self.kwargs['order'])
order = order.resolve(context)
except:
order = self.kwargs['order']
if 'type' in self.kwargs:
try:
event_type = Variable(self.kwargs['type'])
event_type = event_type.resolve(context)
except:
event_type = self.kwargs['type']
if 'group' in self.kwargs:
try:
group = Variable(self.kwargs['group'])
group = str(group.resolve(context))
except:
group = self.kwargs['group']
try:
group = int(group)
except:
group = None
filters = get_query_filters(user, 'events.view_event')
items = Event.objects.filter(filters)
if user.is_authenticated:
if not user.profile.is_superuser:
items = items.distinct()
if event_type:
if ',' in event_type:
items = items.filter(type__name__in=event_type.split(','))
else:
items = items.filter(type__name__iexact=event_type)
if tags: # tags is a comma delimited list
# this is fast; but has one hole
# it finds words inside of other words
# e.g. "prev" is within "prevent"
tag_queries = [Q(tags__iexact=t.strip()) for t in tags]
tag_queries += [Q(tags__istartswith=t.strip() + ",") for t in tags]
tag_queries += [Q(tags__iendswith=", " + t.strip()) for t in tags]
tag_queries += [Q(tags__iendswith="," + t.strip()) for t in tags]
tag_queries += [
Q(tags__icontains=", " + t.strip() + ",") for t in tags
]
tag_queries += [
Q(tags__icontains="," + t.strip() + ",") for t in tags
]
tag_query = reduce(or_, tag_queries)
items = items.filter(tag_query)
if hasattr(self.model, 'group') and group:
items = items.filter(groups=group)
if hasattr(self.model, 'groups') and group:
items = items.filter(groups__in=[group])
objects = []
if start_dt:
items = items.filter(start_dt__gte=start_dt)
# exclude private events
items = items.filter(enable_private_slug=False)
# if order is not specified it sorts by relevance
if order:
if order == "next_upcoming":
if not start_dt:
# Removed seconds and microseconds so we can cache the query better
now = datetime.now().replace(second=0, microsecond=0)
items = items.filter(start_dt__gt=now)
items = items.order_by("start_dt", '-priority')
elif order == "current_and_upcoming":
if not start_dt:
now = datetime.now().replace(second=0, microsecond=0)
items = items.filter(
Q(start_dt__gt=now) | Q(end_dt__gt=now))
items = items.order_by("start_dt", '-priority')
elif order == "current_and_upcoming_by_hour":
now = datetime.now().replace(second=0, microsecond=0)
today = datetime.now().replace(second=0,
hour=0,
minute=0,
microsecond=0)
tomorrow = today + timedelta(days=1)
items = items.filter(
Q(start_dt__lte=tomorrow) & Q(end_dt__gte=today)).extra(
select={
'hour': 'extract( hour from start_dt )'
}).extra(select={
'minute': 'extract( minute from start_dt )'
}).extra(where=["extract( hour from start_dt ) >= %s"],
params=[now.hour])
items = items.distinct()
items = items.order_by('hour', 'minute', '-priority')
else:
items = items.order_by(order)
if randomize:
items = list(items)
objects = random.sample(items, min(len(items), limit))
else:
objects = items[:limit]
context[self.context_var] = objects
return ""
def get_bound_field(self, context):
# First we try to resolve the {% formfield player.name %} syntax were
# player is a model instance.
if '.' in self.field_variable_name:
form = self.get_form_instance(context)
instance_name_in_template, field_name = \
self.field_variable_name.split('.', -1)
instance_in_template = Variable(
instance_name_in_template).resolve(context)
# it could be form.my_field
if isinstance(instance_in_template, models.Model):
instance_from_view = form.instance
if type(instance_from_view) == UndefinedFormModel:
raise ValueError(
'Template contains a formfield, but '
'you did not set form_model on the Page class.'
)
elif type(instance_in_template) != type(instance_from_view):
raise ValueError(
'In the page class, you set form_model to {!r}, '
'but in the template you have a formfield for '
'"{}", which is a different model.'.format(
type(instance_from_view),
instance_name_in_template,
)
)
# we should ensure that Player and Group have readable
# __repr__
elif instance_in_template != instance_from_view:
raise ValueError(
"You have a formfield for '{}' "
"({!r}), which is different from "
"the expected model instance "
"({!r}).".format(
instance_name_in_template,
instance_in_template,
form.instance))
try:
return form[field_name]
except KeyError:
raise ValueError(
"'{field_name}' was used as a formfield in the template, "
"but was not included in the Page's 'form_fields'".format(
field_name=field_name)) from None
# Second we try to resolve it to a bound field.
# No field found, so we return None.
bound_field = Variable(self.field_variable_name).resolve(context)
# We assume it's a BoundField when 'as_widget', 'as_hidden' and
# 'errors' attribtues are available.
if (
not hasattr(bound_field, 'as_widget') or
not hasattr(bound_field, 'as_hidden') or
not hasattr(bound_field, 'errors')):
raise ValueError(
"The given variable '{variable_name}' ({variable!r}) is "
"neither a model field nor a form field.".format(
variable_name=self.field_variable_name,
variable=bound_field))
return bound_field
from django.conf import settings
from django.db import models, connections
from django.utils.translation import ugettext as _
from django.utils.http import urlquote
from django.utils.encoding import iri_to_uri, force_text
from django.utils.html import escape
from django.utils.safestring import mark_safe
from django.utils.text import capfirst
from freppledb.common.models import User
from freppledb import VERSION
MAX_CRUMBS = 10
register = Library()
variable_title = Variable("title")
variable_request = Variable("request")
variable_popup = Variable("is_popup")
#
# A tag to create breadcrumbs on your site
#
class CrumbsNode(Node):
r'''
A generic breadcrumbs framework.
Usage in your templates:
{% crumbs %}
def resolve_bound_field(self, context):
bound_field = Variable(self.field_variable_name).resolve(context)
return bound_field
def test_no_log_when_variable_exists(self):
Variable('article.section').resolve({'article': {'section': 'News'}})
self.assertIsNone(self.test_handler.log_record)
def render(self, context):
request = Variable('request').resolve(context)
view_name = resolve_to_name(request.META['PATH_INFO'])
context[self.var_name] = sidebar_templates.get(view_name, [])
return ''
def var_or_none(x):
if x is not None:
return Variable(x)
def __init__(self, tags_to_add, tags_to_remove):
self.tags_to_add = [Variable(tag) for tag in tags_to_add]
self.tags_to_remove = [Variable(tag) for tag in tags_to_remove]
def __init__(self, actor, varname=None):
self.actor = Variable(actor)
self.varname = varname
def __init__(self, lang_code, variable):
self.lang_code = Variable(lang_code)
self.variable = variable
def __init__(self, nodelist, expire_time_var, fragment_name, vary_on):
self.nodelist = nodelist
self.expire_time_var = Variable(expire_time_var)
self.fragment_name = fragment_name
self.vary_on = vary_on
def __init__(self, languages, variable):
self.languages = Variable(languages)
self.variable = variable
def __init__(self, title, url_node, render_func=create_crumb):
self.title = Variable(title)
self.url_node = url_node
self.render_func = render_func
def __init__(self, filter_expression, noop):
self.noop = noop
self.filter_expression = filter_expression
if isinstance(self.filter_expression.var, basestring):
self.filter_expression.var = Variable(u"'%s'" %
self.filter_expression.var)
def __init__(self, url, varname, value):
self.url = Variable(url)
self.varname = Variable(varname)
self.value = Variable(value)
def __init__(self, promotion):
self.promotion_var = Variable(promotion)
def __init__(self, id_):
self.id = Variable(id_)
def __init__(self, item_to_be_rendered):
self.item_to_be_rendered = Variable(item_to_be_rendered)
def parse_cvars(self, pairs):
cvars = []
for vname, vobj in [pair.split("=") for pair in pairs]:
cvars.append((vname, Variable(vobj)))
return cvars
def __init__(self, nodes, roots):
self.nodes = nodes
self.roots = Variable(roots)
self.tree_query_set = None
def __init__(self, obj):
self.obj = Variable(obj)
def __init__(self, field):
self.field = Variable(field)
