Updates a confirmation comment

        :param confirmation_comment_id: the confirmation comment id
        :param confirmation_comment_dict: dict
        :return: dict
483977
def update_confirmation_comment(self, confirmation_comment_id, confirmation_comment_dict):
        
        return self._create_put_request(
            resource=CONFIRMATION_COMMENTS,
            billomat_id=confirmation_comment_id,
            send_data=confirmation_comment_dict
        )
1121065
def update_confirmation_item(self, confirmation_item_id, confirmation_item_dict):
        
        return self._create_put_request(
            resource=CONFIRMATION_ITEMS,
            billomat_id=confirmation_item_id,
            send_data=confirmation_item_dict
        )
795323
function send_comment( $id , $comment , $comment_ori = 0)
	{
		$params = array();
		$params['comment'] = $comment;
		$this->id_format($id);
		$params['id'] = $id;
		$params['comment_ori'] = $comment_ori;
		return $this->oauth->post( 'comments/create', $params );
	}
672527
def getComment(self, repo_user, repo_name, comment_id):
        
        return self.api.makeRequest(
            ['repos', repo_user, repo_name,
             'pulls', 'comments', str(comment_id)])
252675
def has_comment_access(post_id, comment_id)
      comment = Unsakini::Comment.where(id: comment_id, post_id: post_id, user_id: @user.id).first
      if comment.nil?
        return {status: :forbidden, comment: comment}
      else
        return {status: :ok, comment: comment}
      end
    end
378573
def del_host_comment(self, comment_id):
        
        for item in self.daemon.hosts:
            if comment_id in item.comments:
                item.del_comment(comment_id)
                self.send_an_element(item.get_update_status_brok())
                break
        else:
            self.send_an_element(make_monitoring_log(
                'warning', 'DEL_HOST_COMMENT: comment id: %s does not exist '
                           'and cannot be deleted.' % comment_id))
486228
def comment_unvote(self, comment_id):
        
        return self._get('posts/{0}/unvote.json'.format(comment_id),
                         method='POST', auth=True)
101951
def on_commenting(self, comment):
        """"""

        def update():
            context = self.host.cached_context
            context.data["comment"] = comment
            self.data["comment"] = comment

            # Notify subscribers of the comment
            self.comment_sync(comment)

            self.commented.emit()

        # Update local cache a little later
        util.schedule(update, 100, channel="commenting")
956017
public function addComment($id, $status)
    {
        if ($status == 0) {
            return;
        }

        $comment = get_comment($id);
        $this->updateHtml($comment->comment_post_ID);
        wp_safe_redirect(get_permalink($comment->comment_post_ID));
        exit();
    }
178911
def save_task_comment(self, task_id, task_comment):
        
        magic = self._magic_json(
            action=TouchWorksMagicConstants.ACTION_SAVE_TASK_COMMENT,
            parameter1=task_id,
            parameter6=task_comment)

        response = self._http_request(TouchWorksEndPoints.MAGIC_JSON, data=magic)
        result = self._get_results_or_raise_if_magic_invalid(
            magic,
            response,
            TouchWorksMagicConstants.RESULT_SAVE_TASK_COMMENT)
        return result
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)
1126698
def update_cache_counters
      user.try :recalculate_my_comments_counter!

      if holder
        holder.send :try, :define_denormalize_flags
        holder.increment! "#{ state }_comcoms_count"
        # holder.class.increment_counter("#{ state }_comcoms_count", holder.id)
      end

      if commentable
        commentable.send :define_denormalize_flags
        commentable.increment! "#{ state }_comments_count"
        # holder.class.increment_counter("#{ state }_comments_count", holder.id)
      end
    end
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)
359732
public function getComment($comment_id)
    {
        list($response, $statusCode, $httpHeader) = $this->getCommentWithHttpInfo ($comment_id);
        return $response; 
    }
447131
def update_credit_note_comment(self, credit_note_comment_id, credit_note_comment_dict):
        
        return self._create_put_request(
            resource=CREDIT_NOTE_COMMENTS,
            billomat_id=credit_note_comment_id,
            send_data=credit_note_comment_dict
        )
1344270
def notify_admin_of_new_comment(comID):
    
    comment = query_get_comment(comID)
    if len(comment) > 0:
        (comID2,
         id_bibrec,
         id_user,
         body,
         date_creation,
         star_score, nb_votes_yes, nb_votes_total,
         title,
         nb_abuse_reports, round_name, restriction) = comment
    else:
        return
    user_info = query_get_user_contact_info(id_user)
    if len(user_info) > 0:
        (nickname, email, last_login) = user_info
        if not len(nickname) > 0:
            nickname = email.split('@')[0]
    else:
        nickname = email = "ERROR: Could not retrieve"

    review_stuff = '''
    Star score  = %s
    Title       = %s''' % (star_score, title)

    washer = EmailWasher()
    try:
        body = washer.wash(body)
    except:
        body = cgi.escape(body)

    record_info = webcomment_templates.tmpl_email_new_comment_admin(id_bibrec)
    out = '''
The following %(comment_or_review)s has just been posted (%(date)s).

AUTHOR:
    Nickname    = %(nickname)s
    Email       = %(email)s
    User ID     = %(uid)s

RECORD CONCERNED:
    Record ID   = %(recID)s
    URL         = <%(siteurl)s/%(CFG_SITE_RECORD)s/%(recID)s/%(comments_or_reviews)s/>
%(record_details)s

%(comment_or_review_caps)s:
    %(comment_or_review)s ID    = %(comID)s %(review_stuff)s
    Body        =
<--------------->
%(body)s

<--------------->
ADMIN OPTIONS:
To moderate the %(comment_or_review)s go to %(siteurl)s/%(CFG_SITE_RECORD)s/%(recID)s/%(comments_or_reviews)s/display?%(arguments)s
    ''' % \
        {'comment_or_review': star_score > 0 and 'review' or 'comment',
            'comment_or_review_caps': star_score > 0 and 'REVIEW' or 'COMMENT',
            'comments_or_reviews': star_score > 0 and 'reviews' or 'comments',
            'date': date_creation,
            'nickname': nickname,
            'email': email,
            'uid': id_user,
            'recID': id_bibrec,
            'record_details': record_info,
            'comID': comID2,
            'review_stuff': star_score > 0 and review_stuff or "",
            'body': body.replace('<br />', '\n'),
            'siteurl': CFG_SITE_URL,
            'CFG_SITE_RECORD': CFG_SITE_RECORD,
            'arguments': 'ln=en&do=od#%s' % comID
         }

    from_addr = '%s WebComment <%s>' % (
        CFG_SITE_NAME, CFG_WEBALERT_ALERT_ENGINE_EMAIL)
    comment_collection = get_comment_collection(comID)
    to_addrs = get_collection_moderators(comment_collection)

    rec_collection = guess_primary_collection_of_a_record(id_bibrec)
    report_nums = get_fieldvalues(id_bibrec, "037__a")
    report_nums += get_fieldvalues(id_bibrec, "088__a")
    report_nums = ', '.join(report_nums)
    subject = "A new comment/review has just been posted [%s|%s]" % (
        rec_collection, report_nums)

    send_email(from_addr, to_addrs, subject, out)
770170
def confirm(self, batch_id=None, filename=None):
        
        if batch_id or filename:
            export_history = self.history_model.objects.using(self.using).filter(
                Q(batch_id=batch_id) | Q(filename=filename),
                sent=True,
                confirmation_code__isnull=True,
            )
        else:
            export_history = self.history_model.objects.using(self.using).filter(
                sent=True, confirmation_code__isnull=True
            )
        if export_history.count() == 0:
            raise ConfirmationError(
                "Nothing to do. No history of sent and unconfirmed files"
            )
        else:
            confirmation_code = ConfirmationCode()
            export_history.update(
                confirmation_code=confirmation_code.identifier,
                confirmation_datetime=get_utcnow(),
            )
        return confirmation_code.identifier