Delete record for a domain.
17502
def del_record(cls, fqdn, name, type):
        """"""
        meta = cls.get_fqdn_info(fqdn)
        url = meta['domain_records_href']
        delete_url = url
        if name:
            delete_url = '%s/%s' % (delete_url, name)
        if type:
            delete_url = '%s/%s' % (delete_url, type)
        return cls.json_delete(delete_url)
441893
def switch_delete_record_for_userid(self, userid):
        """"""
        with get_network_conn() as conn:
            conn.execute("DELETE FROM switch WHERE userid=?",
                         (userid,))
            LOG.debug("Switch record for user %s is removed from "
                      "switch table" % userid)
292889
def deallocate(self):
        """"""
        if self._domain is not None:
            domain_delete(self._domain, self.logger)
        if self._hypervisor is not None:
            try:
                self._hypervisor.close()
            except Exception:
                self.logger.exception("Unable to close hypervisor connection.")
1040469
def delete_record(self, identifier=None, rtype=None, name=None, content=None):
        """"""
        version = None
        ret = False

        opts = {}
        if identifier is not None:
            opts['id'] = identifier
        else:
            if not rtype and not name and not content:
                raise ValueError(
                    'Error, at least one parameter from type, name or content must be set')
            if rtype:
                opts['type'] = rtype.upper()
            if name:
                opts['name'] = self._relative_name(name)
            if content:
                opts['value'] = self._txt_encode(
                    content) if opts['type'] == 'TXT' else content

        records = self._api.domain.zone.record.list(
            self._api_key, self._zone_id, 0, opts)

        if records:
            try:
                version = self._api.domain.zone.version.new(
                    self._api_key, self._zone_id)
                for record in records:
                    del record['id']
                    self._api.domain.zone.record.delete(
                        self._api_key, self._zone_id, version, record)
                self._api.domain.zone.version.set(
                    self._api_key, self._zone_id, version)
                ret = True
            finally:
                if not ret and version is not None:
                    self._api.domain.zone.version.delete(
                        self._api_key, self._zone_id, version)

        LOGGER.debug("delete_record: %s", ret)
        return ret
1279118
def delete(self, id):
        """"""
        # url('DataStores', id=ID)
        result = meta.Session.query(DataStore).get(id)
        meta.Session.delete(result)
        meta.Session.commit()

        response.status = 204
        # remove content-type from response headers so that webtest won't get confused
        # http://groups.google.com/group/pylons-discuss/browse_thread/thread/1267650386ae521b
        del response.headers['content-type']
1132328
def _delete_record(self, identifier=None, rtype=None, name=None, content=None):
        
        if not identifier:
            records = self._list_records(rtype, name, content)
            identifiers = [record["id"] for record in records]
        else:
            identifiers = [identifier]

        LOGGER.debug("delete_records: %s", identifiers)

        for record_id in identifiers:
            self._delete(
                "/v1/domains/{0}/records/{1}".format(
                    self.domain, record_id
                )
            )
            LOGGER.debug("delete_record: %s", record_id)

        LOGGER.debug("delete_record: %s", True)
        return True
119927
def delete(gandi, email, force):
    """"""
    login, domain = email

    if not force:
        proceed = click.confirm('Are you sure to delete the '
                                'mailbox %s@%s ?' % (login, domain))

        if not proceed:
            return

    result = gandi.mail.delete(domain, login)

    return result
294715
def filter(self, table, domains, filter_string):
        """"""
        q = filter_string.lower()

        def comp(domain):
            if q in domain.name.lower():
                return True
            return False

        return filter(comp, domains)
222293
def delete(self, record):
        
        index, doc_type = self.record_to_index(record)

        return self.client.delete(
            id=str(record.id),
            index=index,
            doc_type=doc_type,
        )
799617
def records(self, domain, params=None):
        ''' 
        '''
        params = update_params(params, {'domain': domain})
        return self.request('/v1/dns/records', params, 'GET')
1110079
def update_record(self, domain, recordid, params=None):
        ''' 
        '''
        params = update_params(params, {
            'domain': domain,
            'RECORDID': recordid
        })
        return self.request('/v1/dns/update_record', params, 'POST')
413625
def deallocate(self):
        """"""
        if self._domain is not None:
            domain_delete(self._domain, self.logger)
        if self._network is not None:
            self._network_delete()
        if self._storage_pool is not None:
            self._storage_pool_delete()
        if self._hypervisor is not None:
            self._hypervisor_delete()
1313036
public function delete()
    {
        $this->setP3PHeader();
        $this->setCookie($this->name, 'deleted', time() - 31536001, $this->path, $this->domain);
    }
997583
def filter(self, record):
        """"""
        if g and hasattr(g, 'request_id'):
            record.request_id = g.request_id
        return True
250487
def del_cached_domain(domains):
    '''
    
    '''
    cache = salt.cache.Cache(__opts__, syspaths.CACHE_DIR)
    if isinstance(domains, six.string_types):
        domains = domains.split(',')
    if not isinstance(domains, list):
        raise CommandExecutionError(
            'You must pass in either a string containing one or more domains '
            'separated by commas, or a list of single domain strings'
        )
    success = []
    failed = []
    for domain in domains:
        try:
            cache.flush('venafi/domains', domain)
            success.append(domain)
        except CommandExecutionError:
            failed.append(domain)
    return {'Succeeded': success, 'Failed': failed}
1111613
def delete_records(self, zone_name, record_type, subdomain):
        
        records = self._client.get('/domain/zone/{}/record'.format(zone_name),
                                   fieldType=record_type, subDomain=subdomain)
        for record in records:
            self.delete_record(zone_name, record)
316573
def delete(self, callback=None, errback=None):
        
        if not self.data:
            raise RecordException('record not loaded')

        def success(result, *args):
            if callback:
                return callback(result)
            else:
                return result

        return self._rest.delete(self.parentZone.zone,
                                 self.domain, self.type,
                                 callback=success, errback=errback)