POST /repos/:owner/:repo/pulls/:number/comments

        Like create, but reply to an existing comment.

        :param body: The text of the comment.
        :param in_reply_to: The comment ID to reply to.
166347
def replyToComment(self, repo_user, repo_name, pull_number,
                       body, in_reply_to):
        
        return self.api.makeRequest(
            ["repos", repo_user, repo_name,
             "pulls", str(pull_number), "comments"],
            method="POST",
            data=dict(body=body,
                      in_reply_to=in_reply_to))
864214
async def append(self, reply: Reply) \
            -> None:
        
        result = reply.result
        identifier = result.get(f.IDENTIFIER.nm)
        txnId = result.get(TXN_ID)
        logger.debug("Reply being sent {}".format(reply))
        if self._isNewTxn(identifier, reply, txnId):
            self.addToProcessedTxns(identifier, txnId, reply)
        if identifier not in self.responses:
            self.responses[identifier] = asyncio.Queue()
        await self.responses[identifier].put(reply)
355717
def create_comment(github_object, body):
    
    try:
        return github_object.create_issue_comment(body)  # It's a PR
    except AttributeError:
        return github_object.create_comment(body)
755489
def reply(self, text, in_thread=None):
        
        if in_thread is None:
            in_thread = 'thread_ts' in self.body

        if in_thread:
            self.send(text, thread_ts=self.thread_ts)
        else:
            text = self.gen_reply(text)
            self.send(text)
564641
def create_issue_comment(self, body):
        
        assert isinstance(body, (str, unicode)), body
        post_parameters = {
            "body": body,
        }
        headers, data = self._requester.requestJsonAndCheck(
            "POST",
            self.issue_url + "/comments",
            input=post_parameters
        )
        return github.IssueComment.IssueComment(self._requester, headers, data, completed=True)
1365708
def add_comment(self, page_id, text):
        
        data = {'type': 'comment',
                'container': {'id': page_id, 'type': 'page', 'status': 'current'},
                'body': {'storage': {'value': text, 'representation': 'storage'}}}
        return self.post('rest/api/content/', data=data)
1240641
def post(self, body=None, params=None):
        
        return self.transport.perform_request(
            "PUT", "/_license", params=params, body=body
        )
475932
def comments(recid):
    """"""
    from invenio_access.local_config import VIEWRESTRCOLL
    from invenio_access.mailcookie import \
        mail_cookie_create_authorize_action
    from .api import check_user_can_view_comments
    auth_code, auth_msg = check_user_can_view_comments(current_user, recid)
    if auth_code and current_user.is_guest:
        cookie = mail_cookie_create_authorize_action(VIEWRESTRCOLL, {
            'collection': g.collection})
        url_args = {'action': cookie, 'ln': g.ln, 'referer': request.referrer}
        flash(_("Authorization failure"), 'error')
        return redirect(url_for('webaccount.login', **url_args))
    elif auth_code:
        flash(auth_msg, 'error')
        abort(401)

    # FIXME check restricted discussion
    comments = CmtRECORDCOMMENT.query.filter(db.and_(
        CmtRECORDCOMMENT.id_bibrec == recid,
        CmtRECORDCOMMENT.in_reply_to_id_cmtRECORDCOMMENT == 0,
        CmtRECORDCOMMENT.star_score == 0
    )).order_by(CmtRECORDCOMMENT.date_creation).all()
    return render_template('comments/comments.html', comments=comments,
                           option='comments')
1070479
def pull_reply(self, param=None, must=[APIKEY]):
        '''
        '''
        param = {} if param is None else param
        r = self.verify_param(param, must)
        if not r.is_succ():
            return r
        h = CommonResultHandler(lambda rsp: {VERSION_V1:rsp[SMS_REPLY] if SMS_REPLY in rsp else None, VERSION_V2:rsp}[self.version()])
        return self.path('pull_reply.json').post(param, h, r)
920140
def create_request_comment(self, issue_id_or_key, body, public=True):
        
        log.warning('Creating comment...')
        data = {"body": body, "public": public}

        return self.post('rest/servicedeskapi/request/{}/comment'.format(issue_id_or_key), data=data)
115085
def add_comment(self, body, allow_create=False, allow_hashes=False,
                    summary=None):
        ""

        if allow_hashes:
            raise ValueError('allow_hashes not implemented for %s yet' % (
                self.__class__.__name__))
        if self.thread_id is None:
            self.thread_id = self.lookup_thread_id()
        if not os.path.exists(self.thread_id):
            if not allow_create:
                raise KeyError(self.topic)
            with open(self.thread_id, 'a', newline='') as fdesc:
                csv.writer(fdesc).writerow(self.header)

        with open(self.thread_id, 'a', newline='') as fdesc:
            writer = csv.writer(fdesc)
            writer.writerow([self.user, datetime.datetime.utcnow(), summary,
                             body, ''])
1335251
def do_email_reply(self, comment, entry, site):
        
        if not self.email_reply:
            return

        exclude_list = (
            self.mail_comment_notification_recipients
            + [author.email for author in entry.authors.all()]
            + [comment.email]
        )
        recipient_list = (
            set([other_comment.email
                 for other_comment in entry.comments
                 if other_comment.email])
            - set(exclude_list)
        )
        if not recipient_list:
            return

        template = loader.get_template(
            'comments/zinnia/entry/email/reply.txt')
        context = {
            'comment': comment,
            'entry': entry,
            'site': site,
            'protocol': PROTOCOL
        }
        subject = _('[%(site)s] New comment posted on "%(title)s"') % \
            {'site': site.name, 'title': entry.title}
        message = template.render(context)

        mail = EmailMessage(
            subject, message,
            settings.DEFAULT_FROM_EMAIL,
            bcc=recipient_list)
        mail.send(fail_silently=not settings.DEBUG)
286062
def comment_update(self, comment_id, body):
        
        params = {'comment[body]': body}
        return self._get('comments/{0}.json'.format(comment_id), params, 'PUT',
                         auth=True)
1042436
def reply(self, text, markup=None, parse_mode=None):
        
        if markup is None:
            markup = {}

        return self.send_text(
            text,
            reply_to_message_id=self.message["message_id"],
            disable_web_page_preview="true",
            reply_markup=self.bot.json_serialize(markup),
            parse_mode=parse_mode,
        )
1047986
function commentIssue (client, repo, number, comment) {
  debug("commentIssue", repo, number, comment);

  return client.commentIssue(_.merge(extractRepo(repo), {
    "number": number,
    "body":   comment
  })).then(function (comment) {
    return {
      "type":   "comment",
      "issue":  number,
      "url":    comment.html_url
    };
  });
}
722254
def deleteComment(self, repo_user, repo_name, comment_id):
        
        return self.api.makeRequest(
            ["repos", repo_user, repo_name,
             "pulls", "comments", str(comment_id)],
            method="DELETE")
426841
def update_invoice_comment(self, invoice_comment_id, invoice_comment_dict):
        
        return self._create_put_request(
            resource=INVOICE_COMMENTS,
            billomat_id=invoice_comment_id,
            send_data=invoice_comment_dict
        )