def reply(request, mlist_fqdn, message_id_hash): """ Sends a reply to the list. TODO: unit tests """ if request.method != 'POST': raise SuspiciousOperation form = ReplyForm(request.POST) if not form.is_valid(): return HttpResponse(form.errors.as_text(), content_type="text/plain", status=400) store = get_store(request) mlist = store.get_list(mlist_fqdn) if form.cleaned_data["newthread"]: subject = form.cleaned_data["subject"] headers = {} else: message = store.get_message_by_hash_from_list(mlist.name, message_id_hash) subject = message.subject if not message.subject.lower().startswith("re:"): subject = "Re: %s" % subject headers = {"In-Reply-To": "<%s>" % message.message_id, "References": "<%s>" % message.message_id, } try: post_to_list(request, mlist, subject, form.cleaned_data["message"], headers) except PostingFailed, e: return HttpResponse(str(e), content_type="text/plain", status=500)
def reply_to_question(request, question_id): question = Question.objects.get(id=int(question_id)) form = ReplyForm(request.POST) if form.is_valid(): question.reply = form.cleaned_data["text"] question.save() return HttpResponseRedirect(request.META.get('HTTP_REFERER'))
def view(request, pk): if pk > 0: #database queries for bulletin info bulletin = Bulletin.objects.get(pk=pk) allreplies = Reply.objects.filter(thread__bulletin=bulletin) replies= allreplies.filter(public=True).order_by("-timestamp") privatecount = allreplies.filter(public=False).exclude(sender=bulletin.creator).count() else: return render(request, '404.html', {}) if request.method == 'POST': form = ReplyForm(request.POST) if form.is_valid(): cleaned_data = form.clean() if request.POST['visibility'] == 'Public': public = True else: public = False if request.user.userdata != bulletin.creator or public: message = cleaned_data['message'] outmail.replyToBulletin(bulletin, message, request.user.userdata, public) #update page form = ReplyForm() resolveform = ResolverCreditForm() if request.user.is_authenticated and request.user.userdata == bulletin.creator: bulletinform = UpdateBulletinForm() else: bulletinform = {} return render(request, 'bulletin.html', {'bulletin':bulletin, 'replies':replies, 'privatecount':privatecount, 'form':form, 'bulletinform':bulletinform, 'resolveform':resolveform})
def submit_reply(request, board_id, post_id): if not request.user.is_authenticated or request.user.username == "": return render(request, 'login.html', {}) try: board = DefaultBoard.objects.get(pk=board_id) post = Post.objects.get(pk=post_id) if not board.access(request.user, access_type="post", default=False): context = {'board': board} return render(request, 'board_noperm.html', context) if request.method == "POST": form = ReplyForm(request.POST) if not form.is_valid(): return Http404("Error submitting post.") text = form.cleaned_data['text'] board.create_post(subject="Re: " + post.db_subject, text=text, author_name=request.user.username, author_player=request.user, parent=post) return HttpResponseRedirect("/boards/" + str(board.id) + "/" + str(post.id) + "/") else: form = ReplyForm() context = {'board': board, 'board_id': board.id, 'post_id': post.id, 'form': form} return render(request, 'submit_reply.html', context) except (Board.DoesNotExist, Board.MultipleObjectsReturned, Post.DoesNotExist, Post.MultipleObjectsReturned): return Http404("Error accessing boards.")
def thread(request, pk): """Render a single thread's info, usually for the mailbox""" print 'made it!' thread = Reply_Thread.objects.get(id=pk) info={} #You have to belong to the thread to access it! if request.session['pk'] in [thread.bulletin.creator.pk, thread.replier.pk]: info.update({'thread':thread}) new=[] for reply in thread.reply_set.exclude(sender__id=request.session['pk']).filter(read=False): new.append(reply.id) reply.read=True reply.save() #Handle request to add replies to the thread if request.method == 'POST': form = ReplyForm(request.POST) if form.is_valid(): cleaned_data = form.clean() if request.POST['visibility'] == 'Public': public = True else: public = False #Maybe works? user = UserData.objects.get(pk==request.session['pk']) message = cleaned_data['message'] outmail.replyWithThread(thread, message, user, public) #Filling out the necessary context form = ReplyForm() info.update({'form':form, 'new':new}); return render(request, 'elements/replythread.html', info)
def view_question(request,classes,lecture_number,noteslug,qpk): lectures = Lecture.objects.filter(slug=classes, lecture_number=lecture_number) note = Note.objects.filter(slug=noteslug) question = NoteQuestion.objects.filter(pk=qpk) replies = NoteReply.objects.filter(question=question) if request.POST: replyform = ReplyForm(request.POST) if replyform.is_valid(): newreply = replyform.save(commit=False) newreply.author = User.objects.get(username=request.user) newreply.question = question[0] newreply.save() return HttpResponseRedirect('.') else: replyform = ReplyForm(request.POST) args = {} args.update(csrf(request)) isauthor = (question[0].author == request.user.username) or request.user.is_superuser isnoteauthor = (note[0].author == request.user.username) or request.user.is_superuser args['form'] = replyform args['classes'] = lectures[0].course.classes args['lectureslug'] = classes args['lecture_number'] = lecture_number args['note'] = note[0] args['question'] = question[0] args['replies'] = replies args['isauthor'] = isauthor args['isnoteauthor'] = isnoteauthor return render_to_response('view_question.html', args)
def reply(request, mlist_fqdn, message_id_hash): """ Sends a reply to the list. TODO: unit tests """ if request.method != 'POST': raise SuspiciousOperation form = ReplyForm(request.POST) if not form.is_valid(): return HttpResponse(form.errors.as_text(), content_type="text/plain", status=400) store = get_store(request) mlist = store.get_list(mlist_fqdn) if form.cleaned_data["newthread"]: subject = form.cleaned_data["subject"] headers = {} else: message = store.get_message_by_hash_from_list(mlist.name, message_id_hash) subject = message.subject if not message.subject.lower().startswith("re:"): subject = "Re: %s" % subject headers = { "In-Reply-To": "<%s>" % message.message_id, "References": "<%s>" % message.message_id, } try: post_to_list(request, mlist, subject, form.cleaned_data["message"], headers, attachments=request.FILES.getlist('attachment')) except PostingFailed, e: return HttpResponse(str(e), content_type="text/plain", status=500)
def reply_to_question(request, question_id): question = Question.objects.get(id=int(question_id)) form = ReplyForm(request.POST) if form.is_valid(): question.reply = form.cleaned_data["text"] question.save() return redirect_user_to_homepage(request.user.profile.user_type)
def post(self, request, id): form = ReplyForm(request.POST) response = Response.objects.get(pk=id) if not form.is_valid(): print 'errors', form.errors context = { 'form': form, 'response': response, } return render(request, 'claims/responses/detail.html', context) parent = None if form.cleaned_data['comment_id']: parent = Comment.objects.get(pk=form.cleaned_data['comment_id']) print 'trying to make...' Comment.objects.create(user=request.user, response=response, parent=parent, body=form.cleaned_data['body']) print 'made comment, redirecting' return redirect('response-detail', id=response.id)
def reply(request,target_mail_id): """docstring for send_mail""" tmail=get_object_or_404(Mail,id=target_mail_id) if request.POST: form=ReplyForm(request.POST) if form.is_valid(): send_mail(tmail,form) return HttpResponseRedirect('/') else: form=ReplyForm() return render_to_response('reply.html',locals())
def get_thread_posts(request, thread_id): """ Returns all posts in a thread, including the 'thread' post itself. """ thread = get_object_or_404(Thread, pk=thread_id) if thread.hidden: raise Http404 # Mark thread a read for user. read = UserRead.objects.get_or_create(user=request.user, thread=thread_id)[0] read.read = True read.save() if request.method == "POST": form = ReplyForm(request.POST) if form.is_valid(): reply = form.save(commit=False) # TODO: Check if user is logged in reply.author = request.user reply.thread_id = thread_id reply.pub_date = datetime.now() reply.update = datetime.now() reply.save() thread.latest_post = reply thread.save() form = ReplyForm() # Clear the form # Mark thread as unread for other users ur = UserRead.objects.all().filter(thread__exact=thread_id).exclude(user=request.user) for u in ur: u.read = False u.save() # Focus on new post after reply. return HttpResponseRedirect("%s?page=last#post_%s" % (reverse("thread", args=[thread.id]), reply.id)) else: form = ReplyForm() post_list = Post.objects.all().filter(thread=thread_id, hidden=False) p = Paginator(post_list, 5) try: page = int(request.GET.get("page", "1")) except: page = p.num_pages try: posts = p.page(page) except (EmptyPage, InvalidPage): raise Http404 return render_to_response( "dsf/thread_detail.html", {"thread": thread, "posts": posts, "form": form}, context_instance=RequestContext(request), )
def reply(request, topic_id): if request.method == 'POST': form = ReplyForm(request.POST) if form.is_valid(): reply = form.save(commit=False) reply.topic_id = topic_id reply.save() topic = Topic.objects.get(id=topic_id) topic.reply_date = timezone.now() topic.save() return redirect("/") else: form = ReplyForm() return render_to_response('form.html',{'form': form}, context_instance=RequestContext(request))
def window_comment_reply(request): reply_form = ReplyForm(request.POST) if reply_form.is_valid(): reply_dict = reply_form.cleaned_data window_id = request.user_meta['window_model'].id order_model = order.get_order_byid_bywin(window_id, reply_dict) order_dish_model = orderdish.get_order_dish_byid(order_model, reply_dict) if order_dish_model.comment_time: # user can only make reply on comments if order_dish_model.reply_time is None: orderdish.update_reply(order_dish_model, reply_dict) return json_response(OK, CODE_MESSAGE.get(OK)) else: return json_response(ORDER_DISH_REPLIED, CODE_MESSAGE.get(ORDER_DISH_REPLIED)) else: return json_response(ORDER_STATUS_ERROR, CODE_MESSAGE.get(ORDER_STATUS_ERROR)) else: return json_response(PARAM_REQUIRED, CODE_MESSAGE.get(PARAM_REQUIRED))
def edit_post(request, post_id): post = get_object_or_404(Post, pk=post_id) if not request.user is post.author and not request.user.is_superuser: return HttpResponse("Access denied!") if request.method == "POST": form = ReplyForm(request.POST) if form.is_valid(): data = form.cleaned_data body = data["body"] post = get_object_or_404(Post, pk=post_id) post.body = body post.markdown = data["markdown"] post.update = datetime.now() post.save() return HttpResponse(markdown.markdown(post.body)) if request.user.is_superuser or post.author is request.user: form = ReplyForm(post.__dict__) return render_to_response("dsf/post_edit.html", {"form": form, "post_id": post_id}) else: return HttpResponse(_("Access denied!"))
def reply(request, mlist_fqdn, message_id_hash): """ Sends a reply to the list. TODO: unit tests """ if request.method != 'POST': raise SuspiciousOperation form = ReplyForm(request.POST) if not form.is_valid(): return HttpResponse(form.errors.as_text(), content_type="text/plain", status=400) store = get_store(request) mlist = store.get_list(mlist_fqdn) message = store.get_message_by_hash_from_list(mlist.name, message_id_hash) subject = message.subject if not message.subject.lower().startswith("re:"): subject = "Re: %s" % subject _send_email(request, mlist, subject, form.cleaned_data["message"], { "In-Reply-To": "<%s>" % message.message_id, "References": "<%s>" % message.message_id, }) return HttpResponse("The reply has been sent successfully.", mimetype="text/plain")
def reply_view(request, pk_forum, pk_thread): forum = get_object(Forum.objects.active(), pk=pk_forum) category = forum.category threads = forum.threads.active() thread = get_object(threads, pk=pk_thread) form = ReplyForm(request.POST or None) editor_name = MARKUP_EDITORS[MARKUP] editor_style = 'js/forum/markitup/sets/%s/style.css' % editor_name editor_set = 'js/forum/markitup/sets/%s/set.js' % editor_name if form.is_bound and form.is_valid(): new_reply = form.save(request.user.forum_profile, forum, thread) return redirect(new_reply) return render(request, 'forum/reply.html', { 'category': category, 'forum': forum, 'thread': thread, 'form': form, 'editor_name': editor_name, 'editor_style': editor_style, 'editor_set': editor_set, })
def add_reply(request): form = ReplyForm(request.POST) if form.is_valid(): reply = form.save(commit=False) review = request.POST.get('review') user_rep = request.POST.get('user') r1 = reply.rate_objective r2 = reply.rate_complete repute_rev = User_Reputation.objects.get(user = user_rep) reputation = User_Reputation.objects.filter(user = request.user) if reputation: r = User_Reputation.objects.get(user = request.user) repute = r.reputation entity_alpha = r.entity_alpha entity_beta = r.entity_beta else: r = User_Reputation() r.user = request.user r.reputation = 0.5 r.entity_alpha = 0.5 r.entity_beta = 0.5 r.votes = 0 entity_alpha = 0.5 entity_beta = 0.5 repute = 0.5 r.save() #r3 = ((r1+r2)/2) * repute/1000 alpha = ((r1+r2)/2) beta = 1 - alpha entity_alpha += alpha entity_beta += beta entity_reputation = (entity_alpha/(entity_alpha + entity_beta)) r4 = repute_rev.reputation if r4 == 1: repute_rev.reputation = r4 repute_rev.entity_alpha = entity_alpha repute_rev.entity_beta = entity_beta repute_rev.save() else: repute_rev.reputation = (r4 + entity_reputation)/2 repute_rev.entity_alpha = entity_alpha repute_rev.entity_beta = entity_beta repute_rev.save() review = ProductReview.objects.get(id=review) reply.review = review reply.user = request.user reply.save() template = "pdcts/reply_review.html" html = render_to_string(template, {'reply': reply }) response = simplejson.dumps({'success':'True', 'html': html}) else: html = form.errors.as_ul() response = simplejson.dumps({'success':'False', 'html': html}) return HttpResponse(response, content_type='application/javascript; charset=utf-8')
def post_body_view(request, school_name, post_id, post_type): form_msg = {} ctx = {} print post_type if request.method == 'POST': user = request.user ip = get_ip_address(request) post = get_post_by_id(post_id) if post_type == "reply": post_form_kwargs = { "user": user, "post": post, "ip": ip} form = ReplyForm( request.POST, **post_form_kwargs) else: reply_id = request.POST['reply_id'] print reply_id post_form_kwargs = { "user": user, "ip": ip, "reply_id": reply_id} form = CommentForm( request.POST, **post_form_kwargs) if form.is_valid(): print form.cleaned_data form.save() if post_type == "reply": context = Context({'replys': [form.reply], 'commentForm': CommentForm()}) return_str = render_block_to_string( 'discussion/post-body.html', 'replys', context) else: return_str = { "reply_id": form.reply_id, "comment": form.comment.comment_body} form_msg['message'] = return_str else: form_msg['errors'] = form.errors print form_msg json_ctx = json.dumps(form_msg) return HttpResponse(json_ctx, mimetype='application/json') else: replyForm = ReplyForm() commentForm = CommentForm() post = get_post_by_id(post_id) reply = get_post_reply(post_id) ctx = { "school_name": school_name, "post": post, "replys": reply, "commentForm": commentForm, "replyForm": replyForm} return render_to_response( 'discussion/post-body.html', ctx, context_instance=RequestContext(request))
def add_reply(request): form = ReplyForm(request.POST) if form.is_valid(): reply = form.save(commit=False) review = request.POST.get('review') user_rep = request.POST.get('user') r1 = reply.rate_objective r2 = reply.rate_complete repute_rev = User_Reputation.objects.get(user=user_rep) reputation = User_Reputation.objects.filter(user=request.user) if reputation: r = User_Reputation.objects.get(user=request.user) repute = r.reputation entity_alpha = r.entity_alpha entity_beta = r.entity_beta else: r = User_Reputation() r.user = request.user r.reputation = 0.5 r.entity_alpha = 0.5 r.entity_beta = 0.5 r.votes = 0 entity_alpha = 0.5 entity_beta = 0.5 repute = 0.5 r.save() #r3 = ((r1+r2)/2) * repute/1000 alpha = ((r1 + r2) / 2) beta = 1 - alpha entity_alpha += alpha entity_beta += beta entity_reputation = (entity_alpha / (entity_alpha + entity_beta)) r4 = repute_rev.reputation if r4 == 1: repute_rev.reputation = r4 repute_rev.entity_alpha = entity_alpha repute_rev.entity_beta = entity_beta repute_rev.save() else: repute_rev.reputation = (r4 + entity_reputation) / 2 repute_rev.entity_alpha = entity_alpha repute_rev.entity_beta = entity_beta repute_rev.save() review = ProductReview.objects.get(id=review) reply.review = review reply.user = request.user reply.save() template = "pdcts/reply_review.html" html = render_to_string(template, {'reply': reply}) response = simplejson.dumps({'success': 'True', 'html': html}) else: html = form.errors.as_ul() response = simplejson.dumps({'success': 'False', 'html': html}) return HttpResponse(response, content_type='application/javascript; charset=utf-8')