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))