def post(self, gid, pid): u = request.authorization # this gives dict uid = User.objects.get( username=u['username']) # this gives user object user_id = str(uid.id) # this gives the user id in string format body = request.get_json() user = User.objects.get(id=user_id) group = Group.objects.get(id=gid) post = Post.objects.get(id=pid) if post.approval: if user_id in group.role_dict: comment = Comment(**body, post_id=ObjectId(pid)) comment.date_created = datetime.now() comment.save() # update last active status for user temp_dict = group.last_active_dict temp_dict[user_id] = datetime.now() group.update(set__last_active_dict=temp_dict) content = "{name} has posted a comment today".format( name=user.username) queue.enqueue( printhello()) # this is just a check that q works queue.enqueue(send_mail, user.email, content) # queue.enqueue(send_email(user.email, content)) # send_email(user.email, content) return {'comment_id': str(comment.id)}, 200 else: return "You ain't a member of this group", 200
def post(self, topic_id): content = cgi.escape(self.request.get("content")) if content: Comment.save_comment(topic_id, content) else: user_id = users.get_current_user().email() Subscription.save_subscription(topic_id, user_id) return self.redirect_to("topic-details", topic_id=topic_id)
def post(self, post_id): value_csrf = self.request.get('csrf-token') if not memcache.get(value_csrf): return self.write('CSRF Attack Detected!') post = Post.get_by_id(int(post_id)) content = cgi.escape(self.request.get('comment')) Comment.save_comment(post_id, content) return self.redirect_to('post', post_id=post.key.id())
def test_comment_delete_handler(self): # POST test topic via '/topic/add' csrf_token = str(uuid.uuid4()) memcache.add(key=csrf_token, value=True, time=600) title = "Some new topic" content = "This is a new topic. Just for testing purposes." params = {"title": title, "content": content, "csrf_token": csrf_token} post = self.testapp.post('/topic/add', params) self.assertEqual(post.status_int, 302) # POST test comment via '/topic/details/<topic_id>' content = "This is a new comment. Just for testing purposes." params = {"content": content, "csrf_token": csrf_token} topic = Topic.query().get() # topic_id is extracted from request when creating comment via TopicDetails handler # Comment.save_comment(topic_id, content) post = self.testapp.post('/topic/details/' + str(topic.key.id()), params) self.assertEqual(post.status_int, 302) # Delete comment via '/comment/delete/<comment_id>' comment = Comment.query().get() params = {"csrf_token": csrf_token} post = self.testapp.post('/comment/delete/' + str(comment.key.id()), params, {'referer': '/user-comments'}) self.assertEqual(post.status_int, 302) # check if comment.deleted field was set to True self.assertEqual(comment.deleted, True) post = self.testapp.post('/comment/delete/' + str(comment.key.id()), params, {'referer': '/topic/details/' + str(topic.key.id())}) self.assertEqual(post.status_int, 302)
def run(): """Analyse reddit comments from a subreddit.""" print input_path = config.INPUT_PATH comment_row_list = csv_util.read_csv(input_path) comment_list = [] pos_list = [] neg_list = [] # calculate sentiment for each comment for comment_row in comment_row_list: comment = Comment(comment_row) comment = calculate_sentiment(comment) comment_list.append(comment) if comment.compound_score > 0.2: pos_list.append(comment.body) elif comment.compound_score < -0.2: neg_list.append(comment.body) # write out CSV with sentiment score for each comment output_path = config.OUTPUT_PATH csv_util.write_row(output_path, comment=None, header=HEADER) for comment in comment_list: csv_util.write_row(output_path, comment=comment) # distribution analysis (pos_res, all_words_pos, neg_res, all_words_neg) = calculate_word_distributions(pos_list, neg_list)
def parser_song(song_id, art): tree = get_tree(SONG_URL.format(song_id)) song = session.query(Song).filter_by(id=song_id).all() r = post(COMMENTS_URL.format(song_id)) if r.status_code != 200: print('API error: Song: {}'.format(song_id)) return data = r.json() if not song: for404 = tree.xpath('//div[@class="n-for404"]') if for404: return try: song_name = tree.xpath('//em[@class="f-ff2"]/text()')[0].strip() except IndexError: try: song_name = tree.xpath( '//meta[@name="keywords"]/@content')[0].strip() except IndexError: print('Fetch limit!') time.sleep(10) return parser_song(song_id, art) song = Song(id=song_id, name=str(song_name), art_id=art.id, comment_count=int(data['total'])) session.add(song) session.commit() else: song = song[0] for comment_ in data['hotComments']: comment_id = comment_['commentId'] content = comment_['content'] like_count = comment_['likedCount'] user_ = comment_['user'] if not user_: continue user = session.query(User).filter_by(id=user_['userId']).all() if not user: user = User(id=user_['userId'], name=user_['nickname'], picture=user_['avatarUrl']) try: session.add(user) session.commit() except Exception as e: continue else: user = user[0] comment = session.query(Comment).filter_by(id=comment_id).all() if not comment: comment = Comment(id=comment_id, use_id=user.id, song_id=song.id, content=content, like_count=like_count) session.add(comment) session.commit() return song
def post(self): # If not a logged in user redirect to login if not self.user: self.redirect('/login') else: comment = self.request.get('comment') post_id = int(self.request.get('post_id')) post = Post.get_by_id(post_id, parent=blog_key()) author = self.user if not comment: return # do nothing if empty comment else: c = Comment(content=comment, author=author.key, post=post.key) c.put() comment = Comment.render_single_comment(c) # return JSON to Ajax self.write(json.dumps(({'comment': comment})))
def insertComment(self,jokeid,userid,content): if jokeid=='': self.status=201 self.message='jokeid不能为空' jsonStr=self.getJsonResult() self.write(jsonStr) elif userid=='': self.status=201 self.message='userid不能为空' jsonStr=self.getJsonResult() self.write(jsonStr) elif content=='': self.status=201 self.message='content不能为空' jsonStr=self.getJsonResult() self.write(jsonStr) elif not self.checkUser(userid): self.status=201 self.message='该userid不存在' jsonStr=self.getJsonResult() self.write(jsonStr) elif not self.checkJoke(jokeid): self.status=201 self.message='该jokeid不存在' jsonStr=self.getJsonResult() self.write(jsonStr) else: commentid=uuid.uuid1().hex; newcomment=Comment() newcomment.commentid=commentid newcomment.userid=userid newcomment.jokeid=jokeid newcomment.content=content self.db.add(newcomment) self.db.commit() self.db.close() self.status=200 jsonStr=self.getJsonResult() self.write(jsonStr)
def get(self): current_time = datetime.now() time_deleted_limit = current_time - timedelta(minutes=2) comments = Comment.query( Comment.deleted == True, Comment.time_updated < time_deleted_limit).fetch() for comment in comments: comment.key.delete()
def post(self): if not self.user: self.redirect('/login') else: comment_id = int(self.request.get('comment_id')) comment = Comment.get_by_id(comment_id) if self.user.key.id() == comment.author.id(): comment.key.delete() self.write(json.dumps(({'success': 'Comment deleted'})))
def post(self, topic_id): csrf_token = self.request.get("csrf_token") mem_token = memcache.get( key=csrf_token) # find if this CSRF exists in memcache if not mem_token: # if token does not exist in memcache, write the following message return self.write("Attack attempt detected...") user = users.get_current_user() if not user: return self.write( "Please login before you're allowed to post a topic.") topic = Topic.get_by_id(int(topic_id)) text = self.request.get("comment") Comment.create(content=text, user=user, topic=topic) return self.redirect_to("topic_details", topic_id=topic.key.id())
def get(self, topic_id): csrf_token = str(uuid.uuid4()) memcache.add(key=csrf_token, value=True, time=600) topic = Topic.get_by_id(int(topic_id)) comment = Comment.query(Comment.topic_id == topic.key.id()).order( Comment.created).fetch() params = {"topic": topic, "comment": comment, "csrf_token": csrf_token} return self.render_template("topic_details.html", params=params)
def post(self, topic_id): user = users.get_current_user() time = datetime.datetime.now() csrf_token = self.request.get("csrf_token") mem_token = memcache.get(key=csrf_token) if mem_token: return self.write("Hacker at the doors") comment = self.request.get("comment") topic = Topic.get_by_id(int(topic_id)) new_comment = Comment(content=comment, topic_id=topic.key.id(), author_email=user.email(), topic_title=topic.title, created=time) new_comment.put() return self.redirect_to("topic-details", topic_id=topic.key.id())
def get(self, post_id): post = Post.get_by_id(int(post_id)) user = users.get_current_user() email = '' if user: email = user.email() comments = Comment.query(Comment.user_email == email, Comment.postID == post.key.id()).fetch() params = {'post': post, 'comments': comments} return self.render_template('delete_comment.html', params=params)
def get(self): user = users.get_current_user() user_comments = Comment.query( Comment.user_id == user.email(), Comment.deleted == False).order(-Comment.create_time).fetch() params = { "user_comments": user_comments } return self.render_template_with_csrf("user_comments.html", params)
def get(self, gid, pid): user = request.authorization # this gives dict uid = User.objects.get(username=user['username']) # this gives user object group = Group.objects.get(id=gid) post = Post.objects.get(id=pid) if gid in post.group_id: if post.approval: comments = Comment.objects(post_id=pid).to_json() return Response(comments, mimetype="application/json", status=200) else: return "You do not have the required access", 200
def post(self, slug): context = self.get_context(slug) form = context.get('form') if form.validate(): comment = Comment() form.populate_obj(comment) post = context.get('post') post.comments.append(comment) post.save() return redirect(url_for('posts.detail', slug=slug)) return render_template('posts/detail.html', **context)
def store_comment(post_id: int, request: MultiDict, engine: Engine) -> str: """Extract comment information from request object; validate and store :param post_id: post 'id' to which the comment refers :param request: Flask request object :param engine: SQLAlchemy engine object """ # fill in comment form form = CommentForm(request.form) # validate response, comment and store comment in database if request.method == 'POST': if form.validate(): comment = Comment(post_id, request.form.get('name'), request.form.get('content'), request.form.get('email'), request.form.get('occupation')) if comment.to_sql(engine): return 'success' # indicate source of error on failed validation elif len(request.form.get('content')) > 1000: return 'Comment too long. A maximum of 1000 characters is allowed.' elif len(request.form.get('content')) < 5: return 'Comment too short. At least 5 characters are required.' elif len(request.form.get('name')) > 20: return 'Name too long. A maximum of 20 characters is allowed.' elif len(request.form.get('email')) > 50: return 'Email address too long. A maximum of 50 characters is allowed.' elif len(request.form.get('email')) < 5: return 'Email address too short. At least 5 characters are required.' elif len(request.form.get('occupation')) > 100: return 'Occupation name too long. A maximum of 100 characters is allowed.' return ''
def get(self, cid, gid): user = request.authorization uid = User.objects.get(username=user['username']) uid = str(uid.id) try: group = Group.objects.get(id=gid) if uid in group.role_dict: comment = Comment.objects(id=cid).to_json() return Response(comment, mimetype="application/json", status=200) else: return "You are not member of the group", 500 except: return "Invalid group or comment id", 500
def get(self, topic_id): topic = Topic.get_by_id(int(topic_id)) comments = comments = Comment.query(Comment.topic_id == topic.key.id(), Comment.deleted == False).order( Comment.created).fetch() csrf_token = str(uuid.uuid4()) # convert UUID to string memcache.add(key=csrf_token, value=True, time=600) params = { "topic": topic, "comments": comments, "csrf_token": csrf_token } return self.render_template("topic_details.html", params=params)
def delete(self, gid, cid): user = request.authorization # this gives dict uid = User.objects.get( username=user['username']) # this gives user object user_id = str(uid.id) # this gives the user id in string format comment = Comment.objects.get(id=cid) group = Group.objects.get(id=gid) try: role = group.role_dict[user_id] comments = Comment.objects(user_id=user_id) if comment in comments or role == A or role == MD: comment.delete() return "Comment deleted", 200 else: return "You don't have the permission required", 200 except: return "You ain't a member of the group", 200
def post(self, post_id): post = Post.get_by_id(int(post_id)) user = users.get_current_user() email = '' if user: email = user.email() comments = Comment.query(Comment.user_email == email, Comment.postID == post.key.id()).fetch() for comment in comments: if comment.user_email == email: comment.deleted = True comment.put() return self.redirect_to('main-page')
def post(self): if not self.user: self.redirect('/login') else: comment_id = int(self.request.get('comment_id')) new_comment = self.request.get('new_comment') comment = Comment.get_by_id(comment_id) if comment: if comment.author.id() == self.user.key.id(): comment.content = new_comment comment.put() self.write( json.dumps(({ 'comment': self.render_comment(comment.content) }))) else: self.write(json.dumps(({'comment': "There was no comment"})))
def test_topic_details_handler(self): # Create test topic title = "Some new topic" content = "This is a new topic. Just for testing purposes." topic = Topic(user_id=os.environ['USER_EMAIL'], title=title, content=content) topic.put() # GET topic = Topic.query().get() get = self.testapp.get('/topic/details/' + str(topic.key.id())) self.assertEqual(get.status_int, 200) self.assertEqual(topic.title, title) # POST # 1. POST test comment via '/topic/details/<topic_id>' csrf_token = str(uuid.uuid4()) memcache.add(key=csrf_token, value=True, time=600) content = "This is a new comment. Just for testing purposes." params = {"content": content, "csrf_token": csrf_token} # topic_id is extracted from request when creating comment via TopicDetails handler # Comment.save_comment(topic_id, content) post = self.testapp.post('/topic/details/' + str(topic.key.id()), params) self.assertEqual(post.status_int, 302) comment = Comment.query().get() self.assertEqual(comment.content, content) # 2. POST test subscription via '/topic/details/<topic_id>' params = {"csrf_token": csrf_token} # topic_id is extracted from request when creating comment via TopicDetails handler # Subscription.save_comment(topic_id, user_id) post = self.testapp.post('/topic/details/' + str(topic.key.id()), params) self.assertEqual(post.status_int, 302) subscription = Subscription.query().get() self.assertEqual(subscription.user_id, os.environ['USER_EMAIL'])
def get(self, post_id): post = Post.get_by_id(int(post_id)) comments = Comment.query(Comment.postID == post.key.id(), Comment.deleted == False).order(-Comment.time_posted).fetch() admin = users.is_current_user_admin() author = post.user_email user = users.get_current_user() email = '' if user: email = user.email() params = { 'post': post, 'comments': comments, 'admin': admin, 'author': author, 'email': email, } return self.render_template('post.html', params=params)
def add_post_comment(): groups = Group.objects for group in groups: temp_dict = group.last_active_dict for user_id in group.role_dict.keys(): temp_dict[user_id] = datetime.now() name = ''.join([ random.choice(string.ascii_letters + string.digits) for k in range(9) ]) content1 = "post is {name}".format(name=name) post = Post(user_id=ObjectId(user_id), group_id=ObjectId(group.id), content=content1).save() content2 = "comment is {name}".format(name=name) Comment(user_id=ObjectId(user_id), post_id=post.id, content=content2).save() group.update(set__last_active_dict=temp_dict)
def from_sql(engine: Engine, post_id: int, comment_id: int) -> Optional[Comment]: """Generate a Comment object from a SQL table :param engine: SQLAlchemy engine object :param post_id: Entry identifier in comments table :param comment_id: Comment identifier in comments table :return: populated Comment object """ comments = get_comments(engine, post_id, comment_id) comment = None # populate comment if 'id' exists if len(comments) > 0: c = comments[0] comment = Comment(c['post_id'], c['name'], c['content'], c['email']) return comment
def get(self, topic_id): topic = Topic.get_by_id(int(topic_id)) # get comments comments = (Comment.query( Comment.topic_id == topic_id, Comment.deleted == False).order(-Comment.create_time).fetch() ) params = { "topic": topic, "comments": comments } user = users.get_current_user() if user: subscribed = Subscription.query( Subscription.user_id == user.email(), Subscription.topic_id == topic_id).fetch() if subscribed: params["subscribed"] = True return self.render_template_with_csrf("topic_details.html", params)
def insertComment(self, jokeid, userid, content): if jokeid == '': self.status = 201 self.message = 'jokeid不能为空' jsonStr = self.getJsonResult() self.write(jsonStr) elif userid == '': self.status = 201 self.message = 'userid不能为空' jsonStr = self.getJsonResult() self.write(jsonStr) elif content == '': self.status = 201 self.message = 'content不能为空' jsonStr = self.getJsonResult() self.write(jsonStr) elif not self.checkUser(userid): self.status = 201 self.message = '该userid不存在' jsonStr = self.getJsonResult() self.write(jsonStr) elif not self.checkJoke(jokeid): self.status = 201 self.message = '该jokeid不存在' jsonStr = self.getJsonResult() self.write(jsonStr) else: commentid = uuid.uuid1().hex newcomment = Comment() newcomment.commentid = commentid newcomment.userid = userid newcomment.jokeid = jokeid newcomment.content = content self.db.add(newcomment) self.db.commit() self.db.close() self.status = 200 jsonStr = self.getJsonResult() self.write(jsonStr)
def post(self, comment_id): Comment.delete_comment(comment_id) return self.redirect(self.request.referer)
def get(self, topic_id): count_comments = Comment.query( Comment.topic_id == topic_id, Comment.deleted == False).count() return self.write(count_comments)