com.atlassian.usercontext.impl.UserContextClaimsImpl Maven / Gradle / Ivy

Go to download
package com.atlassian.usercontext.impl;

import com.atlassian.asap.api.JwtClaims;
import com.atlassian.usercontext.api.AccountId;
import com.atlassian.usercontext.api.Impersonation;
import com.atlassian.usercontext.api.UserContextClaims;

import javax.json.JsonObject;
import javax.json.JsonString;
import javax.json.JsonValue;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;

import static java.util.Objects.requireNonNull;

/**
 * Implementation for the interface {@link UserContextClaims}.
 */
public class UserContextClaimsImpl implements UserContextClaims {

    // Underlying json object representing all the user context claims
    private final JsonObject jsonObject;

    UserContextClaimsImpl(JwtClaims claims){
        this.jsonObject = requireNonNull(claims.getJson());
    }

    @Override
    public AccountId getAccountId() {
        if (!jsonObject.containsKey(UserContextRegisteredClaim.ACCOUNT_ID_CLAIM.key())
                || jsonObject.isNull(UserContextRegisteredClaim.ACCOUNT_ID_CLAIM.key())) {
            throw new IllegalArgumentException("Missing valid account id claim");
        }

        return AccountId.of(jsonObject.getString(UserContextClaims.UserContextRegisteredClaim.ACCOUNT_ID_CLAIM.key()));
    }

    @Override
    public List getContextRestriction() {
        if (!jsonObject.containsKey(UserContextRegisteredClaim.IMPERSONATION_CONTEXT_RESTRICTION_CLAIM.key())) {
            return Collections.emptyList();
        }

        return jsonObject.getJsonArray(UserContextRegisteredClaim.IMPERSONATION_CONTEXT_RESTRICTION_CLAIM.key())
                .stream()
                .map(obj -> obj.getValueType() == JsonValue.ValueType.STRING ? ((JsonString) obj).getString() : obj.toString())
                .collect(Collectors.toList());
    }

    @Override
    public Optional> getScopes() {
        if (!jsonObject.containsKey(UserContextRegisteredClaim.SCOPE_CLAIM.key())) {
            return Optional.empty();
        }

        String scopeString = jsonObject.getString(UserContextRegisteredClaim.SCOPE_CLAIM.key());
        return Optional.of(new HashSet<>(Arrays.asList(scopeString.split(" "))));
    }

    @Override
    public Optional getSessionId() {
        return Optional.ofNullable(jsonObject.getString(UserContextRegisteredClaim.SESSION_ID_CLAIM.key(), null));
    }

    @Override
    public Optional getEmailDomain() {
        return Optional.ofNullable(jsonObject.getString(UserContextRegisteredClaim.EMAIL_DOMAIN_CLAIM.key(), null));
    }

    @Override
    public Optional isUnverifiedEmail() {
        if (!jsonObject.containsKey(UserContextRegisteredClaim.UNVERIFIED_EMAIL_CLAIM.key())) {
            return Optional.empty();
        }

        return Optional.of(jsonObject.getBoolean(UserContextRegisteredClaim.UNVERIFIED_EMAIL_CLAIM.key()));
    }

    @Override
    public List getImpersonations() {
        if (!jsonObject.containsKey(UserContextRegisteredClaim.IMPERSONATION_CLAIM.key())) {
            return Collections.emptyList();
        }

        return jsonObject
                .getJsonArray(UserContextRegisteredClaim.IMPERSONATION_CLAIM.key())
                .stream()
                .map(ImpersonationImpl::fromJsonValue)
                .collect(Collectors.toList());
    }

    @Override
    public Optional getOauthClientId() {
        return Optional.ofNullable(jsonObject.getString(UserContextRegisteredClaim.OAUTH_CLIENT_ID_CLAIM.key(), null));
    }

    @Override
    public Optional isFirstParty() {
        if (!jsonObject.containsKey(UserContextRegisteredClaim.FIRST_PARTY_CLAIM.key())) {
            return Optional.empty();
        }

        return Optional.of(jsonObject.getBoolean(UserContextRegisteredClaim.FIRST_PARTY_CLAIM.key()));
    }

    @Override
    public Optional getRequestPrincipal() {
        return Optional.ofNullable(jsonObject.getString(UserContextRegisteredClaim.REQUEST_PRINCIPAL_CLAIM.key(), null));
    }

    @Override
    public Optional isOnBehalfOf() {
        if (!jsonObject.containsKey(UserContextRegisteredClaim.ON_BEHALF_OF_CLAIM.key())) {
            return Optional.empty();
        }

        return Optional.of(jsonObject.getBoolean(UserContextRegisteredClaim.ON_BEHALF_OF_CLAIM.key(), false));
    }

}