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.Objects;
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));
    }

    @Override
    public boolean equals(Object o) {
        if(!(o instanceof  UserContextClaims)) {
            return false;
        }
        UserContextClaims cmp = (UserContextClaims) o;
        return Objects.deepEquals(getAccountId(), cmp.getAccountId()) &&
                Objects.deepEquals(getContextRestriction(), cmp.getContextRestriction()) &&
                Objects.deepEquals(getScopes(), cmp.getScopes()) &&
                Objects.deepEquals(getSessionId(), cmp.getSessionId()) &&
                Objects.deepEquals(getEmailDomain(), cmp.getEmailDomain()) &&
                Objects.deepEquals(isUnverifiedEmail(), cmp.isUnverifiedEmail()) &&
                Objects.deepEquals(getImpersonations(), cmp.getImpersonations()) &&
                Objects.deepEquals(getOauthClientId(), cmp.getOauthClientId()) &&
                Objects.deepEquals(isFirstParty(), cmp.isFirstParty()) &&
                Objects.deepEquals(getRequestPrincipal(), cmp.getRequestPrincipal()) &&
                Objects.deepEquals(isOnBehalfOf(), cmp.isOnBehalfOf());
    }

    /**
     * @return a hashCode based on the definition of {@link #equals(Object)}
     */
    @Override
    public int hashCode() {
        return Objects.hash(
                getAccountId(),
                getContextRestriction(),
                getScopes(),
                getSessionId(),
                getEmailDomain(),
                isUnverifiedEmail(),
                getImpersonations(),
                getOauthClientId(),
                isFirstParty(),
                getRequestPrincipal(),
                isOnBehalfOf()
        );
    }

}