Delete selected messages for the current user

        :param ids: list of ids
13842
def delete_messages(self, ids):
        
        str_ids = self._return_comma_list(ids)
        return self.request('MsgAction', {'action': {'op': 'delete',
                                                     'id': str_ids}})
1239479
def clear_messages(self, queue_name, timeout=None):
        '''
        
        '''
        _validate_not_none('queue_name', queue_name)
        request = HTTPRequest()
        request.method = 'DELETE'
        request.host_locations = self._get_host_locations()
        request.path = _get_path(queue_name, True)
        request.query = {'timeout': _int_to_str(timeout)}
        self._perform_request(request)
216355
def delete(self, ids):
        
        url = build_uri_with_ids('api/v3/ipv6/%s/', ids)
        return super(ApiIPv6, self).delete(url)
61834
public void deleteMessage(final String id) throws UnauthorizedException, GeneralException, NotFoundException {
        if (id == null) {
            throw new IllegalArgumentException("Message ID must be specified.");
        }
        messageBirdService.deleteByID(MESSAGESPATH, id);
    }
199769
def clear_messages(self):
        
        while len(self._messages):
            msg = self._messages.pop(0)
            usd = msg.block.userData()
            if usd and hasattr(usd, 'messages'):
                usd.messages[:] = []
            if msg.decoration:
                self.editor.decorations.remove(msg.decoration)
300490
public function deleteUsers(array $ids): void
	{
		if ($this->isAjax()) {
			$users = $this->orm->users->findById($ids);
			foreach ($users as $user) {
				$this->orm->users->remove($user);
			}
			$this->orm->flush();
			$this['userList']->reload();
		} else {
			$this->terminate();
		}
	}
1272930
def delete_by_ids(self, ids):
        
        ids = utils.coerce_to_list(ids)
        uri = "/%s?ids=%s" % (self.uri_base, ",".join(ids))
        return self.api.method_delete(uri)
956442
def DeleteMessageHandlerRequests(self, requests, cursor=None):
    """"""

    query = "DELETE FROM message_handler_requests WHERE request_id IN ({})"
    request_ids = set([r.request_id for r in requests])
    query = query.format(",".join(["%s"] * len(request_ids)))
    cursor.execute(query, request_ids)
584013
def delete_message(self, id, remove):
        
        path = {}
        data = {}
        params = {}

        # REQUIRED - PATH - id
        """ID"""
        path["id"] = id

        # REQUIRED - remove
        """Array of message ids to be deleted"""
        data["remove"] = remove

        self.logger.debug("POST /api/v1/conversations/{id}/remove_messages with query params: {params} and form data: {data}".format(params=params, data=data, **path))
        return self.generic_request("POST", "/api/v1/conversations/{id}/remove_messages".format(**path), data=data, params=params, no_data=True)
1038150
def delete(self, ids):
        
        url = build_uri_with_ids('api/v3/vlan/%s/', ids)

        return super(ApiVlan, self).delete(url)
911976
def remove_message(self, message):
        '''
        
        '''
        if message in self.__messages:
            self.__messages.remove(message)
812907
def DeleteMessageHandlerRequests(self, requests):
    """"""

    for r in requests:
      flow_dict = self.message_handler_requests.get(r.handler_name, {})
      if r.request_id in flow_dict:
        del flow_dict[r.request_id]
      flow_dict = self.message_handler_leases.get(r.handler_name, {})
      if r.request_id in flow_dict:
        del flow_dict[r.request_id]
421058
public function deleteMessages($ids)
    {
        foreach ($ids as $id) {
            imap_delete($this->imap, $id, FT_UID);
        };
        return imap_expunge($this->imap);
    }
1174082
def delete(self, ids):
        
        url = build_uri_with_ids('api/v3/environment/%s/', ids)
        return super(ApiEnvironment, self).delete(url)
783133
def delete(queue_id):
    '''
    

    '''

    ret = {'message': '',
           'result': True
           }

    if not queue_id:
        log.error('Require argument queue_id')

    if not queue_id == 'ALL':
        queue = show_queue()
        _message = None
        for item in queue:
            if item['queue_id'] == queue_id:
                _message = item

        if not _message:
            ret['message'] = 'No message in queue with ID {0}'.format(queue_id)
            ret['result'] = False
            return ret

    cmd = 'postsuper -d {0}'.format(queue_id)
    result = __salt__['cmd.run_all'](cmd)

    if result['retcode'] == 0:
        if queue_id == 'ALL':
            ret['message'] = 'Successfully removed all messages'
        else:
            ret['message'] = 'Successfully removed message with queue id {0}'.format(queue_id)
    else:
        if queue_id == 'ALL':
            ret['message'] = 'Unable to removed all messages'
        else:
            ret['message'] = 'Unable to remove message with queue id {0}: {1}'.format(queue_id, result['stderr'])
    return ret
223314
def delete_messages(self, only_processed=True):
        
        messages = self._processed_messages
        if not only_processed:
            messages += self._messages

        if messages:
            try:
                self.queue.delete_tasks(messages)
            except Exception:
                logging.exception("Error deleting messages")
                raise
170063
def remove(self, ids, **kwargs):
        
        url = build_uri_with_ids('api/v3/interface/%s/', ids)

        return super(ApiInterfaceRequest, self).delete(self.prepare_url(url, kwargs))