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 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 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_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:' + str(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 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 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 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 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 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 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(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 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 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 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 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("<", "&lt;").replace(">", "&gt; ")

    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 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 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 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 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 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)