Exemple #1
0
def play(id, page=None):
    movie = Movie.query.get_or_404(id)
    if page is None:
        page = 1
    comments = Comment.query.filter_by(movie_id=id).order_by(
        Comment.addtime.desc()).paginate(
            page, per_page=current_app.config['HOME_COMMENT_PAGE'])
    app = current_app._get_current_object()
    thread = Thread(target=async_add_playnum, args=[id, app])
    thread.start()
    form = CommentAddForm(request.form)
    if request.method == 'POST' and form.validate():
        if not current_user.is_authenticated:
            return redirect(url_for('home.login'))
        value = form.data
        value['user_id'] = current_user.id
        comment = Comment()
        comment.set_attr(value)
        with db.auto_commit():
            db.session.add(comment)
        flash('添加评论成功~', 'ok')
        thread = Thread(target=async_add_commentnum,
                        args=[form.movie_id.data, app])
        thread.start()
        return redirect(url_for('home.play', id=form.movie_id.data, page=page))
    return render_template('home/play.html',
                           movie=movie,
                           form=form,
                           comments=comments)
Exemple #2
0
def post_comment(token_data):
    '''comment投稿
    Args:
        text:       コメントテキスト
        thread_id:  スレッドID
    Returns:
        200:    正常終了
            list(dict):
                comment情報のリスト
        500:    サーバエラー
    '''
    try:
        params = request.json

        user_id = token_data.get('user_id')
        user = User.get(user_id=user_id)

        params.update({'user_id': user_id, 'name': user.get('nick_name')})

        # comment作成
        Comment.post(params)

        # comment追加後,thread_idに紐づく
        thread = Thread.get(thread_id=params.get('thread_id'))

        result = thread.get('comments')

        return make_response(jsonify(result), 201)
    except Exception as e:
        if str(e) == 'over text length':
            result = {'error_message': 'テキストが長すぎます'}
            return make_response(jsonify(result), 400)

        return make_response('', 500)
Exemple #3
0
def video(id=None, page=None):
    """
    弹幕播放尝试
    """
    movie = Movie.query.get_or_404(int(id))
    movie.playnum = movie.playnum + 1
    form = CommentForm()
    if page is None:
        page = 1
    if "user" in session and form.validate_on_submit():
        data = form.data
        form = dict(content=data["content"],
                    movie_id=int(id),
                    user_id=session['user_id'])
        comment = Comment(form)
        comment.save()
        movie.commentnum = movie.commentnum + 1
        movie.save()
        flash("添加评论成功!", 'ok')
        return redirect(url_for('index.video', id=movie.id, page=1))
    movie.save()
    page_data = Comment.query.join(Movie).join(User).filter(
        id == Comment.movie_id,
        User.id == Comment.user_id,
    ).order_by(Comment.addtime.desc()).paginate(page=page, per_page=10)
    return render_template('home/video.html',
                           movie=movie,
                           form=form,
                           page_data=page_data)
Exemple #4
0
def comments(id):
    post = Post.query.get(int(id))
    comments = (
        Comment.query.filter_by(post_id=id, depth=0).order_by(Comment.created_at).all()
    )
    form = CommentForm()
    if form.validate_on_submit():
        if current_user.is_authenticated:
            c = Comment(messages=form.messages.data)
            c.post_id = post.id
            c.user_id = current_user.id
            c.created_at = datetime.utcnow()
            db.session.add(c)
            db.session.commit()
            return redirect(url_for("comment.comments", id=post.id))
        return redirect(url_for("auth.login"))
    if request.method == "GET":
        form.messages.data = ""
    return render_template(
        "/comment/comment.html",
        title="comment",
        form=form,
        post=post,
        comments=comments,
    )
Exemple #5
0
def comment_submit(id, cid = None):
    form = CommentForm(request.form)

    user = db.session.query(User).get(session['user'])
    image = db.session.query(Image).filter_by(id=id).one()

    if request.method == 'POST' and form.validate():
        comment = Comment(session['user'], image, form.text.data, cid)

        if user.already_commented(image, cid): 
            flash(local.comment['ALREADY_COMMENTED'], 'error')
        else:
            db.session.add(comment)
            db.session.flush()
            comment.vote(1, session['user'])
            db.session.commit()
            flash(local.comment['POSTED'], 'success')

        # Return user to image or comment controllers depending on ref
        if cid is None:
            return redirect(url_for('image', id=image.id))
        else:
            return redirect(url_for('comment', id=image.id, cid=cid))

    flash_errors(form)
    comments = construct_comment_tree(image.comments)
    if cid is None:
        try:
            commented = Comment.query.filter_by(id_user=session['user'], image=image, id_father=None).one()
        except:
            commented = False
        return render('image.html', title=image.name, commented=commented, image=image, form=form, comments=comments)
    else:
        return render('comment.html', title=local.comment['TITLE_ONE'], id=id, cid=cid, comments=comments, form=form)
Exemple #6
0
def post(id):
    post = Post.query.get_or_404(id)
    form = CommentForm()
    if form.validate_on_submit():
        if form.replied_id.data:
            comment = Comment(body=form.body.data,
                              replied_id=form.replied_id.data,
                              author=current_user._get_current_object())
            page = request.args.get('page', 1, type=int)
        else:
            comment = Comment(body=form.body.data,
                              post=post,
                              author=current_user._get_current_object())
            page = 1
        db.session.add(comment)
        db.session.commit()
        flash('成功发表评论')
        return redirect(url_for('.post', id=post.id, page=page))
    page = request.args.get('page', 1, type=int)
    if page == -1:
        page = (post.comments.count() -
                1) // current_app.config['CMS_COMMENTS_PER_PAGE'] + 1
    pagination = post.comments.filter(Comment.disabled != True).order_by(
        Comment.create_time.desc()).paginate(
            page,
            per_page=current_app.config['CMS_COMMENTS_PER_PAGE'],
            error_out=False)
    comments = pagination.items
    return render_template('blog/post.html',
                           post=post,
                           form=form,
                           comments=comments,
                           pagination=pagination)
Exemple #7
0
def comment(user, post):
    comment = Comment()
    comment.body = "Is sajjan ko kya takleef hain bhai?"

    user.comments().save(comment)
    post.comments().save(comment)

    return comment
Exemple #8
0
 def execute(self, *args, **kwargs):
     new_comment = Comment(comment=kwargs["comment"], user=kwargs["owner"])
     COMMENTS.append(new_comment)
     new_comment.comment_id = len(COMMENTS)
     new_comment.owner.comments.append(
         len(COMMENTS))  # store the id of the comment
     self._message = "Comment created successfully"
     return True
Exemple #9
0
 def test_user_has_comment_to_a_comment(self):
     Comment(content="This is a test comment", user_id=2, text_id=1).save()
     pcomment = Comment.query.first()
     Comment(content='This is a child comment',
             user_id=1,
             comment_id=pcomment.id).save()
     user = User.query.get(1)
     self.assertEqual(user.comments.count(), 1)
Exemple #10
0
    def test_user_can_downvote_a_comment(self):
        c1 = Comment(content="This is a test comment", user_id=2, text_id=1)
        c1.save()
        user = User.query.get(1)

        CommentDownvote(user_id=1, comment_id=c1.id).save()

        self.assertEqual(user.has_downvoted_comment.count(), 1)
        self.assertEqual(c1.downvoters.count(), 1)
Exemple #11
0
    def test_user_has_1_karma_after_commenting(self):
        c1 = Comment(
            content="This is a test comment",
            user_id=2,
            text_id=1
        )
        c1.save()

        self.assertEqual(User.query.get(2).comment_karma, 1)
Exemple #12
0
def fake_comments(nums=500):
    with db.auto_commit():
        for i in range(nums):
            # 已审核文章评论
            data = Comment(
                author=faker.name(),
                email=faker.email(),
                site=faker.url(),
                body=faker.sentence(),
                timestamp=faker.date_time_this_year(),
                reviewed=True,
                post=Post.query.get(random.randint(1, Post.query.count()))
            )
            db.session.add(data)


        for i in range(int(nums *0.1)):
            # 未审核评论
            data = Comment(
                author=faker.name(),
                email=faker.email(),
                site=faker.url(),
                body=faker.sentence(),
                timestamp=faker.date_time_this_year(),
                reviewed=False,
                post=Post.query.get(random.randint(1, Post.query.count()))
            )
            db.session.add(data)
            # 管理员评论
            data = Comment(
                author='张小萌',
                email='*****@*****.**',
                site='example.com',
                body=faker.sentence(),
                timestamp=faker.date_time_this_year(),
                from_admin=True,
                reviewed=True,
                post=Post.query.get(random.randint(1, Post.query.count()))
            )
            db.session.add(data)


    # 先 commit 评论之后才能生成针对评论的回复
    with db.auto_commit():
        for i in range(int(nums*0.05)):
            data = Comment(
                author=faker.name(),
                email=faker.email(),
                site=faker.url(),
                body=faker.sentence(),
                timestamp=faker.date_time_this_year(),
                reviewed=True,
                replied=Comment.query.get(
                    random.randint(1, Comment.query.count())),
                post=Post.query.get(random.randint(1, Post.query.count()))
            )
            db.session.add(data)
Exemple #13
0
def addThirdComment():
    form = request.json
    comment_id = form['comment_id']
    comment_id = int(comment_id)
    #文章的id
    article_id = form['article_id']
    #评论用户的id
    user_id = form['user_id']
    #对谁评论的id
    to_user = form['to_user']
    to_user = int(to_user)
    content = form['content']
    with db.auto_commit():
        comment = Comment()
        comment.article_id = article_id
        comment.article_type = 1
        comment.from_uid = user_id
        comment.to_uid = to_user
        comment.origin_uid = to_user
        comment.content = content
        comment.comment_id = comment_id
        db.session.add(comment)
        article = Article.query.filter_by(id=article_id).first()
        article.comments += 1
    return jsonify({'code': 0, 'message': '二级评论成功'})
Exemple #14
0
    def test_user_can_upvote_a_comment(self):
        c1 = Comment(content="This is a test comment", user_id=2, text_id=1)
        c1.save()
        user = User.query.get(1)

        CommentUpvote(user_id=1, comment_id=c1.id).save()

        self.assertEqual(user.has_upvoted_comment.count(), 1)

        # we have to count the original commenter
        self.assertEqual(c1.upvoters.count(), 2)
Exemple #15
0
 def post(self):
     args = post_parser.parse_args()
     from app.models.post import Post
     post = Post.query.get_or_404(args.post_id)
     from app.models.user import User
     author = User.query.get_or_404(args.author_id)
     comment = Comment(body=args.body, post=post, author=author)
     from app import db
     db.session.add(comment)
     db.session.commit()
     return jsonify(comment.to_json())
Exemple #16
0
def add():
    form = request.form
    u = current_user()
    if u is None:
        flash('需要进行登陆', 'info')
        return redirect(url_for('index.login'))
    comment = Comment(form)
    comment.user_id = u.id
    db.session.add(comment)
    db.session.commit()
    flash('评论成功', 'success')
    return redirect(url_for('post.detail', id=comment.post_id))
Exemple #17
0
    def comment(self, post):
        '''Add the comment to the post
        '''

        content = self.request.get('content')
        if content:
            comment = Comment(post=post, user=self.user, content=content)
            comment.put()
            self.redirect('/post/%s' % str(post.key().id()))
        else:
            error = 'Please write something'
            self.render('view_post.html', post=post, error=error)
Exemple #18
0
    def test_user_has_karma_after_being_upvoted_comment(self):
        c = Comment(
            content="This is a test comment",
            user_id=1,
            link_id=1
        )
        c.save()

        for i in range(10):
            CommentUpvote(comment_id=c.id, user_id=i*10).save()

        self.assertEqual(User.query.get(1).comment_karma, 11)
Exemple #19
0
def create_short_comment():
    form = NewBookShortComment().validate_for_api()
    member_id = get_current_member().id
    data = {
        'member_id': member_id,
        'type': ClassicType.BOOK.value,
        'content_id': form.book_id.data,
        'short_comment': form.content.data
    }
    Comment.new_model(data, err_msg='短评不能重复提交')
    res_msg = form.content.data + ' +1'
    return Success(msg=res_msg)
Exemple #20
0
 def post(self, post_id=None, post=None):
     comment_body = self.request.get('new-comment')
     if comment_body:
         comment = Comment(parent=post.key,
                           user=self.user.key,
                           content=comment_body)
         comment.put()
         self.redirect_to(BlogConst.ROUTE_VIEW_POST, post_id=post_id)
     else:
         new_comment = {
             'error': "Please type in a comment before submitting."
         }
         self.render_post(post, new_comment)
Exemple #21
0
def create_comment():
    """
    创建评论
    """
    for m in range(6, 10):
        for u in range(1, 8):
            form = dict(
                content='this is user' + str(u) + '\'s comment',
                movie_id=m,
                user_id=u + 13,
            )
            comment = Comment(form)
            comment.save()
Exemple #22
0
def add_comment_service(data):
    """
    添加评价
    :param data:
    {
        # "user_name": self.user_name,
        # "user_id": self.user_id,
        "content": self.content,
        "product_id": self.product_id,
        "pic": self.pic,
        "real_star": self.real_star,
        "price_star": self.price_star,
        "clean_star": self.clean_star,
    }
    :return:
    """
    session = g.session
    result = session.query(User).filter(User.id == data["user_id"]).one()
    data["user_name"] = result.username
    data["average_star"] = (data["real_star"] + data["price_star"] + data["clean_star"])/3
    comment = Comment()
    for key, value in data.items():
        setattr(comment, key, value)
    session.add(comment)
    session.commit()
    return True
Exemple #23
0
def create_comment(*, account: Account, id: int, content: str) -> list:
    user_account_check(account)
    c = Comment(
        user=get_user_account(account),
        post=get_post(id),
        content=content,
        published_date=int(time.time()),
    )
    c.save()
    create_notification(type='comment',
                        account=account,
                        post_job_id=c.post.id,
                        receiver=c.post.user.account,
                        comment_id=c.id)

    return list_comment(id=id)
Exemple #24
0
    def put(self, board_id, post_id, comment_id):
        try:
            form = CommentEditSchema().load(json.loads(request.data))
            find_comment = Comment.objects(post_id=post_id,
                                           id=comment_id).first()

            if not find_comment.is_writer:
                return jsonify(message="본인이 작성한 댓글이 아니면 수정 할 수 없습니다."), 403

            find_comment.update_comment_modified_time()
            comment = Comment(**form)
            find_comment.update(comment)
        except ValidationError as err:
            return err

        return jsonify(message='댓글이 수정되었습니다.'), 200
def comments(id):
    post = Post.query.get(int(id))
    comments = Comment.query.filter_by(post_id=id, is_spam=False, depth=0).all()
    form = CommentForm()
    if form.validate_on_submit():
        if current_user.is_authenticated:
            c = Comment(messages=form.messages.data)
            c.post_id = post.id
            c.user_id = current_user.id
            db.session.add(c)
            db.session.commit()
            return redirect(url_for('comment.comments', id=post.id))
        return redirect(url_for('auth.login'))
    if request.method == 'GET':
        form.messages.data = ''
    return render_template('/comment/comment.html', title='comment', form=form, post=post, comments=comments)
        
Exemple #26
0
 def test_user_has_comment(self):
     Text(title='Test text',
          text='This is a content',
          user_id=1,
          subreddit_id=1).save()
     Comment(content="This is a test comment", user_id=1, text_id=1).save()
     user = User.query.get(1)
     self.assertEqual(user.comments.count(), 1)
Exemple #27
0
    def delete(self, board_id, post_id, comment_id):
        try:
            find_comment = Comment.objects(post_id=post_id,
                                           id=comment_id).first()
            find_comment.soft_delete()
        except ValidationError as err:
            return err

        return jsonify(message='댓글이 삭제되었습니다.'), 200
Exemple #28
0
def addComment():

    form = request.json
    article_id = form.get('article_id')
    user_id = form.get('user_id')
    content = form.get('content')
    article = Article.query.filter_by(id=article_id).first()
    user = User.query.filter_by(id=user_id).first()
    if article and user:
        with db.auto_commit():
            article.comments += 1
            comment = Comment()
            comment.article_id = article_id
            comment.content = content
            comment.from_uid = user_id
            db.session.add(comment)
        return jsonify({'code': 0, 'message': '评论成功'})
    return jsonify({'code': 1, 'message': '评论失败'})
Exemple #29
0
def new_post_comment(id):
    post = Post.query.get_or_404(id)
    comment = Comment.from_json(request.json)
    comment.author = g.current_user
    comment.post = post
    db.session.add(comment)
    db.session.commit()
    return jsonify(comment.to_json()), 201, \
           {'Location': url_for('api.get_comment', id=comment.id)}
Exemple #30
0
    def my_written_comments(self):
        try:
            find_comments = Comment.objects(writer=g.member_id,
                                            deleted=False).order_by()
            #my_comments = MyCommentsSchema().dump(find_comments, many=True)
        except ValidationError as err:
            return err

        return jsonify(result), 200
Exemple #31
0
    def test_user_has_n_karma_after_commenting_n_times(self):
        for _ in range(10):
            Comment(
                content="This is a test comment",
                user_id=1,
                comment_id=2
            ).save()

        self.assertEqual(User.query.get(1).comment_karma, 10)
Exemple #32
0
    def setUp(self):
        self.setup_app()
        self.create_user()
        self.create_issue()

        self.comment = Comment(
                body='foo bar',
                issue=self.test_issue,
                author=self.test_user
        )
        self.comment.save()
Exemple #33
0
    def test_pre_delete(self):
        c = Comment(body='foo', author=self.test_user)
        c.issue = self.issue
        c.save()

        self.test_user.references.append(self.issue)
        self.test_user.save()

        self.issue.mentions.append(self.test_user)
        self.issue.comments.append(c)
        self.issue.save()

        self.assertEqual(Issue.objects.count(), 1)
        self.assertEqual(Comment.objects.count(), 1)
        self.assertEqual(len(self.test_user.references), 1)

        self.issue.delete()

        self.assertEqual(Issue.objects.count(), 0)
        self.assertEqual(Comment.objects.count(), 0)
        self.assertEqual(len(self.test_user.references), 0)
Exemple #34
0
class CommentTest(AppCase):
    def setUp(self):
        self.setup_app()
        self.create_user()
        self.create_issue()

        self.comment = Comment(
                body='foo bar',
                issue=self.test_issue,
                author=self.test_user
        )
        self.comment.save()

    def tearDown(self):
        self.teardown_dbs()

    def test_pre_delete(self):
        self.test_user.references.append(self.comment)
        self.test_user.save()

        self.test_issue.comments.append(self.comment)
        self.test_issue.save()

        self.comment.mentions.append(self.test_user)
        self.comment.save()

        self.assertEqual(Comment.objects.count(), 1)
        self.assertEqual(len(self.test_user.references), 1)
        self.assertEqual(len(self.test_issue.comments), 1)

        self.comment.delete()

        self.assertEqual(Comment.objects.count(), 0)
        self.assertEqual(len(self.test_user.references), 0)
        self.assertEqual(len(self.test_issue.comments), 0)
Exemple #35
0
def convert_comment(db, site, root_url, filename):
    logger.info('convert %s' % filename)
    d = {}
    content = ''
    with open(filename) as f:
        for line in f:
            match = regex.match(line)
            if match:
                d[match.group(1)] = match.group(2)
            else:
                break
        is_header = True
        for line in f:
            if is_header:
                if line.strip():
                    is_header = False
                else:
                    continue
            content = content + line

    # create DB record
    comment = Comment(site=site, author_name=d['author'], content=content)
    if 'email' in d:
        comment.author_email = d['email'].strip()
    if 'site' in d:
        comment.author_site = d['site'].strip()
    if 'url' in d:
        url = remove_from_string(d['url'], 'https://')
        url = remove_from_string(url, 'http://')
        comment.url = remove_from_string(url, root_url)
        # comment.url = remove_from_string(url, '/')
    # else:
    #    comment.url = d['article']
    if 'date' in d:
        pub = datetime.datetime.strptime(d['date'], '%Y-%m-%d %H:%M:%S')
        comment.created = pub
        comment.published = pub
    comment.save()
Exemple #36
0
 def teardown_dbs(self):
     Issue.drop_collection()
     User.drop_collection()
     Project.drop_collection()
     Attachment.drop_collection()
     Comment.drop_collection()