DELETE /auth/<mount_point>/role/<role>

        :param role:
        :type role:
        :param mount_point:
        :type mount_point:
        :return:
        :rtype:
192382
def delete_ec2_role(self, role, mount_point='aws-ec2'):
        
        return self._adapter.delete('/v1/auth/{0}/role/{1}'.format(mount_point, role))
1319211
def delete_role_policy(role_name, policy_name, region=None, key=None,
                       keyid=None, profile=None):
    '''
    
    '''
    conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)

    _policy = get_role_policy(role_name, policy_name, region, key, keyid, profile)
    if not _policy:
        return True
    try:
        conn.delete_role_policy(role_name, policy_name)
        log.info('Successfully deleted policy %s for IAM role %s.',
                 policy_name, role_name)
        return True
    except boto.exception.BotoServerError as e:
        log.debug(e)
        log.error('Failed to delete policy %s for IAM role %s.',
                  policy_name, role_name)
        return False
705669
def create_role(self, role_name, mount_point='approle', **kwargs):
        

        return self._adapter.post('/v1/auth/{0}/role/{1}'.format(mount_point, role_name), json=kwargs)
885238
def remove_role_from_user(self, user, role):
        
        user.remove_role(role)
        self.save(user)
        events.user_lost_role_event.send(user, role=role)
702465
public ServerUpdater removeRoleFromUser(User user, Role role) {
        delegate.removeRoleFromUser(user, role);
        return this;
    }
1018716
def revoke(self, role):
        
        if role in self.roles:
            self.roles.remove(role)
1339243
def roles_remove(user, role):
    """"""
    user, role = _datastore._prepare_role_modify_args(user, role)
    if user is None:
        raise click.UsageError('Cannot find user.')
    if role is None:
        raise click.UsageError('Cannot find role.')
    if _datastore.remove_role_from_user(user, role):
        click.secho('Role "{0}" removed from user "{1}" '
                    'successfully.'.format(role, user), fg='green')
    else:
        raise click.UsageError('Cannot remove role from user.')
769023
def delete_user_role(self, user, role):
        
        self.project_service.set_auth(self._token_project)
        self.project_service.delete_user_role(user, role)
602276
@Override
	public void removeRole(String username, String oldrole) throws RolesException {
		List<String> users_with_role = new ArrayList<String>();

		if (user_list.containsKey(username)) {
			List<String> roles_of_user = user_list.get(username);
			if (roles_of_user.contains(oldrole)) {
				// Update our user list
				roles_of_user.remove(oldrole);
				user_list.put(username, roles_of_user);
				// Update our roles list
				if (role_list.containsKey(oldrole))
					users_with_role = role_list.get(oldrole);
				users_with_role.remove(username);
				if (users_with_role.size() < 1) {
					role_list.remove(oldrole);
				} else {
					role_list.put(oldrole, users_with_role);
				}

				// Don't forget to update our file_store
				String roles = StringUtils.join(roles_of_user.toArray(new String[0]), ",");
				file_store.setProperty(username, roles);

				// And commit the file_store to disk
				try {
					saveRoles();
				} catch (IOException e) {
					throw new RolesException(e);
				}
			} else {
				throw new RolesException("User '" + username + "' does not have the role '" + oldrole + "'!");
			}
		} else {
			throw new RolesException("User '" + username + "' does not exist!");
		}
	}
603459
def group_remove(groupname,
                 user=None,
                 host=None,
                 port=None,
                 maintenance_db=None,
                 password=None,
                 runas=None):
    '''
    
    '''
    return _role_remove(groupname,
                        user=user,
                        host=host,
                        port=port,
                        maintenance_db=maintenance_db,
                        password=password,
                        runas=runas)
719652
def remove_role(project_root)
      # Choose a role from the availables
      roles = Bebox::Role.list(project_root)
      # Get a role if exist.
      if roles.count > 0
        role_name = choose_option(roles, _('wizard.role.choose_deletion_role'))
      else
        return error _('wizard.role.no_deletion_roles')
      end
      # Ask for deletion confirmation
      return warn(_('wizard.no_changes')) unless confirm_action?(_('wizard.role.confirm_deletion'))
      # Role deletion
      role = Bebox::Role.new(role_name, project_root)
      output = role.remove
      ok _('wizard.role.deletion_success')
      return output
    end
204605
public function destroy(Request $request, Role $role)
    {
        $this->authorize('delete', Role::class);
        $role->deletePermissions($role->permissions);
        $role->deleteUsers($role->users);

        $role->delete();

        return redirect()->route('laralum::roles.index')->with('success', __('laralum_roles::general.role_deleted', ['id' => $role->id]));
    }
377985
public function remove(Role $role)
    {
        $role->delete();

        Alert::info(__('Role was removed'));

        return redirect()->route('platform.systems.roles');
    }
675463
def permission_delete(self, token, id):
        
        return self._realm.client.delete(
            '{}/{}'.format(self.well_known['policy_endpoint'], id),
            headers=self.get_headers(token)
        )
409582
def deleteRole(self, roleID):
        
        url = self._url + "/%s/delete" % roleID
        params = {
            "f" : "json"
        }
        return self._post(url=url,
                             param_dict=params,
                             proxy_url=self._proxy_url,
                             proxy_port=self._proxy_port)
1053171
def user_remove(username,
                user=None,
                host=None,
                port=None,
                maintenance_db=None,
                password=None,
                runas=None):
    '''
    
    '''
    return _role_remove(username,
                        user=user,
                        host=host,
                        port=port,
                        maintenance_db=maintenance_db,
                        password=password,
                        runas=runas)
698204
def delete_role(self, name):
    
    return roles.delete_role(self._get_resource_root(), self.name, name,
        self._get_cluster_name())