def test_validate():
# should not raise any error
User(name='totti', active=True, data=10).validate()
user = User(name='totti', posts=4)
with pytest.raises(ValidationError) as excinfo:
user.validate()
assert excinfo.value.as_dict() == {
'posts': 'invalid value type'
}
comment = Comment(_id=ObjectId(), body='')
with pytest.raises(ValidationError) as excinfo:
comment.validate()
assert excinfo.value.as_dict() == {
'body': 'blank value is not allowed',
'author': 'field is required'
}
post = Post(author=user, comments=[comment])
with pytest.raises(ValidationError) as excinfo:
post.validate()
assert excinfo.value.as_dict() == {
'title': 'field is required',
'comments': {
0: {
'body': 'blank value is not allowed',
'author': 'field is required'
}
}
}
def test_parse_comments(self):
response = '''{"response":[6,
{"cid":2505,"uid":16271479,"date":1298365200,"text":"Добрый день , кароче такая идея когда опросы создаешь вместо статуса - можно выбрать аудитории опрашиваемых, например только женский или мужской пол могут участвовать (то бишь голосовать в опросе)."},
{"cid":2507,"uid":16271479,"date":1286105582,"text":"Это уже не практично, имхо.<br>Для этого делайте группу и там опрос, а в группу принимайте тех, кого нужно.","reply_to_uid":16271479,"reply_to_cid":2505},
{"cid":2547,"uid":2943,"date":1286218080,"text":"Он будет только для групп благотворительных организаций."}]}
'''
group = GroupFactory.create(remote_id=OWNER_ID)
post = PostFactory.create(remote_id=TR_POST_ID, wall_owner=group)
instance = CommentFactory.create(post=post)
author = UserFactory.create(remote_id=16271479)
instance.parse(json.loads(response)['response'][1])
instance.save()
self.assertEqual(instance.remote_id, '201164356_2505')
self.assertEqual(instance.text, u'Добрый день , кароче такая идея когда опросы создаешь вместо статуса - можно выбрать аудитории опрашиваемых, например только женский или мужской пол могут участвовать (то бишь голосовать в опросе).')
self.assertEqual(instance.author, author)
self.assertTrue(isinstance(instance.date, datetime))
instance = Comment(post=post)
instance.parse(json.loads(response)['response'][2])
instance.save()
self.assertEqual(instance.remote_id, '201164356_2507')
self.assertEqual(instance.reply_for.remote_id, 16271479)
def api_create_comment(id):
cookie_str = request.cookies.get(COOKIE_NAME)
user = {}
if cookie_str:
user = cookie2user(cookie_str)
if user is None:
r=jsonify({'error':'Please signin first'})
r.content_type = 'application/json'
return r
if not request.json['content'] or not request.json['content'].strip():
r=jsonify({'error':'no content'})
r.content_type = 'application/json'
return r
blog = Blog.query.filter(Blog.id==id).first()
reprint = Reprint.query.filter(Reprint.id==id).first()
b_id = ''
if blog is not None:
b_id = blog.id
if reprint is not None:
b_id = reprint.id
if not b_id:
r = jsonify({'error':'no blog'})
r.content_type = 'application/json'
return r
comment = Comment(blog_id=b_id, user_id=user.id, user_name=user.name, user_image=user.image, content=request.json['content'].strip())
db.session.add(comment)
db.session.commit()
a = comment.to_dict()
r = jsonify(a)
r.content_type = 'application/json;charset=utf-8'
return r
def post(self, key):
issue = db.get(key)
name = self.request.get("name")
email = self.request.get("email")
text = self.request.get("comment")
comment = Comment(
name = name,
email = email,
comment = text,
issue = issue,
)
comment.put()
context = {
'issue': issue,
}
# prepare the context for the template
# calculate the template path
path = os.path.join(os.path.dirname(__file__), 'templates',
'issue.html')
# render the template with the provided context
self.response.out.write(template.render(path, context))
def comment_add():
log('发送评论')
user_now = current_user()
form = request.get_json()
print('form, ', form)
c = Comment(form)
blog_id = form.get('blog_id', '')
# 设置是谁发的
c.sender_name = user_now.username
c.blog = Blog.query.filter_by(id=blog_id).first()
# 保存到数据库
c.save()
blog = c.blog
blog.com_count = len(Comment.query.filter_by(blog_id=blog.id).all())
blog.save()
log('写评论')
status = {
'content': c.content,
'sender_name': c.sender_name,
'created_time': formatted_time(c.created_time),
'id': c.id,
}
r = json.dumps(status, ensure_ascii=False)
print('r, ', r)
return r
def add_comment(request, movie_id):
newcomment = Comment(text=request.POST['comment_text'], movie=Movie.objects.filter(id=movie_id)[0])
newcomment.save()
comments = Comment.objects.filter(movie=movie_id)
movie = Movie.objects.filter(id=movie_id)[0]
context = {'comments':comments,'movie':movie}
return render(request, 'movies/movie.html', context)
def get(self):
post_id = int(self.request.get('id'))
post = Post.get_by_id(post_id)
post.comment += 1
post.put()
comment = Comment(post=post.key, content=self.request.get("content"))
comment.put()
def product_page(request, product_id):
product = Product.objects.get(pk=product_id)
product = get_object_or_404(Product, pk=product_id)
if request.method == 'POST':
form = CommentForm(request.POST)
if form.is_valid():
author_name = form.cleaned_data.get("author_name") or u"Гость"
body = form.cleaned_data.get("body")
c = Comment(author_name=author_name,
body=body,
product=product)
c.save()
return HttpResponseRedirect('/product/' + product_id)
else:
form = CommentForm()
categories = get_categories()
comments = product.comment_set.all().order_by('-date')[:10]
bread_categories = [MainMock()] + product.category.get_path_up()
print(bread_categories)
context_dict = dict(product=product,
categories=categories,
comments=comments,
form=form,
cart=get_cart(request),
bread_categories=bread_categories,
)
return render(request, 'store/product.html', context_dict)
def post(self):
photo_id = int(self.request.get('pid'))
Author = self.request.get('comment-name')
comment = self.request.get('comment')
photo = Image.get_Detail(photo_id)
logging.error("Author is" + Author)
logging.error(comment)
if Author == '' or comment == '':
pic_id = "/Home#" + str(photo_id)
self.redirect(pic_id)
else:
if photo:
try:
comment = Comment(
Author=Author,
Comment=comment, Image=photo.key)
comment.put()
logging.info("Horray, a comment is saved.")
except:
logging.error("Error saving comment in datastore.")
finally:
pic_id = "/Home#" + str(photo_id)
render = template.render('templates/redirect.html',
{'link': pic_id, 'message': 'Commented'})
self.response.write(render)
def add_comment(post_id):
comment = Comment(request.form['text'])
comment.author_id = current_user().id
comment.post_id = post_id
db.session.add(comment)
db.session.commit()
return redirect('/post/' + str(post_id))
def get(self):
# see if there is a key
comment = None
status = None
try:
comment = Comment.get( self.request.get('key') )
status = self.request.get('status')
except db.BadKeyError:
pass
if comment is None:
# show all the 'new' comments
comments = Comment.all().filter('status =', 'new').order('inserted').fetch(page_count+1)
more = True if len(comments) > page_count else False
comments = comments[:page_count]
vals = {
'comments' : comments,
'more' : more,
}
self.template( 'comment-list.html', vals, 'admin' )
else:
comment.status = status_map[status]
comment.put()
comment.node.regenerate()
self.redirect('./')
return
def newcomment(request, blog_id):
if request.user.is_authenticated():
comment = Comment(comment=request.POST.get('comment'), blog=Blog(pk=blog_id) )
comment.save()
return HttpResponseRedirect(reverse('Blog:main'))
else:
return HttpResponse("You are not logged in.")
def test_parse_comment(self):
response = u'''{"attrs": {"flags": "l,s"},
"author_id": "538901295641",
"date": "2014-04-11 12:53:02",
"id": "MTM5NzIwNjM4MjQ3MTotMTU5NDE6MTM5NzIwNjM4MjQ3MTo2MjUwMzkyOTY2MjMyMDox",
"like_count": 123,
"liked_it": false,
"reply_to_comment_id": "MTM5NzIwNjMzNjI2MTotODE0MzoxMzk3MjA2MzM2MjYxOjYyNTAzOTI5NjYyMzIwOjE=",
"reply_to_id": "134519031824",
"text": "наверное и я так буду делать!",
"type": "ACTIVE_MESSAGE"}'''
comment = CommentFactory(id='MTM5NzIwNjMzNjI2MTotODE0MzoxMzk3MjA2MzM2MjYxOjYyNTAzOTI5NjYyMzIwOjE=')
author = UserFactory(id=134519031824)
discussion = DiscussionFactory()
instance = Comment(discussion=discussion)
instance.parse(json.loads(response))
instance.save()
self.assertEqual(instance.id, 'MTM5NzIwNjM4MjQ3MTotMTU5NDE6MTM5NzIwNjM4MjQ3MTo2MjUwMzkyOTY2MjMyMDox')
self.assertEqual(instance.object_type, 'ACTIVE_MESSAGE')
self.assertEqual(instance.text, u"наверное и я так буду делать!")
self.assertEqual(instance.likes_count, 123)
self.assertEqual(instance.liked_it, False)
self.assertEqual(instance.author, User.objects.get(pk=538901295641))
self.assertEqual(instance.reply_to_comment, comment)
self.assertEqual(instance.reply_to_author, User.objects.get(pk=134519031824))
self.assertTrue(isinstance(instance.date, datetime))
self.assertTrue(isinstance(instance.attrs, dict))
def add(request):
redirect_to=COMMENT_REDIRECT_TO
if request.POST:
form=CommentForm(request.POST)
if form.is_valid():
if 'redirect' in form.cleaned_data:
redirect_to=form.cleaned_data['redirect']
else:
redirect_to=COMMENT_REDIRECT_TO
if not request.user.is_authenticated():
msg = _("In order to post a comment you should have a friendsnippets account.")
msg = urlquote_plus(msg)
if COMMENT_SIGNIN_VIEW:
redirect_to=reverse(COMMENT_SIGNIN_VIEW) + "?next=" + redirect_to + "&msg=" + msg
else:
redirect_to='/'
if not request.user.is_authenticated():
return HttpResponseRedirect(redirect_to)
try:
content_type=ContentType.objects.get(id=form.cleaned_data['content_type'])
except:
pass
if content_type:
params = {
'headline':form.cleaned_data['headline'],
'comment':form.cleaned_data['comment'],
'user':request.user,
'content_type':content_type,
'object_id':form.cleaned_data['object_id'],
}
c = Comment(**params)
c.save()
return HttpResponseRedirect(redirect_to)
def show_aloj_id(request,ide):
pathf=request.path+"/xmlfrances"
pathi=request.path+"/xmlingles"
try:
hotel=Hotel.objects.get(id=ide)
print hotel.stars
print hotel.tipo
except Hotel.DoesNotExist:
context={'name': ""}
return render_to_response('alojid.html',context);
listimages=Image.objects.filter(hid=hotel.id)
listcoms=""
if request.method =='POST':
value = request.POST.get('comentarios', "")
n= hotel.numbercom+1;
hotel.numbercom=n
hotel.save()
comment=Comment(hid=hotel.id,com=hotel,text=value)
comment.save()
listcoms=Comment.objects.filter(hid=hotel.id)
try:
us=PagUser.objects.get(user=request.user.username)
except PagUser.DoesNotExist:
context = {'lista':listimages[0:5],'condicion':"",'url':hotel.url,'name':hotel.name,'address':hotel.address,'body':hotel.body,'comentarios':listcoms,'type':hotel.tipo,'stars':hotel.stars,'pathf':pathf,'pathi':pathi,'id':ide,'email':hotel.email,
'phone':hotel.phone}
return render_to_response('alojid.html', context,context_instance = RequestContext(request))
context = {'lista':listimages[0:5],'condicion':"",'url':hotel.url,'name':hotel.name,'address':hotel.address,'body':hotel.body,'comentarios':listcoms,'type':hotel.tipo,'stars':hotel.stars,'pathf':pathf,'pathi':pathi,'id':ide,'email':hotel.email,
'phone':hotel.phone,'color':us.color,'size':us.size}
return render_to_response('alojid.html', context,context_instance = RequestContext(request))
def post(self, post_id):
session = get_current_session()
if session.has_key('user'):
message = helper.sanitizeHtml(self.request.get('message'))
user = session['user']
key = self.request.get('comment_key')
if len(message) > 0 and key == keys.comment_key:
try:
post = Post.all().filter('nice_url =', helper.parse_post_id( post_id ) ).get()
if post == None: #If for some reason the post doesn't have a nice url, we try the id. This is also the case of all old stories
post = db.get( helper.parse_post_id( post_id ) )
post.remove_from_memcache()
comment = Comment(message=message,user=user,post=post)
comment.put()
helper.killmetrics("Comment","Root", "posted", session, "",self)
vote = Vote(user=user, comment=comment, target_user=user)
vote.put()
Notification.create_notification_for_comment_and_user(comment,post.user)
self.redirect('/noticia/' + post_id)
except db.BadKeyError:
self.redirect('/')
else:
self.redirect('/noticia/' + post_id)
else:
self.redirect('/login')
def test_comment_approved(self):
post = Post(author=self.me, title="Hi", created_date=timezone.now())
post.save()
comment = Comment(author=self.me.username, post=post)
comment.approve()
comment.save()
assert comment in post.approved_comments()
def createComment(self, request):
"""Create new Comment object, returning CommentForm/request."""
author = self._getAuthorFromUser()
data['authorName'] = author.displayName
data['authorID'] = author.authorID
self._checkComment(request)
data = {'comment': request.comment}
# get the article key for where the comment will be added
article_key = self._checkKey(request.websafeArticleKey, 'Article')
comment_id = Comment.allocate_ids(size=1, parent=article_key)[0]
comment_key = ndb.Key(Comment, comment_id, parent=article_key)
data['key'] = comment_key
# create Comment
comment_key = Comment(**data).put()
# send alerts to all authors of Article and all other comments
#taskqueue.add(params={'email': author.mainEmail,
# 'CommentInfo': repr(request)},
# url='/tasks/send_comment_alert'
#)
return self._copyCommentToForm(comment_key.get(), article_key=article_key, author=author)
def submit_comment_view(request):
try:
if request.method == 'GET':
paper_id = int(request.GET['id'])
elif request.method == 'POST':
paper_id = int(request.POST['id'])
paper = Paper.objects.filter(id=paper_id).get()
comment = Comment()
comment.paper = paper
comment.user = request.user
if request.method == 'POST':
form = forms.SubmitCommentForm(request.POST, instance=comment)
if form.is_valid():
form.save(paper)
return HttpResponseRedirect("paper?id=%d" % paper_id)
else:
form = forms.SubmitCommentForm()
except (ValueError, KeyError, Paper.DoesNotExist):
paper = None
form = None
return render_to_response("submit_comment.html", RequestContext(request, {
'form' : form,
'paper' : paper,
}))
def delete_post(cls, post_id, user_id):
error_msg = None
posts = Post.all().order('-created').fetch(limit=10)
updated_post_list = posts
post = Post.get_by_id(post_id)
if user_id == post.created_by:
# delete comments of the post
comments = Comment.all().filter('post_id =', post_id).fetch(limit=10)
for c in comments:
Comment.delete(c)
# delete likes of the post
likes = Like.all().filter('post_id =', post_id).fetch(limit=10)
for l in likes:
Like.delete(l)
# delete the post
updated_post_list = cls.update_list_on_delete(
object_list=posts,
object_id=post_id
)
Post.delete(post)
else:
error_msg = 'You can delete only your own posts'
return updated_post_list, error_msg
def post_comment(request):
user = request.POST.get('user')
content = request.POST.get('content')
email = request.POST.get('email')
blog_id = request.POST.get('blog_id')
quote = request.POST.get("quote", "").split("###")
#过滤content里面的JS字符
content = content.replace("<", "<").replace(">", "> ")
blog = get_object_or_404(Article, pk=blog_id)
if len(quote) == 3 and \
Comment.objects.filter(pk=quote[2]):
content = u"""
<p>
引用来自<code>%s楼-%s</code>的发言
</p>""" % (quote[0], quote[1]) + content
comment = Comment(
article=blog,
email=email,
name=user,
content=content)
comment.save()
return HttpResponse("%d" % comment.id)
def add_comment(request, movie_id):
Cmovie = Movie.objects.filter(pk=movie_id)[0]
newcomment = Comment(text=request.POST['comment_text'], movie=Cmovie)
# when making new objects, always remember to save them
newcomment.save()
return HttpResponseRedirect('/movies/' + movie_id)
def random_comment(blog_post):
possible_comments = [
'Wow cool!',
'Neato!',
'Lame.',
'First post!',
'Was on Reddit yesterday.',
'Pics or didn\'t happen.',
'tl;dr was awesome',
'I was so sad today, this made me laugh so much thanks lol.',
'Do you think they care?',
'Do you believe in life after love?',
'I like this version better.',
'That was just great.',
'Upvoting because after reading your username, I\'m pretty sure you\'re trolling.',
'Lol. I saw this one first and was a bit confused.',
'I laughed so much!',
'This is awesome',
'Windows XP is the Playstation 2 of Operating Systems.',
'I think we\'ve all been there at one point'
]
ts = datetime.now() + timedelta(days=-random.randint(1, 50))
c = Comment(content=possible_comments[random.randint(0, len(possible_comments)-1)], timestamp=ts, blog_post=blog_post.key)
c.put()
def review_comment():
commid = request.json['commid']
review = request.json['review']
user = User.current()
if not user.anonymous:
Comment.approve(commid, review, user)
return jsonify(success=True)
def submit_comment_view(request):
import forms
user = UserProfile.objects.get(username=request.user.username)
try:
if request.method == 'GET':
paper_id = int(request.GET['id'])
elif request.method == 'POST':
paper_id = int(request.POST['id'])
paper = Paper.objects.filter(id=paper_id).get()
comment = Comment()
comment.paper = paper
comment.user = user
if request.method == 'POST':
form = forms.SubmitCommentForm(request.POST, instance=comment)
if form.is_valid():
form.save(paper)
return HttpResponseRedirect("paper?id=%s" % paper_id)
else:
form = forms.SubmitCommentForm()
except (ValueError, KeyError, Paper.DoesNotExist):
paper = None
form = None
return render(request, "submit_comment.html", {
'form' : form,
'paper' : paper,
'which_page' : "submit_comment"
})
def post_comment(text, author, suggestion):
brtext = text.replace('\n', '<br/>')
comment = Comment(text=brtext, author=author, suggestion=suggestion)
comment.put()
author.lastposted = date.today()
author.put()
notify_comment(text, comment)
def _post_comment(self, index_url, comment_str, auther_ip, user):
title=urlparse(index_url).netloc
print comment_str, user
logger.debug('Auther_ip:' + auther_ip
+ ' User:'******' Title:' + title
+ ' Index_url:' + index_url
+ ' Comment_str:' + comment_str)
comment_board, created = CommentBoard.objects.get_or_create(
url=index_url,
title=urlparse(index_url).netloc)
comment_board.save() if created else None
if user.is_authenticated():
comment = Comment(
time_added=datetime.datetime.utcnow().replace(
tzinfo=utc),
comment_str=comment_str,
comment_board=comment_board,
auther_ip=auther_ip,
user=user) # 以后换成auther，现在先用user
else:
'''
Annoymous User access the site.
'''
comment = Comment(
time_added=datetime.datetime.utcnow().replace(
tzinfo=utc),
comment_str=comment_str,
comment_board=comment_board,
auther_ip=auther_ip)
comment.save()
def teamProfile(teamId):
if current_user.team:
if int(teamId) == int(current_user.team_id):
return redirect(url_for('team_page'))
form = CommentForm()
team = db.session.query(Team).filter(Team.id == teamId).first()
comments = db.session.query(Comment).filter(Comment.idea_id == team.idea.id).all()
if not team:
flash('Team '+teamId+' not found.', 'error')
return redirect(url_for('home'))
else:
if form.validate_on_submit():
comment = Comment()
comment.content = form.comment.data
team.idea.comment.append(comment)
current_user.comment.append(comment)
db.session.add(comment)
for member in comment.idea.team.members:
notif = PersonalNotification()
notif.content = current_user.username + " commented on your team's idea."
member.notification.append(notif)
db.session.commit()
return render_template('team_view.html', form=form, team=team, comments=comments)
return render_template('team_view.html', form=form, team=team, comments=comments)
def execute(self):
invite_attendee = None
if self.invite_attendee_id:
invite_attendee = InviteAttendee.get_by_unique_id(
self.invite_attendee_id
)
invite = Invite.get_by_unique_id(self.invite_unique_id)
if invite is None:
raise InviteNotFoundException()
author = None
if invite_attendee is not None:
author = invite_attendee.name or invite_attendee.email or invite_attendee.phone
if invite.comments is None:
invite.comments = []
comment = Comment()
comment.author = author
comment.comment = self.comment
comment.commented_on = datetime.datetime.now()
invite.comments.append(comment)
invite.put()
return comment
def get(self):
params = self.request.url_params
print params
category = params[0]
which = params[1]
article, comment, comments, user = None, None, None, None
if category == 'article':
# delete article and all related comments
old_article = Article.select_one('created_at=?', which)
article = old_article
old_article.delete()
old_comments = Comment.select_all('article_id=?', article.id)
comments = old_comments
if old_comments:
for comment in old_comments:
comment.delete()
elif category == 'user':
old_user = User.select_one('id=?', which)
user = old_user
old_user.delete()
elif category == 'comment':
old_comment = Comment.select_one('id=?', which)
comment = old_comment
old_comment.delete()
return self.render('_delete.html', article=article, comment=comment, \
comments=comments, user=user)
def post(self, request, **kwargs):
status, aoi = self._get_aoi_and_update(self.kwargs.get('pk'))
if aoi.user_can_complete(request.user):
aoi = self._update_aoi(request, aoi, status)
Comment(aoi=aoi,
user=request.user,
text='changed status to %s' % status).save()
features_updated = 0
if 'feature_ids' in request.POST:
features = request.POST['feature_ids']
features = str(features)
if features and len(features):
try:
feature_ids = tuple(
[int(x) for x in features.split(',')])
feature_list = Feature.objects.filter(
id__in=feature_ids)
features_updated = feature_list.update(status=status)
except ValueError:
features_updated = 0
# send aoi completion event for badging
send_aoi_create_event(request.user, aoi.id,
aoi.features.all().count())
return HttpResponse(json.dumps({
aoi.id: aoi.status,
'features_updated': features_updated
}),
mimetype="application/json")
else:
error = dict(
error=403,
details="User not allowed to modify the status of this AOI.",
)
return HttpResponse(json.dumps(error), status=error.get('error'))
def entry_comments_api(entry_id=0):
comments = list(Comment.select().where(
Comment.entry_id == entry_id).order_by(Comment.t).dicts())
likes = list(Like.select().where(Like.entry_id == entry_id).dicts())
uids = list(
set([c['authorId'] for c in comments] + [l['uid'] for l in likes]))
users = dict()
for u in User.select().where(User.uid.in_(uids)).dicts():
users[u['uid']] = {'name': u['name'], 'headPic': u['headPic']}
for like in likes:
like['name'] = users.get(like['uid'], {}).get('name', '')
like['headPic'] = users.get(like['uid'], {}).get('headPic', '')
for comment in comments:
comment['headPic'] = users.get(comment['authorId'],
{}).get('headPic', '')
ret = dict(comments=comments, likes=likes, users=users)
if request.path.split('/')[1] == 'comments':
return jsonify(ret)
return ret
async def api_create_comment(id, request, *, content):
'''
在blog详情页创建评论保存（api）
:param id:
:param request:
:param content:
:return:
'''
# 已登录用户才有权限评论blog
check_signin(request)
user = request.__user__
if not content or not content.strip():
raise APIValueError('content', '请输入评论内容！')
blog = await Blog.findById(id)
if blog is None:
raise APIResourceNotFoundError('Blog', '评论此博客出错！')
comment = Comment(blog_id=blog.id,
user_id=user.id,
user_name=user.name,
user_image=user.image,
content=content.strip())
await comment.save()
return comment
async def api_create_comment(id, request, *, content):
"""
添加评论
:param id:
:param request:
:param content:
:return:
"""
user = request.__user__
if user is None:
raise APIPermissionError('Please signin first.')
if not content or not content.strip():
raise APIValueError('content')
blog = await Blog.find(id)
if blog is None:
raise APIResourceNotFoundError('Blog')
comment = Comment(blog_id=blog.id,
user_id=user.id,
user_name=user.name,
user_image=user.image,
content=content.strip())
await comment.save()
return comment
def get(self, post_id):
if self.good_cookie_exists():
# get user name from cookie
h = self.request.cookies.get('user')
curuser = h.split("|")[0]
comments = Comment.all().filter('post_id =', post_id)
# get post subject from Post table using post_id for
# display at top of page
key = db.Key.from_path('Post', int(post_id))
p = db.get(key)
if not p:
self.redirect("/")
return
subject = p.subject
self.render("comments.html",
comments=comments,
post_id=post_id,
curuser=curuser,
subject=subject)
else:
self.redirect("/login")
return
def comment():
comment_form = forms.CommentForm(request.form)
if request.method == 'POST' and comment_form.validate(): #to validate forms inputs. We also had to add it in _macro.html, in the list {{field.errors}}
'''print(comment_form.username.data)
print(comment_form.email.data)
print(comment_form.comment.data)
else:
print ("Error in the form!!")'''
user_id = session['user_id'] #since we work with cookies, this is the way to get the user_id
comment = Comment(user_id = user_id,
text = comment_form.comment.data)
print(comment)
db.session.add(comment)
db.session.commit()
success_message = "New comment created"
flash(success_message)
title = "Flask Course"
return render_template('comment.html', title = title, form = comment_form)
def create_comment(session, authorId, postId, content, properties):
print("Creating a comment")
try:
comment = Comment()
comment.authorId = authorId
comment.postId = postId
comment.postedAt = datetime.now().isoformat()
comment.content = content
session.add(comment)
session.commit()
session.refresh(comment) # Needs this to refer to comment.id
return json.dumps(
{
'comment_id': comment.id,
'http_response': 200,
'created_at': comment.postedAt
},
indent=2,
default=str)
except (sqlalchemy.exc.InterfaceError, sqlalchemy.exc.OperationalError):
print(
"Database is down, crashing service. Restarting, sending default error on rapid"
)
jsonObject = json.dumps(
{
'comment_id': 9999999,
'http_response': 403,
'created_at': 9999999
},
indent=2,
default=str)
properties.headers['http_response'] = 503
send("ConfirmCommentCreation", jsonObject, properties)
exit()
#raise Exception("Database is down, crashing service. Restarting, sending default error on rapid")
except Exception as e:
print("[-] Exception ", e.__class__, " occurred.")
return json.dumps(
{
'comment_id': 9999999,
'http_response': 403,
'created_at': 9999999
},
indent=2,
default=str)
def post(self, post_id):
"""
post: Post
Args:
self: This object
post_id: Post ID
"""
if not self.user:
return self.redirect('/login')
b = Post.get_by_id(int(post_id), parent=blog_key())
#
# Check that user IDs match
#
user_id = self.user.key().id()
if b.user_id != user_id:
return self.redirect('/blog/%s' % str(b.key().id()))
b.delete()
comments = Comment.all().filter('post_id =', post_id)
for comment in comments:
comment.delete()
self.redirect('/blog/postdeleted')
def post(self, thread_name):
'''Add a comment to thread.'''
args, author_name = parse_and_decode()
text = bleach.clean(args['text'], strip=True)
# Get thread (add if needed)
try:
thread = (db.session.query(Thread)
.filter(Thread.name == thread_name).one())
except NoResultFound:
thread = Thread(name=thread_name)
db.session.add(thread)
db.session.commit()
author_id = get_author_add_if_needed(author_name)
now = arrow.utcnow()
comment = Comment(author_id=author_id, text=text, thread_id=thread.id,
created=now, modified=now)
db.session.add(comment)
db.session.commit()
return get_thread_comments(thread)
def get_single_comment(id):
with sqlite3.connect("./rare.db") as conn:
conn.row_factory = sqlite3.Row
db_cursor = conn.cursor()
db_cursor.execute(
"""
SELECT
c.id,
c.post_id,
c.author_id,
c.content,
c.created_on,
u.username username
FROM Comments c
JOIN Users u
ON u.id = c.author_id
WHERE c.id = ?
""", (id, ))
data = db_cursor.fetchone()
comment = Comment(data['id'], data['post_id'], data['author_id'],
data['content'], data['created_on'],
data['username'])
return json.dumps(comment.__dict__)
def comment():
#Aqui llamaos a la clase forms.CommentForm() q tiene nuestro archivo
#Ahora si nuestra tambien si viene algun tipo de tados creamos una instancia con eso tipo de datos
#Para luego verlos en nuestros inputs
comment_form = forms.CommentForm(request.form)
#Aqui sencillamente lo q se hace es q si el method es Post mostramos los datos nuestro formulario
if request.method == "POST" and comment_form.validate():
user_id = session["user_id"]
comment = Comment(
user_id=user_id,
text=comment_form.comment.data,
)
db.session.add(comment)
db.session.commit()
success_message = "Nuevo Comentario Creado Satifactoriamente!"
flash(success_message)
else:
print("Error En El Formulario!.")
title = "Curso Flask| Formulario De Comentarios"
return render_template("comment.html", title=title, form=comment_form)
def get_single_comment(id):
with sqlite3.connect("./rare.db") as conn:
conn.row_factory = sqlite3.Row
db_cursor = conn.cursor()
db_cursor.execute(
"""
SELECT
c.id,
c.commentSubject,
c.commentBody,
c.userId,
c.postId
FROM Comment c
WHERE c.id = ?
""", (id, ))
data = db_cursor.fetchone()
comment = Comment(data['id'], data['commentSubject'],
data['commentBody'], data['userId'], data['postId'])
return json.dumps(comment.__dict__)
async def api_create_comment(id, request, *, content):
# 对某个博客发表评论
user = request.__user__
# 必须为登陆状态下，评论
if user is None:
raise APIPermissionError('content')
# 评论不能为空
if not content or not content.strip():
raise APIValueError('content')
# 查询一下博客id是否有对应的博客
blog = await Blog.find(id)
# 没有的话抛出错误
if blog is None:
raise APIResourceNotFoundError('Blog')
# 构建一条评论数据
comment = Comment(blog_id=blog.id,
user_id=user.id,
user_name=user.name,
user_image=user.image,
content=content.strip())
# 保存到评论表里
await comment.save()
return comment
def comment_delete():
data = request.get_json()
id = data.get('id')
comment = Comment.find_by_pk(id)
if comment:
try:
comment.topic.update_comment_count(offset=-1)
comment.topic.update_user_comment_count(offset=-1,
user_id=comment.user_id)
comment.delete()
db_session.commit()
cache.update_topic(comment.topic.id, comment.topic)
cache.update_sorted_topics(comment.topic, 'comment_count')
return json_data(data)
except Exception:
db_session.rollback()
return json_error_database()
else:
return json_error_invalid_request()
def get(self, post_id):
k = db.Key.from_path('Comment', int(post_id), parent=blog_key())
c = db.get(k)
if not c:
self.error(404)
return
if self.user and (self.user.key() == c.comment_user.key()):
self.render("deletepage.html", comment=c.content)
elif self.user and (self.user.key() != c.comment_user.key()):
error = "You can only delete comments you created"
posts = greetings = Post.all().order('-created')
comments = Comment.all().order('-created')
self.render('front.html',
posts=posts,
comments=comments,
error=error)
else:
self.redirect('/login')
def get(self, comment_id):
"""
get: Get
Args:
self: This object
comment_id: Comment ID
"""
c = Comment.get_by_id(int(comment_id), parent=blog_key())
if not c:
self.render('notfound.html')
return
#
# Check that user IDs match
#
user_id = self.user.key().id()
if c.user_id != user_id:
self.redirect('/blog/comment/%s' % str(c.key().id()))
content = c.content
self.render('deletecomment.html',
content=content,
comment_id=comment_id)
def get(self, direction='next', page='2', base_id='1'):
if page == '1':
self.redirect(BASE_URL)
return
objs = Article.get_page_posts(direction, page, base_id)
if objs:
if direction == 'prev':
objs.reverse()
fromid = objs[0].id
endid = objs[-1].id
else:
fromid = endid = ''
allpost = Article.count_all_post()
allpage = allpost / EACH_PAGE_POST_NUM
if allpost % EACH_PAGE_POST_NUM:
allpage += 1
output = self.render(
'index.html', {
'title': "%s - %s | Part %s" %
(SITE_TITLE, SITE_SUB_TITLE, page),
'keywords': KEYWORDS,
'description': SITE_DECR,
'objs': objs,
'cats': Category.get_all_cat_name(),
'tags': Tag.get_hot_tag_name(),
'page': int(page),
'allpage': allpage,
'listtype': 'index',
'fromid': fromid,
'endid': endid,
'comments': Comment.get_recent_comments(),
'links': Link.get_all_links(),
},
layout='_layout.html')
self.write(output)
return output
def post_recovery(database_entry, requested_post):
try:
if current_user.email != requested_post["author_email"] \
or current_user.author is False and current_user.admin is False:
return abort(403)
except AttributeError:
return abort(401)
except KeyError:
return abort(400)
comments = requested_post["comments"]
new_post = BlogPost(
author=User.query.filter_by(
email=requested_post["author_email"]).first(),
title=requested_post["post_title"],
subtitle=requested_post["subtitle"],
date=requested_post["date"],
body=requested_post["body"],
img_url=requested_post["img_url"],
)
db.session.add(new_post)
for comment in comments:
new_comment = Comment(
author=User.query.filter_by(email=comment["author_email"]).first(),
parent_post=new_post,
comment=comment["comment"],
date=comment["date"])
db.session.add(new_comment)
for reply in comment["replies"]:
new_reply = Reply(author=User.query.filter_by(
email=reply["author_email"]).first(),
parent_comment=new_comment,
reply=reply["reply"],
date=reply['date'])
db.session.add(new_reply)
db.session.delete(database_entry)
db.session.commit()
return redirect(url_for('home.home_page'))
def movie_detail(movie_id):
movie = Movie.query.filter_by(brief_id=movie_id).first()
if request.method == 'POST':
print(request.form.get('comment'))
comment = request.form.get('comment')
u = User.query.filter_by(id=current_user.get_id()).first()
c = Comment(
user=u,
movie=movie,
comment_time=datetime.datetime.now(),
content=comment,
point=5,
)
db.session.add(c)
db.session.commit()
comments = movie.comments.all()
can_watched = False
if current_user.is_authenticated:
consume_records = ConsumeRecord.query.filter_by(
consumer=current_user).all()
bought_moveis = [record.movie for record in consume_records]
if movie in bought_moveis:
can_watched = True
if not movie:
abort(404)
return render_template(
'movie_detail.html',
movie=movie,
user=current_user,
comments=comments,
can_watched=can_watched,
)
def post(self, user, post_key, comment_id):
"""Handle Post Comments requests."""
data = json.loads(self.request.body)
reply_data = data['replyData']
post = ndb.Key(urlsafe=post_key).get()
institution = post.institution.get()
Utils._assert(not institution.is_active(),
"This institution is not active", NotAuthorizedException)
Utils._assert(post.state == 'deleted', "This post has been deleted",
EntityException)
reply = Comment.create(reply_data, user)
post.reply_comment(reply, comment_id)
notification_message = post.create_notification_message(
user_key=user.key,
current_institution_key=user.current_institution,
sender_institution_key=post.institution)
notification_type = 'COMMENT'
if (post.author != user.key):
send_message_notification(receiver_key=post.author.urlsafe(),
notification_type=notification_type,
entity_key=post.key.urlsafe(),
message=notification_message)
comment = post.get_comment(comment_id)
notification_type = "REPLY_COMMENT"
if (comment.get('author_key') != user.key.urlsafe()):
send_message_notification(receiver_key=comment.get('author_key'),
notification_type=notification_type,
entity_key=post.key.urlsafe(),
message=notification_message)
self.response.write(json.dumps(Utils.toJson(reply)))
def get(self, post_id):
session = get_current_session()
if session.has_key('user'):
user = session['user']
try:
post = db.get(helper.parse_post_id(post_id))
comments = Comment.all().filter(
"post =", post.key()).order("-karma").fetch(1000)
comments = helper.order_comment_list_in_memory(comments)
prefetch.prefetch_comment_list(comments)
display_post_title = True
prefetch.prefetch_posts_list([post])
if helper.is_json(post_id):
comments_json = [
c.to_json() for c in comments if not c.father_ref()
]
if (self.request.get('callback')):
self.response.headers[
'Content-Type'] = "application/javascript"
self.response.out.write(
self.request.get('callback') + '(' +
simplejson.dumps({
'post': post.to_json(),
'comments': comments_json
}) + ')')
else:
self.response.headers['Content-Type'] = "application/json"
self.response.out.write(
simplejson.dumps({
'post': post.to_json(),
'comments': comments_json
}))
else:
self.response.out.write(
template.render('templates/post.html', locals()))
except db.BadKeyError:
self.redirect('/')
def post(self, share_key, comment_id):
shared_file = models.Sharedfile.get_by_share_key(share_key)
user = self.get_current_user_object()
comment = Comment.get("id=%s", comment_id)
if not shared_file or not comment:
raise tornado.web.HTTPError(404)
existing_comment_like = models.CommentLike.get("comment_id = %s and user_id = %s",
comment.id, user.id)
if existing_comment_like:
existing_comment_like.deleted = 1
existing_comment_like.save()
json = self.get_argument("json", False)
if json:
self.set_header("Cache-Control","no-store, no-cache, must-revalidate");
self.set_header("Pragma","no-cache");
self.set_header("Expires", 0);
count = models.CommentLike.where_count("comment_id = %s", comment.id)
return self.write(json_encode({'response':'ok', 'count': count, 'like' : True }))
else:
return self.redirect("/p/%s?salty" % (share_key,))
def commentInfoUpdate():
values = request.values
comment_body = values.get('comment')
comment_since = values.get('comment_since')
token = request.headers.get('token','')
postid = values.get('postid')
if not token:
return jsonify({
'code':-1,
'errmsg':'illegal token'
})
u = getUserbyToken(token)
if u is None:
return jsonify({
'code':-1,
'errmsg':'illegal token'
})
a = Article.query.get(postid)
app.logger.info('article id:: {}'.format(a.id))
if a is None:
return jsonify({
'code':-1,
'errmsg':'illegal token'
})
c = Comment(comment=comment_body,comment_since=comment_since)
db.session.add(c)
u.comments.append(c)
a.comments.append(c)
a.comment_num += 1
# c.user = u
db.session.commit()
return jsonify({
'code':1,
'msg':'add a comment successfully'
})
def update_existing_submissions_comments(self):
for submission in Submission.objects:
last_comment = Comment.objects(
submission_id=submission.id).order_by('timestamp').first()
if last_comment:
reddit_submission = self.reddit.submission(submission.id)
try:
reddit_submission.author
# submission was deleted
except prawcore.exceptions.NotFound:
logging.error('Submission %s was deleted', submission.id)
continue
except prawcore.exceptions.Forbidden:
logging.error('Access restricted for submission %s',
submission.id)
continue
except Exception as exc:
logging.error(exc.message)
continue
self.read_submission_comments(reddit_submission,
submission.subreddit,
submission.id,
timestamp=last_comment.timestamp)
def item(id):
item = Commodity.query.get_or_404(id)
form = CommentForm()
if item.clitime == None:
item.clitime = 0
item.clitime = item.clitime + 1
if form.validate_on_submit():
username = form.reciver.data
reciver = User.query.filter_by(username=username).first()
comment = Comment(body=form.body.data,
commodity=item,
author=current_user._get_current_object(),
reciver=reciver)
print reciver.unreadcomments
reciver.unreadcomments = reciver.unreadcomments + 1
db.session.add(comment)
db.session.commit()
return redirect(url_for('item', id=item.id))
comments = item.comments.filter_by(disabled=0).order_by(
Comment.timestamp.asc())
return render_template('detail.html',
item=item,
comments=comments,
form=form)
def comment(id_):
if request.method != 'POST':
raise RequestMethodNotAllowed(
msg="The method %s is not allowed for the requested URL" %
request.method)
video = db.session.query(Video).filter_by(id=id_).first()
user_id = g.user.uid
if video:
form = VideoPutCommentForm()
if form.validate_for_api() and form.validate():
video.comments = video.comments + 1
db.session.commit()
comment_content = form.comment.data
comment_new = Comment(content=comment_content,
uid=user_id,
target=id_)
db.session.add(comment_new)
db.session.commit()
data = {'id': comment_new.id}
return success(message="评论成功", data=data)
else:
return params_error(message=form.get_error())
else:
return params_error(message="未查到视频")
def add_comment(requested_post, comment):
if requested_post:
post_id = requested_post.id
if current_user.is_authenticated:
new_comment = Comment(author=current_user,
parent_post=requested_post,
comment=comment,
date=generate_date())
new_notification = Notification(
user=requested_post.author,
by_user=current_user.email,
user_name=current_user.name,
parent_comment=new_comment,
category='comment',
body=f"{current_user.name} commented on your post.",
date=generate_date())
db.session.add(new_comment, new_notification)
db.session.commit()
return redirect(url_for('post.show_post', post_id=post_id))
else:
flash("User is not logged in.")
return redirect(url_for('post.show_post', post_id=post_id))
else:
return abort(404)
def get_all_comments():
with sqlite3.connect("./rare.db") as conn:
conn.row_factory = sqlite3.Row
db_cursor = conn.cursor()
db_cursor.execute("""
SELECT
id,
post_id,
author_id,
content
FROM Comments
""")
dataset = db_cursor.fetchall()
comments = []
for row in dataset:
comment = Comment(row['id'], row['post_id'], row['author_id'],
row['content'])
comments.append(comment.__dict__)
return json.dumps(comments)
def module002_new_comment():
form = CommentForm()
id = request.args.get('id')
errors = None
if request.method == 'POST':
post = Post.query.get(id)
follows = db.session.query(Forum).join(Course, User.courses)\
.filter(and_(Forum.course_id == post.forum_id)).first()
if follows is None:
errors = 'You are not following the course'
if current_user.is_authenticated and form.validate_on_submit() and follows is not None:
comment = Comment(author_id=current_user.id,
post_id=id,
body=form.body.data)
db.session.add(comment)
db.session.commit()
flash("Successfully created a new comment")
else:
if errors:
flash(errors)
else:
flash("An error has occurred while sending your comment")
flash("Post id:" + id + " " + form.body.data)
return redirect(url_for('module002.module002_post_comments', id=id))
def get_blog(id):
blog = yield from Blog.find(id)
comments = yield from Comment.findAll('blog_id=?', [id],
orderBy='created_at desc')
for c in comments:
c.html_content = text2html(c.content)
blog.html_content = markdown2.markdown(blog.content)
num = yield from Finance.findNumber('count(id)')
page = Page(num)
if num == 0:
finances = []
else:
finances = yield from Finance.findAll(orderBy='created_at desc')
rev = []
for fin in finances:
rev.append(int(fin.revenue))
return {
'__template__': 'blog.html',
'blog': blog,
'comments': comments,
'page': page,
'finances': finances,
'rev': rev
}
