Delete Client

        Delete a client, please note that any roles related to this client must
        be deleted independently.

        This method is ``stable``
184293
def deleteClient(self, *args, **kwargs):
        

        return self._makeApiCall(self.funcinfo["deleteClient"], *args, **kwargs)
55173
def shutdown(self):
        '''
        
        '''
        for item in self.clients:
            client, address = item
            client.close()
            self.clients.remove(item)
95401
@RequestMapping(value = "/api/profile/{profileIdentifier}/clients/{clientUUID}", method = RequestMethod.DELETE)
    public
    @ResponseBody
    HashMap<String, Object> deleteClient(Model model,
                                         @PathVariable("profileIdentifier") String profileIdentifier,
                                         @PathVariable("clientUUID") String clientUUID) throws Exception {
        logger.info("Attempting to remove the following client: {}", clientUUID);
        if (clientUUID.compareTo(Constants.PROFILE_CLIENT_DEFAULT_ID) == 0)
            throw new Exception("Default client cannot be deleted");

        Integer profileId = ControllerUtils.convertProfileIdentifier(profileIdentifier);
        clientService.remove(profileId, clientUUID);

        HashMap<String, Object> valueHash = new HashMap<String, Object>();
        valueHash.put("clients", clientService.findAllClients(profileId));
        return valueHash;
    }
1145487
def close_related_clients(self, client):
        """"""
        related_clients = self.get_related_clients(client)
        for cl in related_clients:
            self.close_client(client=cl, force=True)
1012119
def delete_event(self, client, check):
        
        self._request('DELETE', '/events/{}/{}'.format(client, check))
        return True
580936
def delete(self):
        
        r = self._client.request('DELETE', self.url)
        logger.info("delete(): %s", r.status_code)
972326
def delete(self):
        

        return self._client._delete(
            self.__class__.base_url(
                self.sys['space'].id,
                self.sys['id'],
                environment_id=self._environment_id
            )
        )
333507
public function delete(Client $client)
    {
        $client->tokens()->update(['revoked' => true]);

        $client->forceFill(['revoked' => true])->save();
    }
1018716
def revoke(self, role):
        
        if role in self.roles:
            self.roles.remove(role)
698204
def delete_role(self, name):
    
    return roles.delete_role(self._get_resource_root(), self.name, name,
        self._get_cluster_name())
82049
def delete(options = {})
      options = options.merge(user_name: @user_name)
      resp = @client.delete_login_profile(options)
      resp.data
    end
904459
def client_unenroll(self, client):
        
        client = self._client_id(client)
        response = self._delete(url.clients_id.format(id=client))
        self._check_response(response, 204)
1099769
def _delete(self, *args, **kwargs):
        
        response = requests.delete(*args, **kwargs)
        response.raise_for_status()
1237857
function remove(client) {
  if(!clients) {
    return;
  }

  var idx = clients.indexOf(client);
  if(idx > -1) {
    clients.splice(idx, 1);
  }
}
848360
def delete_result(self, client, check):
        
        self._request('DELETE', '/results/{}/{}'.format(client, check))
        return True
769023
def delete_user_role(self, user, role):
        
        self.project_service.set_auth(self._token_project)
        self.project_service.delete_user_role(user, role)
1698
def cleanup(self):
        

        while self.inactive_timeout > 0:
            self.time = time.time()

            keys = []

            for key, client in self.clients.items.items():
                t = getattr(client, "active_at", 0)
                if t > 0 and self.time - t > self.inactive_timeout:
                    client.kwargs["link"].disconnect()
                    keys.append(key)

            for key in keys:
                self.log_debug("Removing client (inactive): %s" % key)
                del self.clients[key]

            time.sleep(1)