def field_view(self, request, field, value=None):
easy_model = EasyModel(self.site, self.model)
easy_field = easy_model.field(field.name)
if value is not None:
obj_list = easy_model.objects(**{field.name: value})
return render_to_response(
'databrowse/fieldchoice_detail.html', {
'root_url': self.site.root_url,
'model': easy_model,
'field': easy_field,
'value': value,
'object_list': obj_list
})
obj_list = [
v[field.name]
for v in self.model._default_manager.distinct().order_by(
field.name).values(field.name)
]
return render_to_response(
'databrowse/fieldchoice_list.html', {
'root_url': self.site.root_url,
'model': easy_model,
'field': easy_field,
'object_list': obj_list
})
def auth_processor_no_attr_access(request):
r1 = render_to_response(
'context_processors/auth_attrs_no_access.html',
RequestContext(request, {}, processors=[context_processors.auth]))
# *After* rendering, we check whether the session was accessed
return render_to_response('context_processors/auth_attrs_test_access.html',
{'session_accessed': request.session.accessed})
def preview_post(self, request):
"Validates the POST data. If valid, displays the preview page. Else, redisplays form."
f = self.form(request.POST, auto_id=self.get_auto_id())
context = self.get_context(request, f)
if f.is_valid():
self.process_preview(request, f, context)
context['hash_field'] = self.unused_name('hash')
context['hash_value'] = self.security_hash(request, f)
return render_to_response(self.preview_template, context, context_instance=RequestContext(request))
else:
return render_to_response(self.form_template, context, context_instance=RequestContext(request))
def flag(request, comment_id, next=None):
"""
Flags a comment. Confirmation on GET, action on POST.
Templates: `comments/flag.html`,
Context:
comment
the flagged `comments.comment` object
"""
comment = get_object_or_404(comments.get_model(),
pk=comment_id,
site__pk=settings.SITE_ID)
# Flag on POST
if request.method == 'POST':
perform_flag(request, comment)
return next_redirect(request.POST.copy(),
next,
flag_done,
c=comment.pk)
# Render a form on GET
else:
return render_to_response('comments/flag.html', {
'comment': comment,
"next": next
}, template.RequestContext(request))
def delete(request, comment_id, next=None):
"""
Deletes a comment. Confirmation on GET, action on POST. Requires the "can
moderate comments" permission.
Templates: `comments/delete.html`,
Context:
comment
the flagged `comments.comment` object
"""
comment = get_object_or_404(comments.get_model(),
pk=comment_id,
site__pk=settings.SITE_ID)
# Delete on POST
if request.method == 'POST':
# Flag the comment as deleted instead of actually deleting it.
perform_delete(request, comment)
return next_redirect(request.POST.copy(),
next,
delete_done,
c=comment.pk)
# Render a form on GET
else:
return render_to_response('comments/delete.html', {
'comment': comment,
"next": next
}, template.RequestContext(request))
def view_index(request):
if not utils.docutils_is_available:
return missing_docutils_page(request)
if settings.ADMIN_FOR:
settings_modules = [import_module(m) for m in settings.ADMIN_FOR]
else:
settings_modules = [settings]
views = []
for settings_mod in settings_modules:
urlconf = import_module(settings_mod.ROOT_URLCONF)
view_functions = extract_views_from_urlpatterns(urlconf.urlpatterns)
if Site._meta.installed:
site_obj = Site.objects.get(pk=settings_mod.SITE_ID)
else:
site_obj = GenericSite()
for (func, regex) in view_functions:
views.append({
'full_name': '%s.%s' % (func.__module__, getattr(func, '__name__', func.__class__.__name__)),
'site_id': settings_mod.SITE_ID,
'site': site_obj,
'url': simplify_regex(regex),
})
return render_to_response('admin_doc/view_index.html', {
'root_path': urlresolvers.reverse('admin:index'),
'views': views
}, context_instance=RequestContext(request))
def template_filter_index(request):
if not utils.docutils_is_available:
return missing_docutils_page(request)
load_all_installed_template_libraries()
filters = []
app_libs = template.libraries.items()
builtin_libs = [(None, lib) for lib in template.builtins]
for module_name, library in builtin_libs + app_libs:
for filter_name, filter_func in library.filters.items():
title, body, metadata = utils.parse_docstring(filter_func.__doc__)
if title:
title = utils.parse_rst(title, 'filter', _('filter:') + filter_name)
if body:
body = utils.parse_rst(body, 'filter', _('filter:') + filter_name)
for key in metadata:
metadata[key] = utils.parse_rst(metadata[key], 'filter', _('filter:') + filter_name)
if library in template.builtins:
tag_library = None
else:
tag_library = module_name.split('.')[-1]
filters.append({
'name': filter_name,
'title': title,
'body': body,
'meta': metadata,
'library': tag_library,
})
return render_to_response('admin_doc/template_filter_index.html', {
'root_path': urlresolvers.reverse('admin:index'),
'filters': filters
}, context_instance=RequestContext(request))
def approve(request, comment_id, next=None):
"""
Approve a comment (that is, mark it as public and non-removed). Confirmation
on GET, action on POST. Requires the "can moderate comments" permission.
Templates: `comments/approve.html`,
Context:
comment
the `comments.comment` object for approval
"""
comment = get_object_or_404(comments.get_model(),
pk=comment_id,
site__pk=settings.SITE_ID)
# Delete on POST
if request.method == 'POST':
# Flag the comment as approved.
perform_approve(request, comment)
return next_redirect(request.POST.copy(),
next,
approve_done,
c=comment.pk)
# Render a form on GET
else:
return render_to_response('comments/approve.html', {
'comment': comment,
"next": next
}, template.RequestContext(request))
def model_index(request):
if not utils.docutils_is_available:
return missing_docutils_page(request)
m_list = [m._meta for m in models.get_models()]
return render_to_response('admin_doc/model_index.html', {
'root_path': urlresolvers.reverse('admin:index'),
'models': m_list
}, context_instance=RequestContext(request))
def __search(request, repo):
"""
search in a repository
``repo``
the repository
"""
if 'q' in request.GET:
q = request.GET.get('q')
else:
q = None
results = []
if q is not None:
max = repo.get_context().rev
end = max - global_settings.DJANGO_HG_MAX_SEARCH_RESULTS
c = max
while c > end:
ctx = repo.get_context().repository[c]
files = []
for f in ctx.files():
if f.lower().find(q.lower()) > -1:
files.append(f)
if (codecs.decode(ctx.description(), 'utf8').lower().find(
q.lower()) > -1 or (codecs.decode(
ctx.user(), 'utf8').lower().find(q.lower()) > -1)
or (str(ctx).find(q) > -1) or (len(files) > 0)):
results.append({
"user":
ctx.user(),
"description":
ctx.description(),
"time":
datetime.fromtimestamp(ctx.date()[0]).time(),
"date":
date.fromtimestamp(ctx.date()[0]),
"files_count":
len(ctx.files()),
"files":
files,
"hash":
str(ctx),
"rev":
c,
})
c = c - 1
if c < 0:
break
return render_to_response('django_hg/search.html', {
'max': global_settings.DJANGO_HG_MAX_SEARCH_RESULTS,
'q': q,
'repo': repo,
'results': results,
'rev': 'tip',
'groups': _get_left_side_cont(),
},
context_instance=RequestContext(request))
def homepage_view(self, request):
easy_model = EasyModel(self.site, self.model)
field_list = self.fields.values()
field_list.sort(key=lambda k: k.verbose_name)
return render_to_response(
'databrowse/calendar_homepage.html', {
'root_url': self.site.root_url,
'model': easy_model,
'field_list': field_list
})
def __changesets(request, repo):
"""
display the changesets history of a repository
"""
max = repo.get_context().rev
page = int(request.GET.get('page', 1))
# forbid a page to be greater than the max or to be lower than one
if page > max / global_settings.DJANGO_HG_PAGER_ITEMS:
page = max / global_settings.DJANGO_HG_PAGER_ITEMS + 1
elif page < 1:
page = 1
start = max - (page - 1) * global_settings.DJANGO_HG_PAGER_ITEMS
end = max - (page) * global_settings.DJANGO_HG_PAGER_ITEMS
changelog = []
c = start
while c > end:
try:
ctx = repo.get_context().repository[c]
# we pass a dict instead of the object because it's really, really
# faster (from 12500 to 48 ms with the django repository ! )
changelog.append({
"user":
ctx.user(),
"description":
ctx.description(),
"time":
datetime.fromtimestamp(ctx.date()[0]).time(),
"date":
date.fromtimestamp(ctx.date()[0]),
"files_count":
len(ctx.files()),
"hash":
ctx,
"rev":
c,
})
except:
pass
c = c - 1
if c < 0:
break
return render_to_response('django_hg/changesets.html', {
'changelog': changelog,
'end': end > 0 and end + 1 or 1,
'items_per_page': global_settings.DJANGO_HG_PAGER_ITEMS,
'max': max,
'page': page,
'repo': repo,
'start': start,
'groups': _get_left_side_cont(),
},
context_instance=RequestContext(request))
def __log(request, repo, rev, path):
"""
display the file log
``repo``
the repository
``rev``
the revision in the changesets history
``path``
the file for which we want the log
"""
ctx = repo.get_context().repository[rev]
fctx = ctx.filectx(path)
filelog = []
for fl in fctx.filelog():
l = fctx.filectx(fl)
filelog.append({
'user': l.user(),
"time": datetime.fromtimestamp(l.date()[0]).time(),
"date": date.fromtimestamp(l.date()[0]),
'description': l.description(),
'branch': l.branch(),
'hash': str(l)[str(l).rfind('@') + 1:],
'filesize': l.size(),
'rev': l.rev(),
'files_count': len(ctx.files())
})
filelog.reverse()
from_rev = request.GET.get('from_rev', '')
to_rev = request.GET.get('to_rev', '')
form = HgDiffForm(filelog, {'from_rev': from_rev, 'to_rev': to_rev})
if '' != from_rev and '' != to_rev and form.is_valid():
return HttpResponseRedirect(
reverse('hg-repo-action-rev-path',
kwargs={
'name': repo.name,
'action': 'changesets',
'rev': from_rev,
'path': path
}) + '?from_rev=' + str(from_rev) + '&to_rev=' +
str(to_rev))
return render_to_response('django_hg/log.html', {
'file': path,
'filelog': filelog,
'form': form,
'from_rev': from_rev,
'path': path,
'repo': repo,
'rev': rev,
'to_rev': to_rev,
'groups': _get_left_side_cont(),
},
context_instance=RequestContext(request))
def model_view(self, request, model_databrowse, url):
# If the object ID wasn't provided, redirect to the model page, which is one level up.
if url is None:
return http.HttpResponseRedirect(
urlparse.urljoin(request.path, '../'))
easy_model = EasyModel(model_databrowse.site, model_databrowse.model)
obj = easy_model.object_by_pk(url)
return render_to_response('databrowse/object_detail.html', {
'object': obj,
'root_url': model_databrowse.site.root_url
})
def articles_list(request, *args, **kwargs):
if 'application/xrds+xml' in request.META.get('HTTP_ACCEPT', ''):
return render_to_response(request,
'cicero/yadis.xml', {
'return_to': absolute_url(reverse(auth)),
},
mimetype='application/xrds+xml')
kwargs['extra_context'] = {'groups': _get_left_side_cont()}
return object_list(request, *args, **kwargs)
def confirmed(request):
comment = None
if 'c' in request.GET:
try:
comment = comments.get_model().objects.get(pk=request.GET['c'])
except (ObjectDoesNotExist, ValueError):
pass
return render_to_response(template,
{'comment': comment},
context_instance=RequestContext(request)
)
def post_post(self, request):
"Validates the POST data. If valid, calls done(). Else, redisplays form."
f = self.form(request.POST, auto_id=self.get_auto_id())
if f.is_valid():
if not self._check_security_hash(request.POST.get(self.unused_name('hash'), ''),
request, f):
return self.failed_hash(request) # Security hash failed.
return self.done(request, f.cleaned_data)
else:
return render_to_response(self.form_template,
self.get_context(request, f),
context_instance=RequestContext(request))
def main_view(self, request):
easy_model = EasyModel(self.site, self.model)
html_snippets = mark_safe(u'\n'.join([
p.model_index_html(request, self.model, self.site)
for p in self.plugins.values()
]))
return render_to_response(
'databrowse/model_detail.html', {
'model': easy_model,
'root_url': self.site.root_url,
'plugin_html': html_snippets,
})
def __diff(request, repo, rev, path):
"""
display a diff of a file
``repo``
the repository
``rev``
the revision in the changesets history
``path``
the file for which we want the log
"""
ctx = repo.get_context().repository[rev]
if request.GET.get('from_rev') and request.GET.get('to_rev'):
# compare two given revs
from_rev = request.GET.get('from_rev')
to_rev = request.GET.get('to_rev')
else:
# Compare the rev given as parameter with the previous one the file has
# been changed
from_rev = rev
to_rev = rev
ctx = repo.get_context().repository[rev]
fctx = ctx.filectx(path)
for fl in fctx.filelog():
l = fctx.filectx(fl)
if fl == fctx.filerev() - 1:
from_rev = l.rev()
break
ctx = repo.get_context().repository[from_rev]
fctx = ctx.filectx(path)
data1 = fctx.data().split('\n')
ctx2 = repo.get_context().repository[to_rev]
data2 = ctx2.filectx(path).data().split('\n')
diff = difflib.unified_diff(data1,
data2,
fromfile=path + '@' + str(from_rev),
tofile=path + '@' + str(to_rev))
return render_to_response('django_hg/diff.html', {
'diff': diff,
'file': path,
'from_rev': from_rev,
'path': path,
'repo': repo,
'rev': rev,
'to_rev': to_rev,
'groups': _get_left_side_cont(),
},
context_instance=RequestContext(request))
def choice_detail(request, app_label, module_name, field_name, field_val,
models):
m, f = lookup_field(app_label, module_name, field_name, models)
try:
label = dict(f.field.choices)[field_val]
except KeyError:
raise Http404('Invalid choice value given')
obj_list = m.objects(**{f.field.name: field_val})
return render_to_response('databrowse/choice_detail.html', {
'model': m,
'field': f,
'value': label,
'object_list': obj_list
})
def search(request, slug):
forum = get_object_or_404(Forum, slug=slug)
try:
try:
from sphinxapi import SphinxClient, SPH_MATCH_EXTENDED, SPH_SORT_RELEVANCE
except ImportError:
raise SearchUnavailable()
term = request.GET.get('term', '').encode('utf-8')
if term:
sphinx = SphinxClient()
sphinx.SetServer(settings.CICERO_SPHINX_SERVER,
settings.CICERO_SPHINX_PORT)
sphinx.SetMatchMode(SPH_MATCH_EXTENDED)
sphinx.SetSortMode(SPH_SORT_RELEVANCE)
sphinx.SetFilter('gid', [forum.id])
paginator = Paginator(SphinxObjectList(sphinx, term),
settings.CICERO_PAGINATE_BY)
try:
page = paginator.page(request.GET.get('page', '1'))
except InvalidPage:
raise Http404
else:
paginator = Paginator([], 1)
page = paginator.page(1)
return render_to_response(
request, 'cicero/search.html', {
'page_id': 'search',
'forum': forum,
'term': term,
'paginator': paginator,
'page_obj': page,
'query_dict': request.GET,
})
except SearchUnavailable:
raise
return render_to_response(request, 'cicero/search_unavailable.html',
{})
def topic_to_article(request, article_id):
if not request.user.cicero_profile.moderator:
return HttpResponseForbidden('Нет прав отщеплять топики')
article = get_object_or_404(Article, pk=article_id)
if request.method == 'POST':
form = forms.ToArticleForm(article, request.POST)
if form.is_valid():
new_topic = form.save()
return HttpResponseRedirect(
reverse(topic, args=(new_topic.forum.slug, new_topic.id)))
else:
form = forms.ToArticleForm(article)
return render_to_response(request, 'cicero/topic_to_article.html', {
'form': form,
'article': article,
})
def __browse(request, repo, rev, path):
if rev == 'tip':
rev = repo.get_context().rev
files = repo.get_context().get_directory(path)
if files == False:
raise Http404
return render_to_response('django_hg/browse.html', {
'files': files,
'hash': repo.get_context().repository[rev],
'path': path,
'repo': repo,
'rev': rev,
'groups': _get_left_side_cont(),
},
context_instance=RequestContext(request))
def topic_edit(request, topic_id):
t = get_object_or_404(Topic, pk=topic_id)
if not request.user.cicero_profile.can_change_topic(t):
return HttpResponseForbidden('Нет прав редактировать топик')
if request.method == 'POST':
form = forms.TopicEditForm(request.POST, instance=t)
if form.is_valid():
form.save()
caching.invalidate_by_article(t.forum.slug, t.id)
return HttpResponseRedirect(
reverse(topic, args=[t.forum.slug, t.id]))
else:
form = forms.TopicEditForm(instance=t)
return render_to_response(request, 'cicero/topic_edit.html', {
'form': form,
'topic': t,
})
def __overview(request, repo, rev):
ctx = repo.get_context().repository[rev]
return render_to_response('django_hg/overview.html', {
'ctx': {
"user": ctx.user(),
"description": ctx.description(),
"time": datetime.fromtimestamp(ctx.date()[0]).time(),
"date": date.fromtimestamp(ctx.date()[0]),
"hash": ctx,
"rev": repo.get_context().rev,
"files_count": len(ctx.files())
},
'repo': repo,
'rev': 'tip',
'groups': _get_left_side_cont(),
},
context_instance=RequestContext(request))
def article_edit(request, id):
article = get_object_or_404(Article, pk=id)
if not request.user.cicero_profile.can_change_article(article):
return HttpResponseForbidden('Нет прав для редактирования')
if request.method == 'POST':
form = forms.ArticleEditForm(request.POST, instance=article)
if form.is_valid():
form.save()
caching.invalidate_by_article(article.topic.forum.slug,
article.topic.id)
url = '%s#%s' % (reverse(
topic,
args=(article.topic.forum.slug, article.topic.id)), article.id)
return HttpResponseRedirect(url)
else:
form = forms.ArticleEditForm(instance=article)
return render_to_response(request, 'cicero/article_edit.html', {
'form': form,
'article': article,
})
def _process_new_article(request, article, is_new_topic, check_login):
#spam_status = antispam.conveyor.validate(request, article=article)
# Detected spam is deleted independant on check_login because
# an OpenID server may not return from a check and the spam will hang forever
#if spam_status == 'spam':
# forum = article.topic.forum
# article.delete()
# return render_to_response(request, 'cicero/spam.html', {
# 'forum': forum,
# 'text': article.text,
# 'admins': [e for n, e in settings.ADMINS],
# })
spam_status = 'clean'
if check_login and not request.user.is_authenticated():
form = AuthenticationForm(request,
{'openid_identity': request.POST['name']})
#form = AuthForm(request.session, {'openid_identity': request.POST['name']})
if form.is_valid():
article.set_spam_status(spam_status)
url = form.auth_redirect(post_redirect(request),
data={
'op': 'login',
'acquire': str(article.pk)
})
return HttpResponseRedirect(url)
if spam_status == 'clean':
slug = article.topic.forum.slug
_publish_article(slug, article)
url = reverse(topic, args=[slug, article.topic_id])
if not is_new_topic:
url += '?page=last'
url += '#%s' % article.id
return HttpResponseRedirect(url)
# Любой не-clean и не-spam статус -- разного рода подозрения
article.set_spam_status(spam_status)
return render_to_response(request, 'cicero/spam_suspect.html', {
'article': article,
})
def view_detail(request, view):
if not utils.docutils_is_available:
return missing_docutils_page(request)
mod, func = urlresolvers.get_mod_func(view)
try:
view_func = getattr(import_module(mod), func)
except (ImportError, AttributeError):
raise Http404
title, body, metadata = utils.parse_docstring(view_func.__doc__)
if title:
title = utils.parse_rst(title, 'view', _('view:') + view)
if body:
body = utils.parse_rst(body, 'view', _('view:') + view)
for key in metadata:
metadata[key] = utils.parse_rst(metadata[key], 'model', _('view:') + view)
return render_to_response('admin_doc/view_detail.html', {
'root_path': urlresolvers.reverse('admin:index'),
'name': view,
'summary': title,
'body': body,
'meta': metadata,
}, context_instance=RequestContext(request))
def template_detail(request, template):
templates = []
for site_settings_module in settings.ADMIN_FOR:
settings_mod = import_module(site_settings_module)
if Site._meta.installed:
site_obj = Site.objects.get(pk=settings_mod.SITE_ID)
else:
site_obj = GenericSite()
for dir in settings_mod.TEMPLATE_DIRS:
template_file = os.path.join(dir, template)
templates.append({
'file': template_file,
'exists': os.path.exists(template_file),
'contents': lambda: os.path.exists(template_file) and open(template_file).read() or '',
'site_id': settings_mod.SITE_ID,
'site': site_obj,
'order': list(settings_mod.TEMPLATE_DIRS).index(dir),
})
return render_to_response('admin_doc/template_detail.html', {
'root_path': urlresolvers.reverse('admin:index'),
'name': template,
'templates': templates,
}, context_instance=RequestContext(request))
def render_template(self,
request,
form,
previous_fields,
step,
context=None):
"""
Renders the template for the given step, returning an HttpResponse object.
Override this method if you want to add a custom context, return a
different MIME type, etc. If you only need to override the template
name, use get_template() instead.
The template will be rendered with the following context:
step_field -- The name of the hidden field containing the step.
step0 -- The current step (zero-based).
step -- The current step (one-based).
step_count -- The total number of steps.
form -- The Form instance for the current step (either empty
or with errors).
previous_fields -- A string representing every previous data field,
plus hashes for completed forms, all in the form of
hidden fields. Note that you'll need to run this
through the "safe" template filter, to prevent
auto-escaping, because it's raw HTML.
"""
context = context or {}
context.update(self.extra_context)
return render_to_response(self.get_template(step),
dict(context,
step_field=self.step_field_name,
step0=step,
step=step + 1,
step_count=self.num_steps(),
form=form,
previous_fields=previous_fields),
context_instance=RequestContext(request))
