Deletes the specified domain and all of its resource records. If the
        domain has subdomains, each subdomain will now become a root domain. If
        you wish to also delete any subdomains, pass True to 'delete_subdomains'.
971486
def delete(self, domain, delete_subdomains=False):
        
        uri = "/%s/%s" % (self.uri_base, utils.get_id(domain))
        if delete_subdomains:
            uri = "%s?deleteSubdomains=true" % uri
        resp, resp_body = self._async_call(uri, method="DELETE",
                error_class=exc.DomainDeletionFailed, has_response=False)
251531
def delete_record(self, domain, record):
        
        uri = "/domains/%s/records/%s" % (utils.get_id(domain),
                utils.get_id(record))
        resp, resp_body = self._async_call(uri, method="DELETE",
                error_class=exc.DomainRecordDeletionFailed, has_response=False)
        return resp_body
963212
def domain_delete(auth=None, **kwargs):
    '''
    
    '''
    cloud = get_operator_cloud(auth)
    kwargs = _clean_kwargs(**kwargs)
    return cloud.delete_domain(**kwargs)
186385
def delete_record(self, domain, recordid, params=None):
        ''' 
        '''
        params = update_params(params, {
            'domain': domain,
            'RECORDID': recordid
        })
        return self.request('/v1/dns/delete_record', params, 'POST')
249834
function setDomain()
    {
        $this->domains = func_get_args();
        $this->removeDNProp('id-at-commonName');
        $this->setDNProp('id-at-commonName', $this->domains[0]);
    }
415309
def strip_domain(jid)
      domain = jid.domain.split('.').drop(1).join('.')
      JID.new(domain)
    end
192297
public function setDomain( $domain )
	{
		if ( $domain == $this->getDomain() ) { return; }

		$this->_values['domain'] = (string) $domain;
		$this->setModified();
	}
820845
public static base_response delete(nitro_service client, dnsnsrec resource) throws Exception {
		dnsnsrec deleteresource = new dnsnsrec();
		deleteresource.domain = resource.domain;
		deleteresource.nameserver = resource.nameserver;
		return deleteresource.delete_resource(client);
	}
1292423
def delete_record(self, record):
        
        self.children.remove(record.resource)
        record.delete()
473207
def save(self, replace=True):
        
        self.domain.put_attributes(self.name, self, replace)
        # Delete any attributes set to "None"
        if replace:
            del_attrs = []
            for name in self:
                if self[name] == None:
                    del_attrs.append(name)
            if len(del_attrs) > 0:
                self.domain.delete_attributes(self.name, del_attrs)
932547
def is_subdomain(domain, reference):
    
    index_of_reference = domain.find(reference)
    if index_of_reference > 0 and domain[index_of_reference:] == reference:
        return True
    return False
1258633
def delete_branch(cls, resource_id=None, db_session=None, *args, **kwargs):
        
        tablename = cls.model.__table__.name

        # lets lock rows to prevent bad tree states
        resource = ResourceService.lock_resource_for_update(
            resource_id=resource_id, db_session=db_session
        )
        parent_id = resource.parent_id
        ordering = resource.ordering
        raw_q = """
            WITH RECURSIVE subtree AS (
                    SELECT res.resource_id
                    FROM {tablename} AS res WHERE res.resource_id = :resource_id
                  UNION ALL
                    SELECT res_u.resource_id
                    FROM {tablename} res_u, subtree st
                    WHERE res_u.parent_id = st.resource_id
            )
            DELETE FROM resources where resource_id in (select * from subtree);
        """.format(
            tablename=tablename
        )  # noqa
        db_session = get_db_session(db_session)
        text_obj = sa.text(raw_q)
        db_session.execute(text_obj, params={"resource_id": resource_id})
        cls.shift_ordering_down(parent_id, ordering, db_session=db_session)
        return True
1351025
def terminating_sip_domains(self):
        
        if self._terminating_sip_domains is None:
            self._terminating_sip_domains = TerminatingSipDomainList(
                self._version,
                trunk_sid=self._solution['sid'],
            )
        return self._terminating_sip_domains
603570
def _delete_subtree(self, nodes):
        
        nodes = nodes if isinstance(nodes, list) else [nodes]
        iobj = [
            (self._db[node]["parent"], node)
            for node in nodes
            if self._node_name_in_tree(node)
        ]
        for parent, node in iobj:
            # Delete link to parent (if not root node)
            del_list = self._get_subtree(node)
            if parent:
                self._db[parent]["children"].remove(node)
            # Delete children (sub-tree)
            for child in del_list:
                del self._db[child]
            if self._empty_tree():
                self._root = None
                self._root_hierarchy_length = None
1338943
public void setDomains(java.util.Collection<DomainSummary> domains) {
        if (domains == null) {
            this.domains = null;
            return;
        }

        this.domains = new java.util.ArrayList<DomainSummary>(domains);
    }
967656
def shutdown(self, delete=False):
        
        disks = self.get_disks()
        self.domain.destroy()
        if delete:
            for disk in disks:
                disk.wipe()
                disk.delete()
758573
public static base_responses delete(nitro_service client, dnsnameserver resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			dnsnameserver deleteresources[] = new dnsnameserver[resources.length];
			for (int i=0;i<resources.length;i++){
				deleteresources[i] = new dnsnameserver();
				deleteresources[i].ip = resources[i].ip;
				deleteresources[i].dnsvservername = resources[i].dnsvservername;
			}
			result = delete_bulk_request(client, deleteresources);
		}
		return result;
	}