def init_with_context(self, context):
settings_app_names = getattr(settings, "APP_NAMES", {})
items = self._visible_models(context['request'])
apps = {}
for model, perms in items:
app_label = model._meta.app_label
if app_label not in apps:
#FIXME: only this lines different!
try:
title = settings_app_names[app_label]
except KeyError:
title = capfirst(app_label.title())
apps[app_label] = {
#FIXME: only this line different!
'title': title,
'url': reverse('admin:app_list', args=(app_label,)),
'models': []
}
model_dict = {}
model_dict['title'] = capfirst(model._meta.verbose_name_plural)
if perms['change']:
model_dict['change_url'] = self._get_admin_change_url(model)
if perms['add']:
model_dict['add_url'] = self._get_admin_add_url(model)
apps[app_label]['models'].append(model_dict)
apps_sorted = apps.keys()
apps_sorted.sort()
for app in apps_sorted:
# sort model list alphabetically
apps[app]['models'].sort(lambda x, y: cmp(x['title'], y['title']))
self.children.append(apps[app])
def get_metadata(self, request, ptypes, entity=None):
context = NearbyDetailView.initial_context(self, request, ptypes, entity)
if len(context['entity_types']) == 0:
return {
'exclude_from_search': True,
'title': 'Things near %s' % entity.title,
}
if len(context['entity_types']) > 1:
return {
'exclude_from_search': True,
'title': '%s near%s%s' % (
capfirst(context['entity_types'][0].verbose_name_plural),
entity and ' ' or '',
entity and entity.title or 'by',
),
}
return {
'title': '%s near%s%s' % (
capfirst(context['entity_types'][0].verbose_name_plural),
entity and ' ' or '',
entity and entity.title or 'by',
),
'additional': '<strong>%d %s</strong> within 1km' % (
len([e for e in context['entities'] if e.location.transform(27700, clone=True).distance(context['point'].transform(27700, clone=True)) <= 1000]),
context['entity_types'][0].verbose_name_plural,
),
}
def render(self, context):
try:
parameters = resolve_parameters_from_context(self.parameters, context)
obj = None
if 'obj' in parameters:
obj = parameters['obj']
if obj is None:
obj = context['user']
if callable(obj):
obj = obj()
url = obj.get_absolute_url()
command = 'view'
if 'command' in parameters:
command = parameters['command']
css_command = command
if css_command == 'edit':
css_command = 'change'
if 'title' in parameters:
title = _(parameters['title'])
elif command == 'view':
title = _(capfirst(unicode(obj)))
else:
title = _(capfirst(command))
if command != 'view':
url += command+'/'
if 'add ' in command:
foo = command.split(' ')
if foo[1] == 'member':
url = '/groups/'+unicode(obj.id)+'/add_member/'
elif foo[1] == 'friend':
url = '/users/'+unicode(obj.id)+'/add_friend/'
else:
url = '/'+foo[1]+'s/add/'
if isinstance(obj, Group):
url += '?group_id='+unicode(obj.id)
else:
url += '?user_id='+unicode(obj.id)
from curia.authentication import has_perm
perm = has_perm(user=context['user'], obj=obj, command=command)
if perm:
return self.has_permission(context, url, css_command, title, perm.motivation)
else:
return self.no_permission(context, url, css_command, title, perm.motivation)
except TemplateSyntaxError:
if settings.TEMPLATE_DEBUG:
raise
return ''
def add_collection_relations(self, request):
from django.forms.formsets import formset_factory
from django.template.defaultfilters import capfirst, pluralize
CollectionFormSet = formset_factory(CollectionRelationForm, extra=4)
form = ContentTypeForm(request.GET)
formset = CollectionFormSet()
if request.method == "POST":
formset = CollectionFormSet(request.POST)
form = ContentTypeForm(request.POST)
if form.is_valid():
try:
ct = ContentType.objects.get(pk=form.cleaned_data.get('ct'))
except ContentType.DoesNotExist:
raise Http404
else:
# The form is invalid, which should never happen (even on initial GET).
# TODO: Should I raise 404 or redirect?
raise Http404
if formset.is_bound and formset.is_valid():
ids = form.cleaned_data.get('ids').split(',')
objects = ct.model_class()._default_manager.filter(pk__in=ids)
num_collections = 0
for c_form in formset.forms:
collection_id = c_form.cleaned_data.get('collection', None)
if collection_id is not None:
collection = Collection.objects.get(pk=collection_id)
for obj in objects:
cr = CollectionRelation.objects.create(content_object=obj, collection=collection)
collection.collectionrelation_set.add(cr)
num_collections += 1
redir_url = '%sadmin_%s_%s_changelist' % (
self.admin_site.name,
ct.model_class()._meta.app_label,
ct.model_class()._meta.module_name)
request.user.message_set.create(
message='%s %s%s successfully added to the selected %s%s.' % (
len(objects),
capfirst(ct.model_class()._meta.verbose_name),
pluralize(len(objects)),
capfirst(Collection._meta.verbose_name),
pluralize(num_collections)
))
return HttpResponseRedirect(reverse(redir_url))
t = loader.get_template('admin/massmedia/add_collection_relations.html')
c = RequestContext(request, {
'ct_opts': ct.model_class()._meta,
'collection_opts': Collection._meta,
'formset': formset,
'form': form,
'media': form.media + formset.media
})
return HttpResponse(t.render(c))
def app_index(self, request, app_label, extra_context=None):
user = request.user
has_module_perms = user.has_module_perms(app_label)
app_dict = {}
for model, model_admin in self._registry.items():
if app_label == model._meta.app_label:
if has_module_perms:
perms = model_admin.get_model_perms(request)
# Check whether user has any perm for this module.
# If so, add the module to the model_list.
if True in perms.values():
info = (self.app_name, app_label, model._meta.module_name)
model_dict = {
'name': capfirst(model._meta.verbose_name_plural),
'perms': perms,
}
if perms.get('change', False):
try:
# model_dict['admin_url'] = reverse('%s:%s_%s_changelist' % info, current_app=self.name)
model_dict['admin_url'] = reverse('%s:%s_%s_changelist' % info, current_app=self.name)
except NoReverseMatch:
pass
if perms.get('add', False):
try:
model_dict['add_url'] = reverse('%s:%s_%s_add' % info, current_app=self.name)
except NoReverseMatch:
pass
if app_dict:
app_dict['models'].append(model_dict),
else:
# First time around, now that we know there's
# something to display, add in the necessary meta
# information.
app_dict = {
'name': app_label.title(),
'app_url': '',
'has_module_perms': has_module_perms,
'models': [model_dict],
}
if not app_dict:
raise Http404('The requested admin page does not exist.')
# Sort the models alphabetically within each app.
app_dict['models'].sort(key=lambda x: x['name'])
context = self.get_context(**{
'title': _('%s administration') % capfirst(app_label),
'app_list': [app_dict],
})
context.update(extra_context or {})
return TemplateResponse(request, self.app_index_template or [
self.get_template('%s/app_index.html' % app_label),
self.get_template('app_index.html'),
], context, current_app=self.name)
def verbose_field_name(instance, field_name):
try:
verbose_field_name = defaultfilters.capfirst(
instance._meta.get_field(field_name).verbose_name
)
except exceptions.FieldDoesNotExist:
verbose_field_name = defaultfilters.capfirst(
instance.get_all_fields()[field_name].field.verbose_name
)
return verbose_field_name
def definition(self):
"""
A humanized definition of what's the in field for documentation.
"""
s = ""
if self.__dict__['_verbose_name']:
s += capfirst(self.__dict__['_verbose_name'])
if self.help_text:
if self.__dict__['_verbose_name']:
s += ": "
s += capfirst(self.help_text)
return s.strip()
def definition(self):
"""
A humanized definition of what's the in field for documentation.
"""
s = ""
if self.__dict__['_verbose_name']:
s += capfirst(self.__dict__['_verbose_name'])
if self.help_text:
if self.__dict__['_verbose_name']:
s += ": "
s += capfirst(self.help_text)
return s.strip()
def get_metadata(self, request, ptypes):
context = CategoryDetailView.initial_context(self, request, ptypes)
if len(context["entity_types"]) > 1:
return {
"exclude_from_search": True,
"title": "All %s near%s%s" % capfirst(context["entity_types"][0].verbose_name_plural),
}
return {
"title": "All %s near%s%s" % capfirst(context["entity_types"][0].verbose_name_plural),
"additional": "<strong>%d %s</strong>"
% (len(context["entities"]), context["entity_types"][0].verbose_name_plural),
}
def update(request):
user = request.user
if request.method == "POST" and user.is_authenticated():
first_name = request.POST.get('first_name', None)
if first_name:
user.first_name = capfirst(first_name)
user.save()
return HttpResponse(user.first_name)
last_name = request.POST.get('last_name', None)
if last_name:
user.last_name = capfirst(last_name)
user.save()
return HttpResponse(user.last_name)
return HttpResponse("")
def test_email_invitation(self):
invitation = PrescriberWithOrgSentInvitationFactory()
email = invitation.email_invitation
# Subject
self.assertIn(invitation.organization.display_name, email.subject)
# Body
self.assertIn(capfirst(invitation.first_name), email.body)
self.assertIn(capfirst(invitation.last_name), email.body)
self.assertIn(invitation.acceptance_link, email.body)
self.assertIn(invitation.organization.display_name, email.body)
# To
self.assertIn(invitation.email, email.to)
def test_email_invitation(self):
invitation = SentSiaeStaffInvitationFactory()
email = invitation.email_invitation
# Subject
self.assertIn(invitation.siae.display_name, email.subject)
# Body
self.assertIn(capfirst(invitation.first_name), email.body)
self.assertIn(capfirst(invitation.last_name), email.body)
self.assertIn(invitation.acceptance_link, email.body)
self.assertIn(invitation.siae.display_name, email.body)
# To
self.assertIn(invitation.email, email.to)
def inline_formset_data(self):
verbose_name = self.opts.verbose_name
return json.dumps({
'name': '#%s' % self.formset.prefix,
'options': {
'prefix': self.formset.prefix,
'addText': ugettext('Add another %(verbose_name)s') % {
'verbose_name': capfirst(verbose_name),
},
'deleteText': ugettext('Remove'),
},
'nestedOptions': {
'sortableFieldName': getattr(self.opts, 'sortable_field_name', None),
'lookupRelated': getattr(self.opts, 'related_lookup_fields', {}),
'lookupAutocomplete': getattr(self.opts, 'autocomplete_lookup_fields', {}),
'formsetFkName': self.formset.fk.name if getattr(self.formset, 'fk', None) else '',
'nestingLevel': getattr(self.formset, 'nesting_depth', 0),
'fieldNames': {
'position': getattr(self.opts, 'sortable_field_name', None),
'pk': self.opts.opts.pk.name,
},
'inlineModel': self.inline_model_id,
'sortableOptions': self.opts.sortable_options,
},
})
def formfield(self, form_class=forms.MultipleChoiceField, **kwargs):
defaults = {
'required': False,
'label': capfirst(self.verbose_name)
}
defaults.update(kwargs)
return form_class(**defaults)
def label_tag(self):
attrs = {}
if not self.is_first:
attrs["class"] = "inline"
label = self.field["label"]
contents = capfirst(force_unicode(escape(label))) + u":"
return mark_safe("<label%(attrs)s>%(contents)s</label>" % {"attrs": flatatt(attrs), "contents": contents})
def test_accepted_notif_sender(self):
invitation = PrescriberWithOrgSentInvitationFactory()
email = invitation.email_accepted_notif_sender
# Subject
self.assertIn(capfirst(invitation.first_name), email.subject)
self.assertIn(capfirst(invitation.last_name), email.subject)
# Body
self.assertIn(capfirst(invitation.first_name), email.body)
self.assertIn(capfirst(invitation.last_name), email.body)
self.assertIn(invitation.email, email.body)
self.assertIn(invitation.organization.display_name, email.body)
# To
self.assertIn(invitation.sender.email, email.to)
def format_callback(_obj):
opts = _obj._meta
return u'{model_name}: {instance_name}'.format(
model_name=capfirst(opts.verbose_name),
instance_name=force_text(_obj)
)
def breadcrumb(self, request, context, ptypes):
return Breadcrumb(
"places",
lazy_parent("category-list"),
capfirst(context["entity_types"][0].verbose_name_plural),
lazy_reverse("category-detail", args=[ptypes]),
)
def get_metadata(self, request, scheme, value):
entity = get_entity(scheme, value)
user_location = request.session.get('geolocation:location')
distance, bearing = entity.get_distance_and_bearing_from(user_location)
additional = '<strong>%s</strong>' % capfirst(
entity.primary_type.verbose_name)
if distance:
additional += ', ' + _('about %(distance)s %(bearing)s') % {
'distance': humanise_distance(distance),
'bearing': bearing
}
routes = sorted(set(sor.route.service_id
for sor in entity.stoponroute_set.all()),
key=bus_route_sorter)
if routes:
additional += ', ' + ungettext('service %(services)s stops here',
'services %(services)s stop here',
len(routes)) % {
'services': ' '.join(routes)
}
return {
'title': entity.title,
'additional': additional,
'entity': entity,
}
def render_alert(
content,
*,
alert_type="info",
dismissible=True,
extra_classes="",
):
"""Render a Bootstrap alert."""
button = ""
if alert_type not in ALERT_TYPES:
raise ValueError(
f"Value {alert_type} is not a valid alert type. Please choose from {', '.join(ALERT_TYPES)}."
)
css_classes = [f"alert alert-{alert_type}"]
if dismissible:
css_classes.append("alert-dismissible fade show")
close = capfirst(_("close"))
button = f'<button type="button" class="btn-close" data-bs-dismiss="alert" aria-label="{close}"></button>'
css_classes = merge_css_classes(*css_classes, extra_classes)
return render_tag(
"div",
attrs={
"class": css_classes,
"role": "alert"
},
content=format_html("{content}" + button, content=content),
)
def render(self, name, value, attrs=None):
output = []
# TODO: convert to navigation app
if value['links']:
output.append(u'<div class="group navform wat-cf">')
for link in value['links']:
output.append(
u'''
<button class="button" type="submit" name="action" value="%(action)s">
<span class="famfam active famfam-%(famfam)s"></span>%(text)s
</button>
''' % {
'famfam':
link.get('famfam', u'link'),
'text':
capfirst(link['text']),
'action':
reverse(link.get('view'),
args=[
value['current_document'].pk,
value['smart_link_instance'].pk
])
})
output.append(u'</div>')
output.append(u'<div style="white-space:nowrap; overflow: auto;">')
for document in value['documents']:
output.append(
u'<div style="display: inline-block; margin: 0px 10px 10px 10px; %s">'
% (u'border: 5px solid black; padding: 3px;'
if value['current_document'] == document else u''))
output.append(u'<div class="tc">%s</div>' % document)
output.append(u'<div class="tc">%s: %d</div>' %
(ugettext(u'Pages'), document.pages.count()))
output.append(get_tags_inline_widget(document))
output.append(u'<div style="padding: 5px;">' % document)
output.append(
document_html_widget(
document,
click_view='document_display',
view='document_preview_multipage',
fancybox_class='fancybox-noscaling',
gallery_name=u'smart_link_%d_documents_gallery' %
value['smart_link_instance'].pk))
output.append(u'</div>')
output.append(u'<div class="tc">')
output.append(
u'<a href="%s"><span class="famfam active famfam-page_go"></span>%s</a>'
% (reverse('document_view_simple',
args=[document.pk]), ugettext(u'Select')))
output.append(u'</div>')
output.append(u'</div>')
output.append(u'</div>')
output.append(
u'<br /><span class="famfam active famfam-magnifier"></span>%s' %
ugettext(
u'Click on the image for full size view of the first page.'))
return mark_safe(u''.join(output))
def get_metadata(self, request, ptypes, entity=None):
context = NearbyDetailView.initial_context(self, request, ptypes,
entity)
if len(context['entity_types']) == 0:
return {
'exclude_from_search': True,
'title': _('Things near %(title)s') % {
'title': entity.title
}
}
et_name = capfirst(context['entity_types'][0].verbose_name_plural)
if entity is not None:
title = _('%(entity_type)s near %(entity)s') % {
'entity_type': et_name,
'title': entity.title
}
else:
title = _('%(et)s nearby') % {'et': et_name}
if len(context['entity_types']) > 1:
return {'exclude_from_search': True, 'title': title}
number = len([
e for e in context['entities']
if haversine(e.location, context['point']) <= 1000
])
entity_type = context['entity_types'][0].verbose_name_plural
return {
'title': title,
'additional': _('<strong>%(number)d %(entity_type)s</strong> within 1km') \
% {'number': number, 'entity_type': entity_type}
}
def get_metadata(self, request, ptypes, entity=None):
context = NearbyDetailView.initial_context(self, request, ptypes, entity)
if len(context["entity_types"]) == 0:
return {"exclude_from_search": True, "title": _("Things near %(title)s") % {"title": entity.title}}
et_name = capfirst(context["entity_types"][0].verbose_name_plural)
if entity is not None:
title = _("%(entity_type)s near %(entity)s") % {"entity_type": et_name, "title": entity.title}
else:
title = _("%(et)s nearby") % {"et": et_name}
if len(context["entity_types"]) > 1:
return {"exclude_from_search": True, "title": title}
number = len(
[
e
for e in context["entities"]
if e.location.transform(27700, clone=True).distance(context["point"].transform(27700, clone=True))
<= 1000
]
)
entity_type = context["entity_types"][0].verbose_name_plural
return {
"title": title,
"additional": _("<strong>%(number)d %(entity_type)s</strong> within 1km")
% {"number": number, "entity_type": entity_type},
}
def link_tag(context,
named_url,
label=None,
nav=False,
next='',
classes='',
wrapper_classes='',
badge=False,
badge_val=''):
request = context['request']
if next == '' and named_url in ['login', 'signup']:
if 'next' in request.GET:
next = request.GET['next']
else:
next = request.path
if next == reverse('login') or next == reverse('signup'):
next = ''
else:
next = '?next=' + next
if not label:
label = named_url.replace('_', ' ')
label = format_title(label) if nav else capfirst(label)
url = reverse(named_url)
wrapper_classes += ' active' if nav and request.path == url else ''
return {
'nav': nav,
'href': url + next,
'label': label,
'classes': classes,
'wrapper_classes': wrapper_classes,
'badge': badge,
'badge_val': badge_val,
}
def link_tag(context, named_url, title=None, nav=False, next='', classes='', wrapper_classes='', balance=False):
request = context['request']
if next == '' and named_url in ['login', 'signup']:
if 'next' in request.GET:
next = request.GET['next']
else:
next = request.path
if next == reverse('login') or next == reverse('signup'):
next = ''
else:
next = '?next=' + next
if not title:
title = named_url.replace('_', ' ')
title = format_title(title) if nav else capfirst(title)
url = reverse(named_url)
wrapper_classes += ' active' if nav and request.path == url else ''
return {
'nav': nav,
'href': url + next,
'title': title,
'classes': classes,
'wrapper_classes': wrapper_classes,
'balance': request.user.profile.balance if balance else None,
}
def label_tag(self):
attrs = {}
if not self.is_first:
attrs["class"] = "inline"
label = self.field['label']
return format_html('<label{}>{}{}</label>', flatatt(attrs),
capfirst(label), self.form.label_suffix)
def breadcrumb(self, request, context, ptypes):
return Breadcrumb(
'places',
lazy_parent('category-list'),
capfirst(context['entity_types'][0].verbose_name_plural),
lazy_reverse('category-detail', args=[ptypes]),
)
def get_metadata(self, request, ptypes):
context = CategoryDetailView.initial_context(self, request, ptypes)
if len(context['entity_types']) > 1:
return {
'exclude_from_search':True,
'title': 'All %s near%s%s' % capfirst(context['entity_types'][0].verbose_name_plural),
}
return {
'title': 'All %s near%s%s' % capfirst(context['entity_types'][0].verbose_name_plural),
'additional': '<strong>%d %s</strong>' % (
len(context['entities']),
context['entity_types'][0].verbose_name_plural,
),
}
def test_accepted_notif_sender(self):
invitation = SentSiaeStaffInvitationFactory()
email = invitation.email_accepted_notif_sender
# Subject
self.assertIn(capfirst(invitation.first_name), email.subject)
self.assertIn(capfirst(invitation.last_name), email.subject)
# Body
self.assertIn(capfirst(invitation.first_name), email.body)
self.assertIn(capfirst(invitation.last_name), email.body)
self.assertIn(invitation.email, email.body)
self.assertIn(invitation.siae.display_name, email.body)
# To
self.assertIn(invitation.sender.email, email.to)
def wrapper(self, obj):
attr = getattr(obj, attr_name)
if attr:
return '<a href="%s" target="_blank">%s</a>' % (
attr.url, capfirst(_('link')),)
else:
return '<span>---</span>'
def test_send_invitation(self):
invitation = SentSiaeStaffInvitationFactory()
email = invitation.email_invitation
# Subject
self.assertIn(invitation.sender.get_full_name().title(), email.subject)
# Body
self.assertIn(capfirst(invitation.first_name), email.body)
self.assertIn(capfirst(invitation.last_name), email.body)
self.assertIn(invitation.acceptance_link, email.body)
self.assertIn(str(timezone.localdate(invitation.expiration_date).day), email.body)
# To
self.assertIn(invitation.email, email.to)
def get_row_data(self):
for inst in self.context['usage'].get_instances():
yield (inst['name'], inst['vcpus'], inst['memory_mb'],
inst['local_gb'], floatformat(inst['hours'],
2), inst['uptime'],
capfirst(inst['state']))
def label_tag(self):
"""Return the HTML for a label tag for this field.
This will create a ``<label class="rb-c-form-field_label">`` element
containing the label.
Returns:
django.utils.safestring.SafeText:
The ``<label>`` tag for this field.
"""
field = self.field
attrs = {}
classes = ['rb-c-form-field__label']
if not self.is_first:
classes.append('-is-inline')
attrs['class'] = ' '.join(classes)
if self.is_readonly:
return format_html('<label{0}>{1}:</label>', flatatt(attrs),
capfirst(force_text(field['label'])))
else:
if self.has_field_first:
label_suffix = ''
else:
label_suffix = None
return field.label_tag(contents=conditional_escape(
force_text(field.label)),
attrs=attrs,
label_suffix=label_suffix)
def lookups(self, request, model):
lookups = []
content_types = ContentType.objects.get_for_models(*get_registered_content())
for key, value in six.iteritems(content_types):
lookups.append((value.id, capfirst(key._meta.verbose_name)))
lookups.sort(key=lambda item: item[1])
return lookups
def page_view(request, page_id=None, slug=None, preview=True):
#check_permissions(request.user, [PERMISSION_USER_EDIT])
if page_id:
page = get_object_or_404(Page, pk=page_id)
elif slug:
page = get_object_or_404(Page, slug=capfirst(slug))
else:
raise Http404
context = {
'template_id': u'crud_view',
'title': page.title,
'content': page.render(),
}
if not preview:
context['template_id'] = u'cms_render'
if preview:
context.update({
'object': page,
'object_name': _(u'CMS page'),
})
return render_to_response('generic_template.html', context,
context_instance=RequestContext(request))
def save(self, old_record, list_record, detail_record):
if old_record is not None:
self.logger.debug('Record already exists')
return
division = self.get_or_create_lookup('division', list_record['division'], list_record['division'])
event = self.get_or_create_lookup('event', list_record['event'], list_record['event'])
disposition = self.get_or_create_lookup('disposition', list_record['disposition'], list_record['disposition'])
category_name = CATEGORIES[event.code.upper().strip()]
category = self.get_or_create_lookup('category', capfirst(category_name.lower()), category_name)
attributes = {
'raw_address': list_record['address'],
'division': division.id,
'disposition': disposition.id,
'event': event.id,
'event_time': list_record['item_time'],
'category': category.id
}
self.create_newsitem(
attributes,
title=event.name,
item_date=list_record['item_date'],
location_name=list_record['address'],
)
def env_info_counters(self, request, export=False):
app_dict = {}
for model, model_admin in self._registry.items():
app_label = model._meta.app_label
info = (self.name, app_label, model._meta.module_name)
model_dict = {
'name': capfirst(model._meta.verbose_name_plural),
'perms': model_admin.get_model_perms(request),
'admin_url': self.reverse_admin(model),
'row_count': model.objects.count(),
}
if app_label in app_dict:
app_dict[app_label]['models'].append(model_dict)
else:
app_dict[app_label] = {
'name': app_label.title(),
'models': [model_dict],
}
# Sort the apps alphabetically.
app_list = app_dict.values()
app_list.sort(key=lambda x: x['name'])
# Sort the models alphabetically within each app.
for app in app_list:
app['models'].sort(key=lambda x: x['name'])
context = self.get_context(**{
'title': _('Site administration'),
'app_list': app_list,
'STATIC_URL': settings.STATIC_URL,
})
return render_to_response(('%s/env_info_counters.html' % self.template_prefix,
'iadmin/env_info_counters.html'), context)
def label_tag(self):
attrs = {}
if not self.is_first:
attrs["class"] = "inline"
label = self.field["label"]
return format_html("<label{}>{}:</label>", flatatt(attrs),
capfirst(label))
def lookups(self, request, model_admin):
lookups = []
content_types = ContentType.objects.get_for_models(*get_registered_content())
for key, value in content_types.items():
lookups.append((value.id, capfirst(key._meta.verbose_name)))
lookups.sort(key=lambda item: item[1])
return lookups
def link_tag(context, named_url, label=None, nav=False, next='', classes='', wrapper_classes='', badge=False,
badge_val=''):
request = context['request']
if next == '' and named_url in ['login', 'signup']:
if 'next' in request.GET:
next = request.GET['next']
else:
next = request.path
if next == reverse('login') or next == reverse('signup'):
next = ''
else:
next = '?next=' + next
if not label:
label = named_url.replace('_', ' ')
label = format_title(label) if nav else capfirst(label)
url = reverse(named_url)
wrapper_classes += ' active' if nav and request.path == url else ''
return {
'nav': nav,
'href': url + next,
'label': label,
'classes': classes,
'wrapper_classes': wrapper_classes,
'badge': badge,
'badge_val': badge_val,
}
def create_permission_structure(permission_structure, deny, type):
if deny:
key = 'deny_'
title = 'Deny '
else:
key = 'accept_'
title = 'Accept '
key += type
title += type
permission_structure.types[key] = {}
permission_structure.types[key]['type'] = key
permission_structure.types[key]['title'] = _(title)
permission_structure.types[key]['label'] = _(capfirst(type))
permission_structure.types[key]['permissions'] = {}
if type == 'user':
permissions = UserPermission.objects.filter(
content_type=content_type, object_id=object_id, deny=deny)
else:
permissions = GroupPermission.objects.filter(
content_type=content_type, object_id=object_id, deny=deny)
for permission in permissions:
if type == 'user':
id = permission.user.id
else:
id = permission.group.id
if id in permission_structure.types[key]['permissions']:
permission_structure.types[key]['permissions'][
id].add_permission(permission)
else:
permission_structure.types[key]['permissions'][
id] = Permission(permission,
permission_structure.permission_id)
permission_structure.permission_id += 1
def render_widget(request, link):
context = RequestContext(request)
request = Variable('request').resolve(context)
current_path = request.META['PATH_INFO']
current_view = resolve_to_name(current_path)
query_string = urlparse.urlparse(
request.get_full_path()).query or urlparse.urlparse(
request.META.get('HTTP_REFERER', u'/')).query
parsed_query_string = urlparse.parse_qs(query_string)
links = resolve_links(context, [link], current_view, current_path,
parsed_query_string)
if links:
link = links[0]
return mark_safe(
u'<a style="text-decoration:none; margin-right: 10px;" href="%(url)s"><button style="vertical-align: top; padding: 1px; width: 110px; height: 100px; margin: 10px;"><img src="%(static_url)simages/icons/%(icon)s" alt="%(image_alt)s" /><p style="margin: 0px 0px 0px 0px;">%(string)s</p></button></a>'
% {
'url':
reverse(link['view']) if 'view' in link else link['url'],
'icon': link.get('icon', 'link_button.png'),
'static_url': settings.STATIC_URL,
'string': capfirst(link['text']),
'image_alt': _(u'icon'),
})
else:
return u''
def _event_notification(receiver, event, verb):
if type(receiver) is not list:
receiver = [receiver]
# prepare the subject
subject = capfirst(_('your event has been {verb}').format(verb=_(verb)))
# prepare the messages
context = {
'host': event.host,
'event': event,
}
txt_message = render_to_string(
'eventary/email/event_{verb}.txt'.format(verb=verb),
context,
)
html_message = render_to_string(
'eventary/email/event_{verb}.html'.format(verb=verb),
context,
)
# send the email
send_mail(subject,
txt_message,
settings.DEFAULT_FROM_EMAIL,
receiver,
html_message=html_message)
def breadcrumb(self, request, context, ptypes):
return Breadcrumb(
'places',
lazy_parent('category-list'),
capfirst(context['entity_types'][0].verbose_name_plural),
lazy_reverse('category-detail', args=[ptypes]),
)
def label_tag(self):
attrs = {}
if not self.is_first:
attrs["class"] = "inline"
label = self.field['label']
return format_html('<label{}>{}:</label>', flatatt(attrs),
capfirst(force_text(label)))
def create_permission_structure(permission_structure, deny, type):
if deny:
key = 'deny_'
title = 'Deny '
else:
key = 'accept_'
title = 'Accept '
key += type
title += type
permission_structure.types[key] = {}
permission_structure.types[key]['type'] = key
permission_structure.types[key]['title'] = _(title)
permission_structure.types[key]['label'] = _(capfirst(type))
permission_structure.types[key]['permissions'] = {}
if type == 'user':
permissions = UserPermission.objects.filter(content_type=content_type, object_id=object_id, deny=deny)
else:
permissions = GroupPermission.objects.filter(content_type=content_type, object_id=object_id, deny=deny)
for permission in permissions:
if type == 'user':
id = permission.user.id
else:
id = permission.group.id
if id in permission_structure.types[key]['permissions']:
permission_structure.types[key]['permissions'][id].add_permission(permission)
else:
permission_structure.types[key]['permissions'][id] = Permission(permission, permission_structure.permission_id)
permission_structure.permission_id += 1
def get_metadata(self, request, ptypes, entity=None):
context = NearbyDetailView.initial_context(self, request, ptypes, entity)
if len(context['entity_types']) == 0:
return {
'exclude_from_search': True,
'title': _('Things near %(title)s') % {'title': entity.title}
}
et_name = capfirst(context['entity_types'][0].verbose_name_plural)
if entity is not None:
title = _('%(entity_type)s near %(entity)s') % {
'entity_type':et_name,
'title': entity.title
}
else:
title = u'附近的%(et)s' % {'et': et_name}
if len(context['entity_types']) > 1:
return {
'exclude_from_search': True,
'title': title}
number = len([e for e in context['entities'] if e.location.transform(3857, clone=True).distance(context['point'].transform(3857, clone=True)) <= 1000])
entity_type = context['entity_types'][0].verbose_name_plural
return {
'title': title,
'additional': _('<strong>%(number)d %(entity_type)s</strong> within 1km') % {'number': number,
'entity_type': entity_type}
}
def timberjack_history_view(self, request, object_pk):
model = self.model
instance = self.get_object(request, unquote(object_pk))
if instance is None:
raise Http404(_('%(name)s object with primary key %(key)r does not exist.') % {
'name': force_text(model._meta.verbose_name),
'key': escape(object_pk),
})
if not self.has_change_permission(request, instance):
raise PermissionDenied
ctype = get_content_type_for_model(model)
action_list = ObjectAccessLog.objects.filter(
object_pk=instance.pk,
content_type__fields__model=ctype.model,
content_type__fields__app_label=ctype.app_label
).order_by('-timestamp')[:self.timberjack_max_history_items] # TODO: Create a proper pagination for results!
context = dict(
self.admin_site.each_context(request),
title=_('Access history: %s') % force_text(instance),
action_list=action_list,
opts=model._meta,
module_name=capfirst(force_text(model._meta.verbose_name_plural)),
object=instance,
preserved_filters=self.get_preserved_filters(request)
)
return TemplateResponse(request, self.timberjack_history_template, context=context)
def order_by_tag(context,
order,
field,
verbose_name=None,
key='order',
page_field='page'):
verbose_name = verbose_name or capfirst(field)
order_display = ''
order_field = '-%s' % field
if order:
if order[0] == '-':
order = order[1:]
desc = True
else:
desc = False
if order == field:
order_display = u' ↓' if desc else u' ↑'
if desc:
order_field = field
request = context.get('request')
get_vars = request.GET.copy() if request else {}
get_vars[key] = order_field
get_vars.pop(page_field, None)
return mark_safe('<a href="?%s">%s</a>%s' %
(get_vars.urlencode(), verbose_name, order_display))
def inline_formset_data(self):
verbose_name = self.opts.verbose_name
return json.dumps({
'name': '#%s' % self.formset.prefix,
'options': {
'prefix': self.formset.prefix,
'addText': ugettext('Add another %(verbose_name)s') % {
'verbose_name': capfirst(verbose_name),
},
'deleteText': ugettext('Remove'),
},
'nestedOptions': {
'sortableFieldName':
getattr(self.opts, 'sortable_field_name', None),
'lookupRelated':
getattr(self.opts, 'related_lookup_fields', {}),
'lookupAutocomplete':
getattr(self.opts, 'autocomplete_lookup_fields', {}),
'formsetFkName':
self.formset.fk.name
if getattr(self.formset, 'fk', None) else '',
'nestingLevel':
getattr(self.formset, 'nesting_depth', 0),
'fieldNames': {
'position': getattr(self.opts, 'sortable_field_name',
None),
'pk': self.opts.opts.pk.name,
},
'inlineModel':
self.inline_model_id,
'sortableOptions':
self.opts.sortable_options,
},
})
def admin_apps(context):
app_dict = {}
user = context.get('user')
for model, model_admin in site._registry.items():
app_label = model._meta.app_label
has_module_perms = user.has_module_perms(app_label)
if has_module_perms:
perms = model_admin.get_model_perms(context.get('request'))
if True in perms.values():
info = (app_label, model._meta.model_name)
model_dict = {
'name': capfirst(model._meta.verbose_name_plural),
'object_name': model._meta.object_name,
'perms': perms,
}
if perms.get('change', False):
try:
model_dict['admin_url'] = reverse(
'admin:%s_%s_changelist' % info,
current_app=site.name)
except NoReverseMatch:
pass
if perms.get('add', False):
try:
model_dict['add_url'] = reverse('admin:%s_%s_add' %
info,
current_app=site.name)
except NoReverseMatch:
pass
if app_label in app_dict:
app_dict[app_label]['models'].append(model_dict)
else:
app_config = apps.get_app_config(app_label)
icon = 'fa fa-circle'
if hasattr(app_config, 'icon'):
icon = app_config.icon
app_dict[app_label] = {
'name':
app_config.verbose_name,
'app_label':
app_label,
'icon':
icon,
'app_url':
reverse('admin:app_list',
kwargs={'app_label': app_label},
current_app=site.name),
'has_module_perms':
has_module_perms,
'models': [model_dict],
}
app_list = list(six.itervalues(app_dict))
app_list.sort(key=lambda x: x['name'].lower())
for app in app_list:
app['models'].sort(key=lambda x: x['name'])
return {'app_list': app_list}
def obj_to_dict(obj):
"""
A helper that changes various types of content into a unified format,
that will help us show them in templates. Works as a simple serializer.
*deprecated* - it's much better to use activities app.
"""
content_type = ContentType.objects.get_for_model(obj)
context = {
"type": content_type.model,
"name": capfirst(_(content_type.model)),
"slug": obj.slug,
"ct": content_type.pk,
"pk": obj.pk,
"url": obj.get_absolute_url(),
"title": obj.__unicode__(),
"image": obj.image_url,
"thumbnail": obj.thumbnail,
"retina_thumbnail": False,
"location": obj.location.__unicode__(),
"meta": {},
"date_created": obj.date_created.isoformat(),
"creator": {
"id": obj.creator.pk,
"url": obj.creator.profile.get_absolute_url(),
"img": obj.creator.profile.avatar.url,
"name": obj.creator.get_full_name(),
},
}
if hasattr(obj, "category") and obj.category is not None and obj.category.pk:
context.update({"category": {"pk": obj.category.pk, "name": obj.category.__unicode__()}})
if hasattr(obj, "retina_thumbnail") and not obj.has_default_image:
context["retina_thumbnail"] = obj.retina_thumbnail
if hasattr(obj, "has_default_image"):
context["default_image"] = obj.has_default_image
if content_type.model == "idea":
context.update({"description": obj.description, "meta": {"votes": obj.get_votes()}})
elif content_type.model == "poll":
context.update({"description": obj.question})
elif content_type.model == "news":
context.update({"description": obj.content})
elif content_type.model == "discussion":
context.update({"description": obj.intro, "meta": {"answers": obj.entry_set.count()}})
elif content_type.model == "socialproject":
context["description"] = obj.get_description()
context["name"] = _("Project")
else:
raise Exception(_("Wrong model instance"))
context["description"] = truncatewords_html(context["description"], 15)
return context
def get_metadata(self, request, scheme, value):
entity = get_entity(scheme, value)
user_location = request.session.get("geolocation:location")
distance, bearing = entity.get_distance_and_bearing_from(user_location)
additional = "<strong>%s</strong>" % capfirst(entity.primary_type.verbose_name)
if distance:
additional += ", approximately %.3fkm %s" % (distance / 1000, bearing)
return {"title": entity.title, "additional": additional}
def find_model_index(name):
count = 0
for model, model_admin in admin.site._registry.items():
if capfirst(model._meta.verbose_name_plural) == name:
return count
else:
count += 1
return count
def label_tag(self):
attrs = {}
if not self.is_first:
attrs["class"] = "inline"
label = self.field['label']
return format_html('<label{}>{}:</label>',
flatatt(attrs),
capfirst(force_text(label)))
def breadcrumb(self, request, context, scheme, value, ptype):
entity_type = get_object_or_404(EntityType, slug=ptype)
return Breadcrumb(
"places",
lazy_parent("entity-nearby-list", scheme=scheme, value=value),
"%s near %s" % (capfirst(entity_type.verbose_name_plural), context["entity"].title),
lazy_reverse("places:entity_nearby_detail", args=[scheme, value, ptype]),
)
def render_widget(link):
return mark_safe(u'<a style="text-decoration:none; margin-right: 10px;" href="%(url)s"><button style="vertical-align: top; padding: 1px; width: 110px; height: 100px; margin: 10px;"><img src="%(static_url)simages/icons/%(icon)s" alt="%(image_alt)s" /><p style="margin: 0px 0px 0px 0px;">%(string)s</p></button></a>' % {
'url': reverse(link['view']) if 'view' in link else link['url'],
'icon': link.get('icon', 'link_button.png'),
'static_url': settings.STATIC_URL,
'string': capfirst(link['text']),
'image_alt': _(u'icon'),
})
def breadcrumb(self, request, context, scheme, value, ptype):
entity_type = get_object_or_404(EntityType, slug=ptype)
return Breadcrumb(
'places',
lazy_parent('entity-nearby-list', scheme=scheme, value=value),
u'在%s附近的%s' % (
context['entity'].title, capfirst(entity_type.verbose_name_plural),),
lazy_reverse('places:entity_nearby_detail', args=[scheme, value, ptype]))
