org.keycloak.protocol.oidc.mappers.OIDCAttributeMapperHelper クラス

org.keycloak.protocol.oidc.mappers.OIDCAttributeMapperHelper 連携図

静的公開メンバ関数
static Object	mapAttributeValue (ProtocolMapperModel mappingModel, Object attributeValue)
static List< String >	splitClaimPath (String claimPath)
static void	mapClaim (IDToken token, ProtocolMapperModel mappingModel, Object attributeValue)
static ProtocolMapperModel	createClaimMapper (String name, String userAttribute, String tokenClaimName, String claimType, boolean accessToken, boolean idToken, String mapperId)
static ProtocolMapperModel	createClaimMapper (String name, String userAttribute, String tokenClaimName, String claimType, boolean accessToken, boolean idToken, boolean userinfo, String mapperId)
static boolean	includeInIDToken (ProtocolMapperModel mappingModel)
static boolean	includeInAccessToken (ProtocolMapperModel mappingModel)
static boolean	isMultivalued (ProtocolMapperModel mappingModel)
static boolean	includeInUserInfo (ProtocolMapperModel mappingModel)
static void	addAttributeConfig (List< ProviderConfigProperty > configProperties, Class<? extends ProtocolMapper > protocolMapperClass)
static void	addTokenClaimNameConfig (List< ProviderConfigProperty > configProperties)
static void	addJsonTypeConfig (List< ProviderConfigProperty > configProperties)
static void	addIncludeInTokensConfig (List< ProviderConfigProperty > configProperties, Class<? extends ProtocolMapper > protocolMapperClass)

静的公開変数類
static final String	TOKEN_CLAIM_NAME = "claim.name"
static final String	TOKEN_CLAIM_NAME_LABEL = "tokenClaimName.label"
static final String	TOKEN_CLAIM_NAME_TOOLTIP = "tokenClaimName.tooltip"
static final String	JSON_TYPE = "jsonType.label"
static final String	JSON_TYPE_TOOLTIP = "jsonType.tooltip"
static final String	INCLUDE_IN_ACCESS_TOKEN = "access.token.claim"
static final String	INCLUDE_IN_ACCESS_TOKEN_LABEL = "includeInAccessToken.label"
static final String	INCLUDE_IN_ACCESS_TOKEN_HELP_TEXT = "includeInAccessToken.tooltip"
static final String	INCLUDE_IN_ID_TOKEN = "id.token.claim"
static final String	INCLUDE_IN_ID_TOKEN_LABEL = "includeInIdToken.label"
static final String	INCLUDE_IN_ID_TOKEN_HELP_TEXT = "includeInIdToken.tooltip"
static final String	INCLUDE_IN_USERINFO = "userinfo.token.claim"
static final String	INCLUDE_IN_USERINFO_LABEL = "includeInUserInfo.label"
static final String	INCLUDE_IN_USERINFO_HELP_TEXT = "includeInUserInfo.tooltip"

静的非公開メンバ関数
static< X, T > List< T >	transform (List< X > attributeValue, Function< X, T > mapper)
static Object	convertToType (String type, Object attributeValue)
static String	getString (Object attributeValue)
static Long	getLong (Object attributeValue)
static Integer	getInteger (Object attributeValue)
static Boolean	getBoolean (Object attributeValue)

静的非公開変数類
static final Pattern	CLAIM_COMPONENT = Pattern.compile("^((\\\\.|[^\\\\.])+?)\\.")
static final Pattern	BACKSLASHED_CHARACTER = Pattern.compile("\\\\(.)")

詳解

著者

Bill Burke

バージョン

Revision

1

関数詳解

addAttributeConfig()

static void org.keycloak.protocol.oidc.mappers.OIDCAttributeMapperHelper.addAttributeConfig ( List< ProviderConfigProperty >  configProperties, Class<? extends ProtocolMapper >  protocolMapperClass  )

inlinestatic

                                                                                                                                              {
        addTokenClaimNameConfig(configProperties);
        addJsonTypeConfig(configProperties);

        addIncludeInTokensConfig(configProperties, protocolMapperClass);
    }

addIncludeInTokensConfig()

static void org.keycloak.protocol.oidc.mappers.OIDCAttributeMapperHelper.addIncludeInTokensConfig ( List< ProviderConfigProperty >  configProperties, Class<? extends ProtocolMapper >  protocolMapperClass  )

inlinestatic

                                                                                                                                                    {
        if (OIDCIDTokenMapper.class.isAssignableFrom(protocolMapperClass)) {
            ProviderConfigProperty property = new ProviderConfigProperty();
            property.setName(INCLUDE_IN_ID_TOKEN);
            property.setLabel(INCLUDE_IN_ID_TOKEN_LABEL);
            property.setType(ProviderConfigProperty.BOOLEAN_TYPE);
            property.setDefaultValue("true");
            property.setHelpText(INCLUDE_IN_ID_TOKEN_HELP_TEXT);
            configProperties.add(property);
        }

        if (OIDCAccessTokenMapper.class.isAssignableFrom(protocolMapperClass)) {
            ProviderConfigProperty property = new ProviderConfigProperty();
            property.setName(INCLUDE_IN_ACCESS_TOKEN);
            property.setLabel(INCLUDE_IN_ACCESS_TOKEN_LABEL);
            property.setType(ProviderConfigProperty.BOOLEAN_TYPE);
            property.setDefaultValue("true");
            property.setHelpText(INCLUDE_IN_ACCESS_TOKEN_HELP_TEXT);
            configProperties.add(property);
        }

        if (UserInfoTokenMapper.class.isAssignableFrom(protocolMapperClass)) {
            ProviderConfigProperty property = new ProviderConfigProperty();
            property.setName(INCLUDE_IN_USERINFO);
            property.setLabel(INCLUDE_IN_USERINFO_LABEL);
            property.setType(ProviderConfigProperty.BOOLEAN_TYPE);
            property.setDefaultValue("true");
            property.setHelpText(INCLUDE_IN_USERINFO_HELP_TEXT);
            configProperties.add(property);
        }
    }

addJsonTypeConfig()

static void org.keycloak.protocol.oidc.mappers.OIDCAttributeMapperHelper.addJsonTypeConfig ( List< ProviderConfigProperty >  configProperties )

inlinestatic

                                                                                        {
        ProviderConfigProperty property = new ProviderConfigProperty();
        property.setName(JSON_TYPE);
        property.setLabel(JSON_TYPE);
        List<String> types = new ArrayList(3);
        types.add("String");
        types.add("long");
        types.add("int");
        types.add("boolean");
        property.setType(ProviderConfigProperty.LIST_TYPE);
        property.setOptions(types);
        property.setHelpText(JSON_TYPE_TOOLTIP);
        configProperties.add(property);
    }

addTokenClaimNameConfig()

static void org.keycloak.protocol.oidc.mappers.OIDCAttributeMapperHelper.addTokenClaimNameConfig ( List< ProviderConfigProperty >  configProperties )

inlinestatic

                                                                                              {
        ProviderConfigProperty property = new ProviderConfigProperty();
        property.setName(TOKEN_CLAIM_NAME);
        property.setLabel(TOKEN_CLAIM_NAME_LABEL);
        property.setType(ProviderConfigProperty.STRING_TYPE);
        property.setHelpText(TOKEN_CLAIM_NAME_TOOLTIP);
        configProperties.add(property);
    }

convertToType()

static Object org.keycloak.protocol.oidc.mappers.OIDCAttributeMapperHelper.convertToType ( String  type, Object  attributeValue  )

inlinestaticprivate

                                                                            {
        if (type == null || attributeValue == null) return attributeValue;
        switch (type) {
            case "boolean":
                Boolean booleanObject = getBoolean(attributeValue);
                if (booleanObject != null) return booleanObject;
                if (attributeValue instanceof List) {
                    return transform((List<Boolean>) attributeValue, OIDCAttributeMapperHelper::getBoolean);
                }
                throw new RuntimeException("cannot map type for token claim");
            case "String":
                if (attributeValue instanceof String) return attributeValue;
                if (attributeValue instanceof List) {
                    return transform((List<String>) attributeValue, OIDCAttributeMapperHelper::getString);
                }
                return attributeValue.toString();
            case "long":
                Long longObject = getLong(attributeValue);
                if (longObject != null) return longObject;
                if (attributeValue instanceof List) {
                    return transform((List<Long>) attributeValue, OIDCAttributeMapperHelper::getLong);
                }
                throw new RuntimeException("cannot map type for token claim");
            case "int":
                Integer intObject = getInteger(attributeValue);
                if (intObject != null) return intObject;
                if (attributeValue instanceof List) {
                    return transform((List<Integer>) attributeValue, OIDCAttributeMapperHelper::getInteger);
                }
                throw new RuntimeException("cannot map type for token claim");
            default:
                return null;
        }
    }

createClaimMapper() [1/2]

static ProtocolMapperModel org.keycloak.protocol.oidc.mappers.OIDCAttributeMapperHelper.createClaimMapper ( String  name, String  userAttribute, String  tokenClaimName, String  claimType, boolean  accessToken, boolean  idToken, String  mapperId  )

inlinestatic

                                                                         {
        return createClaimMapper(name, userAttribute,tokenClaimName, claimType, accessToken, idToken, true, mapperId);
    }

createClaimMapper() [2/2]

static ProtocolMapperModel org.keycloak.protocol.oidc.mappers.OIDCAttributeMapperHelper.createClaimMapper ( String  name, String  userAttribute, String  tokenClaimName, String  claimType, boolean  accessToken, boolean  idToken, boolean  userinfo, String  mapperId  )

inlinestatic

                                                   {
        ProtocolMapperModel mapper = new ProtocolMapperModel();
        mapper.setName(name);
        mapper.setProtocolMapper(mapperId);
        mapper.setProtocol(OIDCLoginProtocol.LOGIN_PROTOCOL);
        Map<String, String> config = new HashMap<String, String>();
        config.put(ProtocolMapperUtils.USER_ATTRIBUTE, userAttribute);
        config.put(TOKEN_CLAIM_NAME, tokenClaimName);
        config.put(JSON_TYPE, claimType);
        if (accessToken) config.put(INCLUDE_IN_ACCESS_TOKEN, "true");
        if (idToken) config.put(INCLUDE_IN_ID_TOKEN, "true");
        if (userinfo) config.put(INCLUDE_IN_USERINFO, "true");
        mapper.setConfig(config);
        return mapper;
    }

getBoolean()

static Boolean org.keycloak.protocol.oidc.mappers.OIDCAttributeMapperHelper.getBoolean ( Object  attributeValue )

inlinestaticprivate

                                                             {
        if (attributeValue instanceof Boolean) return (Boolean) attributeValue;
        if (attributeValue instanceof String) return Boolean.valueOf((String) attributeValue);
        return null;
    }

getInteger()

static Integer org.keycloak.protocol.oidc.mappers.OIDCAttributeMapperHelper.getInteger ( Object  attributeValue )

inlinestaticprivate

                                                             {
        if (attributeValue instanceof Integer) return (Integer) attributeValue;
        if (attributeValue instanceof String) return Integer.valueOf((String) attributeValue);
        return null;
    }

getLong()

static Long org.keycloak.protocol.oidc.mappers.OIDCAttributeMapperHelper.getLong ( Object  attributeValue )

inlinestaticprivate

                                                       {
        if (attributeValue instanceof Long) return (Long) attributeValue;
        if (attributeValue instanceof String) return Long.valueOf((String) attributeValue);
        return null;
    }

getString()

static String org.keycloak.protocol.oidc.mappers.OIDCAttributeMapperHelper.getString ( Object  attributeValue )

inlinestaticprivate

                                                           {
        return attributeValue.toString();
    }

includeInAccessToken()

static boolean org.keycloak.protocol.oidc.mappers.OIDCAttributeMapperHelper.includeInAccessToken ( ProtocolMapperModel  mappingModel )

inlinestatic

                                                                                 {
        return "true".equals(mappingModel.getConfig().get(INCLUDE_IN_ACCESS_TOKEN));
    }

includeInIDToken()

static boolean org.keycloak.protocol.oidc.mappers.OIDCAttributeMapperHelper.includeInIDToken ( ProtocolMapperModel  mappingModel )

inlinestatic

                                                                             {
        return "true".equals(mappingModel.getConfig().get(INCLUDE_IN_ID_TOKEN));
    }

includeInUserInfo()

static boolean org.keycloak.protocol.oidc.mappers.OIDCAttributeMapperHelper.includeInUserInfo ( ProtocolMapperModel  mappingModel )

inlinestatic

                                                                             {
        String includeInUserInfo = mappingModel.getConfig().get(INCLUDE_IN_USERINFO);

        // Backwards compatibility
        if (includeInUserInfo == null && includeInIDToken(mappingModel)) {
            return true;
        }

        return "true".equals(includeInUserInfo);
    }

isMultivalued()

static boolean org.keycloak.protocol.oidc.mappers.OIDCAttributeMapperHelper.isMultivalued ( ProtocolMapperModel  mappingModel )

inlinestatic

                                                                          {
        return "true".equals(mappingModel.getConfig().get(ProtocolMapperUtils.MULTIVALUED));
    }

mapAttributeValue()

static Object org.keycloak.protocol.oidc.mappers.OIDCAttributeMapperHelper.mapAttributeValue ( ProtocolMapperModel  mappingModel, Object  attributeValue  )

inlinestatic

                                                                                                    {
        if (attributeValue == null) return null;

        if (attributeValue instanceof List) {
            List<Object> valueAsList = (List<Object>) attributeValue;
            if (valueAsList.isEmpty()) return null;

            if (isMultivalued(mappingModel)) {
                List<Object> result = new ArrayList<>();
                for (Object valueItem : valueAsList) {
                    result.add(mapAttributeValue(mappingModel, valueItem));
                }
                return result;
            } else {
                if (valueAsList.size() > 1) {
                    ServicesLogger.LOGGER.multipleValuesForMapper(attributeValue.toString(), mappingModel.getName());
                }

                attributeValue = valueAsList.get(0);
            }
        }

        String type = mappingModel.getConfig().get(JSON_TYPE);
        Object converted = convertToType(type, attributeValue);
        return converted != null ? converted : attributeValue;
    }

mapClaim()

static void org.keycloak.protocol.oidc.mappers.OIDCAttributeMapperHelper.mapClaim ( IDToken  token, ProtocolMapperModel  mappingModel, Object  attributeValue  )

inlinestatic

                                                                                                        {
        attributeValue = mapAttributeValue(mappingModel, attributeValue);
        if (attributeValue == null) return;

        String protocolClaim = mappingModel.getConfig().get(TOKEN_CLAIM_NAME);
        if (protocolClaim == null) {
            return;
        }
        List<String> split = splitClaimPath(protocolClaim);
        final int length = split.size();
        int i = 0;
        Map<String, Object> jsonObject = token.getOtherClaims();
        for (String component : split) {
            i++;
            if (i == length) {
                jsonObject.put(component, attributeValue);
            } else {
                Map<String, Object> nested = (Map<String, Object>)jsonObject.get(component);

                if (nested == null) {
                    nested = new HashMap<String, Object>();
                    jsonObject.put(component, nested);
                }

                jsonObject = nested;
            }
        }
    }

splitClaimPath()

static List<String> org.keycloak.protocol.oidc.mappers.OIDCAttributeMapperHelper.splitClaimPath ( String  claimPath )

inlinestatic

                                                                {
        final LinkedList<String> claimComponents = new LinkedList<>();
        Matcher m = CLAIM_COMPONENT.matcher(claimPath);
        int start = 0;
        while (m.find()) {
            claimComponents.add(BACKSLASHED_CHARACTER.matcher(m.group(1)).replaceAll("$1"));
            start = m.end();
            // This is necessary to match the start of region as the start of string as determined by ^
            m.region(start, claimPath.length());
        }
        if (claimPath.length() > start) {
            claimComponents.add(BACKSLASHED_CHARACTER.matcher(claimPath.substring(start)).replaceAll("$1"));
        }
        return claimComponents;
    }

transform()

static <X, T> List<T> org.keycloak.protocol.oidc.mappers.OIDCAttributeMapperHelper.transform ( List< X >  attributeValue, Function< X, T >  mapper  )

inlinestaticprivate

                                                                                           {
        return attributeValue.stream()
                .filter(Objects::nonNull)
                .map(mapper)
                .collect(Collectors.toList());
    }

メンバ詳解

BACKSLASHED_CHARACTER

final Pattern org.keycloak.protocol.oidc.mappers.OIDCAttributeMapperHelper.BACKSLASHED_CHARACTER = Pattern.compile("\\\\(.)")

staticprivate

CLAIM_COMPONENT

final Pattern org.keycloak.protocol.oidc.mappers.OIDCAttributeMapperHelper.CLAIM_COMPONENT = Pattern.compile("^((\\\\.|[^\\\\.])+?)\\.")

staticprivate

INCLUDE_IN_ACCESS_TOKEN

final String org.keycloak.protocol.oidc.mappers.OIDCAttributeMapperHelper.INCLUDE_IN_ACCESS_TOKEN = "access.token.claim"

static

INCLUDE_IN_ACCESS_TOKEN_HELP_TEXT

final String org.keycloak.protocol.oidc.mappers.OIDCAttributeMapperHelper.INCLUDE_IN_ACCESS_TOKEN_HELP_TEXT = "includeInAccessToken.tooltip"

static

INCLUDE_IN_ACCESS_TOKEN_LABEL

final String org.keycloak.protocol.oidc.mappers.OIDCAttributeMapperHelper.INCLUDE_IN_ACCESS_TOKEN_LABEL = "includeInAccessToken.label"

static

INCLUDE_IN_ID_TOKEN

final String org.keycloak.protocol.oidc.mappers.OIDCAttributeMapperHelper.INCLUDE_IN_ID_TOKEN = "id.token.claim"

static

INCLUDE_IN_ID_TOKEN_HELP_TEXT

final String org.keycloak.protocol.oidc.mappers.OIDCAttributeMapperHelper.INCLUDE_IN_ID_TOKEN_HELP_TEXT = "includeInIdToken.tooltip"

static

INCLUDE_IN_ID_TOKEN_LABEL

final String org.keycloak.protocol.oidc.mappers.OIDCAttributeMapperHelper.INCLUDE_IN_ID_TOKEN_LABEL = "includeInIdToken.label"

static

INCLUDE_IN_USERINFO

final String org.keycloak.protocol.oidc.mappers.OIDCAttributeMapperHelper.INCLUDE_IN_USERINFO = "userinfo.token.claim"

static

INCLUDE_IN_USERINFO_HELP_TEXT

final String org.keycloak.protocol.oidc.mappers.OIDCAttributeMapperHelper.INCLUDE_IN_USERINFO_HELP_TEXT = "includeInUserInfo.tooltip"

static

INCLUDE_IN_USERINFO_LABEL

final String org.keycloak.protocol.oidc.mappers.OIDCAttributeMapperHelper.INCLUDE_IN_USERINFO_LABEL = "includeInUserInfo.label"

static

JSON_TYPE

final String org.keycloak.protocol.oidc.mappers.OIDCAttributeMapperHelper.JSON_TYPE = "jsonType.label"

static

JSON_TYPE_TOOLTIP

final String org.keycloak.protocol.oidc.mappers.OIDCAttributeMapperHelper.JSON_TYPE_TOOLTIP = "jsonType.tooltip"

static

TOKEN_CLAIM_NAME

final String org.keycloak.protocol.oidc.mappers.OIDCAttributeMapperHelper.TOKEN_CLAIM_NAME = "claim.name"

static

TOKEN_CLAIM_NAME_LABEL

final String org.keycloak.protocol.oidc.mappers.OIDCAttributeMapperHelper.TOKEN_CLAIM_NAME_LABEL = "tokenClaimName.label"

static

TOKEN_CLAIM_NAME_TOOLTIP

final String org.keycloak.protocol.oidc.mappers.OIDCAttributeMapperHelper.TOKEN_CLAIM_NAME_TOOLTIP = "tokenClaimName.tooltip"

static

---

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

• D:/AppData/doxygen/keycloak/src/keycloak/src/main/java/org/keycloak/protocol/oidc/mappers/OIDCAttributeMapperHelper.java