def edit_base(request):
profile = get_profile(request)
if request.method == "GET":
c = {"profile":profile}
update_context(request, c)
return my_render(request, 'profile/profile_edit_base.html', c)
elif request.method == "POST":
profile_name = request.POST.get("name", "")
profile_summary = request.POST.get("summary", "")
profile_computer = request.POST.get("computer", "")
profile_editor = request.POST.get("editor", "")
if profile_name:
profile.name = profile_name
profile.summary = profile_summary
profile.computer = profile_computer
profile.editor = profile_editor
profile.save()
cache_clear() # FIXME
request.session["ok_message"] = u"기본정보가 수정되었습니다"
else:
request.session["error_message"] = u"이름을 입력 해 주세요"
return redirect('scode.profile_views.edit_base')
def recommend(request, q_id):
profile = get_profile(request)
try:
question = Question.objects.get(id=q_id)
except Question.DoesNotExist:
request.session["error_message"] = u"해당 글을 찾을 수 없습니다."
return redirect('/')
if request.method == "GET":
c = {"question": question}
update_context(request, c)
if profile == question.profile:
request.session["error_message"] = u"본인이 작성한 글은 추천할 수 없습니다."
return redirect(question.get_absolute_url())
if profile in question.recommender.all():
request.session["error_message"] = u"이미 추천하셨습니다"
return redirect(question.get_absolute_url())
return my_render(request, 'scode/scode_recommend.html', c)
elif request.method == "POST":
if profile not in question.recommender.all():
question.recommender.add(profile)
request.session["ok_message"] = u"이 글을 추천하였습니다"
cache_remove(question.id)
return redirect(question.get_absolute_url())
def answer(request, p_id):
user_profile = Profile.objects.get(id=p_id)
questions = Question.objects.filter(category='Q').order_by("register_time")
questions_has_answer = questions.filter(answers__profile=user_profile)
width = TABLE_WIDTH
tables = []
total = questions.count()
answer = questions_has_answer.count()
if total:
solve_rate = round((answer * 1.0 / total) * 100.0, 1)
else:
solve_rate = 0
tr = []
for i, question in enumerate(questions):
question.index = i+1
if question in questions_has_answer:
question.has_answer = True
question.the_answer = question.answers.filter(profile=user_profile)[0]
else:
question.has_answer = False
if i % width == 0: # append tr
tr = []
tables.append(tr)
tr.append(question)
remains = width - total % width
if remains == 10:
remains = 0
for i in range(remains):
tr.append("")
levels = [
[0,0,'warning'],
[0,0,'success'],
[0,0,'info'],
[0,0,'primary'],
[0,0,'danger'],
]
for question in questions_has_answer:
level_index = int(question.getLevel())-1
levels[level_index][0] += 1
if answer:
for level in levels:
cnt = level[0]
level[1] = round((cnt * 1.0 / answer) * 100.0, 1)
c = {"user_profile":user_profile,
"total":total,
"answer":answer,
"solve_rate":solve_rate,
"levels":levels,
"tables":tables,}
update_context(request, c)
return my_render(request, 'profile/profile_info.html', c)
def subscribe(request, q_id):
profile = get_profile(request)
try:
question = Question.objects.get(id=q_id)
except Question.DoesNotExist:
request.session["error_message"] = u"해당 글을 찾을 수 없습니다."
return redirect('/')
if request.method == "GET":
if profile == question.profile:
request.session["error_message"] = u"본인이 작성한 글은 구독할 수 없습니다."
return redirect(question.get_absolute_url())
c = {"question": question,
"profile": profile, }
update_context(request, c)
return my_render(request, 'scode/scode_subscribe.html', c)
elif request.method == "POST":
_type = request.POST.get("_type", "")
if _type == "register":
if profile not in question.subscriber.all():
question.subscriber.add(profile)
request.session["ok_message"] = u"구독 신청이 완료되었습니다."
elif _type == "cancel":
if profile in question.subscriber.all():
question.subscriber.remove(profile)
request.session["ok_message"] = u"구독 신청이 취소되었습니다."
cache_remove(question.id, extra=False)
return redirect('/scode/subscribe/%s' % question.id)
def comment_edit(request, c_id):
profile = get_profile(request)
if request.method == "GET":
comment = Comment.objects.get(id=c_id)
if comment.profile == profile:
pass
elif profile.user.is_staff:
pass
elif profile.belt >= Profile.BELT_BLACK:
pass
else:
q_id = comment.get_question().id
request.session["error_message"] = u"댓글을 수정할 수 있는 권한이 없습니다"
return redirect('/scode/%s' % q_id)
c = {"comment": comment}
update_context(request, c)
return my_render(request, 'scode/comment_edit.html', c)
elif request.method == "POST":
comment = Comment.objects.get(id=c_id)
content = unicode.strip(request.POST.get("content", ""))
comment.content = content
comment.modify_time = datetime.datetime.today()
comment.save()
question = comment.get_question()
question.save()
request.session["ok_message"] = u"댓글이 수정되었습니다"
cache_remove(question.id)
return redirect(comment.get_absolute_url())
def comment_delete(request, c_id):
profile = get_profile(request)
comment = Comment.objects.get(id=c_id)
if comment.profile == profile:
pass
elif profile.user.is_staff:
pass
elif profile.belt >= profile.BELT_BLACK:
pass
else:
q_id = comment.get_question().id
request.session["error_message"] = u"댓글을 삭제할 수 있는 권한이 없습니다"
return redirect('/scode/%s' % q_id)
if request.method == "GET":
c = {"comment": comment}
update_context(request, c)
return my_render(request, 'scode/comment_delete.html', c)
elif request.method == "POST":
answer = comment.get_answer()
question = comment.get_question()
comment.delete()
request.session["ok_message"] = u"댓글이 삭제되었습니다"
cache_remove(question.id)
if answer:
return redirect(answer.get_absolute_url())
else:
return redirect('/scode/%s' % question.id)
def comment_not_recommend(request, c_id):
profile = get_profile(request)
try:
comment = Comment.objects.get(id=c_id)
except Comment.DoesNotExist:
request.session["error_message"] = u"댓글을 찾을 수 없습니다."
return redirect('/')
question = comment.get_question()
if profile == comment.profile:
request.session["error_message"] = u"본인이 작성한 댓글은 비추천할 수 없습니다."
return redirect('/scode/%s' % question.id)
if profile in comment.recommender.all() or profile in comment.not_recommender.all():
request.session["error_message"] = u"이미 추천 또는 비추천하셨습니다"
return redirect('/scode/%s' % question.id)
if request.method == "GET":
c = {"comment": comment}
update_context(request, c)
return my_render(request, 'scode/comment_not_recommend.html', c)
elif request.method == "POST":
if profile not in comment.not_recommender.all():
comment.not_recommender.add(profile)
request.session["ok_message"] = u"댓글을 비추천하였습니다"
cache_remove(question.id)
return redirect(comment.get_absolute_url())
def edit_image(request):
profile = get_profile(request)
if request.method == "GET":
c = {"profile":profile}
update_context(request, c)
return my_render(request, 'profile/profile_edit_image.html', c)
elif request.method == "POST":
form = ImageUploadForm(request.POST, request.FILES)
im_path = request.POST.get("im_path")
if form.is_valid():
profile.image = form.cleaned_data['image']
elif im_path:
x1 = request.POST.get("x1")
y1 = request.POST.get("y1")
x2 = request.POST.get("x2")
y2 = request.POST.get("y2")
img = Image.open(im_path)
cropped = img.crop(map(int, [x1,y1,x2,y2]))
t = os.path.splitext(profile.image.path)
crop_image = t[0]+"_crop"+t[1]
cropped.save(crop_image)
profile.image.save(profile.image.path, File(open(crop_image, 'rb')))
profile.save()
cache_clear() # FIXME
request.session["ok_message"] = u"프로필 이미지가 수정되었습니다"
return redirect('scode.profile_views.edit_image')
def feedback(request):
if request.method == "GET":
c = {}
update_context(request, c)
return my_render(request, 'help/feedback.html', c)
elif request.method == "POST":
content = request.POST.get("content", "")
if not content:
request.session["error_message"] = u"피드백 내용을 입력 해 주세요."
return redirect('/help/feedback')
profile = get_profile(request)
if profile:
content = u'"%s (%s)" 님의 피드백.' % (profile.name, profile.email) \
+ "\n\n" + content
# send mail
send_mail(u"코딩도장 피드백이 도착했습니다.",
content,
settings.DEFAULT_FROM_EMAIL,
[settings.ADMINS[0][1]])
request.session["ok_message"] = u"감사합니다. 피드백이 전송되었습니다."
return redirect('/help/feedback')
def question(request, p_id):
user_profile = Profile.objects.get(id=p_id)
questions = Question.objects.filter(category='Q').order_by("register_time")
questions_own = questions.filter(profile=user_profile)
width = TABLE_WIDTH
tables = []
total = questions.count()
own = questions_own.count()
for i, question in enumerate(questions):
question.index = i+1
if question in questions_own:
question.is_own = True
if i % width == 0: # append tr
tr = []
tables.append(tr)
tr.append(question)
remains = width - total % width
if remains == 10:
remains = 0
for i in range(remains):
tr.append("")
c = {"user_profile":user_profile,
"total":total,
"own":own,
"tables":tables,}
update_context(request, c)
return my_render(request, 'profile/profile_info.html', c)
def comment_recommend_show(request, c_id):
try:
obj = Comment.objects.get(id=c_id)
except Comment.DoesNotExist:
request.session["error_message"] = u"해당 댓글을 찾을 수 없습니다."
return redirect('/')
c = {"obj": obj, "obj_type": "C"}
update_context(request, c)
return my_render(request, 'scode/scode_recommend_show.html', c)
def answer_recommend_show(request, a_id):
try:
obj = Answer.objects.get(id=a_id)
except Answer.DoesNotExist:
request.session["error_message"] = u"해당 글을 찾을 수 없습니다."
return redirect('/')
c = {"obj": obj, "obj_type": "A"}
update_context(request, c)
return my_render(request, 'scode/scode_recommend_show.html', c)
def tag(request, tagid):
try:
_tag = Tag.objects.get(id=tagid)
except Tag.DoesNotExist:
request.session["error_message"] = u"해당 알고리즘을 찾을 수 없습니다."
return redirect('/')
questions = Question.objects.filter(tags=_tag, category='Q').distinct()
c = {"tag": _tag, "questions": questions}
update_context(request, c)
return my_render(request, 'scode/scode_tag.html', c)
def recv_recommend(request, p_id):
user_profile = Profile.objects.get(id=p_id)
questions = Question.objects.filter(category='Q').order_by("register_time")
questions_recommend = Question.objects.filter(category='Q', profile=user_profile, recommender__isnull=False)
questions_answers_recommend = Question.objects.filter(category='Q', answers__profile=user_profile, answers__recommender__isnull=False)
recommend_question_count = 0
recommend_answer_count = 0
width = TABLE_WIDTH
tables = []
total = questions.count()
for i, question in enumerate(questions):
question.index = i+1
question.is_recommend = False
question.recommend_question_count = 0
question.recommend_answer_count = 0
if question in questions_recommend:
question.is_recommend = True
question.the_url = question.get_absolute_url()
question.recommend_question_count = question.recommender.count()
recommend_question_count += question.recommend_question_count
if question in questions_answers_recommend:
question.is_recommend = True
recommend_answers = question.answers.filter(profile=user_profile)
question.the_url = recommend_answers[0].get_absolute_url()
for recommend_answer in recommend_answers:
question.recommend_answer_count += recommend_answer.recommender.count()
recommend_answer_count += question.recommend_answer_count
if i % width == 0: # append tr
tr = []
tables.append(tr)
tr.append(question)
remains = width - total % width
if remains == 10:
remains = 0
for i in range(remains):
tr.append("")
c = {"user_profile":user_profile,
"total":total,
"recommend_question_count":recommend_question_count,
"recommend_answer_count":recommend_answer_count,
"tables":tables,}
update_context(request, c)
return my_render(request, 'profile/profile_info.html', c)
def _revision(request, obj):
revisions = []
prev_content = None
for no, revision in enumerate(obj.revisions.all().order_by("modify_time")):
if prev_content == None: prev_content = revision.content
diff, plus, minus = get_diff(prev_content, revision.content)
revision.diff = diff
revision.no = no + 1
revision.plus = plus
revision.minus = minus
prev_content = revision.content
revisions.append(revision)
c = {"revisions": reversed(revisions), "object": obj}
update_context(request, c)
return my_render(request, 'scode/scode_revision.html', c)
def answer_edit(request, a_id):
profile = get_profile(request)
answer = Answer.objects.get(id=a_id)
#
# 수정권한 체크
#
if answer.profile == profile:
pass
elif profile.user.is_staff:
pass
elif profile.belt >= Profile.BELT_RED: # 빨간띠 이상
pass
else:
q_id = answer.get_question().id
request.session["error_message"] = u"풀이를 수정할 수 있는 권한이 없습니다"
return redirect('/scode/%s' % q_id)
if request.method == "GET":
c = {"answer": answer}
update_context(request, c)
return my_render(request, 'scode/answer_edit.html', c)
elif request.method == "POST":
content = unicode.strip(request.POST.get("content", ""))
prev_content = answer.content
answer.content = content
answer.modify_time = datetime.datetime.today()
answer.save()
if content != prev_content: # make revision
revision = Revision(profile=profile, content=content)
revision.save()
answer.revisions.add(revision)
question = answer.get_question()
#
# 풀이 수정 시 문제의 modify_time 변경, 최근목록으로 표시되기 위해
#
# question.modify_time = datetime.datetime.today()
# question.save()
request.session["ok_message"] = u"풀이가 수정되었습니다"
cache_remove(question.id)
return redirect(answer.get_absolute_url())
def _info(request, user_profile, objects, total_count, method_name, is_date=True):
page = int(request.POST.get("page", "1"))
paginator = Paginator(objects, PER_PAGE)
try:
objects = paginator.page(page)
except PageNotAnInteger:
objects = paginator.page(1)
except EmptyPage:
objects = paginator.page(paginator.num_pages)
c = {"user_profile":user_profile,
"per_page":PER_PAGE,
"total_count":total_count,
"method_name":method_name,
"is_date":is_date,
"objects":objects,}
update_context(request, c)
return my_render(request, 'profile/profile_info.html', c)
def answer_delete(request, a_id):
profile = get_profile(request)
answer = Answer.objects.get(id=a_id)
if answer.profile != profile and not profile.user.is_staff:
q_id = answer.get_question().id
request.session["error_message"] = u"풀이를 삭제할 수 있는 권한이 없습니다"
return redirect('/scode/%s' % q_id)
if request.method == "GET":
c = {"answer": answer}
update_context(request, c)
return my_render(request, 'scode/answer_delete.html', c)
elif request.method == "POST":
question = answer.get_question()
answer.comments.all().delete()
answer.delete()
request.session["ok_message"] = u"풀이가 삭제되었습니다"
cache_remove(question.id)
return redirect('/scode/%s' % question.id)
def edit_password(request):
profile = get_profile(request)
if request.method == "GET":
c = {"profile":profile}
update_context(request, c)
return my_render(request, 'profile/profile_edit_password.html', c)
elif request.method == "POST":
cpasswd = request.POST["cpasswd"]
npasswd = request.POST["npasswd"]
u = User.objects.get(username=profile.email)
if not cpasswd or not npasswd:
request.session["error_message"] = u"입력값을 확인하세요"
elif not u.check_password(cpasswd):
request.session["error_message"] = u"기존 비밀번호가 틀리게 입력되었습니다"
else:
u.set_password(npasswd)
u.save()
request.session["ok_message"] = u"비밀번호가 변경되었습니다"
return redirect('scode.profile_views.edit_password')
def delete(request, q_id):
profile = get_profile(request)
question = Question.objects.get(id=q_id)
if question.profile != profile and not profile.user.is_staff:
request.session["error_message"] = u"글을 삭제할 수 있는 권한이 없습니다"
return redirect('/scode/%s' % q_id)
if request.method == "GET":
c = {"question": question}
update_context(request, c)
return my_render(request, 'scode/scode_delete.html', c)
elif request.method == "POST":
question.comments.all().delete()
for answer in question.answers.all():
answer.comments.all().delete()
answer.delete()
question.delete()
request.session["ok_message"] = "글이 삭제되었습니다"
cache_remove(question.id)
return redirect('scode.scode_views.index')
def answer_recommend(request, a_id):
profile = get_profile(request)
try:
answer = Answer.objects.get(id=a_id)
except Answer.DoesNotExist:
request.session["error_message"] = u"풀이를 찾을 수 없습니다."
return redirect('/')
#
# check auth
#
question = answer.get_question()
if profile == answer.profile:
request.session["error_message"] = u"본인이 작성한 글은 추천할 수 없습니다."
return redirect('/scode/%s' % question.id)
if profile in answer.recommender.all():
request.session["error_message"] = u"이미 추천하셨습니다"
return redirect('/scode/%s' % question.id)
#
# 스태프, 검은띠는 Multi vote 가능
#
if profile.belt != Profile.BELT_BLACK and not profile.user.is_staff:
for _a in question.answers.all():
if profile in _a.recommender.all():
request.session["error_message"] = u"이미 추천하셨습니다"
return redirect('/scode/%s' % question.id)
if request.method == "GET":
c = {"answer": answer}
update_context(request, c)
return my_render(request, 'scode/answer_recommend.html', c)
elif request.method == "POST":
answer.recommender.add(profile)
request.session["ok_message"] = u"풀이를 추천하였습니다"
cache_remove(question.id)
return redirect(answer.get_absolute_url())
def level(request, p_id):
user_profile = Profile.objects.get(id=p_id)
questions = Question.objects.filter(category='Q').order_by("register_time")
questions_level = questions.filter(level__profile=user_profile)
width = TABLE_WIDTH
tables = []
total = questions.count()
level_count = questions_level.count()
for i, question in enumerate(questions):
question.index = i+1
question.is_level = False
if question in questions_level:
question.is_level = True
question_level = question.level.filter(profile=user_profile)[0]
question.the_level = question_level.level
question.the_level_color = get_level_label(str(question_level.level))
if i % width == 0: # append tr
tr = []
tables.append(tr)
tr.append(question)
remains = width - total % width
if remains == 10:
remains = 0
for i in range(remains):
tr.append("")
c = {"user_profile":user_profile,
"total":total,
"level_count":level_count,
"tables":tables,}
update_context(request, c)
return my_render(request, 'profile/profile_info.html', c)
def tag_edit(request, tagid):
profile = get_profile(request)
#
# check authority
#
if profile.user.is_staff:
pass
elif profile.belt >= profile.BELT_BLUE:
pass
else:
request.session["error_message"] = u"알고리즘 수정은 파란 띠 이상부터 가능합니다"
return redirect('/scode/tag/%s' % tagid)
if request.method == "GET":
tag = Tag.objects.get(id=tagid)
c = {"tag": tag}
update_context(request, c)
return my_render(request, 'scode/tag_edit.html', c)
elif request.method == "POST":
tag = Tag.objects.get(id=tagid)
prev_content = tag.content
content = unicode.strip(request.POST.get("content", ""))
tag.content = content
tag.modify_time = datetime.datetime.today()
tag.save()
if content != prev_content: # make revision
revision = Revision(profile=profile, content=content)
revision.save()
tag.revisions.add(revision)
request.session["ok_message"] = u"알고리즘이 수정되었습니다"
return redirect(tag.get_absolute_url())
def privacy(request):
return my_render(request, 'help/help_privacy.html', {})
def ie7(request):
return my_render(request, 'help/ie7.html', {})
def google_apps(request):
return my_render(request, 'help/google_apps.html', {})
def rank(request):
cache = cache_get(request, "rank")
if cache: return HttpResponse(cache)
#
# rank[profile] = [0,0,0,0,0]
# 0 - score
# 1 - question count
# 2 - answer count
# 3 - recv recommend count
# 4 - make recommend count
# 5 - vote level
#
rank = {}
for q in Question.objects.filter(category='Q'):
if q.profile not in rank:
rank[q.profile] = [0,0,0,0,0,0]
rank[q.profile][0] += 2
rank[q.profile][1] += 1 # question count ++
for p in q.recommender.all():
rank[q.profile][0] += p.belt * 5
rank[q.profile][3] += 1 # recv recommend count++
if p not in rank:
rank[p] = [0,0,0,0,0,0]
rank[p][0] += 1
rank[p][4] += 1 # make recommend count ++
for a in q.answers.all():
level = int(q.getLevel())
if a.profile not in rank:
rank[a.profile] = [0,0,0,0,0,0]
rank[a.profile][0] += level * 5
rank[a.profile][2] += 1 # answer count ++
for p in a.recommender.all():
rank[a.profile][0] += p.belt * 5
rank[a.profile][3] += 1 # recv recommend count++
if p not in rank:
rank[p] = [0,0,0,0,0,0]
rank[p][0] += 1
rank[p][4] += 1 # make recommend count ++
for ql in q.level.all():
if ql.profile not in rank:
rank[ql.profile] = [0,0,0,0,0,0]
rank[ql.profile][0] += 3
rank[ql.profile][5] += 1 # vote count ++
# exclude staff user from rank
for step in Profile.objects.filter(user__is_staff=True):
if step in rank: del rank[step]
import operator
sorted_rank = sorted(rank.iteritems(), key=operator.itemgetter(1), reverse=True)
if len(sorted_rank) >= 100:
last = sorted_rank[99]
else:
if sorted_rank:
last = sorted_rank[-1]
else:
last = None
sorted_rank = [s for s in sorted_rank if s[1] >= last[1]]
scores = []
for profile, score in sorted_rank:
#logger.debug(score)
scores.append(score)
rank_order = get_rank_order(scores)
c = {"rank": zip(sorted_rank, rank_order)}
update_context(request, c)
response = my_render(request, 'scode/scode_rank.html', c)
cache_put(request, "rank", response.content)
return response
def page_500(request):
return my_render(request, 'error/500.html', {})
def view(request, q_id):
#
# 페이지 내 정렬 : 추천순, 최신순
#
orderby = request.GET.get("orderby", "")
answer_id = request.GET.get("answer", "")
has_page = request.POST.get("page", "")
has_message = _has_message(request)
#
# 캐시하지 않는 경우:
# ----------------------------------------
# 1. 오류메시지 또는 성공메시지가 있는 경우
# 2. 답변 정렬이 있는 경우
# 3. 특정 답변으로 이동요청
# 4. 답변 페이징이 있는 경우
#
if not has_message and not orderby and not answer_id and not has_page:
cache = cache_get(request, q_id)
if cache:
return HttpResponse(cache)
try:
question = Question.objects.get(id=q_id)
except Question.DoesNotExist:
request.session["error_message"] = u"해당 글을 찾을 수 없습니다."
return redirect('/')
#
# similar_questions: 동일한 태그를 가지고 있는 질문들
#
similar_questions = Question.objects.filter(tags__in=question.tags.all(), category='Q').distinct()
#
# 페이지 우측에 태그별 갯수를 표시하기 위해서 필요
#
tags = []
tmp = similar_questions.values('tags') \
.annotate(num_tags=Count('tags')).order_by('-num_tags')
for t in tmp:
if t['tags']:
tag = Tag.objects.get(id=t['tags'])
tag.count = t['num_tags']
tags.append(tag)
if orderby == "time":
answers = question.answers.all().order_by("-register_time")
else:
answers = question.answers.all().annotate(
recommend_count=Count('recommender')).order_by("-recommend_count", "register_time")
#
# answer_id 기 요청된 경우
# 해당 답변이 있는 페이지를 보여주어야 한다.
#
answer_page = 0
if answer_id:
index = 0
for i, _answer in enumerate(answers):
if _answer.id == int(answer_id):
index = i
break
answer_page = index / PER_PAGE + 1
#
# get total_page
#
total_count = answers.count()
page_t = divmod(total_count, PER_PAGE)
total_page = page_t[0]
if page_t[1]: total_page += 1
paginator = Paginator(answers, PER_PAGE)
try:
page = int(request.POST.get("page", "1"))
#
# 특정 답변이 요청된 경우 그 답변이 있는 페이지를 보여준다.
#
if answer_page:
page = answer_page
answers = paginator.page(page)
except PageNotAnInteger:
answers = paginator.page(1)
except EmptyPage:
answers = paginator.page(paginator.num_pages)
level = question.getLevel()
level_label = get_level_label(level)
c = {"question": question,
"similar_questions": similar_questions,
"level": level,
"level_label": level_label,
"tags": tags,
"answers": answers,
"orderby": orderby,
"total_page": total_page,
"per_page": PER_PAGE}
update_context(request, c)
response = my_render(request, 'scode/scode_view.html', c)
response["X-XSS-Protection"] = "0"
#
# 위 캐시하지 않는 경우를 제외하고 캐시한다.
#
if not has_message and not orderby and not answer_id and not has_page:
cache_put(request, q_id, response.content)
return response
def index(request, page=1):
#
# sort: newest, answer, level, recommend, (unanswerd)
#
sort = request.GET.get("sort", "newest")
#
# sort_order: fw, rw(reverse order)
#
sort_order = request.GET.get("sort_order", "fw")
#
# save session for listings
#
request.session["page"] = page
request.session["sort"] = sort
request.session["sort_order"] = sort_order
has_message = _has_message(request)
#
# if has_message, don't return cached page
#
if not has_message:
cache = cache_get(request, "list.%s.%s.%s" % (sort, sort_order, page))
if cache:
return HttpResponse(cache)
questions = Question.objects.filter(category='Q')
if sort == "newest":
if sort_order == "fw":
order_by = "-register_time"
else:
order_by = "register_time"
questions = questions.order_by(order_by)
elif sort == "unanswered":
questions = questions.filter(answers=None).order_by("-modify_time")
elif sort == "answer":
questions = questions.annotate(num_answers=Count('answers'))
if sort_order == "fw":
questions = questions.order_by('-num_answers', '-modify_time')
else:
questions = questions.order_by('num_answers', '-modify_time')
elif sort == "recommend":
if sort_order == "fw":
order_by = True
else:
order_by = False
questions = sorted(questions, key=Question.vote_count, reverse=order_by)
elif sort == "level":
if sort_order == "fw":
order_by = False
else:
order_by = True
questions = sorted(questions, key=Question.getLevel, reverse=order_by)
else:
sort = "newest"
if sort in ["recommend", "level"]: # sorted list
total_count = len(questions)
else:
total_count = questions.count()
#
# pagination of questions
#
paginator = Paginator(questions, PER_PAGE)
try:
questions = paginator.page(page)
except PageNotAnInteger:
questions = paginator.page(1)
except EmptyPage:
questions = paginator.page(paginator.num_pages)
# total answer count
total_answer_count = Answer.objects.count()
c = {
"questions": questions,
"total_count": total_count,
"total_answer_count": total_answer_count,
"per_page": PER_PAGE,
"sort": sort,
"sort_order": sort_order,
}
update_context(request, c)
response = my_render(request, 'scode/scode_list.html', c)
if not has_message:
#
# save response to cache
#
cache_put(request, "list.%s.%s.%s" % (sort, sort_order, page), response.content)
return response
