def show_detail(request, pk):
context = {}
show = Show.objects.get(pk=pk)
context['form'] = CommentForm()
context['show'] = show
context['imdb'] = 'http://www.imdb.com/title/' + str(show.imdb_id)
if request.method == 'POST':
form = CommentForm(request.POST)
context['form'] = form
if form.is_valid():
if request.user.is_anonymous:
print 'anonymous user'
return HttpResponseRedirect('/please_login/')
else:
new_comment = Comment()
new_comment.text = form.cleaned_data['text']
new_comment.user = request.user
new_comment.show = show
new_comment.save()
return HttpResponseRedirect('/show_detail/%s' % pk)
else:
print 'form not valid'
return render_to_response('show_detail.html',
context,
context_instance=RequestContext(request))
def post(request):
if request.method == 'POST':
comment_form = CommentForm(request.POST)
new_comment = comment_form.save(commit=False)
new_comment.user = request.user
new_comment.post = my_models.Post.objects.get(
id=request.GET.get("post_id"))
new_comment.save()
return redirect(request.get_full_path())
else:
article = get_object_or_404(my_models.Post,
id=request.GET.get("post_id"))
tags = my_models.Tag.objects.all()
auth_count = User.objects.count()
ix = randint(0, auth_count - 1)
random_user = User.objects.all()[ix:ix + 1][0]
comment_form = CommentForm()
return render(
request, 'main/post.html', {
"article":
article,
'parts':
my_models.Part.objects.all(),
"tags":
tags,
"random_user":
random_user,
"comment_form":
comment_form,
"four_popular_posts":
sorted(list(my_models.Post.objects.all()),
key=lambda x: x.comment.count(),
reverse=True)[0:4],
})
def episode_detail(request, pk):
context = {}
episode = Episode.objects.get(pk=pk)
context['form'] = CommentForm()
context['episode'] = episode
context['imdb'] = 'http://www.imdb.com/title/' + str(episode.imdb_id)
if request.method == 'POST':
form = CommentForm(request.POST)
context['form'] = form
if form.is_valid():
if request.user.is_authenticated:
new_comment = Comment()
new_comment.text = form.cleaned_data['text']
new_comment.user = request.user
new_comment.episode = episode
new_comment.save()
elif request.user.is_anonymous:
print 'anonymous user'
return HttpResponseRedirect('/please_login/')
return HttpResponseRedirect('/episode_detail/%s' % pk)
else:
print 'form not valid'
return render_to_response('episode_detail.html',
context,
context_instance=RequestContext(request))
def index(request):
if request.method == 'GET':
form = CommentForm()
images = Image.objects.all().order_by('-id')[:3]
comments = Comment.objects.all()
return render(request, 'index.html', {
'images': images,
'comments': comments,
'form': form
})
else:
form = CommentForm(request.POST)
form.instance.username = request.user.username
form.instance.photo_id = request.POST['txt']
if form.is_valid():
form.save()
return redirect('/')
else:
return HttpResponse(form
)
def movie_detail(request, pk):
context = {}
movie = Movie.objects.get(pk=pk)
context['movie'] = movie
context['imdb'] = 'http://www.imdb.com/title/' + str(movie.imdb_id)
context['form1'] = CommentForm()
if request.method == 'POST':
form1 = CommentForm(request.POST)
context['form1'] = form1
if form1.is_valid():
print 'valid form1'
print request.user
if request.user.is_authenticated():
print 'comment'
new_comment = Comment()
new_comment.is_response = False
new_comment.text = form1.cleaned_data['text']
new_comment.user = request.user
new_comment.movie = movie
new_comment.save()
return HttpResponseRedirect('/movie_detail/%s' % pk)
else:
print 'anonymous user'
return HttpResponseRedirect('/please_login/')
else:
print 'form1 not valid'
else:
print 'GET'
return render_to_response('movie_detail.html',
context,
context_instance=RequestContext(request))
def add_comment_page(request, **kwargs):
form = CommentForm()
slug = kwargs['slug']
post =Post.objects.get(slug=slug)
if request.method == 'POST':
form = CommentForm(request.POST)
if form.is_valid:
form.instance.post_id = post.id
form.save(commit=True)
messages.success(request,'Your comment has been submitted and will be visible after the site owner approves',extra_tags='alert')
return HttpResponseRedirect(reverse('content',kwargs={'slug':slug}) + '#comments')
def post(self, request, *args, **kwargs):
form = CommentForm(request.POST)
if form.is_valid():
comment = form.save(commit=False)
comment.page = self.page
comment.save()
return HttpResponseRedirect(self.request.path_info)
def modify_post(comment_id):
comment = Comment.query.get_or_404(comment_id)
if g.user != comment.user:
flash('수정권한이 없습니다')
return redirect(url_for('post.detail', post_id=comment.post.id))
if request.method == 'POST':
form = CommentForm()
if form.validate_on_submit():
form.populate_obj(comment)
comment.modify_date = datetime.now() # 수정일시 저장
db.session.commit()
return redirect('{}#comment_{}'.format(
url_for('post.detail', post_id=comment.post.id), comment.id))
else:
form = CommentForm(obj=comment)
return render_template('comment/comment_form.html', form=form)
def post(id):
post = Post.query.get_or_404(id)
form = CommentForm()
if form.validate_on_submit():
comment = Comment(body=form.body.data,
post=post,
author=current_user._get_current_object())
db.session.add(comment)
flash('Your comment has been published.')
return redirect(url_for('.post', id=post.id, page=-1))
page = request.args.get('page', 1, type=int)
if page == -1:
page = (post.comments.count() - 1) / \
current_app.config['FLASKY_COMMENTS_PER_PAGE'] + 1
if page == 0:
page = 1
print(page)
pagination = post.comments.order_by(Comment.timestamp.asc()).paginate(
page,
per_page=current_app.config['FLASKY_COMMENTS_PER_PAGE'],
error_out=False)
comments = pagination.items
return render_template('post.html',
posts=[post],
form=form,
comments=comments,
pagination=pagination)
def detail(request, pk):
post = Post.objects.get(pk=pk)
comments = Comment.objects.filter(post=post)
form = CommentForm()
if request.method == "POST":
form = CommentForm(request.POST)
if form.is_valid():
comment = Comment(
author=form.cleaned_data["author"],
body=form.cleaned_data["body"],
post=post,
)
comment.save()
context = {"post": post, "comments": comments, "form": form}
return render(request, "main/detail.html", context)
def index_2(request, pk):
new = get_object_or_404(Posts, id=pk)
comment = Comments.objects.filter(post=pk)
if request.method == 'POST':
form = CommentForm(request.POST)
if form.is_valid():
form = form.save(commit=False)
form.user = request.user
form.post = new
form.save()
return redirect(index_2, pk)
else:
form = CommentForm()
return render(request, 'main/index_2.html', {
'new': new,
'comment': comment,
'form': form
})
def post_details(request, post_list_id):
try:
latest_post = Post.objects.get(id=post_list_id)
except Post.DoesNotExist:
raise Http404("Post not found")
if request.method == 'POST':
form = CommentForm(request.POST)
if form.is_valid():
form.save()
return redirect('/blog/'+str(post_list_id)+'/')
else:
form = CommentForm()
context = {
'latest_post': latest_post,
'comments': latest_post.comments.all(),
'form': form
}
return render(request, 'main/detail.html', context)
def film(request, pk):
film = get_object_or_404(Film, id=pk)
form = CommentForm(request.POST or None)
if form.is_valid():
form.instance.user = request.user
form.instance.film = film
form.save()
return redirect(film)
return render(request, 'main/film.html', {'film': film, "form": form})
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
comments = self.page.comments.all()
comment_form = CommentForm()
context = {
'comments': comments,
'comment_form': comment_form,
'title': self.page.title,
'abstract': self.page.abstract
}
return context
def post_detail(request, pk):
template_name = 'post-detail.html'
post = get_object_or_404(Post, pk=pk)
image = post.get_image
images = post.images.exclude(id=image.id)
comments = post.comments.filter(active=True)
new_comment = None
# Comment posted
if request.method == 'POST':
comment_form = CommentForm(data=request.POST)
if comment_form.is_valid():
# Create Comment object but don't save to database yet
new_comment = comment_form.save(commit=False)
# Assign the current post to the comment
new_comment.post = post
# Save the comment to the database
new_comment.save()
else:
comment_form = CommentForm()
return render(request, template_name, locals())
def show_defect(request, defect_id):
context = dict()
defect = Defect.objects.get(id=defect_id)
context['defect'] = defect
form = CommentForm()
try:
comments = Comment.objects.filter(defect=defect)
except Comment.DoesNotExist:
comments = None
context['comments'] = comments
context['form'] = form
return render(request, "main/defect_details.html", context)
def view_test_result(request, result_id=None):
context = dict()
if result_id:
result = TestResult.objects.get(id=result_id)
form = CommentForm()
try:
comments = Comment.objects.filter(test_result=result)
except Comment.DoesNotExist:
comments = None
context['result'] = result
context['comments'] = comments
context['form'] = form
return render(request, "main/test_result.html", context)
def create_reply(reply_id):
form = CommentForm()
reply = Reply.query.get_or_404(reply_id)
if request.method == 'POST' and form.validate_on_submit():
comment = Comment(user=g.user,
content=form.content.data,
create_date=datetime.now(),
reply=reply)
db.session.add(comment)
db.session.commit()
return redirect('{}#comment_{}'.format(
url_for('post.detail', post_id=reply.post.id), comment.id))
return render_template('comment/comment_form.html', form=form)
def view_test_session(request, test_session_id=None):
context = dict()
if test_session_id:
session = TestSession.objects.get(id=test_session_id)
form = CommentForm()
try:
comments = Comment.objects.filter(test_session=session)
except Comment.DoesNotExist:
comments = None
context['test_session'] = session
context['comments'] = comments
context['form'] = form
return render(request, "main/test_session.html", context)
def add_comment_defect(request, defect_id):
if request.method == 'POST':
form = CommentForm(request.POST)
if form.is_valid():
defect = Defect.objects.get(id=defect_id)
comment_text = form.cleaned_data['comment_body']
comment = Comment.objects.create(
comment_body=comment_text,
commenter=request.user,
modified_date=datetime.datetime.now())
comment.defect.add(defect)
comment.save()
return redirect('defect_by_id', defect_id)
def board_url(request, pk):
context = {}
board = Board.objects.get(pk=pk)
comments = Comment.objects.filter(board=board)
context['board'] = board
context['title'] = "Message Board"
context['list'] = json.dumps(
work_plz_v2(comments.filter(parent_comment=None)))
context['comment_form'] = CommentForm()
return render_to_response('board_page.html',
context,
context_instance=RequestContext(request))
def add_comment_test_session(request, test_session_id):
if request.method == 'POST':
form = CommentForm(request.POST)
if form.is_valid():
test_session = TestSession.objects.get(id=test_session_id)
comment_text = form.cleaned_data['comment_body']
comment = Comment.objects.create(
comment_body=comment_text,
commenter=request.user,
modified_date=datetime.datetime.now())
comment.test_session.add(test_session)
comment.save()
return redirect('view_test_session', test_session_id)
def post(id):
form = CommentForm()
post = Post.query.filter_by(id=id).first_or_404()
if form.validate_on_submit():
comment = Comment(body=form.comment.data,
author=current_user,
source=post)
db.session.add(comment)
db.session.commit()
flash('Comment successful.')
return redirect(url_for('post', id=id))
comments = post.comments
return render_template('idpost.html',
post=post,
form=form,
comments=comments)
def show_forum(request, course_name_slug, forum_name_slug):
context_dict = {}
try:
course = Course.objects.get(slug=course_name_slug)
forum = Forum.objects.get(slug=forum_name_slug)
post_list = Post.objects.filter(forum=forum)
post_form = PostForm()
comment_form = CommentForm()
comment_dict = {}
current_user = request.user
registered_account = check_user(current_user=current_user)
if registered_account != 1 and registered_account != 2:
is_user = False
else:
is_user = True
if check_user(current_user=current_user) == 2:
is_tutor = True
print("tutor")
else:
is_tutor = False
print("student")
for post in post_list:
comment_dict[post.id] = Comment.objects.filter(post=post)
context_dict['course'] = course
context_dict['forum'] = forum
context_dict['posts'] = post_list
context_dict['comment_dict'] = comment_dict
context_dict['post_form'] = post_form
context_dict['comment_form'] = comment_form
context_dict['is_tutor'] = is_tutor
context_dict['is_user'] = is_user
except Forum.DoesNotExist:
context_dict['forum'] = None
context_dict['posts'] = None
context_dict['comment_dict'] = None
return render(request, 'main/forum.html', context=context_dict)
def post_comment(request):
if request.POST and request.is_ajax():
json_context = {'success': False, 'form_errors': []}
form = CommentForm(request.POST)
comment = form.save()
if form.is_valid():
json_context['success'] = 'Комментарий успешно добавлен!'
json_context['commentHtml'] = render_to_string(
'comments/post_comments.html', {
'nodes': [comment],
'can_post': True
})
else:
json_context['form_errors'] = form.errors
return HttpResponse(json.dumps(json_context),
content_type="application/json")
return HttpResponseForbidden()
def showWorker(request):
userAauthorized = request.user.is_authenticated
if userAauthorized:
refreshLastOnline(request.user)
id = request.GET.get("id", None)
if id == None:
return render(request, 'errors/404.html', status=404)
if userAauthorized != True:
return render(request, 'errors/405.html', status=403)
else:
if request.method == "GET":
commentForm = CommentForm()
workerList = gerWorkList(user=request.user,
idWorker=[id],
userAauthorized=userAauthorized,
its_superuser=request.user.is_superuser)
comments = getComments(idWorker=id)
if len(workerList) == 0:
return render(request, 'errors/404.html', status=404)
else:
context = {}
context["worker"] = workerList[0]
context["commentForm"] = commentForm
context["comments"] = comments
context["userAauthorized"] = userAauthorized
if userAauthorized:
context['its_company'] = True if UserType.GetUserType(
request.user) == 2 else False
else:
context['its_company'] = False
return render(request, 'Worker.html', context)
def add_comment(request, blog_id):
form = CommentForm(request.POST)
article = get_object_or_404(Blog, id=blog_id)
if form.is_valid():
comment = BlogComment()
comment.path = []
comment.article_id = article
comment.author_id = auth.get_user(request)
comment.content = form.cleaned_data['comment_area']
comment.save()
try:
comment.path.extend(BlogComment.objects.get(id=form.cleaned_data['parent_comment']).path)
comment.path.append(comment.id)
except ObjectDoesNotExist:
comment.path.append(comment.id)
comment.save()
return HttpResponse("!")
def create_comment(request, course_name_slug, forum_name_slug, post_name_slug):
try:
forum = Forum.objects.get(slug=forum_name_slug)
except Forum.DoesNoExist:
forum = None
try:
course = Course.objects.get(slug=course_name_slug)
except Course.DoesNotExist:
course = None
try:
post = Post.objects.get(slug=post_name_slug)
except Post.DoesNotExist:
post = None
if course is None or forum is None or post is None:
return redirect('/main/forum/<slug:course_name_slug>/<slug:forum_name_slug/')
form = ReplyForm()
# If user inputs comment
if request.method == 'POST':
form = CommentForm(request.POST)
# If input is valid
if form.is_valid():
# Save the form
comment = form.save(commit=False)
comment.user = request.user
comment.post = post
comment.save()
return redirect(reverse('main:forum',
kwargs={'course_name_slug': course_name_slug,
'forum_name_slug': forum_name_slug}))
else:
print(form.errors)
return redirect(reverse('main:forum',
kwargs={'course_name_slug': course_name_slug,
'forum_name_slug': forum_name_slug}))
def comment():
form = CommentForm()
page = request.url
post_id = request.args.get('post_id')
post = Post.query.filter_by(id=post_id).first_or_404()
body = request.args.get('body')
comments = Comment.query.filter_by(post_id=post_id).order_by(Comment.timestamp.desc())
#comments = comments.query.order_by(comments.timestamp.desc())
if form.validate_on_submit():
language = guess_language(form.comment.data)
if language == 'UNKNOWN' or len(language) > 5:
language = ''
comment = Comment(body=form.comment.data, author=current_user,
language=language, post_id=post_id)
db.session.add(comment)
db.session.commit()
flash(_('Your comment is now live!'))
return redirect(page) #(url_for('main.explore'))
return render_template('comment.html', title=_('Comment'),
form=form, body=body, post=post, comments=comments)
def test_create_comment(django_user_model):
user = django_user_model.objects.create(username='******')
user.set_password('takeajacket')
user.save()
cult = Cult.objects.create(
name='Sweet Dreams',
slug='sweet-dreams',
doctrine='Hold your head up, keep your head up!',
city='Amsterdam',
)
event = Event.objects.create(
cult=cult,
title='SpaceX Falcon Heavy launch',
slug='falcon-heavy-launch',
details='Mars! Incoming!',
date='2118-02-02',
time='18:00',
venue='SpaceX Fans HQ',
address='2314 Olympus Str, 553 77',
maps_url='https://goo.gl/maps/sample-link',
)
Membership.objects.create(
cult=cult,
user=user,
role=Membership.LEADER,
)
form_data = {
'body': 'Elon for president!',
}
form = CommentForm(data=form_data)
assert form.is_valid()
c = Client()
logged_in = c.login(username='******', password='******')
response = c.post('/' + cult.slug + '/' + event.slug + '/comment/',
form_data)
assert logged_in
assert response.status_code == 302
assert Comment.objects.first()
assert Comment.objects.first().body == form_data['body']
assert Comment.objects.first().author == user
assert Comment.objects.first().event == event
