def answer(request, id):#process a new answer
question = get_object_or_404(Question, id=id)
if request.method == "POST":
form = AnswerForm(question, request.user, request.POST)
if form.is_valid():
wiki = form.cleaned_data['wiki']
text = form.cleaned_data['text']
update_time = datetime.datetime.now()
if request.user.is_authenticated():
Answer.objects.create_new(
question=question,
author=request.user,
added_at=update_time,
wiki=wiki,
text=sanitize_html(markdowner.convert(text)),
email_notify=form.cleaned_data['email_notify']
)
else:
request.session.flush()
html = sanitize_html(markdowner.convert(text))
summary = strip_tags(html)[:120]
anon = AnonymousAnswer(
question=question,
wiki=wiki,
text=text,
summary=summary,
session_key=request.session.session_key,
ip_addr=request.META['REMOTE_ADDR'],
)
anon.save()
return HttpResponseRedirect(reverse('auth_action_signin', kwargs={'action': 'newanswer'}))
return HttpResponseRedirect(question.get_absolute_url())
def question_revisions(request, id):
post = get_object_or_404(Question, id=id)
revisions = list(post.revisions.all())
revisions.reverse()
for i, revision in enumerate(revisions):
revision.html = QUESTION_REVISION_TEMPLATE % {
'title': revision.title,
'html': sanitize_html(markdowner.convert(revision.text)),
'tags': ' '.join(['<a class="post-tag">%s</a>' % tag
for tag in revision.tagnames.split(' ')]),
}
if i > 0:
revisions[i].diff = htmldiff(revisions[i-1].html, revision.html)
else:
revisions[i].diff = QUESTION_REVISION_TEMPLATE % {
'title': revisions[0].title,
'html': sanitize_html(markdowner.convert(revisions[0].text)),
'tags': ' '.join(['<a class="post-tag">%s</a>' % tag
for tag in revisions[0].tagnames.split(' ')]),
}
revisions[i].summary = _('initial version')
return render_to_response('revisions_question.html', {
'post': post,
'revisions': revisions,
}, context_instance=RequestContext(request))
def ask(request):#view used to ask a new question
"""a view to ask a new question
gives space for q title, body, tags and checkbox for to post as wiki
user can start posting a question anonymously but then
must login/register in order for the question go be shown
"""
if request.method == "POST" and "text" in request.POST:
form = AskForm(request.POST)
if form.is_valid():
added_at = datetime.datetime.now()
title = strip_tags(form.cleaned_data['title'].strip())
wiki = form.cleaned_data['wiki']
tagnames = form.cleaned_data['tags'].strip()
text = form.cleaned_data['text']
html = sanitize_html(markdowner.convert(text))
summary = strip_tags(html)[:120]
if request.user.is_authenticated():
author = request.user
question = Question.objects.create_new(
title = title,
author = author,
added_at = added_at,
wiki = wiki,
tagnames = tagnames,
summary = summary,
text = sanitize_html(markdowner.convert(text))
)
return HttpResponseRedirect(question.get_absolute_url())
else:
request.session.flush()
session_key = request.session.session_key
question = AnonymousQuestion(
session_key = session_key,
title = title,
tagnames = tagnames,
wiki = wiki,
text = text,
summary = summary,
added_at = added_at,
ip_addr = request.META['REMOTE_ADDR'],
)
question.save()
return HttpResponseRedirect(reverse('auth_action_signin', kwargs={'action': 'newquestion'}))
elif request.method == "POST" and "go" in request.POST:
form = AskForm({'title': request.POST['q']})
else:
form = AskForm()
tags = _get_tags_cache_json()
return render_to_response('ask.html', {
'form' : form,
'tags' : tags,
'email_validation_faq_url':reverse('faq') + '#validate',
}, context_instance=RequestContext(request))
def apply_edit(self, edited_at=None, edited_by=None, text=None, comment=None, wiki=False):
if text is None:
text = self.get_latest_revision().text
if edited_at is None:
edited_at = datetime.datetime.now()
if edited_by is None:
raise Exception('edited_by is required')
self.last_edited_at = edited_at
self.last_edited_by = edited_by
self.html = sanitize_html(markdowner.convert(text))
#todo: bug wiki has no effect here
self.save()
self.add_revision(
revised_by=edited_by,
revised_at=edited_at,
text=text,
comment=comment
)
self.question.last_activity_at = edited_at
self.question.last_activity_by = edited_by
self.question.save()
def create_new(self, title=None,author=None,added_at=None, wiki=False,tagnames=None, text=None):
html = sanitize_html(markdowner.convert(text))
summary = strip_tags(html)[:120]
question = Question(
title = title,
author = author,
added_at = added_at,
last_activity_at = added_at,
last_activity_by = author,
wiki = wiki,
tagnames = tagnames,
html = html,
text = text,
summary = summary
)
if question.wiki:
question.last_edited_by = question.author
question.last_edited_at = added_at
question.wikified_at = added_at
question.save()
question.add_revision(
author=author,
text=text,
comment=CONST['default_version'],
revised_at=added_at,
)
return question
def _as_markdown(cls, content, *extensions, **extension_configs):
try:
return mark_safe(sanitize_html(markdown.markdown(
content, extensions=extensions, extension_configs=extension_configs)))
except:
logging.exception("Caught exception in markdown parser rendering %s", cls.__name__)
return ''
def _as_markdown(cls, content, *extensions):
try:
return mark_safe(sanitize_html(markdown.markdown(content, extensions=extensions)))
except Exception, e:
import traceback
logging.error("Caught exception %s in markdown parser rendering %s %s:\s %s" % (
str(e), cls.__name__, str(e), traceback.format_exc()))
return ''
def _as_markdown(cls, content, *extensions):
try:
return mark_safe(sanitize_html(markdown.markdown(content, extensions=extensions)))
except Exception, e:
import traceback
logging.error("Caught exception %s in markdown parser rendering %s %s:\s %s" % (
str(e), cls.__name__, str(e), traceback.format_exc()))
return ''
def edit_answer(request, id):
answer = get_object_or_404(Answer, id=id)
if answer.deleted and not auth.can_view_deleted_post(request.user, answer):
raise Http404
elif not auth.can_edit_post(request.user, answer):
raise Http404
else:
latest_revision = answer.get_latest_revision()
if request.method == "POST":
if 'select_revision' in request.POST:
# user has changed revistion number
revision_form = RevisionForm(answer, latest_revision, request.POST)
if revision_form.is_valid():
# Replace with those from the selected revision
form = EditAnswerForm(answer,
AnswerRevision.objects.get(answer=answer,
revision=revision_form.cleaned_data['revision']))
else:
form = EditAnswerForm(answer, latest_revision, request.POST)
else:
form = EditAnswerForm(answer, latest_revision, request.POST)
if form.is_valid():
html = sanitize_html(markdowner.convert(form.cleaned_data['text']))
if form.has_changed():
edited_at = datetime.datetime.now()
updated_fields = {
'last_edited_at': edited_at,
'last_edited_by': request.user,
'html': html,
}
Answer.objects.filter(id=answer.id).update(**updated_fields)
revision = AnswerRevision(
answer=answer,
author=request.user,
revised_at=edited_at,
text=form.cleaned_data['text']
)
if form.cleaned_data['summary']:
revision.summary = form.cleaned_data['summary']
else:
revision.summary = 'No.%s Revision' % latest_revision.revision
revision.save()
answer.question.last_activity_at = edited_at
answer.question.last_activity_by = request.user
answer.question.save()
return HttpResponseRedirect(answer.get_absolute_url())
else:
revision_form = RevisionForm(answer, latest_revision)
form = EditAnswerForm(answer, latest_revision)
return render_to_response('answer_edit.html', {
'answer': answer,
'revision_form': revision_form,
'form': form,
}, context_instance=RequestContext(request))
def edit_user(request, id):
user = get_object_or_404(User, id=id)
if request.user != user:
raise Http404
if request.method == "POST":
form = EditUserForm(user, request.POST)
if form.is_valid():
new_email = sanitize_html(form.cleaned_data['email'])
set_new_email(user, new_email)
if settings.EDITABLE_SCREEN_NAME:
user.username = sanitize_html(form.cleaned_data['username'])
user.real_name = sanitize_html(form.cleaned_data['realname'])
user.website = sanitize_html(form.cleaned_data['website'])
user.location = sanitize_html(form.cleaned_data['city'])
user.date_of_birth = sanitize_html(form.cleaned_data['birthday'])
if len(user.date_of_birth) == 0:
user.date_of_birth = '1900-01-01'
user.about = sanitize_html(form.cleaned_data['about'])
user.save()
# send user updated singal if full fields have been updated
if user.email and user.real_name and user.website and user.location and \
user.date_of_birth and user.about:
user_updated.send(sender=user.__class__, instance=user, updated_by=user)
return HttpResponseRedirect(user.get_profile_url())
else:
form = EditUserForm(user)
return render_to_response('user_edit.html', {
'form' : form,
'gravatar_faq_url' : reverse('faq') + '#gravatar',
}, context_instance=RequestContext(request))
def ask_book(request, short_name):
if request.method == "POST":
form = AskForm(request.POST)
if form.is_valid():
added_at = datetime.datetime.now()
html = sanitize_html(markdowner.convert(form.cleaned_data['text']))
question = Question(
title = strip_tags(form.cleaned_data['title']),
author = request.user,
added_at = added_at,
last_activity_at = added_at,
last_activity_by = request.user,
wiki = form.cleaned_data['wiki'],
tagnames = form.cleaned_data['tags'].strip(),
html = html,
summary = strip_tags(html)[:120]
)
if question.wiki:
question.last_edited_by = question.author
question.last_edited_at = added_at
question.wikified_at = added_at
question.save()
# create the first revision
QuestionRevision.objects.create(
question = question,
revision = 1,
title = question.title,
author = request.user,
revised_at = added_at,
tagnames = question.tagnames,
summary = CONST['default_version'],
text = form.cleaned_data['text']
)
books = Book.objects.extra(where=['short_name = %s'], params=[short_name])
match_count = len(books)
if match_count == 1:
# the book info
book = books[0]
book.questions.add(question)
return HttpResponseRedirect(question.get_absolute_url())
else:
form = AskForm()
tags = _get_tags_cache_json()
return render_to_response('ask.html', {
'form' : form,
'tags' : tags,
'email_validation_faq_url': reverse('faq') + '#validate',
}, context_instance=RequestContext(request))
def edit_user(request, id):
user = get_object_or_404(User, id=id)
if request.user != user:
raise Http404
if request.method == "POST":
form = EditUserForm(user, request.POST)
if form.is_valid():
new_email = sanitize_html(form.cleaned_data['email'])
set_new_email(user, new_email)
#user.username = sanitize_html(form.cleaned_data['username'])
user.real_name = sanitize_html(form.cleaned_data['realname'])
user.website = sanitize_html(form.cleaned_data['website'])
user.location = sanitize_html(form.cleaned_data['city'])
user.date_of_birth = sanitize_html(form.cleaned_data['birthday'])
if len(user.date_of_birth) == 0:
user.date_of_birth = '1900-01-01'
user.about = sanitize_html(form.cleaned_data['about'])
user.save()
# send user updated signal if full fields have been updated
if user.email and user.real_name and user.website and user.location and \
user.date_of_birth and user.about:
user_updated.send(sender=user.__class__,
instance=user,
updated_by=user)
return HttpResponseRedirect(user.get_profile_url())
else:
form = EditUserForm(user)
return render_to_response('users/edit.html', {
'form': form,
'gravatar_faq_url': reverse('faq') + '#gravatar',
},
context_instance=RequestContext(request))
def edit_user(request, id):
user = get_object_or_404(User, id=id)
if not (request.user.is_superuser or request.user == user):
return HttpResponseForbidden()
if request.method == "POST":
form = EditUserForm(user, request.POST)
if form.is_valid():
new_email = sanitize_html(form.cleaned_data['email'])
set_new_email(user, new_email)
if settings.EDITABLE_SCREEN_NAME:
user.username = sanitize_html(form.cleaned_data['username'])
user.real_name = sanitize_html(form.cleaned_data['realname'])
user.website = sanitize_html(form.cleaned_data['website'])
user.location = sanitize_html(form.cleaned_data['city'])
user.date_of_birth = form.cleaned_data['birthday']
if user.date_of_birth == "None":
user.date_of_birth = datetime(1900, 1, 1, 0, 0)
user.about = sanitize_html(form.cleaned_data['about'])
user.save()
EditProfileAction(user=user, ip=request.META['REMOTE_ADDR']).save()
return HttpResponseRedirect(user.get_profile_url())
else:
form = EditUserForm(user)
return render_to_response('users/edit.html', {
'user': user,
'form' : form,
'gravatar_faq_url' : reverse('faq') + '#gravatar',
}, context_instance=RequestContext(request))
def apply_edit(self, edited_at=None, edited_by=None, title=None,\
text=None, comment=None, tags=None, wiki=False):
latest_revision = self.get_latest_revision()
#a hack to allow partial edits - important for SE loader
if title is None:
title = self.title
if text is None:
text = latest_revision.text
if tags is None:
tags = latest_revision.tagnames
if edited_by is None:
raise Exception('parameter edited_by is required')
if edited_at is None:
edited_at = datetime.datetime.now()
#todo: have this copy-paste in few places
html = sanitize_html(markdowner.convert(text))
question_summary = strip_tags(html)[:120]
# Update the Question itself
self.title = title
self.last_edited_at = edited_at
self.last_activity_at = edited_at
self.last_edited_by = edited_by
self.last_activity_by = edited_by
self.tagnames = tags
self.summary = question_summary
self.html = html
self.text = text
#wiki is an eternal trap whence there is no exit
if self.wiki == False and wiki == True:
self.wiki = True
self.save()
# Update the Question tag associations
if latest_revision.tagnames != tags:
tags_updated = Question.objects.update_tags(self, tags, edited_by)
# Create a new revision
self.add_revision(
author = edited_by,
text = text,
revised_at = edited_at,
comment = comment,
)
def answer_revisions(request, id):
post = get_object_or_404(Answer, id=id)
revisions = list(post.revisions.all())
revisions.reverse()
for i, revision in enumerate(revisions):
revision.html = ANSWER_REVISION_TEMPLATE % {
'html': sanitize_html(markdowner.convert(revision.text))
}
if i > 0:
revisions[i].diff = htmldiff(revisions[i-1].html, revision.html)
else:
revisions[i].diff = revisions[i].text
revisions[i].summary = _('initial version')
return render_to_response('revisions_answer.html', {
'post': post,
'revisions': revisions,
}, context_instance=RequestContext(request))
def forwards(self, orm):
sys.path.append(os.path.join(os.path.dirname(__file__),'../markdownext'))
count = orm.Node.objects.count()
progress = ProgressBar(count)
for node in orm.Node.objects.all():
rev = node.active_revision
if not rev:
try:
rev = node.revisions.order_by('-revision')[0]
except:
continue
node.body = sanitize_html(markdown.markdown(rev.body, ['urlize']))
node.save()
progress.update()
def create_new(self, question=None, author=None, added_at=None, wiki=False, text='', email_notify=False):
answer = Answer(
question = question,
author = author,
added_at = added_at,
wiki = wiki,
text = text,
html = sanitize_html(markdowner.convert(text)),
)
if answer.wiki:
answer.last_edited_by = answer.author
answer.last_edited_at = added_at
answer.wikified_at = added_at
answer.save()
answer.add_revision(
revised_by=author,
revised_at=added_at,
text=text,
comment=CONST['default_version'],
)
#update question data
question.last_activity_at = added_at
question.last_activity_by = author
question.save()
Question.objects.update_answer_count(question)
#set notification/delete
if email_notify:
if author not in question.followed_by.all():
question.followed_by.add(author)
else:
#not sure if this is necessary. ajax should take care of this...
try:
question.followed_by.remove(author)
except:
pass
return answer
def edit_user(request, id, slug):
user = get_object_or_404(User, id=id)
if not (request.user.is_superuser or request.user == user):
return HttpResponseUnauthorized(request)
if request.method == "POST":
form = EditUserForm(user, request.POST)
if form.is_valid():
new_email = sanitize_html(form.cleaned_data['email'])
if new_email != user.email:
user.email = new_email
user.email_isvalid = False
try:
hash = ValidationHash.objects.get(user=request.user,
type='email')
hash.delete()
except:
pass
if settings.EDITABLE_SCREEN_NAME:
user.username = sanitize_html(form.cleaned_data['username'])
user.real_name = sanitize_html(form.cleaned_data['realname'])
user.website = sanitize_html(form.cleaned_data['website'])
user.location = sanitize_html(form.cleaned_data['city'])
user.date_of_birth = form.cleaned_data['birthday']
if user.date_of_birth == "None":
user.date_of_birth = datetime(1900, 1, 1, 0, 0)
user.about = sanitize_html(form.cleaned_data['about'])
user.save()
EditProfileAction(user=user, ip=request.META['REMOTE_ADDR']).save()
messages.info(request, _("Profile updated."))
return HttpResponseRedirect(user.get_profile_url())
else:
form = EditUserForm(user)
return render_to_response('users/edit.html', {
'user': user,
'form': form,
'gravatar_faq_url': reverse('faq') + '#gravatar',
},
context_instance=RequestContext(request))
def edit_user(request, id, slug):
user = get_object_or_404(User, id=id)
if not (request.user.is_superuser or request.user == user):
return HttpResponseUnauthorized(request)
if request.method == "POST":
form = EditUserForm(user, request.POST)
if form.is_valid():
new_email = sanitize_html(form.cleaned_data['email'])
if new_email != user.email:
user.email = new_email
user.email_isvalid = False
try:
hash = ValidationHash.objects.get(user=request.user, type='email')
hash.delete()
except:
pass
if settings.EDITABLE_SCREEN_NAME:
user.username = sanitize_html(form.cleaned_data['username'])
user.real_name = sanitize_html(form.cleaned_data['realname'])
user.website = sanitize_html(form.cleaned_data['website'])
user.location = sanitize_html(form.cleaned_data['city'])
user.date_of_birth = form.cleaned_data['birthday']
if user.date_of_birth == "None":
user.date_of_birth = datetime(1900, 1, 1, 0, 0)
user.about = sanitize_html(form.cleaned_data['about'])
user.save()
EditProfileAction(user=user, ip=request.META['REMOTE_ADDR']).save()
messages.info(request, _("Profile updated."))
return HttpResponseRedirect(user.get_profile_url())
else:
form = EditUserForm(user)
return render_to_response('users/edit.html', {
'user': user,
'form' : form,
'gravatar_faq_url' : reverse('faq') + '#gravatar',
}, context_instance=RequestContext(request))
def as_markdown(self, *extensions):
return mark_safe(sanitize_html(markdown.markdown(self.body, extensions=extensions)))
def html(self):
return mark_safe(sanitize_html(markdown.markdown(self.body)))
def _edit_question(request, question):#non-url subview of edit_question - just edit the body/title
latest_revision = question.get_latest_revision()
revision_form = None
if request.method == 'POST':
if 'select_revision' in request.POST:
# user has changed revistion number
revision_form = RevisionForm(question, latest_revision, request.POST)
if revision_form.is_valid():
# Replace with those from the selected revision
form = EditQuestionForm(question,
QuestionRevision.objects.get(question=question,
revision=revision_form.cleaned_data['revision']))
else:
form = EditQuestionForm(question, latest_revision, request.POST)
else:
# Always check modifications against the latest revision
form = EditQuestionForm(question, latest_revision, request.POST)
if form.is_valid():
html = sanitize_html(markdowner.convert(form.cleaned_data['text']))
if form.has_changed():
edited_at = datetime.datetime.now()
tags_changed = (latest_revision.tagnames !=
form.cleaned_data['tags'])
# Update the Question itself
updated_fields = {
'title': form.cleaned_data['title'],
'last_edited_at': edited_at,
'last_edited_by': request.user,
'last_activity_at': edited_at,
'last_activity_by': request.user,
'tagnames': form.cleaned_data['tags'],
'summary': strip_tags(html)[:120],
'html': html,
}
# only save when it's checked
# because wiki doesn't allow to be edited if last version has been enabled already
# and we make sure this in forms.
if ('wiki' in form.cleaned_data and
form.cleaned_data['wiki']):
updated_fields['wiki'] = True
updated_fields['wikified_at'] = edited_at
Question.objects.filter(
id=question.id).update(**updated_fields)
# Update the Question's tag associations
if tags_changed:
Question.objects.update_tags(question, form.cleaned_data['tags'], request.user)
#tags_updated.send(sender=question.__class__, question=question)
# Create a new revision
revision = QuestionRevision(
question = question,
title = form.cleaned_data['title'],
author = request.user,
revised_at = edited_at,
tagnames = form.cleaned_data['tags'],
text = form.cleaned_data['text'],
)
if form.cleaned_data['summary']:
revision.summary = form.cleaned_data['summary']
else:
revision.summary = 'No.%s Revision' % latest_revision.revision
revision.save()
return HttpResponseRedirect(question.get_absolute_url())
else:
revision_form = RevisionForm(question, latest_revision)
form = EditQuestionForm(question, latest_revision)
return render_to_response('question_edit.html', {
'question': question,
'revision_form': revision_form,
'form' : form,
'tags' : _get_tags_cache_json()
}, context_instance=RequestContext(request))
def html(self):
return mark_safe(sanitize_html(markdown.markdown(self.body)))
