org.keycloak.broker.oidc.mappers.UsernameTemplateMapper クラス

org.keycloak.broker.oidc.mappers.UsernameTemplateMapper の継承関係図

org.keycloak.broker.oidc.mappers.UsernameTemplateMapper 連携図

公開メンバ関数
List< ProviderConfigProperty >	getConfigProperties ()
String	getId ()
String []	getCompatibleProviders ()
String	getDisplayCategory ()
String	getDisplayType ()
void	updateBrokeredUser (KeycloakSession session, RealmModel realm, UserModel user, IdentityProviderMapperModel mapperModel, BrokeredIdentityContext context)
void	preprocessFederatedIdentity (KeycloakSession session, RealmModel realm, IdentityProviderMapperModel mapperModel, BrokeredIdentityContext context)
String	getHelpText ()
boolean	valueEquals (String desiredValue, Object value)

静的公開メンバ関数
static Object	getClaimValue (JsonWebToken token, String claim)
static Object	getClaimValue (IdentityProviderMapperModel mapperModel, BrokeredIdentityContext context)
static Object	getClaimValue (BrokeredIdentityContext context, String claim)

静的公開変数類
static final String []	COMPATIBLE_PROVIDERS = {KeycloakOIDCIdentityProviderFactory.PROVIDER_ID, OIDCIdentityProviderFactory.PROVIDER_ID}
static final String	TEMPLATE = "template"
static final String	PROVIDER_ID = "oidc-username-idp-mapper"
static final String	CLAIM = "claim"
static final String	CLAIM_VALUE = "claim.value"

限定公開メンバ関数
boolean	hasClaimValue (IdentityProviderMapperModel mapperModel, BrokeredIdentityContext context)

静的関数
	[static initializer]

静的変数
static Pattern	substitution = Pattern.compile("\\$\\{([^}]+)\\}")

静的非公開変数類
static final List< ProviderConfigProperty >	configProperties = new ArrayList<ProviderConfigProperty>()

詳解

著者

Bill Burke

バージョン

Revision

1

関数詳解

[static initializer]()

org.keycloak.broker.oidc.mappers.UsernameTemplateMapper.[static initializer] ( )

inlinestaticpackage

getClaimValue() [1/3]

static Object org.keycloak.broker.oidc.mappers.AbstractClaimMapper.getClaimValue ( JsonWebToken  token, String  claim  )

inlinestaticinherited

                                                                         {
        List<String> split = OIDCAttributeMapperHelper.splitClaimPath(claim);
        Map<String, Object> jsonObject = token.getOtherClaims();
        final int length = split.size();
        int i = 0;
        for (String component : split) {
            i++;
            if (i == length) {
                return jsonObject.get(component);
            } else {
                Object val = jsonObject.get(component);
                if (!(val instanceof Map)) return null;
                jsonObject = (Map<String, Object>)val;
            }
        }
        return null;
    }

getClaimValue() [2/3]

static Object org.keycloak.broker.oidc.mappers.AbstractClaimMapper.getClaimValue ( IdentityProviderMapperModel  mapperModel, BrokeredIdentityContext  context  )

inlinestaticinherited

                                                                                                                 {
        String claim = mapperModel.getConfig().get(CLAIM);
        return getClaimValue(context, claim);
    }

getClaimValue() [3/3]

static Object org.keycloak.broker.oidc.mappers.AbstractClaimMapper.getClaimValue ( BrokeredIdentityContext  context, String  claim  )

inlinestaticinherited

                                                                                      {
        {  // search access token
            JsonWebToken token = (JsonWebToken)context.getContextData().get(KeycloakOIDCIdentityProvider.VALIDATED_ACCESS_TOKEN);
            if (token != null) {
                Object value = getClaimValue(token, claim);
                if (value != null) return value;
            }

        }
        {  // search ID Token
            JsonWebToken token = (JsonWebToken)context.getContextData().get(KeycloakOIDCIdentityProvider.VALIDATED_ID_TOKEN);
            if (token != null) {
                Object value = getClaimValue(token, claim);
                if (value != null) return value;
            }

        }
        {
            // Search the OIDC UserInfo claim set (if any)
            JsonNode profileJsonNode = (JsonNode) context.getContextData().get(OIDCIdentityProvider.USER_INFO);
            Object value = AbstractJsonUserAttributeMapper.getJsonValue(profileJsonNode, claim);
            if (value != null) return value;
        }
        return null;
    }

getCompatibleProviders()

String [] org.keycloak.broker.oidc.mappers.UsernameTemplateMapper.getCompatibleProviders ( )

inline

                                             {
        return COMPATIBLE_PROVIDERS;
    }

getConfigProperties()

List<ProviderConfigProperty> org.keycloak.broker.oidc.mappers.UsernameTemplateMapper.getConfigProperties ( )

inline

                                                              {
        return configProperties;
    }

getDisplayCategory()

String org.keycloak.broker.oidc.mappers.UsernameTemplateMapper.getDisplayCategory ( )

inline

                                       {
        return "Preprocessor";
    }

getDisplayType()

String org.keycloak.broker.oidc.mappers.UsernameTemplateMapper.getDisplayType ( )

inline

                                   {
        return "Username Template Importer";
    }

getHelpText()

String org.keycloak.broker.oidc.mappers.UsernameTemplateMapper.getHelpText ( )

inline

                                {
        return "Format the username to import.";
    }

getId()

String org.keycloak.broker.oidc.mappers.UsernameTemplateMapper.getId ( )

inline

                          {
        return PROVIDER_ID;
    }

hasClaimValue()

boolean org.keycloak.broker.oidc.mappers.AbstractClaimMapper.hasClaimValue ( IdentityProviderMapperModel  mapperModel, BrokeredIdentityContext  context  )

inlineprotectedinherited

                                                                                                              {
        Object value = getClaimValue(mapperModel, context);
        String desiredValue = mapperModel.getConfig().get(CLAIM_VALUE);
        return valueEquals(desiredValue, value);
    }

preprocessFederatedIdentity()

void org.keycloak.broker.oidc.mappers.UsernameTemplateMapper.preprocessFederatedIdentity ( KeycloakSession  session, RealmModel  realm, IdentityProviderMapperModel  mapperModel, BrokeredIdentityContext  context  )

inline

                                                                                                                                                                 {
        String template = mapperModel.getConfig().get(TEMPLATE);
        Matcher m = substitution.matcher(template);
        StringBuffer sb = new StringBuffer();
        while (m.find()) {
            String variable = m.group(1);
            if (variable.equals("ALIAS")) {
                m.appendReplacement(sb, context.getIdpConfig().getAlias());
            } else if (variable.equals("UUID")) {
                m.appendReplacement(sb, KeycloakModelUtils.generateId());
            } else if (variable.startsWith("CLAIM.")) {
                String name = variable.substring("CLAIM.".length());
                Object value = AbstractClaimMapper.getClaimValue(context, name);
                if (value == null) value = "";
                m.appendReplacement(sb, value.toString());
            } else {
                m.appendReplacement(sb, m.group(1));
            }

        }
        m.appendTail(sb);
        String username = sb.toString();
        context.setModelUsername(username);

    }

updateBrokeredUser()

void org.keycloak.broker.oidc.mappers.UsernameTemplateMapper.updateBrokeredUser ( KeycloakSession  session, RealmModel  realm, UserModel  user, IdentityProviderMapperModel  mapperModel, BrokeredIdentityContext  context  )

inline

                                                                                                                                                                        {
    }

valueEquals()

boolean org.keycloak.broker.oidc.mappers.AbstractClaimMapper.valueEquals ( String  desiredValue, Object  value  )

inlineinherited

                                                                  {
        if (value instanceof String) {
            if (desiredValue.equals(value)) return true;
        } else if (value instanceof Double) {
            try {
                if (Double.valueOf(desiredValue).equals(value)) return true;
            } catch (Exception e) {

            }
        } else if (value instanceof Integer) {
            try {
                if (Integer.valueOf(desiredValue).equals(value)) return true;
            } catch (Exception e) {

            }
        } else if (value instanceof Boolean) {
            try {
                if (Boolean.valueOf(desiredValue).equals(value)) return true;
            } catch (Exception e) {

            }
        } else if (value instanceof List) {
            List list = (List)value;
            for (Object val : list) {
                if (valueEquals(desiredValue, val)) return true;
            }
        }
        return false;
    }

メンバ詳解

CLAIM

final String org.keycloak.broker.oidc.mappers.AbstractClaimMapper.CLAIM = "claim"

staticinherited

CLAIM_VALUE

final String org.keycloak.broker.oidc.mappers.AbstractClaimMapper.CLAIM_VALUE = "claim.value"

staticinherited

COMPATIBLE_PROVIDERS

final String [] org.keycloak.broker.oidc.mappers.UsernameTemplateMapper.COMPATIBLE_PROVIDERS = {KeycloakOIDCIdentityProviderFactory.PROVIDER_ID, OIDCIdentityProviderFactory.PROVIDER_ID}

static

configProperties

final List<ProviderConfigProperty> org.keycloak.broker.oidc.mappers.UsernameTemplateMapper.configProperties = new ArrayList<ProviderConfigProperty>()

staticprivate

PROVIDER_ID

final String org.keycloak.broker.oidc.mappers.UsernameTemplateMapper.PROVIDER_ID = "oidc-username-idp-mapper"

static

substitution

Pattern org.keycloak.broker.oidc.mappers.UsernameTemplateMapper.substitution = Pattern.compile("\\$\\{([^}]+)\\}")

staticpackage

TEMPLATE

final String org.keycloak.broker.oidc.mappers.UsernameTemplateMapper.TEMPLATE = "template"

static

---

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

• D:/AppData/doxygen/keycloak/rest-service/src/services/src/main/java/org/keycloak/broker/oidc/mappers/UsernameTemplateMapper.java