org.keycloak.services.resources.admin.RealmAdminResource クラス

org.keycloak.services.resources.admin.RealmAdminResource 連携図

公開メンバ関数
	RealmAdminResource (AdminPermissionEvaluator auth, RealmModel realm, TokenManager tokenManager, AdminEventBuilder adminEvent)
ClientRepresentation	convertClientDescription (String description)
AttackDetectionResource	getAttackDetection ()
ClientsResource	getClients ()
ClientScopesResource	getClientTemplates ()
ClientScopesResource	getClientScopes ()
List< ClientScopeRepresentation >	getDefaultDefaultClientScopes ()
void	addDefaultDefaultClientScope (@PathParam("clientScopeId") String clientScopeId)
void	removeDefaultDefaultClientScope (@PathParam("clientScopeId") String clientScopeId)
List< ClientScopeRepresentation >	getDefaultOptionalClientScopes ()
void	addDefaultOptionalClientScope (@PathParam("clientScopeId") String clientScopeId)
void	removeDefaultOptionalClientScope (@PathParam("clientScopeId") String clientScopeId)
ClientInitialAccessResource	getClientInitialAccess ()
ClientRegistrationPolicyResource	getClientRegistrationPolicy ()
ComponentResource	getComponents ()
RoleContainerResource	getRoleContainerResource ()
RealmRepresentation	getRealm ()
Response	updateRealm (final RealmRepresentation rep)
void	deleteRealm ()
UsersResource	users ()
ManagementPermissionReference	getUserMgmtPermissions ()
ManagementPermissionReference	setUsersManagementPermissionsEnabled (ManagementPermissionReference ref)
UserStorageProviderResource	userStorage ()
AuthenticationManagementResource	flows ()
RoleByIdResource	rolesById ()
GlobalRequestResult	pushRevocation ()
GlobalRequestResult	logoutAll ()
void	deleteSession (@PathParam("session") String sessionId)
List< Map< String, String > >	getClientSessionStats ()
RealmEventsConfigRepresentation	getRealmEventsConfig ()
void	updateRealmEventsConfig (final RealmEventsConfigRepresentation rep)
List< EventRepresentation >	getEvents (@QueryParam("type") List< String > types, @QueryParam("client") String client, @QueryParam("user") String user, @QueryParam("dateFrom") String dateFrom, @QueryParam("dateTo") String dateTo, @QueryParam("ipAddress") String ipAddress, @QueryParam("first") Integer firstResult, @QueryParam("max") Integer maxResults)
List< AdminEventRepresentation >	getEvents (@QueryParam("operationTypes") List< String > operationTypes, @QueryParam("authRealm") String authRealm, @QueryParam("authClient") String authClient, @QueryParam("authUser") String authUser, @QueryParam("authIpAddress") String authIpAddress, @QueryParam("resourcePath") String resourcePath, @QueryParam("dateFrom") String dateFrom, @QueryParam("dateTo") String dateTo, @QueryParam("first") Integer firstResult, @QueryParam("max") Integer maxResults, @QueryParam("resourceTypes") List< String > resourceTypes)
void	clearEvents ()
void	clearAdminEvents ()
Response	testLDAPConnection (@FormParam("action") String action, @FormParam("connectionUrl") String connectionUrl, @FormParam("bindDn") String bindDn, @FormParam("bindCredential") String bindCredential, @FormParam("useTruststoreSpi") String useTruststoreSpi, @FormParam("connectionTimeout") String connectionTimeout, @FormParam("componentId") String componentId)
Response	testSMTPConnection (final @PathParam("config") String config) throws Exception
IdentityProvidersResource	getIdentityProviderResource ()
List< GroupRepresentation >	getDefaultGroups ()
void	addDefaultGroup (@PathParam("groupId") String groupId)
void	removeDefaultGroup (@PathParam("groupId") String groupId)
GroupsResource	getGroups ()
GroupRepresentation	getGroupByPath (@PathParam("path") String path)
Response	partialImport (PartialImportRepresentation rep)
RealmRepresentation	partialExport (@QueryParam("exportGroupsAndRoles") Boolean exportGroupsAndRoles, @QueryParam("exportClients") Boolean exportClients)
void	clearRealmCache ()
void	clearUserCache ()
void	clearKeysCache ()
KeyResource	keys ()

静的公開メンバ関数
static ManagementPermissionReference	toUsersMgmtRef (AdminPermissionManagement permissions)

限定公開変数類
AdminPermissionEvaluator	auth
RealmModel	realm
KeycloakSession	session
ClientConnection	connection
HttpHeaders	headers

静的限定公開変数類
static final Logger	logger = Logger.getLogger(RealmAdminResource.class)

非公開メンバ関数
List< ClientScopeRepresentation >	getDefaultClientScopes (boolean defaultScope)
void	addDefaultClientScope (String clientScopeId, boolean defaultScope)
List< EventRepresentation >	toEventListRep (List< Event > events)
List< AdminEventRepresentation >	toAdminEventRep (List< AdminEvent > events)

非公開変数類
TokenManager	tokenManager
AdminEventBuilder	adminEvent

詳解

Base resource class for the admin REST api of one realm

Realms Admin

著者

Bill Burke

バージョン

Revision

1

構築子と解体子

RealmAdminResource()

org.keycloak.services.resources.admin.RealmAdminResource.RealmAdminResource ( AdminPermissionEvaluator  auth, RealmModel  realm, TokenManager  tokenManager, AdminEventBuilder  adminEvent  )

inline

                                                                                                                                        {
        this.auth = auth;
        this.realm = realm;
        this.tokenManager = tokenManager;
        this.adminEvent = adminEvent.realm(realm).resource(ResourceType.REALM);
    }

関数詳解

addDefaultClientScope()

void org.keycloak.services.resources.admin.RealmAdminResource.addDefaultClientScope ( String  clientScopeId, boolean  defaultScope  )

inlineprivate

                                                                                   {
        auth.clients().requireManageClientScopes();

        ClientScopeModel clientScope = realm.getClientScopeById(clientScopeId);
        if (clientScope == null) {
            throw new NotFoundException("Client scope not found");
        }
        realm.addDefaultClientScope(clientScope, defaultScope);

        adminEvent.operation(OperationType.CREATE).resource(ResourceType.CLIENT_SCOPE).resourcePath(session.getContext().getUri()).success();
    }

addDefaultDefaultClientScope()

void org.keycloak.services.resources.admin.RealmAdminResource.addDefaultDefaultClientScope ( @PathParam("clientScopeId") String  clientScopeId )

inline

                                                                                               {
        addDefaultClientScope(clientScopeId,true);
    }

addDefaultGroup()

void org.keycloak.services.resources.admin.RealmAdminResource.addDefaultGroup ( @PathParam("groupId") String  groupId )

inline

                                                                      {
        auth.realm().requireManageRealm();

        GroupModel group = realm.getGroupById(groupId);
        if (group == null) {
            throw new NotFoundException("Group not found");
        }
        realm.addDefaultGroup(group);

        adminEvent.operation(OperationType.CREATE).resource(ResourceType.GROUP).resourcePath(session.getContext().getUri()).success();
    }

addDefaultOptionalClientScope()

void org.keycloak.services.resources.admin.RealmAdminResource.addDefaultOptionalClientScope ( @PathParam("clientScopeId") String  clientScopeId )

inline

                                                                                                {
        addDefaultClientScope(clientScopeId, false);
    }

clearAdminEvents()

void org.keycloak.services.resources.admin.RealmAdminResource.clearAdminEvents ( )

inline

Delete all admin events

                                   {
        auth.realm().requireManageEvents();

        EventStoreProvider eventStore = session.getProvider(EventStoreProvider.class);
        eventStore.clearAdmin(realm.getId());
    }

clearEvents()

void org.keycloak.services.resources.admin.RealmAdminResource.clearEvents ( )

inline

Delete all events

                              {
        auth.realm().requireManageEvents();

        EventStoreProvider eventStore = session.getProvider(EventStoreProvider.class);
        eventStore.clear(realm.getId());
    }

clearKeysCache()

void org.keycloak.services.resources.admin.RealmAdminResource.clearKeysCache ( )

inline

Clear cache of external public keys (Public keys of clients or Identity providers)

                                 {
        auth.realm().requireManageRealm();

        PublicKeyStorageProvider cache = session.getProvider(PublicKeyStorageProvider.class);
        if (cache != null) {
            cache.clearCache();
        }

        adminEvent.operation(OperationType.ACTION).resourcePath(session.getContext().getUri()).success();
    }

clearRealmCache()

void org.keycloak.services.resources.admin.RealmAdminResource.clearRealmCache ( )

inline

Clear realm cache

                                  {
        auth.realm().requireManageRealm();

        CacheRealmProvider cache = session.getProvider(CacheRealmProvider.class);
        if (cache != null) {
            cache.clear();
        }

        adminEvent.operation(OperationType.ACTION).resourcePath(session.getContext().getUri()).success();
    }

clearUserCache()

void org.keycloak.services.resources.admin.RealmAdminResource.clearUserCache ( )

inline

Clear user cache

                                 {
        auth.realm().requireManageRealm();

        UserCache cache = session.getProvider(UserCache.class);
        if (cache != null) {
            cache.clear();
        }

        adminEvent.operation(OperationType.ACTION).resourcePath(session.getContext().getUri()).success();
    }

convertClientDescription()

ClientRepresentation org.keycloak.services.resources.admin.RealmAdminResource.convertClientDescription ( String  description )

inline

Base path for importing clients under this realm.

戻り値

                                                                             {
        auth.clients().requireManage();

        if (realm == null) {
            throw new NotFoundException("Realm not found.");
        }

        for (ProviderFactory<ClientDescriptionConverter> factory : session.getKeycloakSessionFactory().getProviderFactories(ClientDescriptionConverter.class)) {
            if (((ClientDescriptionConverterFactory) factory).isSupported(description)) {
                return factory.create(session).convertToInternal(description);
            }
        }

        throw new BadRequestException("Unsupported format");
    }

deleteRealm()

void org.keycloak.services.resources.admin.RealmAdminResource.deleteRealm ( )

inline

Delete the realm

                              {
        auth.realm().requireManageRealm();

        if (!new RealmManager(session).removeRealm(realm)) {
            throw new NotFoundException("Realm doesn't exist");
        }
    }

deleteSession()

void org.keycloak.services.resources.admin.RealmAdminResource.deleteSession ( @PathParam("session") String  sessionId )

inline

Remove a specific user session. Any client that has an admin url will also be told to invalidate this particular session.

引数

sessionId

                                                                      {
        auth.users().requireManage();

        UserSessionModel userSession = session.sessions().getUserSession(realm, sessionId);
        if (userSession == null) throw new NotFoundException("Sesssion not found");
        AuthenticationManager.backchannelLogout(session, realm, userSession, session.getContext().getUri(), connection, headers, true);
        adminEvent.operation(OperationType.DELETE).resource(ResourceType.USER_SESSION).resourcePath(session.getContext().getUri()).success();

    }

flows()

AuthenticationManagementResource org.keycloak.services.resources.admin.RealmAdminResource.flows ( )

inline

                                                    {
        AuthenticationManagementResource resource = new AuthenticationManagementResource(realm, session, auth, adminEvent);
        ResteasyProviderFactory.getInstance().injectProperties(resource);
        //resourceContext.initResource(resource);
        return resource;

    }

getAttackDetection()

AttackDetectionResource org.keycloak.services.resources.admin.RealmAdminResource.getAttackDetection ( )

inline

Base path for managing attack detection.

戻り値

                                                        {
        AttackDetectionResource resource = new AttackDetectionResource(auth, realm, adminEvent);
        ResteasyProviderFactory.getInstance().injectProperties(resource);
        return resource;
    }

getClientInitialAccess()

ClientInitialAccessResource org.keycloak.services.resources.admin.RealmAdminResource.getClientInitialAccess ( )

inline

Base path for managing client initial access tokens

戻り値

                                                                {
        ClientInitialAccessResource resource = new ClientInitialAccessResource(realm, auth, adminEvent);
        ResteasyProviderFactory.getInstance().injectProperties(resource);
        return resource;
    }

getClientRegistrationPolicy()

ClientRegistrationPolicyResource org.keycloak.services.resources.admin.RealmAdminResource.getClientRegistrationPolicy ( )

inline

                                                                          {
        ClientRegistrationPolicyResource resource = new ClientRegistrationPolicyResource(realm, auth, adminEvent);
        ResteasyProviderFactory.getInstance().injectProperties(resource);
        return resource;
    }

getClients()

ClientsResource org.keycloak.services.resources.admin.RealmAdminResource.getClients ( )

inline

Base path for managing clients under this realm.

戻り値

                                        {
        ClientsResource clientsResource = new ClientsResource(realm, auth, adminEvent);
        ResteasyProviderFactory.getInstance().injectProperties(clientsResource);
        return clientsResource;
    }

getClientScopes()

ClientScopesResource org.keycloak.services.resources.admin.RealmAdminResource.getClientScopes ( )

inline

Base path for managing client scopes under this realm.

戻り値

                                                  {
        ClientScopesResource clientScopesResource = new ClientScopesResource(realm, auth, adminEvent);
        ResteasyProviderFactory.getInstance().injectProperties(clientScopesResource);
        return clientScopesResource;
    }

getClientSessionStats()

List<Map<String, String> > org.keycloak.services.resources.admin.RealmAdminResource.getClientSessionStats ( )

inline

Get client session stats

Returns a JSON map. The key is the client id, the value is the number of sessions that currently are active with that client. Only clients that actually have a session associated with them will be in this map.

戻り値

                                                             {
        auth.realm().requireViewRealm();

        Map<String, Map<String, String>> data = new HashMap();
        {
            Map<String, Long> activeCount =session.sessions().getActiveClientSessionStats(realm, false);
            for (Map.Entry<String, Long> entry : activeCount.entrySet()) {
                Map<String, String> map = new HashMap<>();
                ClientModel client = realm.getClientById(entry.getKey());
                map.put("id", client.getId());
                map.put("clientId", client.getClientId());
                map.put("active", entry.getValue().toString());
                map.put("offline", "0");
                data.put(client.getId(), map);

            }
        }
        {
            Map<String, Long> offlineCount = session.sessions().getActiveClientSessionStats(realm, true);
            for (Map.Entry<String, Long> entry : offlineCount.entrySet()) {
                Map<String, String> map = data.get(entry.getKey());
                if (map == null) {
                    map = new HashMap<>();
                    ClientModel client = realm.getClientById(entry.getKey());
                    map.put("id", client.getId());
                    map.put("clientId", client.getClientId());
                    map.put("active", "0");
                    data.put(client.getId(), map);
                }
                map.put("offline", entry.getValue().toString());
            }
        }
        List<Map<String, String>> result = new LinkedList<>();
        for (Map<String, String> item : data.values()) result.add(item);
        return result;
    }

getClientTemplates()

ClientScopesResource org.keycloak.services.resources.admin.RealmAdminResource.getClientTemplates ( )

inline

This endpoint is deprecated. It's here just because of backwards compatibility. Use getClientScopes() instead

戻り値

                                                     {
        return getClientScopes();
    }

getComponents()

ComponentResource org.keycloak.services.resources.admin.RealmAdminResource.getComponents ( )

inline

Base path for managing components under this realm.

戻り値

                                             {
        ComponentResource resource = new ComponentResource(realm, auth, adminEvent);
        ResteasyProviderFactory.getInstance().injectProperties(resource);
        return resource;
    }

getDefaultClientScopes()

List<ClientScopeRepresentation> org.keycloak.services.resources.admin.RealmAdminResource.getDefaultClientScopes ( boolean  defaultScope )

inlineprivate

                                                                                         {
        auth.clients().requireViewClientScopes();

        List<ClientScopeRepresentation> defaults = new LinkedList<>();
        for (ClientScopeModel clientScope : realm.getDefaultClientScopes(defaultScope)) {
            ClientScopeRepresentation rep = new ClientScopeRepresentation();
            rep.setId(clientScope.getId());
            rep.setName(clientScope.getName());
            defaults.add(rep);
        }
        return defaults;
    }

getDefaultDefaultClientScopes()

List<ClientScopeRepresentation> org.keycloak.services.resources.admin.RealmAdminResource.getDefaultDefaultClientScopes ( )

inline

Get realm default client scopes. Only name and ids are returned.

戻り値

                                                                           {
        return getDefaultClientScopes(true);
    }

getDefaultGroups()

List<GroupRepresentation> org.keycloak.services.resources.admin.RealmAdminResource.getDefaultGroups ( )

inline

Get group hierarchy. Only name and ids are returned.

戻り値

                                                        {
        auth.realm().requireViewRealm();

        List<GroupRepresentation> defaults = new LinkedList<>();
        for (GroupModel group : realm.getDefaultGroups()) {
            defaults.add(ModelToRepresentation.toRepresentation(group, false));
        }
        return defaults;
    }

getDefaultOptionalClientScopes()

List<ClientScopeRepresentation> org.keycloak.services.resources.admin.RealmAdminResource.getDefaultOptionalClientScopes ( )

inline

Get realm optional client scopes. Only name and ids are returned.

戻り値

                                                                            {
        return getDefaultClientScopes(false);
    }

getEvents() [1/2]

List<EventRepresentation> org.keycloak.services.resources.admin.RealmAdminResource.getEvents ( @QueryParam("type") List< String >  types, @QueryParam("client") String  client, @QueryParam("user") String  user, @QueryParam("dateFrom") String  dateFrom, @QueryParam("dateTo") String  dateTo, @QueryParam("ipAddress") String  ipAddress, @QueryParam("first") Integer  firstResult, @QueryParam("max") Integer  maxResults  )

inline

Get events

Returns all events, or filters them based on URL query parameters listed here

引数

types	The types of events to return
client	App or oauth client name
user	User id
ipAddress	IP address
dateTo	To date
dateFrom	From date
firstResult	Paging offset
maxResults	Maximum results size (defaults to 100)

戻り値

                                                                                      {
        auth.realm().requireViewEvents();

        EventStoreProvider eventStore = session.getProvider(EventStoreProvider.class);

        EventQuery query = eventStore.createQuery().realm(realm.getId());
        if (client != null) {
            query.client(client);
        }

        if (types != null && !types.isEmpty()) {
            EventType[] t = new EventType[types.size()];
            for (int i = 0; i < t.length; i++) {
                t[i] = EventType.valueOf(types.get(i));
            }
            query.type(t);
        }

        if (user != null) {
            query.user(user);
        }

        if(dateFrom != null) {
            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
            Date from = null;
            try {
                from = df.parse(dateFrom);
            } catch (ParseException e) {
                throw new BadRequestException("Invalid value for 'Date(From)', expected format is yyyy-MM-dd");
            }
            query.fromDate(from);
        }

        if(dateTo != null) {
            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
            Date to = null;
            try {
                to = df.parse(dateTo);
            } catch (ParseException e) {
                throw new BadRequestException("Invalid value for 'Date(To)', expected format is yyyy-MM-dd");
            }
            query.toDate(to);
        }

        if (ipAddress != null) {
            query.ipAddress(ipAddress);
        }
        if (firstResult != null) {
            query.firstResult(firstResult);
        }
        if (maxResults != null) {
            query.maxResults(maxResults);
        } else {
            query.maxResults(Constants.DEFAULT_MAX_RESULTS);
        }

        return toEventListRep(query.getResultList());
    }

getEvents() [2/2]

List<AdminEventRepresentation> org.keycloak.services.resources.admin.RealmAdminResource.getEvents ( @QueryParam("operationTypes") List< String >  operationTypes, @QueryParam("authRealm") String  authRealm, @QueryParam("authClient") String  authClient, @QueryParam("authUser") String  authUser, @QueryParam("authIpAddress") String  authIpAddress, @QueryParam("resourcePath") String  resourcePath, @QueryParam("dateFrom") String  dateFrom, @QueryParam("dateTo") String  dateTo, @QueryParam("first") Integer  firstResult, @QueryParam("max") Integer  maxResults, @QueryParam("resourceTypes") List< String >  resourceTypes  )

inline

Get admin events

Returns all admin events, or filters events based on URL query parameters listed here

引数

operationTypes
authRealm
authClient
authUser	user id
authIpAddress
resourcePath
dateTo
dateFrom
firstResult
maxResults	Maximum results size (defaults to 100)

戻り値

                                                                                                             {
        auth.realm().requireViewEvents();

        EventStoreProvider eventStore = session.getProvider(EventStoreProvider.class);
        AdminEventQuery query = eventStore.createAdminQuery().realm(realm.getId());;

        if (authRealm != null) {
            query.authRealm(authRealm);
        }

        if (authClient != null) {
            query.authClient(authClient);
        }

        if (authUser != null) {
            query.authUser(authUser);
        }

        if (authIpAddress != null) {
            query.authIpAddress(authIpAddress);
        }

        if (resourcePath != null) {
            query.resourcePath(resourcePath);
        }

        if (operationTypes != null && !operationTypes.isEmpty()) {
            OperationType[] t = new OperationType[operationTypes.size()];
            for (int i = 0; i < t.length; i++) {
                t[i] = OperationType.valueOf(operationTypes.get(i));
            }
            query.operation(t);
        }

        if (resourceTypes != null && !resourceTypes.isEmpty()) {
            ResourceType[] t = new ResourceType[resourceTypes.size()];
            for (int i = 0; i < t.length; i++) {
                t[i] = ResourceType.valueOf(resourceTypes.get(i));
            }
            query.resourceType(t);
        }



        if(dateFrom != null) {
            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
            Date from = null;
            try {
                from = df.parse(dateFrom);
            } catch (ParseException e) {
                throw new BadRequestException("Invalid value for 'Date(From)', expected format is yyyy-MM-dd");
            }
            query.fromTime(from);
        }

        if(dateTo != null) {
            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
            Date to = null;
            try {
                to = df.parse(dateTo);
            } catch (ParseException e) {
                throw new BadRequestException("Invalid value for 'Date(To)', expected format is yyyy-MM-dd");
            }
            query.toTime(to);
        }

        if (firstResult != null) {
            query.firstResult(firstResult);
        }
        if (maxResults != null) {
            query.maxResults(maxResults);
        } else {
            query.maxResults(Constants.DEFAULT_MAX_RESULTS);
        }

        return toAdminEventRep(query.getResultList());
    }

getGroupByPath()

GroupRepresentation org.keycloak.services.resources.admin.RealmAdminResource.getGroupByPath ( @PathParam("path") String  path )

inline

                                                                              {
        GroupModel found = KeycloakModelUtils.findGroupByPath(realm, path);
        if (found == null) {
            throw new NotFoundException("Group path does not exist");

        }
        auth.groups().requireView(found);
        return ModelToRepresentation.toGroupHierarchy(found, true);
    }

getGroups()

GroupsResource org.keycloak.services.resources.admin.RealmAdminResource.getGroups ( )

inline

                                      {
        GroupsResource resource =  new GroupsResource(realm, session, this.auth, adminEvent);
        ResteasyProviderFactory.getInstance().injectProperties(resource);
        return resource;
    }

getIdentityProviderResource()

IdentityProvidersResource org.keycloak.services.resources.admin.RealmAdminResource.getIdentityProviderResource ( )

inline

                                                                   {
        return new IdentityProvidersResource(realm, session, this.auth, adminEvent);
    }

getRealm()

RealmRepresentation org.keycloak.services.resources.admin.RealmAdminResource.getRealm ( )

inline

Get the top-level representation of the realm

It will not include nested information like User and Client representations.

戻り値

                                          {
        if (auth.realm().canViewRealm()) {
            return ModelToRepresentation.toRepresentation(realm, false);
        } else {
            auth.realm().requireViewRealmNameList();

            RealmRepresentation rep = new RealmRepresentation();
            rep.setRealm(realm.getName());

            if (auth.realm().canViewIdentityProviders()) {
                RealmRepresentation r = ModelToRepresentation.toRepresentation(realm, false);
                rep.setIdentityProviders(r.getIdentityProviders());
                rep.setIdentityProviderMappers(r.getIdentityProviderMappers());
            }

            return rep;
        }
    }

getRealmEventsConfig()

RealmEventsConfigRepresentation org.keycloak.services.resources.admin.RealmAdminResource.getRealmEventsConfig ( )

inline

Get the events provider configuration

Returns JSON object with events provider configuration

戻り値

                                                                  {
        auth.realm().requireViewEvents();

        RealmEventsConfigRepresentation config = ModelToRepresentation.toEventsConfigReprensetation(realm);
        if (config.getEnabledEventTypes() == null || config.getEnabledEventTypes().isEmpty()) {
            config.setEnabledEventTypes(new LinkedList<String>());
            for (EventType e : EventType.values()) {
                if (e.isSaveByDefault()) {
                    config.getEnabledEventTypes().add(e.name());
                }
            }
        }
        return config;
    }

getRoleContainerResource()

RoleContainerResource org.keycloak.services.resources.admin.RealmAdminResource.getRoleContainerResource ( )

inline

base path for managing realm-level roles of this realm

戻り値

                                                            {
        return new RoleContainerResource(session, session.getContext().getUri(), realm, auth, realm, adminEvent);
    }

getUserMgmtPermissions()

ManagementPermissionReference org.keycloak.services.resources.admin.RealmAdminResource.getUserMgmtPermissions ( )

inline

                                                                  {
        auth.realm().requireViewRealm();

        AdminPermissionManagement permissions = AdminPermissions.management(session, realm);
        if (permissions.users().isPermissionsEnabled()) {
            return toUsersMgmtRef(permissions);
        } else {
            return new ManagementPermissionReference();
        }

    }

keys()

KeyResource org.keycloak.services.resources.admin.RealmAdminResource.keys ( )

inline

                              {
        KeyResource resource =  new KeyResource(realm, session, this.auth);
        ResteasyProviderFactory.getInstance().injectProperties(resource);
        return resource;
    }

logoutAll()

GlobalRequestResult org.keycloak.services.resources.admin.RealmAdminResource.logoutAll ( )

inline

Removes all user sessions. Any client that has an admin url will also be told to invalidate any sessions they have.

                                           {
        auth.users().requireManage();

        session.sessions().removeUserSessions(realm);
        GlobalRequestResult result = new ResourceAdminManager(session).logoutAll(session.getContext().getUri().getRequestUri(), realm);
        adminEvent.operation(OperationType.ACTION).resourcePath(session.getContext().getUri()).representation(result).success();
        return result;
    }

partialExport()

RealmRepresentation org.keycloak.services.resources.admin.RealmAdminResource.partialExport ( @QueryParam("exportGroupsAndRoles") Boolean  exportGroupsAndRoles, @QueryParam("exportClients") Boolean  exportClients  )

inline

Partial export of existing realm into a JSON file.

引数

exportGroupsAndRoles
exportClients

戻り値

                                                                                                         {

        boolean groupsAndRolesExported = exportGroupsAndRoles != null && exportGroupsAndRoles;
        boolean clientsExported = exportClients != null && exportClients;

        ExportOptions options = new ExportOptions(false, clientsExported, groupsAndRolesExported);
        RealmRepresentation rep = ExportUtils.exportRealm(session, realm, options, false);
        return stripForExport(session, rep);
    }

partialImport()

Response org.keycloak.services.resources.admin.RealmAdminResource.partialImport ( PartialImportRepresentation  rep )

inline

Partial import from a JSON file to an existing realm.

引数

rep

戻り値

                                                                   {
        auth.realm().requireManageRealm();

        PartialImportManager partialImport = new PartialImportManager(rep, session, realm, adminEvent);
        return partialImport.saveResources();
    }

pushRevocation()

GlobalRequestResult org.keycloak.services.resources.admin.RealmAdminResource.pushRevocation ( )

inline

Push the realm's revocation policy to any client that has an admin url associated with it.

                                                {
        auth.realm().requireManageRealm();

        GlobalRequestResult result = new ResourceAdminManager(session).pushRealmRevocationPolicy(session.getContext().getUri().getRequestUri(), realm);
        adminEvent.operation(OperationType.ACTION).resourcePath(session.getContext().getUri()).representation(result).success();
        return result;
    }

removeDefaultDefaultClientScope()

void org.keycloak.services.resources.admin.RealmAdminResource.removeDefaultDefaultClientScope ( @PathParam("clientScopeId") String  clientScopeId )

inline

                                                                                                  {
        auth.clients().requireManageClientScopes();

        ClientScopeModel clientScope = realm.getClientScopeById(clientScopeId);
        if (clientScope == null) {
            throw new NotFoundException("Client scope not found");
        }
        realm.removeDefaultClientScope(clientScope);

        adminEvent.operation(OperationType.DELETE).resource(ResourceType.CLIENT_SCOPE).resourcePath(session.getContext().getUri()).success();
    }

removeDefaultGroup()

void org.keycloak.services.resources.admin.RealmAdminResource.removeDefaultGroup ( @PathParam("groupId") String  groupId )

inline

                                                                         {
        auth.realm().requireManageRealm();

        GroupModel group = realm.getGroupById(groupId);
        if (group == null) {
            throw new NotFoundException("Group not found");
        }
        realm.removeDefaultGroup(group);

        adminEvent.operation(OperationType.DELETE).resource(ResourceType.GROUP).resourcePath(session.getContext().getUri()).success();
    }

removeDefaultOptionalClientScope()

void org.keycloak.services.resources.admin.RealmAdminResource.removeDefaultOptionalClientScope ( @PathParam("clientScopeId") String  clientScopeId )

inline

                                                                                                   {
        removeDefaultDefaultClientScope(clientScopeId);
    }

rolesById()

RoleByIdResource org.keycloak.services.resources.admin.RealmAdminResource.rolesById ( )

inline

Path for managing all realm-level or client-level roles defined in this realm by its id.

戻り値

                                        {
         RoleByIdResource resource = new RoleByIdResource(realm, auth, adminEvent);
        ResteasyProviderFactory.getInstance().injectProperties(resource);
        //resourceContext.initResource(resource);
        return resource;
    }

setUsersManagementPermissionsEnabled()

ManagementPermissionReference org.keycloak.services.resources.admin.RealmAdminResource.setUsersManagementPermissionsEnabled ( ManagementPermissionReference  ref )

inline

                                                                                                                 {
        auth.realm().requireManageRealm();

        AdminPermissionManagement permissions = AdminPermissions.management(session, realm);
        permissions.users().setPermissionsEnabled(ref.isEnabled());
        if (ref.isEnabled()) {
            return toUsersMgmtRef(permissions);
        } else {
            return new ManagementPermissionReference();
        }
    }

testLDAPConnection()

Response org.keycloak.services.resources.admin.RealmAdminResource.testLDAPConnection ( @FormParam("action") String  action, @FormParam("connectionUrl") String  connectionUrl, @FormParam("bindDn") String  bindDn, @FormParam("bindCredential") String  bindCredential, @FormParam("useTruststoreSpi") String  useTruststoreSpi, @FormParam("connectionTimeout") String  connectionTimeout, @FormParam("componentId") String  componentId  )

inline

Test LDAP connection

引数

action
connectionUrl
bindDn
bindCredential

戻り値

                                                                                     {
        auth.realm().requireManageRealm();

        if (componentId != null && bindCredential.equals(ComponentRepresentation.SECRET_VALUE)) {
            bindCredential = realm.getComponent(componentId).getConfig().getFirst(LDAPConstants.BIND_CREDENTIAL);
        }

        boolean result = new LDAPConnectionTestManager().testLDAP(action, connectionUrl, bindDn, bindCredential, useTruststoreSpi, connectionTimeout);
        return result ? Response.noContent().build() : ErrorResponse.error("LDAP test error", Response.Status.BAD_REQUEST);
    }

testSMTPConnection()

Response org.keycloak.services.resources.admin.RealmAdminResource.testSMTPConnection ( final @PathParam("config") String  config ) throws Exception

inline

Test SMTP connection with current logged in user

引数

config

SMTP server configuration

戻り値

例外

Exception

                                                                                                  {
        Map<String, String> settings = readValue(config, new TypeReference<Map<String, String>>() {
        });

        try {
            UserModel user = auth.adminAuth().getUser();
            if (user.getEmail() == null) {
                return ErrorResponse.error("Logged in user does not have an e-mail.", Response.Status.INTERNAL_SERVER_ERROR);
            }
            if (ComponentRepresentation.SECRET_VALUE.equals(settings.get("password"))) {
                settings.put("password", realm.getSmtpConfig().get("password"));
            }
            session.getProvider(EmailTemplateProvider.class).sendSmtpTestEmail(settings, user);
        } catch (Exception e) {
            e.printStackTrace();
            logger.errorf("Failed to send email \n %s", e.getCause());
            return ErrorResponse.error("Failed to send email", Response.Status.INTERNAL_SERVER_ERROR);
        }

        return Response.noContent().build();
    }

toAdminEventRep()

List<AdminEventRepresentation> org.keycloak.services.resources.admin.RealmAdminResource.toAdminEventRep ( List< AdminEvent >  events )

inlineprivate

                                                                                    {
        List<AdminEventRepresentation> reps = new ArrayList<>();
        for (AdminEvent event : events) {
            reps.add(ModelToRepresentation.toRepresentation(event));
        }

        return reps;
    }

toEventListRep()

List<EventRepresentation> org.keycloak.services.resources.admin.RealmAdminResource.toEventListRep ( List< Event >  events )

inlineprivate

                                                                         {
        List<EventRepresentation> reps = new ArrayList<>();
        for (Event event : events) {
            reps.add(ModelToRepresentation.toRepresentation(event));
        }
        return reps;
    }

toUsersMgmtRef()

static ManagementPermissionReference org.keycloak.services.resources.admin.RealmAdminResource.toUsersMgmtRef ( AdminPermissionManagement  permissions )

inlinestatic

                                                                                                      {
        ManagementPermissionReference ref = new ManagementPermissionReference();
        ref.setEnabled(true);
        ref.setResource(permissions.users().resource().getId());
        Map<String, String> scopes = permissions.users().getPermissions();
        ref.setScopePermissions(scopes);
        return ref;
    }

updateRealm()

Response org.keycloak.services.resources.admin.RealmAdminResource.updateRealm ( final RealmRepresentation  rep )

inline

Update the top-level information of the realm

Any user, roles or client information in the representation will be ignored. This will only update top-level attributes of the realm.

引数

rep

戻り値

                                                               {
        auth.realm().requireManageRealm();

        logger.debug("updating realm: " + realm.getName());

        if (Config.getAdminRealm().equals(realm.getName()) && (rep.getRealm() != null && !rep.getRealm().equals(Config.getAdminRealm()))) {
            return ErrorResponse.error("Can't rename master realm", Status.BAD_REQUEST);
        }

        try {
            if (!Constants.GENERATE.equals(rep.getPublicKey()) && (rep.getPrivateKey() != null && rep.getPublicKey() != null)) {
                try {
                    KeyPairVerifier.verify(rep.getPrivateKey(), rep.getPublicKey());
                } catch (VerificationException e) {
                    return ErrorResponse.error(e.getMessage(), Status.BAD_REQUEST);
                }
            }

            if (!Constants.GENERATE.equals(rep.getPublicKey()) && (rep.getCertificate() != null)) {
                try {
                    X509Certificate cert = PemUtils.decodeCertificate(rep.getCertificate());
                    if (cert == null) {
                        return ErrorResponse.error("Failed to decode certificate", Status.BAD_REQUEST);
                    }
                } catch (Exception e)  {
                    return ErrorResponse.error("Failed to decode certificate", Status.BAD_REQUEST);
                }
            }

            boolean wasDuplicateEmailsAllowed = realm.isDuplicateEmailsAllowed();
            RepresentationToModel.updateRealm(rep, realm, session);

            // Refresh periodic sync tasks for configured federationProviders
            List<UserStorageProviderModel> federationProviders = realm.getUserStorageProviders();
            UserStorageSyncManager usersSyncManager = new UserStorageSyncManager();
            for (final UserStorageProviderModel fedProvider : federationProviders) {
                usersSyncManager.notifyToRefreshPeriodicSync(session, realm, fedProvider, false);
            }

            adminEvent.operation(OperationType.UPDATE).representation(StripSecretsUtils.strip(rep)).success();
            
            if (rep.isDuplicateEmailsAllowed() != null && rep.isDuplicateEmailsAllowed() != wasDuplicateEmailsAllowed) {
                UserCache cache = session.getProvider(UserCache.class);
                if (cache != null) cache.clear();
            }
            
            return Response.noContent().build();
        } catch (ModelDuplicateException e) {
            return ErrorResponse.exists("Realm with same name exists");
        } catch (ModelException e) {
            return ErrorResponse.error(e.getMessage(), Status.BAD_REQUEST);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            return ErrorResponse.error("Failed to update realm", Response.Status.INTERNAL_SERVER_ERROR);
        }
    }

updateRealmEventsConfig()

void org.keycloak.services.resources.admin.RealmAdminResource.updateRealmEventsConfig ( final RealmEventsConfigRepresentation  rep )

inline

Update the events provider

Change the events provider and/or its configuration

引数

rep

                                                                                   {
        auth.realm().requireManageEvents();

        logger.debug("updating realm events config: " + realm.getName());
        new RealmManager(session).updateRealmEventsConfig(rep, realm);
        adminEvent.operation(OperationType.UPDATE).resource(ResourceType.REALM).realm(realm)
                .resourcePath(session.getContext().getUri()).representation(rep)
                // refresh the builder to consider old and new config
                .refreshRealmEventsConfig(session)
                .success();
    }

users()

UsersResource org.keycloak.services.resources.admin.RealmAdminResource.users ( )

inline

Base path for managing users in this realm.

戻り値

                                 {
        UsersResource users = new UsersResource(realm, auth, adminEvent);
        ResteasyProviderFactory.getInstance().injectProperties(users);
        //resourceContext.initResource(users);
        return users;
    }

userStorage()

UserStorageProviderResource org.keycloak.services.resources.admin.RealmAdminResource.userStorage ( )

inline

                                                     {
        UserStorageProviderResource fed = new UserStorageProviderResource(realm, auth, adminEvent);
        ResteasyProviderFactory.getInstance().injectProperties(fed);
        //resourceContext.initResource(fed);
        return fed;
    }

メンバ詳解

adminEvent

AdminEventBuilder org.keycloak.services.resources.admin.RealmAdminResource.adminEvent

private

auth

AdminPermissionEvaluator org.keycloak.services.resources.admin.RealmAdminResource.auth

protected

connection

ClientConnection org.keycloak.services.resources.admin.RealmAdminResource.connection

protected

headers

HttpHeaders org.keycloak.services.resources.admin.RealmAdminResource.headers

protected

logger

final Logger org.keycloak.services.resources.admin.RealmAdminResource.logger = Logger.getLogger(RealmAdminResource.class)

staticprotected

realm

RealmModel org.keycloak.services.resources.admin.RealmAdminResource.realm

protected

session

KeycloakSession org.keycloak.services.resources.admin.RealmAdminResource.session

protected

tokenManager

TokenManager org.keycloak.services.resources.admin.RealmAdminResource.tokenManager

private

---

このクラス詳解は次のファイルから抽出されました:

• D:/AppData/doxygen/keycloak/rest-service/src/services/src/main/java/org/keycloak/services/resources/admin/RealmAdminResource.java