def logout(request,
next_page=None,
template_name='registration/logged_out.html',
redirect_field_name=REDIRECT_FIELD_NAME,
current_app=None,
extra_context=None):
"""
Logs out the user and displays 'You are logged out' message.
"""
auth_logout(request)
redirect_to = request.REQUEST.get(redirect_field_name, '')
if redirect_to:
netloc = urlparse.urlparse(redirect_to)[1]
# Security check -- don't allow redirection to a different host.
if not (netloc and netloc != request.get_host()):
return HttpResponseRedirect(redirect_to)
if next_page is None:
current_site = get_current_site(request)
context = {
'site': current_site,
'site_name': current_site.name,
'title': _('Logged out')
}
if extra_context is not None:
context.update(extra_context)
return TemplateResponse(request,
template_name,
context,
current_app=current_app)
else:
# Redirect to this page until the session has been cleared.
return HttpResponseRedirect(next_page or request.path)
def update_settings(request, *args, **kwargs):
data = request.POST
owners = data['perm_owners']
readers = data['perm_readers']
writers = data['perm_writers']
repo_url = data['repo_url'] # or
repo_name = kwargs['repo']
try:
from cicero.models import Profile
repo_obj = Repo.objects.get(name=repo_name)
profile = request.user.cicero_profile
is_banned = profile.is_banned
if is_banned:
return HttpResponseRedirect(post_redirect(request))
is_superuser = profile.user.is_superuser
is_moderator = profile.moderator
uowners = repo_obj.users_owner.split('\n')
if is_superuser or is_moderator or (user in uowners):
repo_obj.users_owner = owners
repo_obj.users_read = readers
repo_obj.users_write = writers
repo_obj.save()
except:
pass
#return HttpResponse('ok')
return HttpResponseRedirect(post_redirect(request))
def article_delete(request, id):
article = get_object_or_404(Article, pk=id)
if not request.user.cicero_profile.can_change_article(article):
return HttpResponseForbidden('Нет прав для удаления')
article.deleted = datetime.now()
article.save()
caching.invalidate_by_article(article.topic.forum.slug, article.topic.id)
if article.topic.article_set.count():
return HttpResponseRedirect(
reverse(topic, args=(article.topic.forum.slug, article.topic.id)))
else:
article.topic.deleted = datetime.now()
article.topic.save()
return HttpResponseRedirect(
reverse(forum, args=(article.topic.forum.slug, )))
def password_change(request,
template_name='registration/password_change_form.html',
post_change_redirect=None,
password_change_form=PasswordChangeForm,
current_app=None,
extra_context=None):
if post_change_redirect is None:
post_change_redirect = reverse(
'my_django.contrib.auth.views.password_change_done')
if request.method == "POST":
form = password_change_form(user=request.user, data=request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect(post_change_redirect)
else:
form = password_change_form(user=request.user)
context = {
'form': form,
}
if extra_context is not None:
context.update(extra_context)
return TemplateResponse(request,
template_name,
context,
current_app=current_app)
def add_template_response(request, message_type):
for msg in request.POST.getlist('messages'):
getattr(messages, message_type)(request, msg)
show_url = reverse(
'my_django.contrib.messages.tests.urls.show_template_response')
return HttpResponseRedirect(show_url)
def inner(request, *args, **kwargs):
if not self.has_permission(request):
if request.path == reverse('admin:logout',
current_app=self.name):
index_path = reverse('admin:index', current_app=self.name)
return HttpResponseRedirect(index_path)
return self.login(request)
return view(request, *args, **kwargs)
def change_openid(request):
forms = _profile_forms(request)
form = forms['openid'].__class__(request.session, request.POST)
forms['openid'] = form
if form.is_valid():
after_auth_redirect = form.auth_redirect(post_redirect(request),
{'op': 'change_openid'})
return HttpResponseRedirect(after_auth_redirect)
return _profile_page(request, forms)
def mark_read(request, slug=None):
qs = Article.objects.all()
if slug:
qs = qs.filter(topic__forum__slug=slug)
if request.user.is_authenticated():
profile = request.user.cicero_profile
profile.add_read_articles(qs)
profile.save()
caching.invalidate_by_user(request)
return HttpResponseRedirect(request.META.get('HTTP_REFERER') or '../')
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 article_spam(request, id):
if not request.user.cicero_profile.moderator:
return HttpResponseForbidden('Нет прав определять спам')
article = get_object_or_404(Article, pk=id)
if not article.from_guest():
pass
# scipio_profile = article.author.user.scipio_profile
# if scipio_profile.spamer is None:
# scipio_profile.spamer = True
# scipio_profile.save()
#antispam.conveyor.submit_spam(article=article)
slug, topic_id = article.topic.forum.slug, article.topic.id
article.delete()
caching.invalidate_by_article(slug, topic_id)
if Topic.objects.filter(pk=topic_id).count():
return HttpResponseRedirect(reverse(topic, args=(slug, topic_id)))
else:
return HttpResponseRedirect(reverse(forum, args=(slug, )))
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 post_profile(request, form_name):
forms = _profile_forms(request)
profile = {
# 'settings': request.user.cicero_profile,
# 'personal': request.user.scipio_profile,
}[form_name]
form = forms[form_name].__class__(request.POST, instance=profile)
forms[form_name] = form
if form.is_valid():
form.save()
return HttpResponseRedirect('../')
return _profile_page(request, forms)
def login(request,
template_name='registration/login.html',
redirect_field_name=REDIRECT_FIELD_NAME,
authentication_form=AuthenticationForm,
current_app=None,
extra_context=None):
"""
Displays the login form and handles the login action.
"""
redirect_to = request.REQUEST.get(redirect_field_name, '')
if request.method == "POST":
form = authentication_form(data=request.POST)
if form.is_valid():
netloc = urlparse.urlparse(redirect_to)[1]
# Use default setting if redirect_to is empty
if not redirect_to:
redirect_to = settings.LOGIN_REDIRECT_URL
# Heavier security check -- don't allow redirection to a different
# host.
elif netloc and netloc != request.get_host():
redirect_to = settings.LOGIN_REDIRECT_URL
# Okay, security checks complete. Log the user in.
auth_login(request, form.get_user())
if request.session.test_cookie_worked():
request.session.delete_test_cookie()
return HttpResponseRedirect(redirect_to)
else:
form = authentication_form(request)
request.session.set_test_cookie()
current_site = get_current_site(request)
context = {
'form': form,
redirect_field_name: redirect_to,
'site': current_site,
'site_name': current_site.name,
}
if extra_context is not None:
context.update(extra_context)
return TemplateResponse(request,
template_name,
context,
current_app=current_app)
def serve(request, path, document_root=None, show_indexes=False):
"""
Serve static files below a given point in the directory structure.
To use, put a URL pattern such as::
(r'^(?P<path>.*)$', 'django.views.static.serve', {'document_root' : '/path/to/my/files/'})
in your URLconf. You must provide the ``document_root`` param. You may
also set ``show_indexes`` to ``True`` if you'd like to serve a basic index
of the directory. This index view will use the template hardcoded below,
but if you'd like to override it, you can create a template called
``static/directory_index.html``.
"""
path = posixpath.normpath(urllib.unquote(path))
path = path.lstrip('/')
newpath = ''
for part in path.split('/'):
if not part:
# Strip empty path components.
continue
drive, part = os.path.splitdrive(part)
head, part = os.path.split(part)
if part in (os.curdir, os.pardir):
# Strip '.' and '..' in path.
continue
newpath = os.path.join(newpath, part).replace('\\', '/')
if newpath and path != newpath:
return HttpResponseRedirect(newpath)
fullpath = os.path.join(document_root, newpath)
if os.path.isdir(fullpath):
if show_indexes:
return directory_index(newpath, fullpath)
raise Http404(_(u"Directory indexes are not allowed here."))
if not os.path.exists(fullpath):
raise Http404(_(u'"%(path)s" does not exist') % {'path': fullpath})
# Respect the If-Modified-Since header.
statobj = os.stat(fullpath)
mimetype, encoding = mimetypes.guess_type(fullpath)
mimetype = mimetype or 'application/octet-stream'
if not was_modified_since(request.META.get('HTTP_IF_MODIFIED_SINCE'),
statobj.st_mtime, statobj.st_size):
return HttpResponseNotModified(mimetype=mimetype)
with open(fullpath, 'rb') as f:
response = HttpResponse(f.read(), mimetype=mimetype)
response["Last-Modified"] = http_date(statobj.st_mtime)
if stat.S_ISREG(statobj.st_mode):
response["Content-Length"] = statobj.st_size
if encoding:
response["Content-Encoding"] = encoding
return response
def add(request, message_type):
# don't default to False here, because we want to test that it defaults
# to False if unspecified
fail_silently = request.POST.get('fail_silently', None)
for msg in request.POST.getlist('messages'):
if fail_silently is not None:
getattr(messages, message_type)(request,
msg,
fail_silently=fail_silently)
else:
getattr(messages, message_type)(request, msg)
show_url = reverse('my_django.contrib.messages.tests.urls.show')
return HttpResponseRedirect(show_url)
def redirect(post_save_redirect, obj):
"""
Returns a HttpResponseRedirect to ``post_save_redirect``.
``post_save_redirect`` should be a string, and can contain named string-
substitution place holders of ``obj`` field names.
If ``post_save_redirect`` is None, then redirect to ``obj``'s URL returned
by ``get_absolute_url()``. If ``obj`` has no ``get_absolute_url`` method,
then raise ImproperlyConfigured.
This function is meant to handle the post_save_redirect parameter to the
``create_object`` and ``update_object`` views.
"""
if post_save_redirect:
return HttpResponseRedirect(post_save_redirect % obj.__dict__)
elif hasattr(obj, 'get_absolute_url'):
return HttpResponseRedirect(obj.get_absolute_url())
else:
raise ImproperlyConfigured(
"No URL to redirect to. Either pass a post_save_redirect"
" parameter to the generic view or define a get_absolute_url"
" method on the Model.")
def delete_object(request,
model,
post_delete_redirect,
object_id=None,
slug=None,
slug_field='slug',
template_name=None,
template_loader=loader,
extra_context=None,
login_required=False,
context_processors=None,
template_object_name='object'):
"""
Generic object-delete function.
The given template will be used to confirm deletetion if this view is
fetched using GET; for safty, deletion will only be performed if this
view is POSTed.
Templates: ``<app_label>/<model_name>_confirm_delete.html``
Context:
object
the original object being deleted
"""
if extra_context is None: extra_context = {}
if login_required and not request.user.is_authenticated():
return redirect_to_login(request.path)
obj = lookup_object(model, object_id, slug, slug_field)
if request.method == 'POST':
obj.delete()
msg = ugettext("The %(verbose_name)s was deleted.") %\
{"verbose_name": model._meta.verbose_name}
messages.success(request, msg, fail_silently=True)
return HttpResponseRedirect(post_delete_redirect)
else:
if not template_name:
template_name = "%s/%s_confirm_delete.html" % (
model._meta.app_label, model._meta.object_name.lower())
t = template_loader.get_template(template_name)
c = RequestContext(request, {
template_object_name: obj,
}, context_processors)
apply_extra_context(extra_context, c)
response = HttpResponse(t.render(c))
populate_xheaders(request, response, model,
getattr(obj, obj._meta.pk.attname))
return response
def logout(request, *args, **kwargs):
from my_django.contrib.auth import logout
logout(request)
try:
del request.session['member_id']
except KeyError:
pass
#return HttpResponse("You're logged out.")
# url = '%s#%s' % (reverse(topic, args=(article.topic.forum.slug, article.topic.id)), article.id)
# print url
# return HttpResponseRedirect(request.META.get('HTTP_REFERER') or '../')
return HttpResponseRedirect(post_redirect(request))
def post_comment(request):
data = request.POST
path = data['path']
repo_url = data['repo_url']
repo = Repo.objects.get(url=repo_url)
line = data['line']
text = data['text']
rev = data['rev']
Comment.objects.create(repo=repo,
file_path=path,
rev=rev,
line=line,
content=text)
#return HttpResponse('ok')
return HttpResponseRedirect(post_redirect(request))
def clone_repo(request):
data = request.POST
repo_url = data['repo_url']
repo_home = settings.REPO_HOME
sh.cd(repo_home)
try:
git.clone(repo_url)
except:
sh.mkdir(repo_url)
sh.cd(repo_url)
git.init()
fresh_repo_list()
repo_name = repo_url.split('/')[-1][:-4]
Repo.objects.create(name=repo_name, url=repo_url)
#return HttpResponse('ok')
return HttpResponseRedirect(post_redirect(request))
def redirect_to_login(next,
login_url=None,
redirect_field_name=REDIRECT_FIELD_NAME):
"""
Redirects the user to the login page, passing the given 'next' page
"""
if not login_url:
login_url = settings.LOGIN_URL
login_url_parts = list(urlparse.urlparse(login_url))
if redirect_field_name:
querystring = QueryDict(login_url_parts[4], mutable=True)
querystring[redirect_field_name] = next
login_url_parts[4] = querystring.urlencode(safe='/')
return HttpResponseRedirect(urlparse.urlunparse(login_url_parts))
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 article_publish(request, id):
if not request.user.cicero_profile.moderator:
return HttpResponseForbidden('Нет прав публиковать спам')
article = get_object_or_404(Article, pk=id)
#antispam.conveyor.submit_ham(article.spam_status, article=article)
article.set_spam_status('clean')
if not article.from_guest():
pass
# scipio_profile = article.author.user.scipio_profile
# if scipio_profile.spamer is None:
# scipio_profile.spamer = False
# scipio_profile.save()
caching.invalidate_by_article(article.topic.forum.slug, article.topic.id)
return HttpResponseRedirect(reverse(spam_queue))
def article_undelete(request, id):
try:
article = Article.deleted_objects.get(pk=id)
except Article.DoesNotExist:
raise Http404
if not request.user.cicero_profile.can_change_article(article):
return HttpResponseForbidden('Нет прав для восстановления')
Article.deleted_objects.filter(pk=id).update(deleted=None)
try:
article_topic = Topic.deleted_objects.get(pk=article.topic_id)
Topic.deleted_objects.filter(pk=article.topic_id).update(deleted=None)
except Topic.DoesNotExist:
article_topic = article.topic
caching.invalidate_by_article(article_topic.forum.slug, article_topic.id)
return HttpResponseRedirect(
reverse(topic, args=(article_topic.forum.slug, article_topic.id)))
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 password_reset_confirm(
request,
uidb36=None,
token=None,
template_name='registration/password_reset_confirm.html',
token_generator=default_token_generator,
set_password_form=SetPasswordForm,
post_reset_redirect=None,
current_app=None,
extra_context=None):
"""
View that checks the hash in a password reset link and presents a
form for entering a new password.
"""
assert uidb36 is not None and token is not None # checked by URLconf
if post_reset_redirect is None:
post_reset_redirect = reverse(
'my_django.contrib.auth.views.password_reset_complete')
try:
uid_int = base36_to_int(uidb36)
user = User.objects.get(id=uid_int)
except (ValueError, User.DoesNotExist):
user = None
if user is not None and token_generator.check_token(user, token):
validlink = True
if request.method == 'POST':
form = set_password_form(user, request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect(post_reset_redirect)
else:
form = set_password_form(None)
else:
validlink = False
form = None
context = {
'form': form,
'validlink': validlink,
}
if extra_context is not None:
context.update(extra_context)
return TemplateResponse(request,
template_name,
context,
current_app=current_app)
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 password_reset(
request,
is_admin_site=False,
template_name='registration/password_reset_form.html',
email_template_name='registration/password_reset_email.html',
subject_template_name='registration/password_reset_subject.txt',
password_reset_form=PasswordResetForm,
token_generator=default_token_generator,
post_reset_redirect=None,
from_email=None,
current_app=None,
extra_context=None):
if post_reset_redirect is None:
post_reset_redirect = reverse(
'my_django.contrib.auth.views.password_reset_done')
if request.method == "POST":
form = password_reset_form(request.POST)
if form.is_valid():
opts = {
'use_https': request.is_secure(),
'token_generator': token_generator,
'from_email': from_email,
'email_template_name': email_template_name,
'subject_template_name': subject_template_name,
'request': request,
}
if is_admin_site:
opts = dict(opts, domain_override=request.META['HTTP_HOST'])
form.save(**opts)
return HttpResponseRedirect(post_reset_redirect)
else:
form = password_reset_form()
context = {
'form': form,
}
if extra_context is not None:
context.update(extra_context)
return TemplateResponse(request,
template_name,
context,
current_app=current_app)
def process_response(self, request, response):
language = translation.get_language()
if (response.status_code == 404
and not translation.get_language_from_path(request.path_info)
and self.is_language_prefix_patterns_used()):
urlconf = getattr(request, 'urlconf', None)
language_path = '/%s%s' % (language, request.path_info)
if settings.APPEND_SLASH and not language_path.endswith('/'):
language_path = language_path + '/'
if is_valid_path(language_path, urlconf):
language_url = "%s://%s/%s%s" % (
request.is_secure() and 'https' or 'http',
request.get_host(), language, request.get_full_path())
return HttpResponseRedirect(language_url)
translation.deactivate()
patch_vary_headers(response, ('Accept-Language', ))
if 'Content-Language' not in response:
response['Content-Language'] = language
return response
def carma(request, tgt_user, inc_dec, **kwargs):
#print tgt_user
u = '%s' % (request.user, )
#print u
if request.user.is_authenticated() and tgt_user != u and (
inc_dec == "inc" or inc_dec == "dec"):
profile = request.user.cicero_profile
is_can_change_carmas = profile.today_change_carmas < profile.max_change_carmas
#print is_can_change_carmas
if is_can_change_carmas:
profile.today_change_carmas += 1
profile.save()
from my_django.contrib.auth.models import User
try:
u = User.objects.get(username__exact=tgt_user)
profile = Profile.objects.filter(user=u).get()
if inc_dec == "inc":
profile.carma += 1
else:
profile.carma -= 1
profile.save()
except User.DoesNotExist:
pass
caching.invalidate_by_user(request)
else:
is_can_change_carmas = False
#kwargs['queryset'] = topic.article_set.filter(spam_status='clean', is_forum=True).select_related()
#kwargs['extra_context'] = {'topic': topic, 'form': form, 'page_id': 'topic', 'show_last_link': True,
# 'groups': _get_left_side_cont(),
# 'is_user_can_add_topic_or_article': is_user_can_add_topic_or_article(request)}
#return object_list(request, **kwargs)
if is_can_change_carmas:
return HttpResponseRedirect(
post_redirect(request)
) #HttpResponse(u"carma of %s succesfully changed" % (tgt_user,))
else:
return HttpResponse(u"you can not change this carma")
