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

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

公開メンバ関数
	AuthenticationManagementResource (RealmModel realm, KeycloakSession session, AdminPermissionEvaluator auth, AdminEventBuilder adminEvent)
List< Map< String, Object > >	getFormProviders ()
List< Map< String, Object > >	getAuthenticatorProviders ()
List< Map< String, Object > >	getClientAuthenticatorProviders ()
List< Map< String, Object > >	buildProviderMetadata (List< ProviderFactory > factories)
List< Map< String, Object > >	getFormActionProviders ()
List< AuthenticationFlowRepresentation >	getFlows ()
Response	createFlow (AuthenticationFlowRepresentation flow)
AuthenticationFlowRepresentation	getFlow (@PathParam("id") String id)
Response	updateFlow (@PathParam("id") String id, AuthenticationFlowRepresentation flow)
void	deleteFlow (@PathParam("id") String id)
Response	copy (@PathParam("flowAlias") String flowAlias, Map< String, String > data)
Response	addExecutionFlow (@PathParam("flowAlias") String flowAlias, Map< String, String > data)
Response	addExecutionToFlow (@PathParam("flowAlias") String flowAlias, Map< String, String > data)
Response	getExecutions (@PathParam("flowAlias") String flowAlias)
void	recurseExecutions (AuthenticationFlowModel flow, List< AuthenticationExecutionInfoRepresentation > result, int level)
void	updateExecutions (@PathParam("flowAlias") String flowAlias, AuthenticationExecutionInfoRepresentation rep)
Response	getExecution (final @PathParam("executionId") String executionId)
Response	addExecution (AuthenticationExecutionRepresentation execution)
AuthenticationFlowModel	getParentFlow (AuthenticationExecutionModel model)
void	raisePriority (@PathParam("executionId") String execution)
List< AuthenticationExecutionModel >	getSortedExecutions (AuthenticationFlowModel parentFlow)
void	lowerPriority (@PathParam("executionId") String execution)
void	removeExecution (@PathParam("executionId") String execution)
Response	newExecutionConfig (@PathParam("executionId") String execution, AuthenticatorConfigRepresentation json)
AuthenticatorConfigRepresentation	getAuthenticatorConfig (@PathParam("executionId") String execution, @PathParam("id") String id)
List< Map< String, String > >	getUnregisteredRequiredActions ()
void	registerRequiredAction (Map< String, String > data)
List< RequiredActionProviderRepresentation >	getRequiredActions ()
RequiredActionProviderRepresentation	getRequiredAction (@PathParam("alias") String alias)
void	updateRequiredAction (@PathParam("alias") String alias, RequiredActionProviderRepresentation rep)
void	removeRequiredAction (@PathParam("alias") String alias)
void	raiseRequiredActionPriority (@PathParam("alias") String alias)
void	lowerRequiredActionPriority (@PathParam("alias") String alias)
AuthenticatorConfigInfoRepresentation	getAuthenticatorConfigDescription (@PathParam("providerId") String providerId)
Map< String, List< ConfigPropertyRepresentation > >	getPerClientConfigDescription ()
Response	createAuthenticatorConfig (AuthenticatorConfigRepresentation rep)
AuthenticatorConfigRepresentation	getAuthenticatorConfig (@PathParam("id") String id)
void	removeAuthenticatorConfig (@PathParam("id") String id)
void	updateAuthenticatorConfig (@PathParam("id") String id, AuthenticatorConfigRepresentation rep)

静的公開メンバ関数
static AuthenticationFlowModel	copyFlow (RealmModel realm, AuthenticationFlowModel flow, String newName)
static void	copy (RealmModel realm, String newName, AuthenticationFlowModel from, AuthenticationFlowModel to)
static RequiredActionProviderRepresentation	toRepresentation (RequiredActionProviderModel model)

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

非公開メンバ関数
void	deleteFlow (String id, boolean isTopMostLevel)
int	getNextPriority (AuthenticationFlowModel parentFlow)
int	getNextRequiredActionPriority ()
ConfigPropertyRepresentation	getConfigPropertyRep (ProviderConfigProperty prop)

非公開変数類
final RealmModel	realm
final KeycloakSession	session
AdminPermissionEvaluator	auth
AdminEventBuilder	adminEvent

詳解

Authentication Management

著者

Bill Burke

構築子と解体子

AuthenticationManagementResource()

org.keycloak.services.resources.admin.AuthenticationManagementResource.AuthenticationManagementResource ( RealmModel  realm, KeycloakSession  session, AdminPermissionEvaluator  auth, AdminEventBuilder  adminEvent  )

inline

                                                                                                                                                    {
        this.realm = realm;
        this.session = session;
        this.auth = auth;
        this.adminEvent = adminEvent.resource(ResourceType.AUTH_FLOW);
    }

関数詳解

addExecution()

Response org.keycloak.services.resources.admin.AuthenticationManagementResource.addExecution ( AuthenticationExecutionRepresentation  execution )

inline

Add new authentication execution

引数

execution

JSON model describing authentication execution

                                                                                  {
        auth.realm().requireManageRealm();

        AuthenticationExecutionModel model = RepresentationToModel.toModel(realm, execution);
        AuthenticationFlowModel parentFlow = getParentFlow(model);
        if (parentFlow.isBuiltIn()) {
            throw new BadRequestException("It is illegal to add execution to a built in flow");
        }
        model.setPriority(getNextPriority(parentFlow));
        model = realm.addAuthenticatorExecution(model);

        adminEvent.operation(OperationType.CREATE).resource(ResourceType.AUTH_EXECUTION).resourcePath(session.getContext().getUri(), model.getId()).representation(execution).success();
        return Response.created(session.getContext().getUri().getAbsolutePathBuilder().path(model.getId()).build()).build();
    }

addExecutionFlow()

Response org.keycloak.services.resources.admin.AuthenticationManagementResource.addExecutionFlow ( @PathParam("flowAlias") String  flowAlias, Map< String, String >  data  )

inline

Add new flow with new execution to existing flow

引数

flowAlias	Alias of parent authentication flow
data	New authentication flow / execution JSON data containing 'alias', 'type', 'provider', and 'description' attributes

                                                                                                         {
        auth.realm().requireManageRealm();

        AuthenticationFlowModel parentFlow = realm.getFlowByAlias(flowAlias);
        if (parentFlow == null) {
            return ErrorResponse.error("Parent flow doesn't exists", Response.Status.BAD_REQUEST);
        }
        String alias = data.get("alias");
        String type = data.get("type");
        String provider = data.get("provider");
        String description = data.get("description");


        AuthenticationFlowModel newFlow = realm.getFlowByAlias(alias);
        if (newFlow != null) {
            return ErrorResponse.exists("New flow alias name already exists");
        }
        newFlow = new AuthenticationFlowModel();
        newFlow.setAlias(alias);
        newFlow.setDescription(description);
        newFlow.setProviderId(type);
        newFlow = realm.addAuthenticationFlow(newFlow);
        AuthenticationExecutionModel execution = new AuthenticationExecutionModel();
        execution.setParentFlow(parentFlow.getId());
        execution.setFlowId(newFlow.getId());
        execution.setRequirement(AuthenticationExecutionModel.Requirement.DISABLED);
        execution.setAuthenticatorFlow(true);
        execution.setAuthenticator(provider);
        execution.setPriority(getNextPriority(parentFlow));
        execution = realm.addAuthenticatorExecution(execution);

        data.put("id", execution.getId());
        adminEvent.operation(OperationType.CREATE).resource(ResourceType.AUTH_EXECUTION_FLOW).resourcePath(session.getContext().getUri()).representation(data).success();

        String addExecutionPathSegment = UriBuilder.fromMethod(AuthenticationManagementResource.class, "addExecutionFlow").build(parentFlow.getAlias()).getPath();
        return Response.created(session.getContext().getUri().getBaseUriBuilder().path(session.getContext().getUri().getPath().replace(addExecutionPathSegment, "")).path("flows").path(newFlow.getId()).build()).build();
    }

addExecutionToFlow()

Response org.keycloak.services.resources.admin.AuthenticationManagementResource.addExecutionToFlow ( @PathParam("flowAlias") String  flowAlias, Map< String, String >  data  )

inline

Add new authentication execution to a flow

引数

flowAlias	Alias of parent flow
data	New execution JSON data containing 'provider' attribute

                                                                                                           {
        auth.realm().requireManageRealm();

        AuthenticationFlowModel parentFlow = realm.getFlowByAlias(flowAlias);
        if (parentFlow == null) {
            throw new BadRequestException("Parent flow doesn't exists");
        }
        if (parentFlow.isBuiltIn()) {
            throw new BadRequestException("It is illegal to add execution to a built in flow");
        }
        String provider = data.get("provider");

        // make sure provider is one of the registered providers
        ProviderFactory f;
        if (parentFlow.getProviderId().equals(AuthenticationFlow.CLIENT_FLOW)) {
            f = session.getKeycloakSessionFactory().getProviderFactory(ClientAuthenticator.class, provider);
        } else if (parentFlow.getProviderId().equals(AuthenticationFlow.FORM_FLOW)) {
            f = session.getKeycloakSessionFactory().getProviderFactory(FormAction.class, provider);
        } else {
            f = session.getKeycloakSessionFactory().getProviderFactory(Authenticator.class, provider);
        }
        if (f == null) {
            throw new BadRequestException("No authentication provider found for id: " + provider);
        }

        AuthenticationExecutionModel execution = new AuthenticationExecutionModel();
        execution.setParentFlow(parentFlow.getId());
        execution.setRequirement(AuthenticationExecutionModel.Requirement.DISABLED);
        execution.setAuthenticatorFlow(false);
        execution.setAuthenticator(provider);
        execution.setPriority(getNextPriority(parentFlow));

        execution = realm.addAuthenticatorExecution(execution);

        data.put("id", execution.getId());
        adminEvent.operation(OperationType.CREATE).resource(ResourceType.AUTH_EXECUTION).resourcePath(session.getContext().getUri()).representation(data).success();

        String addExecutionPathSegment = UriBuilder.fromMethod(AuthenticationManagementResource.class, "addExecutionToFlow").build(parentFlow.getAlias()).getPath();
        return Response.created(session.getContext().getUri().getBaseUriBuilder().path(session.getContext().getUri().getPath().replace(addExecutionPathSegment, "")).path("executions").path(execution.getId()).build()).build();
    }

buildProviderMetadata()

List<Map<String, Object> > org.keycloak.services.resources.admin.AuthenticationManagementResource.buildProviderMetadata ( List< ProviderFactory >  factories )

inline

                                                                                            {
        List<Map<String, Object>> providers = new LinkedList<>();
        for (ProviderFactory factory : factories) {
            Map<String, Object> data = new HashMap<>();
            data.put("id", factory.getId());
            ConfigurableAuthenticatorFactory configured = (ConfigurableAuthenticatorFactory)factory;
            data.put("description", configured.getHelpText());
            data.put("displayName", configured.getDisplayType());

            providers.add(data);
        }
        return providers;
    }

copy() [1/2]

Response org.keycloak.services.resources.admin.AuthenticationManagementResource.copy ( @PathParam("flowAlias") String  flowAlias, Map< String, String >  data  )

inline

Copy existing authentication flow under a new name

The new name is given as 'newName' attribute of the passed JSON object

引数

flowAlias	Name of the existing authentication flow
data	JSON containing 'newName' attribute

                                                                                             {
        auth.realm().requireManageRealm();

        String newName = data.get("newName");
        if (realm.getFlowByAlias(newName) != null) {
            return ErrorResponse.exists("New flow alias name already exists");
        }

        AuthenticationFlowModel flow = realm.getFlowByAlias(flowAlias);
        if (flow == null) {
            logger.debug("flow not found: " + flowAlias);
            return Response.status(NOT_FOUND).build();
        }
        AuthenticationFlowModel copy = copyFlow(realm, flow, newName);

        data.put("id", copy.getId());
        adminEvent.operation(OperationType.CREATE).resourcePath(session.getContext().getUri()).representation(data).success();

        return Response.status(Response.Status.CREATED).build();

    }

copy() [2/2]

static void org.keycloak.services.resources.admin.AuthenticationManagementResource.copy ( RealmModel  realm, String  newName, AuthenticationFlowModel  from, AuthenticationFlowModel  to  )

inlinestatic

                                                                                                                        {
        for (AuthenticationExecutionModel execution : realm.getAuthenticationExecutions(from.getId())) {
            if (execution.isAuthenticatorFlow()) {
                AuthenticationFlowModel subFlow = realm.getAuthenticationFlowById(execution.getFlowId());
                AuthenticationFlowModel copy = new AuthenticationFlowModel();
                copy.setAlias(newName + " " + subFlow.getAlias());
                copy.setDescription(subFlow.getDescription());
                copy.setProviderId(subFlow.getProviderId());
                copy.setBuiltIn(false);
                copy.setTopLevel(false);
                copy = realm.addAuthenticationFlow(copy);
                execution.setFlowId(copy.getId());
                copy(realm, newName, subFlow, copy);
            }
            execution.setId(null);
            execution.setParentFlow(to.getId());
            realm.addAuthenticatorExecution(execution);
        }
    }

copyFlow()

static AuthenticationFlowModel org.keycloak.services.resources.admin.AuthenticationManagementResource.copyFlow ( RealmModel  realm, AuthenticationFlowModel  flow, String  newName  )

inlinestatic

                                                                                                                   {
        AuthenticationFlowModel copy = new AuthenticationFlowModel();
        copy.setAlias(newName);
        copy.setDescription(flow.getDescription());
        copy.setProviderId(flow.getProviderId());
        copy.setBuiltIn(false);
        copy.setTopLevel(flow.isTopLevel());
        copy = realm.addAuthenticationFlow(copy);
        copy(realm, newName, flow, copy);
        return copy;
    }

createAuthenticatorConfig()

Response org.keycloak.services.resources.admin.AuthenticationManagementResource.createAuthenticatorConfig ( AuthenticatorConfigRepresentation  rep )

inline

Create new authenticator configuration

引数

rep	JSON describing new authenticator configuration

非推奨:

Use newExecutionConfig(String, AuthenticatorConfigRepresentation) instead

                                                                                     {
        auth.realm().requireManageRealm();

        AuthenticatorConfigModel config = realm.addAuthenticatorConfig(RepresentationToModel.toModel(rep));
        adminEvent.operation(OperationType.CREATE).resource(ResourceType.AUTHENTICATOR_CONFIG).resourcePath(session.getContext().getUri(), config.getId()).representation(rep).success();
        return Response.created(session.getContext().getUri().getAbsolutePathBuilder().path(config.getId()).build()).build();
    }

createFlow()

Response org.keycloak.services.resources.admin.AuthenticationManagementResource.createFlow ( AuthenticationFlowRepresentation  flow )

inline

Create a new authentication flow

引数

flow	Authentication flow representation

戻り値

                                                                      {
        auth.realm().requireManageRealm();

        if (flow.getAlias() == null || flow.getAlias().isEmpty()) {
            return ErrorResponse.exists("Failed to create flow with empty alias name");
        }

        if (realm.getFlowByAlias(flow.getAlias()) != null) {
            return ErrorResponse.exists("Flow " + flow.getAlias() + " already exists");
        }

        AuthenticationFlowModel createdModel = realm.addAuthenticationFlow(RepresentationToModel.toModel(flow));

        flow.setId(createdModel.getId());
        adminEvent.operation(OperationType.CREATE).resourcePath(session.getContext().getUri(), createdModel.getId()).representation(flow).success();
        return Response.created(session.getContext().getUri().getAbsolutePathBuilder().path(flow.getId()).build()).build();
    }

deleteFlow() [1/2]

void org.keycloak.services.resources.admin.AuthenticationManagementResource.deleteFlow ( @PathParam("id") String  id )

inline

Delete an authentication flow

引数

id

Flow id

                                                       {
        auth.realm().requireManageRealm();
        
        deleteFlow(id, true);
    }

deleteFlow() [2/2]

void org.keycloak.services.resources.admin.AuthenticationManagementResource.deleteFlow ( String  id, boolean  isTopMostLevel  )

inlineprivate

                                                               {
        AuthenticationFlowModel flow = realm.getAuthenticationFlowById(id);
        if (flow == null) {
            throw new NotFoundException("Could not find flow with id");
        }
        if (flow.isBuiltIn()) {
            throw new BadRequestException("Can't delete built in flow");
        }
        
        List<AuthenticationExecutionModel> executions = realm.getAuthenticationExecutions(id);
        for (AuthenticationExecutionModel execution : executions) {
            if(execution.getFlowId() != null) {
                deleteFlow(execution.getFlowId(), false);
            }
        }
        realm.removeAuthenticationFlow(flow);

        // Use just one event for top-level flow. Using separate events won't work properly for flows of depth 2 or bigger
        if (isTopMostLevel) adminEvent.operation(OperationType.DELETE).resourcePath(session.getContext().getUri()).success();
    }

getAuthenticatorConfig() [1/2]

AuthenticatorConfigRepresentation org.keycloak.services.resources.admin.AuthenticationManagementResource.getAuthenticatorConfig ( @PathParam("executionId") String  execution, @PathParam("id") String  id  )

inline

Get execution's configuration

引数

execution	Execution id
id	Configuration id

非推奨:

Use rather getAuthenticatorConfig(String)

                                                                                                                                           {
        auth.realm().requireViewRealm();

        AuthenticatorConfigModel config = realm.getAuthenticatorConfigById(id);
        if (config == null) {
            throw new NotFoundException("Could not find authenticator config");

        }
        return ModelToRepresentation.toRepresentation(config);
    }

getAuthenticatorConfig() [2/2]

AuthenticatorConfigRepresentation org.keycloak.services.resources.admin.AuthenticationManagementResource.getAuthenticatorConfig ( @PathParam("id") String  id )

inline

Get authenticator configuration

引数

id	Configuration id

                                                                                                {
        auth.realm().requireViewRealm();

        AuthenticatorConfigModel config = realm.getAuthenticatorConfigById(id);
        if (config == null) {
            throw new NotFoundException("Could not find authenticator config");

        }
        return ModelToRepresentation.toRepresentation(config);
    }

getAuthenticatorConfigDescription()

AuthenticatorConfigInfoRepresentation org.keycloak.services.resources.admin.AuthenticationManagementResource.getAuthenticatorConfigDescription ( @PathParam("providerId") String  providerId )

inline

Get authenticator provider's configuration description

                                                                                                                               {
        auth.realm().requireViewRealm();

        ConfigurableAuthenticatorFactory factory = CredentialHelper.getConfigurableAuthenticatorFactory(session, providerId);
        if (factory == null) {
            throw new NotFoundException("Could not find authenticator provider");
        }
        AuthenticatorConfigInfoRepresentation rep = new AuthenticatorConfigInfoRepresentation();
        rep.setProviderId(providerId);
        rep.setName(factory.getDisplayType());
        rep.setHelpText(factory.getHelpText());
        rep.setProperties(new LinkedList<>());
        List<ProviderConfigProperty> configProperties = factory.getConfigProperties();
        for (ProviderConfigProperty prop : configProperties) {
            ConfigPropertyRepresentation propRep = getConfigPropertyRep(prop);
            rep.getProperties().add(propRep);
        }
        return rep;
    }

getAuthenticatorProviders()

List<Map<String, Object> > org.keycloak.services.resources.admin.AuthenticationManagementResource.getAuthenticatorProviders ( )

inline

Get authenticator providers

Returns a list of authenticator providers.

                                                                 {
        auth.realm().requireViewRealm();

        List<ProviderFactory> factories = session.getKeycloakSessionFactory().getProviderFactories(Authenticator.class);
        return buildProviderMetadata(factories);
    }

getClientAuthenticatorProviders()

List<Map<String, Object> > org.keycloak.services.resources.admin.AuthenticationManagementResource.getClientAuthenticatorProviders ( )

inline

Get client authenticator providers

Returns a list of client authenticator providers.

                                                                       {
        auth.requireAnyAdminRole();

        List<ProviderFactory> factories = session.getKeycloakSessionFactory().getProviderFactories(ClientAuthenticator.class);
        return buildProviderMetadata(factories);
    }

getConfigPropertyRep()

ConfigPropertyRepresentation org.keycloak.services.resources.admin.AuthenticationManagementResource.getConfigPropertyRep ( ProviderConfigProperty  prop )

inlineprivate

                                                                                           {
        return ModelToRepresentation.toRepresentation(prop);
    }

getExecution()

Response org.keycloak.services.resources.admin.AuthenticationManagementResource.getExecution ( final @PathParam("executionId") String  executionId )

inline

Get Single Execution

                                                                                     {
        //http://localhost:8080/auth/admin/realms/master/authentication/executions/cf26211b-9e68-4788-b754-1afd02e59d7f
        auth.realm().requireManageRealm();

        final Optional<AuthenticationExecutionModel> model = Optional.ofNullable(realm.getAuthenticationExecutionById(executionId));
        if (!model.isPresent()) {
            logger.debugv("Could not find execution by Id: {}", executionId);
            throw new NotFoundException("Illegal execution");
        }

        return Response.ok(model.get()).build();
    }

getExecutions()

Response org.keycloak.services.resources.admin.AuthenticationManagementResource.getExecutions ( @PathParam("flowAlias") String  flowAlias )

inline

Get authentication executions for a flow

引数

flowAlias

Flow alias

                                                                            {
        auth.realm().requireViewRealm();

        AuthenticationFlowModel flow = realm.getFlowByAlias(flowAlias);
        if (flow == null) {
            logger.debug("flow not found: " + flowAlias);
            return Response.status(NOT_FOUND).build();
        }
        List<AuthenticationExecutionInfoRepresentation> result = new LinkedList<>();

        int level = 0;

        recurseExecutions(flow, result, level);
        return Response.ok(result).build();
    }

getFlow()

AuthenticationFlowRepresentation org.keycloak.services.resources.admin.AuthenticationManagementResource.getFlow ( @PathParam("id") String  id )

inline

Get authentication flow for id

引数

id

Flow id

戻り値

                                                                                {
        auth.realm().requireViewRealm();

        AuthenticationFlowModel flow = realm.getAuthenticationFlowById(id);
        if (flow == null) {
            throw new NotFoundException("Could not find flow with id");
        }
        return ModelToRepresentation.toRepresentation(realm, flow);
    }

getFlows()

List<AuthenticationFlowRepresentation> org.keycloak.services.resources.admin.AuthenticationManagementResource.getFlows ( )

inline

Get authentication flows

Returns a list of authentication flows.

                                                             {
        auth.realm().requireViewRealm();

        List<AuthenticationFlowRepresentation> flows = new LinkedList<>();
        for (AuthenticationFlowModel flow : realm.getAuthenticationFlows()) {
            // KEYCLOAK-3517, we need a better way to filter non-configurable internal flows
            if (flow.isTopLevel() && !flow.getAlias().equals(DefaultAuthenticationFlows.SAML_ECP_FLOW)) {
                flows.add(ModelToRepresentation.toRepresentation(realm, flow));
            }
        }
        return flows;
    }

getFormActionProviders()

List<Map<String, Object> > org.keycloak.services.resources.admin.AuthenticationManagementResource.getFormActionProviders ( )

inline

Get form action providers

Returns a list of form action providers.

                                                              {
        auth.realm().requireViewRealm();

        List<ProviderFactory> factories = session.getKeycloakSessionFactory().getProviderFactories(FormAction.class);
        return buildProviderMetadata(factories);
    }

getFormProviders()

List<Map<String, Object> > org.keycloak.services.resources.admin.AuthenticationManagementResource.getFormProviders ( )

inline

Get form providers

Returns a list of form providers.

                                                        {
        auth.realm().requireViewRealm();

        List<ProviderFactory> factories = session.getKeycloakSessionFactory().getProviderFactories(FormAuthenticator.class);
        return buildProviderMetadata(factories);
    }

getNextPriority()

int org.keycloak.services.resources.admin.AuthenticationManagementResource.getNextPriority ( AuthenticationFlowModel  parentFlow )

inlineprivate

                                                                    {
        List<AuthenticationExecutionModel> executions = getSortedExecutions(parentFlow);
        return executions.isEmpty() ? 0 : executions.get(executions.size() - 1).getPriority() + 1;
    }

getNextRequiredActionPriority()

int org.keycloak.services.resources.admin.AuthenticationManagementResource.getNextRequiredActionPriority ( )

inlineprivate

                                                {
        List<RequiredActionProviderModel> actions = realm.getRequiredActionProviders();
        return actions.isEmpty() ? 0 : actions.get(actions.size() - 1).getPriority() + 1;
    }

getParentFlow()

AuthenticationFlowModel org.keycloak.services.resources.admin.AuthenticationManagementResource.getParentFlow ( AuthenticationExecutionModel  model )

inline

                                                                                     {
        if (model.getParentFlow() == null) {
            throw new BadRequestException("parent flow not set on new execution");
        }
        AuthenticationFlowModel parentFlow = realm.getAuthenticationFlowById(model.getParentFlow());
        if (parentFlow == null) {
            throw new BadRequestException("execution parent flow does not exist");

        }
        return parentFlow;
    }

getPerClientConfigDescription()

Map<String, List<ConfigPropertyRepresentation> > org.keycloak.services.resources.admin.AuthenticationManagementResource.getPerClientConfigDescription ( )

inline

Get configuration descriptions for all clients

                                                                                           {
        auth.requireAnyAdminRole();

        List<ProviderFactory> factories = session.getKeycloakSessionFactory().getProviderFactories(ClientAuthenticator.class);

        Map<String, List<ConfigPropertyRepresentation>> toReturn = new HashMap<>();
        for (ProviderFactory clientAuthenticatorFactory : factories) {
            String providerId = clientAuthenticatorFactory.getId();
            ConfigurableAuthenticatorFactory factory = CredentialHelper.getConfigurableAuthenticatorFactory(session, providerId);
            ClientAuthenticatorFactory clientAuthFactory = (ClientAuthenticatorFactory) factory;
            List<ProviderConfigProperty> perClientConfigProps = clientAuthFactory.getConfigPropertiesPerClient();
            List<ConfigPropertyRepresentation> result = new LinkedList<>();
            for (ProviderConfigProperty prop : perClientConfigProps) {
                ConfigPropertyRepresentation propRep = getConfigPropertyRep(prop);
                result.add(propRep);
            }

            toReturn.put(providerId, result);
        }

        return toReturn;
    }

getRequiredAction()

RequiredActionProviderRepresentation org.keycloak.services.resources.admin.AuthenticationManagementResource.getRequiredAction ( @PathParam("alias") String  alias )

inline

Get required action for alias

引数

alias

Alias of required action

                                                                                                    {
        auth.realm().requireViewRealm();

        RequiredActionProviderModel model = realm.getRequiredActionProviderByAlias(alias);
        if (model == null) {
            throw new NotFoundException("Failed to find required action");
        }
        return toRepresentation(model);
    }

getRequiredActions()

List<RequiredActionProviderRepresentation> org.keycloak.services.resources.admin.AuthenticationManagementResource.getRequiredActions ( )

inline

Get required actions

Returns a list of required actions.

                                                                           {
        auth.requireAnyAdminRole();

        List<RequiredActionProviderRepresentation> list = new LinkedList<>();
        for (RequiredActionProviderModel model : realm.getRequiredActionProviders()) {
            RequiredActionProviderRepresentation rep = toRepresentation(model);
            list.add(rep);
        }
        return list;
    }

getSortedExecutions()

List<AuthenticationExecutionModel> org.keycloak.services.resources.admin.AuthenticationManagementResource.getSortedExecutions ( AuthenticationFlowModel  parentFlow )

inline

                                                                                                      {
        List<AuthenticationExecutionModel> executions = new LinkedList<>(realm.getAuthenticationExecutions(parentFlow.getId()));
        Collections.sort(executions, AuthenticationExecutionModel.ExecutionComparator.SINGLETON);
        return executions;
    }

getUnregisteredRequiredActions()

List<Map<String, String> > org.keycloak.services.resources.admin.AuthenticationManagementResource.getUnregisteredRequiredActions ( )

inline

Get unregistered required actions

Returns a list of unregistered required actions.

                                                                      {
        auth.realm().requireViewRealm();

        List<ProviderFactory> factories = session.getKeycloakSessionFactory().getProviderFactories(RequiredActionProvider.class);
        List<Map<String, String>> unregisteredList = new LinkedList<>();
        for (ProviderFactory factory : factories) {
            RequiredActionFactory requiredActionFactory = (RequiredActionFactory) factory;
            boolean found = false;
            for (RequiredActionProviderModel model : realm.getRequiredActionProviders()) {
                if (model.getProviderId().equals(factory.getId())) {
                    found = true;
                    break;
                }
            }
            if (!found) {
                Map<String, String> data = new HashMap<>();
                data.put("name", requiredActionFactory.getDisplayText());
                data.put("providerId", requiredActionFactory.getId());
                unregisteredList.add(data);
            }

        }
        return unregisteredList;
    }

lowerPriority()

void org.keycloak.services.resources.admin.AuthenticationManagementResource.lowerPriority ( @PathParam("executionId") String  execution )

inline

Lower execution's priority

引数

execution

Execution id

                                                                          {
        auth.realm().requireManageRealm();

        AuthenticationExecutionModel model = realm.getAuthenticationExecutionById(execution);
        if (model == null) {
            session.getTransactionManager().setRollbackOnly();
            throw new NotFoundException("Illegal execution");

        }
        AuthenticationFlowModel parentFlow = getParentFlow(model);
        if (parentFlow.isBuiltIn()) {
            throw new BadRequestException("It is illegal to modify execution in a built in flow");
        }
        List<AuthenticationExecutionModel> executions = getSortedExecutions(parentFlow);
        int i = 0;
        for (i = 0; i < executions.size(); i++) {
            if (executions.get(i).getId().equals(model.getId())) {
                break;
            }
        }
        if (i + 1 >= executions.size()) return;
        AuthenticationExecutionModel next = executions.get(i + 1);
        int tmp = model.getPriority();
        model.setPriority(next.getPriority());
        realm.updateAuthenticatorExecution(model);
        next.setPriority(tmp);
        realm.updateAuthenticatorExecution(next);

        adminEvent.operation(OperationType.UPDATE).resource(ResourceType.AUTH_EXECUTION).resourcePath(session.getContext().getUri()).success();
    }

lowerRequiredActionPriority()

void org.keycloak.services.resources.admin.AuthenticationManagementResource.lowerRequiredActionPriority ( @PathParam("alias") String  alias )

inline

Lower required action's priority

引数

alias

Alias of required action

                                                                              {
        auth.realm().requireManageRealm();

        RequiredActionProviderModel model = realm.getRequiredActionProviderByAlias(alias);
        if (model == null) {
            throw new NotFoundException("Failed to find required action.");
        }

        List<RequiredActionProviderModel> actions = realm.getRequiredActionProviders();
        int i = 0;
        for (i = 0; i < actions.size(); i++) {
            if (actions.get(i).getId().equals(model.getId())) {
                break;
            }
        }
        if (i + 1 >= actions.size()) return;
        RequiredActionProviderModel next = actions.get(i + 1);
        int tmp = model.getPriority();
        model.setPriority(next.getPriority());
        realm.updateRequiredActionProvider(model);
        next.setPriority(tmp);
        realm.updateRequiredActionProvider(next);

        adminEvent.operation(OperationType.UPDATE).resource(ResourceType.REQUIRED_ACTION).resourcePath(session.getContext().getUri()).success();
    }

newExecutionConfig()

Response org.keycloak.services.resources.admin.AuthenticationManagementResource.newExecutionConfig ( @PathParam("executionId") String  execution, AuthenticatorConfigRepresentation  json  )

inline

Update execution with new configuration

引数

execution	Execution id
json	JSON with new configuration

戻り値

                                                                                                                           {
        auth.realm().requireManageRealm();

        AuthenticationExecutionModel model = realm.getAuthenticationExecutionById(execution);
        if (model == null) {
            session.getTransactionManager().setRollbackOnly();
            throw new NotFoundException("Illegal execution");

        }
        AuthenticatorConfigModel config = RepresentationToModel.toModel(json);
        if (config.getAlias() == null) {
            return ErrorResponse.error("Alias missing", Response.Status.BAD_REQUEST);
        }
        config = realm.addAuthenticatorConfig(config);
        model.setAuthenticatorConfig(config.getId());
        realm.updateAuthenticatorExecution(model);

        json.setId(config.getId());
        adminEvent.operation(OperationType.CREATE).resource(ResourceType.AUTH_EXECUTION).resourcePath(session.getContext().getUri()).representation(json).success();
        return Response.created(session.getContext().getUri().getAbsolutePathBuilder().path(config.getId()).build()).build();
    }

raisePriority()

void org.keycloak.services.resources.admin.AuthenticationManagementResource.raisePriority ( @PathParam("executionId") String  execution )

inline

Raise execution's priority

引数

execution

Execution id

                                                                          {
        auth.realm().requireManageRealm();

        AuthenticationExecutionModel model = realm.getAuthenticationExecutionById(execution);
        if (model == null) {
            session.getTransactionManager().setRollbackOnly();
            throw new NotFoundException("Illegal execution");

        }
        AuthenticationFlowModel parentFlow = getParentFlow(model);
        if (parentFlow.isBuiltIn()) {
            throw new BadRequestException("It is illegal to modify execution in a built in flow");
        }
        List<AuthenticationExecutionModel> executions = getSortedExecutions(parentFlow);
        AuthenticationExecutionModel previous = null;
        for (AuthenticationExecutionModel exe : executions) {
            if (exe.getId().equals(model.getId())) {
                break;
            }
            previous = exe;

        }
        if (previous == null) return;
        int tmp = previous.getPriority();
        previous.setPriority(model.getPriority());
        realm.updateAuthenticatorExecution(previous);
        model.setPriority(tmp);
        realm.updateAuthenticatorExecution(model);

        adminEvent.operation(OperationType.UPDATE).resource(ResourceType.AUTH_EXECUTION).resourcePath(session.getContext().getUri()).success();
    }

raiseRequiredActionPriority()

void org.keycloak.services.resources.admin.AuthenticationManagementResource.raiseRequiredActionPriority ( @PathParam("alias") String  alias )

inline

Raise required action's priority

引数

alias

Alias of required action

                                                                              {
        auth.realm().requireManageRealm();

        RequiredActionProviderModel model = realm.getRequiredActionProviderByAlias(alias);
        if (model == null) {
            throw new NotFoundException("Failed to find required action.");
        }

        List<RequiredActionProviderModel> actions = realm.getRequiredActionProviders();
        RequiredActionProviderModel previous = null;
        for (RequiredActionProviderModel action : actions) {
            if (action.getId().equals(model.getId())) {
                break;
            }
            previous = action;
        }
        if (previous == null) return;
        int tmp = previous.getPriority();
        previous.setPriority(model.getPriority());
        realm.updateRequiredActionProvider(previous);
        model.setPriority(tmp);
        realm.updateRequiredActionProvider(model);

        adminEvent.operation(OperationType.UPDATE).resource(ResourceType.REQUIRED_ACTION).resourcePath(session.getContext().getUri()).success();
    }

recurseExecutions()

void org.keycloak.services.resources.admin.AuthenticationManagementResource.recurseExecutions ( AuthenticationFlowModel  flow, List< AuthenticationExecutionInfoRepresentation >  result, int  level  )

inline

                                                                                                                                   {
        int index = 0;
        List<AuthenticationExecutionModel> executions = realm.getAuthenticationExecutions(flow.getId());
        for (AuthenticationExecutionModel execution : executions) {
            AuthenticationExecutionInfoRepresentation rep = new AuthenticationExecutionInfoRepresentation();
            rep.setLevel(level);
            rep.setIndex(index++);
            rep.setRequirementChoices(new LinkedList<String>());
            if (execution.isAuthenticatorFlow()) {
                AuthenticationFlowModel flowRef = realm.getAuthenticationFlowById(execution.getFlowId());
                if (AuthenticationFlow.BASIC_FLOW.equals(flowRef.getProviderId())) {
                    rep.getRequirementChoices().add(AuthenticationExecutionModel.Requirement.ALTERNATIVE.name());
                    rep.getRequirementChoices().add(AuthenticationExecutionModel.Requirement.REQUIRED.name());
                    rep.getRequirementChoices().add(AuthenticationExecutionModel.Requirement.DISABLED.name());
                } else if (AuthenticationFlow.FORM_FLOW.equals(flowRef.getProviderId())) {
                    rep.getRequirementChoices().add(AuthenticationExecutionModel.Requirement.REQUIRED.name());
                    rep.getRequirementChoices().add(AuthenticationExecutionModel.Requirement.DISABLED.name());
                    rep.setProviderId(execution.getAuthenticator());
                    rep.setAuthenticationConfig(execution.getAuthenticatorConfig());
                } else if (AuthenticationFlow.CLIENT_FLOW.equals(flowRef.getProviderId())) {
                    rep.getRequirementChoices().add(AuthenticationExecutionModel.Requirement.ALTERNATIVE.name());
                    rep.getRequirementChoices().add(AuthenticationExecutionModel.Requirement.REQUIRED.name());
                    rep.getRequirementChoices().add(AuthenticationExecutionModel.Requirement.DISABLED.name());
                }
                rep.setDisplayName(flowRef.getAlias());
                rep.setConfigurable(false);
                rep.setId(execution.getId());
                rep.setAuthenticationFlow(execution.isAuthenticatorFlow());
                rep.setRequirement(execution.getRequirement().name());
                rep.setFlowId(execution.getFlowId());
                result.add(rep);
                AuthenticationFlowModel subFlow = realm.getAuthenticationFlowById(execution.getFlowId());
                recurseExecutions(subFlow, result, level + 1);
            } else {
                String providerId = execution.getAuthenticator();
                ConfigurableAuthenticatorFactory factory = CredentialHelper.getConfigurableAuthenticatorFactory(session, providerId);
                rep.setDisplayName(factory.getDisplayType());
                rep.setConfigurable(factory.isConfigurable());
                for (AuthenticationExecutionModel.Requirement choice : factory.getRequirementChoices()) {
                    rep.getRequirementChoices().add(choice.name());
                }
                rep.setId(execution.getId());

                if (factory.isConfigurable()) {
                    String authenticatorConfigId = execution.getAuthenticatorConfig();
                    if(authenticatorConfigId != null) {
                        AuthenticatorConfigModel authenticatorConfig = realm.getAuthenticatorConfigById(authenticatorConfigId);

                        if (authenticatorConfig != null) {
                            rep.setAlias(authenticatorConfig.getAlias());
                        }
                    }
                }

                rep.setRequirement(execution.getRequirement().name());
                rep.setProviderId(execution.getAuthenticator());
                rep.setAuthenticationConfig(execution.getAuthenticatorConfig());
                result.add(rep);
            }
        }
    }

registerRequiredAction()

void org.keycloak.services.resources.admin.AuthenticationManagementResource.registerRequiredAction ( Map< String, String >  data )

inline

Register a new required actions

引数

data	JSON containing 'providerId', and 'name' attributes.

                                                                 {
        auth.realm().requireManageRealm();

        String providerId = data.get("providerId");
        String name = data.get("name");
        RequiredActionProviderModel requiredAction = new RequiredActionProviderModel();
        requiredAction.setAlias(providerId);
        requiredAction.setName(name);
        requiredAction.setProviderId(providerId);
        requiredAction.setDefaultAction(false);
        requiredAction.setPriority(getNextRequiredActionPriority());
        requiredAction.setEnabled(true);
        requiredAction = realm.addRequiredActionProvider(requiredAction);

        data.put("id", requiredAction.getId());
        adminEvent.operation(OperationType.CREATE).resource(ResourceType.REQUIRED_ACTION).resourcePath(session.getContext().getUri()).representation(data).success();
    }

removeAuthenticatorConfig()

void org.keycloak.services.resources.admin.AuthenticationManagementResource.removeAuthenticatorConfig ( @PathParam("id") String  id )

inline

Delete authenticator configuration

引数

id	Configuration id

                                                                      {
        auth.realm().requireManageRealm();

        AuthenticatorConfigModel config = realm.getAuthenticatorConfigById(id);
        if (config == null) {
            throw new NotFoundException("Could not find authenticator config");

        }
        List<AuthenticationFlowModel> flows = new LinkedList<>();
        for (AuthenticationFlowModel flow : realm.getAuthenticationFlows()) {
            for (AuthenticationExecutionModel exe : realm.getAuthenticationExecutions(flow.getId())) {
                if (id.equals(exe.getAuthenticatorConfig())) {
                    exe.setAuthenticatorConfig(null);
                    realm.updateAuthenticatorExecution(exe);
                }
            }
        }

        realm.removeAuthenticatorConfig(config);

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

removeExecution()

void org.keycloak.services.resources.admin.AuthenticationManagementResource.removeExecution ( @PathParam("executionId") String  execution )

inline

Delete execution

引数

execution

Execution id

                                                                            {
        auth.realm().requireManageRealm();

        AuthenticationExecutionModel model = realm.getAuthenticationExecutionById(execution);
        if (model == null) {
            session.getTransactionManager().setRollbackOnly();
            throw new NotFoundException("Illegal execution");

        }
        AuthenticationFlowModel parentFlow = getParentFlow(model);
        if (parentFlow.isBuiltIn()) {
            throw new BadRequestException("It is illegal to remove execution from a built in flow");
        }

        if(model.getFlowId() != null) {
                AuthenticationFlowModel nonTopLevelFlow = realm.getAuthenticationFlowById(model.getFlowId());
                realm.removeAuthenticationFlow(nonTopLevelFlow);
        }

        realm.removeAuthenticatorExecution(model);

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

removeRequiredAction()

void org.keycloak.services.resources.admin.AuthenticationManagementResource.removeRequiredAction ( @PathParam("alias") String  alias )

inline

Delete required action

引数

alias

Alias of required action

                                                                       {
        auth.realm().requireManageRealm();

        RequiredActionProviderModel model = realm.getRequiredActionProviderByAlias(alias);
        if (model == null) {
            throw new NotFoundException("Failed to find required action.");
        }
        realm.removeRequiredActionProvider(model);

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

toRepresentation()

static RequiredActionProviderRepresentation org.keycloak.services.resources.admin.AuthenticationManagementResource.toRepresentation ( RequiredActionProviderModel  model )

inlinestatic

                                                                                                           {
        RequiredActionProviderRepresentation rep = new RequiredActionProviderRepresentation();
        rep.setAlias(model.getAlias());
        rep.setName(model.getName());
        rep.setDefaultAction(model.isDefaultAction());
        rep.setPriority(model.getPriority());
        rep.setEnabled(model.isEnabled());
        rep.setConfig(model.getConfig());
        return rep;
    }

updateAuthenticatorConfig()

void org.keycloak.services.resources.admin.AuthenticationManagementResource.updateAuthenticatorConfig ( @PathParam("id") String  id, AuthenticatorConfigRepresentation  rep  )

inline

Update authenticator configuration

引数

id	Configuration id
rep	JSON describing new state of authenticator configuration

                                                                                                             {
        auth.realm().requireManageRealm();

        AuthenticatorConfigModel exists = realm.getAuthenticatorConfigById(id);
        if (exists == null) {
            throw new NotFoundException("Could not find authenticator config");

        }
        exists.setAlias(rep.getAlias());
        exists.setConfig(rep.getConfig());
        realm.updateAuthenticatorConfig(exists);
        adminEvent.operation(OperationType.UPDATE).resource(ResourceType.AUTHENTICATOR_CONFIG).resourcePath(session.getContext().getUri()).representation(rep).success();
    }

updateExecutions()

void org.keycloak.services.resources.admin.AuthenticationManagementResource.updateExecutions ( @PathParam("flowAlias") String  flowAlias, AuthenticationExecutionInfoRepresentation  rep  )

inline

Update authentication executions of a flow

引数

flowAlias	Flow alias
rep

                                                                                                                          {
        auth.realm().requireManageRealm();

        AuthenticationFlowModel flow = realm.getFlowByAlias(flowAlias);
        if (flow == null) {
            logger.debug("flow not found: " + flowAlias);
            throw new NotFoundException("flow not found");
        }

        AuthenticationExecutionModel model = realm.getAuthenticationExecutionById(rep.getId());
        if (model == null) {
            session.getTransactionManager().setRollbackOnly();
            throw new NotFoundException("Illegal execution");

        }
        if (!model.getRequirement().name().equals(rep.getRequirement())) {
            model.setRequirement(AuthenticationExecutionModel.Requirement.valueOf(rep.getRequirement()));
            realm.updateAuthenticatorExecution(model);
            adminEvent.operation(OperationType.UPDATE).resource(ResourceType.AUTH_EXECUTION).resourcePath(session.getContext().getUri()).representation(rep).success();
        }
    }

updateFlow()

Response org.keycloak.services.resources.admin.AuthenticationManagementResource.updateFlow ( @PathParam("id") String  id, AuthenticationFlowRepresentation  flow  )

inline

Update an authentication flow

引数

flow	Authentication flow representation

戻り値

                                                                                                  {
        auth.realm().requireManageRealm();

        AuthenticationFlowRepresentation existingFlow = getFlow(id);

        if (flow.getAlias() == null || flow.getAlias().isEmpty()) {
            return ErrorResponse.exists("Failed to update flow with empty alias name");
        }

        flow.setId(existingFlow.getId());
        realm.updateAuthenticationFlow(RepresentationToModel.toModel(flow));
        adminEvent.operation(OperationType.UPDATE).resourcePath(session.getContext().getUri()).representation(flow).success();

        return Response.accepted(flow).build();
    }

updateRequiredAction()

void org.keycloak.services.resources.admin.AuthenticationManagementResource.updateRequiredAction ( @PathParam("alias") String  alias, RequiredActionProviderRepresentation  rep  )

inline

Update required action

引数

alias	Alias of required action
rep	JSON describing new state of required action

                                                                                                                 {
        auth.realm().requireManageRealm();

        RequiredActionProviderModel model = realm.getRequiredActionProviderByAlias(alias);
        if (model == null) {
            throw new NotFoundException("Failed to find required action");
        }
        RequiredActionProviderModel update = new RequiredActionProviderModel();
        update.setId(model.getId());
        update.setName(rep.getName());
        update.setAlias(rep.getAlias());
        update.setProviderId(model.getProviderId());
        update.setDefaultAction(rep.isDefaultAction());
        update.setPriority(rep.getPriority());
        update.setEnabled(rep.isEnabled());
        update.setConfig(rep.getConfig());
        realm.updateRequiredActionProvider(update);

        adminEvent.operation(OperationType.UPDATE).resource(ResourceType.REQUIRED_ACTION).resourcePath(session.getContext().getUri()).representation(rep).success();
    }

メンバ詳解

adminEvent

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

private

auth

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

private

logger

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

staticprotected

realm

final RealmModel org.keycloak.services.resources.admin.AuthenticationManagementResource.realm

private

session

final KeycloakSession org.keycloak.services.resources.admin.AuthenticationManagementResource.session

private

---

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

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