Delete a service comment
        Format of the line that triggers function call::

        DEL_SVC_COMMENT;<comment_id>

        :param comment_id: comment id to delete
        :type comment_id: int
        :return: None
179941
def del_svc_comment(self, comment_id):
        
        for svc in self.daemon.services:
            if comment_id in svc.comments:
                svc.del_comment(comment_id)
                self.send_an_element(svc.get_update_status_brok())
                break
        else:
            self.send_an_element(make_monitoring_log(
                'warning', 'DEL_SVC_COMMENT: comment id: %s does not exist '
                           'and cannot be deleted.' % comment_id))
534241
def delete(self, id):
        
        url = self._url('%s' % (id))
        return self.client.delete(url)
729609
async def abort(self, *, comment: str = None):
        
        params = {
            "system_id": self.system_id
        }
        if comment:
            params["comment"] = comment
        self._data = await self._handler.abort(**params)
        return self
113084
def comments(self, message_id):
        
        path = '/msg/comments/%u' % message_id
        req = ET.Element('request')
        return self._request(path, req)
668551
def forum_post_delete(self, post_id):
        
        return self._get('forum_posts/{0}.json'.format(post_id),
                         method='DELETE', auth=True)
904766
async def delete(self, service_id: str) -> bool:
        

        await self.docker._query(
            "services/{service_id}".format(service_id=service_id), method="DELETE"
        )
        return True
1032391
def del_all_host_comments(self, host):
        
        comments = list(host.comments.keys())
        for uuid in comments:
            host.del_comment(uuid)
        self.send_an_element(host.get_update_status_brok())
320164
def delete(message_id, reservation_id = nil)
      # API does not accept any options
      options = {}
      options['id'] = message_id
      unless reservation_id.nil?
        options['reservation_id'] = reservation_id
      end
      Message.new(self, options).delete
    end
1368667
def help_center_article_comment_delete(self, article_id, id, **kwargs):
        ""
        api_path = "/api/v2/help_center/articles/{article_id}/comments/{id}.json"
        api_path = api_path.format(article_id=article_id, id=id)
        return self.call(api_path, method="DELETE", **kwargs)
1018720
def remove(cls, id):
        

        api = Client.instance().api
        api.index(id).delete()
233444
function removeComments(node) {
  var _arr3 = COMMENT_KEYS;

  for (var _i3 = 0; _i3 < _arr3.length; _i3++) {
    var key = _arr3[_i3];
    delete node[key];
  }
  return node;
}
910888
def remove_service_checks(self, service_id):
    
    from hypermap.aggregator.models import Service
    service = Service.objects.get(id=service_id)

    service.check_set.all().delete()
    layer_to_process = service.layer_set.all()
    for layer in layer_to_process:
        layer.check_set.all().delete()
540185
public function unMarkComment($msg_data_id, $user_comment_id, $index = null) {
        $args = $this->getUnMarkComment()->parameters(
            compact('msg_data_id', 'user_comment_id', 'index'))->json();
        return $args['errcode'] == 0;
    }
699638
def handle_comment(self, comment):
        

        match = _COND_COMMENT_PATTERN.match(comment)
        if match is not None:
            cond = match.group(1)
            content = match.group(2)

            self._buffer.append(_COND_COMMENT_START_FORMAT % cond)
            self._push_status()
            self.feed(content)
            self._pop_status()
            self._buffer.append(_COND_COMMENT_END_FORMAT)
        elif not self.remove_comments:
            self._buffer.append(_COMMENT_FORMAT % comment)
988181
public void deleteComment(String commentId) throws FlickrException {
        Map<String, Object> parameters = new HashMap<String, Object>();
        parameters.put("method", METHOD_DELETE_COMMENT);

        parameters.put("comment_id", commentId);

        // Note: This method requires an HTTP POST request.
        Response response = transportAPI.post(transportAPI.getPath(), parameters, apiKey, sharedSecret);
        if (response.isError()) {
            throw new FlickrException(response.getErrorCode(), response.getErrorMessage());
        }
        // This method has no specific response - It returns an empty
        // sucess response if it completes without error.
    }
495164
def delete(self, subscription_id, data=None):
        
        if not subscription_id or not subscription_id.startswith(self.RESOURCE_ID_PREFIX):
            raise IdentifierError(
                "Invalid subscription ID: '{id}'. A subscription ID should start with '{prefix}'.".format(
                    id=subscription_id, prefix=self.RESOURCE_ID_PREFIX)
            )
        result = super(CustomerSubscriptions, self).delete(subscription_id, data)
        return self.get_resource_object(result)
624167
function(id, params, headers, callback) {
        var url;
        url = this.client.url() + ("comments/" + (id || ''));
        return this.client.del(url, params, headers, callback);
      }