/*******************************************************************************
 * Copyright 2017 The MIT Internet Trust Consortium
 *
 * Portions copyright 2011-2013 The MITRE Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *******************************************************************************/
/**
 *
 */
package org.mitre.oauth2.model;

import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import javax.persistence.Basic;
import javax.persistence.CollectionTable;
import javax.persistence.Column;
import javax.persistence.Convert;
import javax.persistence.ElementCollection;
import javax.persistence.Entity;
import javax.persistence.EnumType;
import javax.persistence.Enumerated;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.PrePersist;
import javax.persistence.PreUpdate;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;
import javax.persistence.Transient;

import org.mitre.oauth2.model.convert.JWEAlgorithmStringConverter;
import org.mitre.oauth2.model.convert.JWEEncryptionMethodStringConverter;
import org.mitre.oauth2.model.convert.JWKSetStringConverter;
import org.mitre.oauth2.model.convert.JWSAlgorithmStringConverter;
import org.mitre.oauth2.model.convert.JWTStringConverter;
import org.mitre.oauth2.model.convert.PKCEAlgorithmStringConverter;
import org.mitre.oauth2.model.convert.SimpleGrantedAuthorityStringConverter;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.oauth2.provider.ClientDetails;

import com.nimbusds.jose.EncryptionMethod;
import com.nimbusds.jose.JWEAlgorithm;
import com.nimbusds.jose.JWSAlgorithm;
import com.nimbusds.jose.jwk.JWKSet;
import com.nimbusds.jwt.JWT;

/**
 * @author jricher
 *
 */
@Entity
@Table(name = "client_details")
@NamedQueries({
        @NamedQuery(name = ClientDetailsEntity.QUERY_ALL, query = "SELECT c FROM ClientDetailsEntity c"),
        @NamedQuery(name = ClientDetailsEntity.QUERY_BY_CLIENT_ID, query = "select c from ClientDetailsEntity c where c.clientId = :" + ClientDetailsEntity.PARAM_CLIENT_ID)
})
public class ClientDetailsEntity implements ClientDetails {

        public static final String QUERY_BY_CLIENT_ID = "ClientDetailsEntity.getByClientId";
        public static final String QUERY_ALL = "ClientDetailsEntity.findAll";

        public static final String PARAM_CLIENT_ID = "clientId";

        private static final int DEFAULT_ID_TOKEN_VALIDITY_SECONDS = 600;

        private static final long serialVersionUID = -1617727085733786296L;

        private Long id;

        /** Fields from the OAuth2 Dynamic Registration Specification */
        private String clientId = null; // client_id
        private String clientSecret = null; // client_secret
        private Set<String> redirectUris = new HashSet<>(); // redirect_uris
        private String clientName; // client_name
        private String clientUri; // client_uri
        private String logoUri; // logo_uri
        private Set<String> contacts; // contacts
        private String tosUri; // tos_uri
        private AuthMethod tokenEndpointAuthMethod = AuthMethod.SECRET_BASIC; // token_endpoint_auth_method
        private Set<String> scope = new HashSet<>(); // scope
        private Set<String> grantTypes = new HashSet<>(); // grant_types
        private Set<String> responseTypes = new HashSet<>(); // response_types
        private String policyUri;
        private String jwksUri; // URI pointer to keys
        private JWKSet jwks; // public key stored by value
        private String softwareId;
        private String softwareVersion;

        /** Fields from OIDC Client Registration Specification **/
        private AppType applicationType; // application_type
        private String sectorIdentifierUri; // sector_identifier_uri
        private SubjectType subjectType; // subject_type

        private JWSAlgorithm requestObjectSigningAlg = null; // request_object_signing_alg

        private JWSAlgorithm userInfoSignedResponseAlg = null; // user_info_signed_response_alg
        private JWEAlgorithm userInfoEncryptedResponseAlg = null; // user_info_encrypted_response_alg
        private EncryptionMethod userInfoEncryptedResponseEnc = null; // user_info_encrypted_response_enc

        private JWSAlgorithm idTokenSignedResponseAlg = null; // id_token_signed_response_alg
        private JWEAlgorithm idTokenEncryptedResponseAlg = null; // id_token_encrypted_response_alg
        private EncryptionMethod idTokenEncryptedResponseEnc = null; // id_token_encrypted_response_enc

        private JWSAlgorithm tokenEndpointAuthSigningAlg = null; // token_endpoint_auth_signing_alg

        private Integer defaultMaxAge; // default_max_age
        private Boolean requireAuthTime; // require_auth_time
        private Set<String> defaultACRvalues; // default_acr_values

        private String initiateLoginUri; // initiate_login_uri
        private Set<String> postLogoutRedirectUris; // post_logout_redirect_uris

        private Set<String> requestUris; // request_uris

        /** Fields to support the ClientDetails interface **/
        private Set<GrantedAuthority> authorities = new HashSet<>();
        private Integer accessTokenValiditySeconds = 0; // in seconds
        private Integer refreshTokenValiditySeconds = 0; // in seconds
        private Set<String> resourceIds = new HashSet<>();
        private Map<String, Object> additionalInformation = new HashMap<>();

        /** Our own fields **/
        private String clientDescription = ""; // human-readable description
        private boolean reuseRefreshToken = true; // do we let someone reuse a refresh token?
        private boolean dynamicallyRegistered = false; // was this client dynamically registered?
        private boolean allowIntrospection = false; // do we let this client call the introspection endpoint?
        private Integer idTokenValiditySeconds; //timeout for id tokens
        private Date createdAt; // time the client was created
        private boolean clearAccessTokensOnRefresh = true; // do we clear access tokens on refresh?
        private Integer deviceCodeValiditySeconds; // timeout for device codes

        /** fields for UMA */
        private Set<String> claimsRedirectUris;

        /** Software statement **/
        private JWT softwareStatement;

        /** PKCE **/
        private PKCEAlgorithm codeChallengeMethod;

        public enum AuthMethod {
                SECRET_POST("client_secret_post"),
                SECRET_BASIC("client_secret_basic"),
                SECRET_JWT("client_secret_jwt"),
                PRIVATE_KEY("private_key_jwt"),
                NONE("none");

                private final String value;

                // map to aid reverse lookup
                private static final Map<String, AuthMethod> lookup = new HashMap<>();
                static {
                        for (AuthMethod a : AuthMethod.values()) {
                                lookup.put(a.getValue(), a);
                        }
                }

                AuthMethod(String value) {
                        this.value = value;
                }

                public String getValue() {
                        return value;
                }

                public static AuthMethod getByValue(String value) {
                        return lookup.get(value);
                }
        }

        public enum AppType {
                WEB("web"), NATIVE("native");

                private final String value;

                // map to aid reverse lookup
                private static final Map<String, AppType> lookup = new HashMap<>();
                static {
                        for (AppType a : AppType.values()) {
                                lookup.put(a.getValue(), a);
                        }
                }

                AppType(String value) {
                        this.value = value;
                }

                public String getValue() {
                        return value;
                }

                public static AppType getByValue(String value) {
                        return lookup.get(value);
                }
        }

        public enum SubjectType {
                PAIRWISE("pairwise"), PUBLIC("public");

                private final String value;

                // map to aid reverse lookup
                private static final Map<String, SubjectType> lookup = new HashMap<>();
                static {
                        for (SubjectType u : SubjectType.values()) {
                                lookup.put(u.getValue(), u);
                        }
                }

                SubjectType(String value) {
                        this.value = value;
                }

                public String getValue() {
                        return value;
                }

                public static SubjectType getByValue(String value) {
                        return lookup.get(value);
                }
        }

        /**
         * Create a blank ClientDetailsEntity
         */
        public ClientDetailsEntity() {

        }

        @PrePersist
        @PreUpdate
        private void prePersist() {
                // make sure that ID tokens always time out, default to 5 minutes
                if (getIdTokenValiditySeconds() == null) {
                        setIdTokenValiditySeconds(DEFAULT_ID_TOKEN_VALIDITY_SECONDS);
                }
        }

        /**
         * @return the id
         */
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        @Column(name = "id")
        public Long getId() {
                return id;
        }

        /**
         *
         * @param id the id to set
         */
        public void setId(Long id) {
                this.id = id;
        }

        /**
         * @return the clientDescription
         */
        @Basic
        @Column(name="client_description")
        public String getClientDescription() {
                return clientDescription;
        }

        /**
         * @param clientDescription Human-readable long description of the client (optional)
         */
        public void setClientDescription(String clientDescription) {
                this.clientDescription = clientDescription;
        }

        /**
         * @return the allowRefresh
         */
        @Transient
        public boolean isAllowRefresh() {
                if (grantTypes != null) {
                        return getAuthorizedGrantTypes().contains("refresh_token");
                } else {
                        return false; // if there are no grants, we can't be refreshing them, can we?
                }
        }

        @Basic
        @Column(name="reuse_refresh_tokens")
        public boolean isReuseRefreshToken() {
                return reuseRefreshToken;
        }

        public void setReuseRefreshToken(boolean reuseRefreshToken) {
                this.reuseRefreshToken = reuseRefreshToken;
        }

        /**
         * Number of seconds ID token is valid for. MUST be a positive integer, can not be null.
         *
         * @return the idTokenValiditySeconds
         */
        @Basic
        @Column(name="id_token_validity_seconds")
        public Integer getIdTokenValiditySeconds() {
                return idTokenValiditySeconds;
        }

        /**
         * @param idTokenValiditySeconds the idTokenValiditySeconds to set
         */
        public void setIdTokenValiditySeconds(Integer idTokenValiditySeconds) {
                this.idTokenValiditySeconds = idTokenValiditySeconds;
        }

        /**
         * @return the dynamicallyRegistered
         */
        @Basic
        @Column(name="dynamically_registered")
        public boolean isDynamicallyRegistered() {
                return dynamicallyRegistered;
        }

        /**
         * @param dynamicallyRegistered the dynamicallyRegistered to set
         */
        public void setDynamicallyRegistered(boolean dynamicallyRegistered) {
                this.dynamicallyRegistered = dynamicallyRegistered;
        }





        /**
         * @return the allowIntrospection
         */
        @Basic
        @Column(name="allow_introspection")
        public boolean isAllowIntrospection() {
                return allowIntrospection;
        }

        /**
         * @param allowIntrospection the allowIntrospection to set
         */
        public void setAllowIntrospection(boolean allowIntrospection) {
                this.allowIntrospection = allowIntrospection;
        }

        /**
         *
         */
        @Override
        @Transient
        public boolean isSecretRequired() {
                if (getTokenEndpointAuthMethod() != null &&
                                (getTokenEndpointAuthMethod().equals(AuthMethod.SECRET_BASIC) ||
                                                getTokenEndpointAuthMethod().equals(AuthMethod.SECRET_POST) ||
                                                getTokenEndpointAuthMethod().equals(AuthMethod.SECRET_JWT))) {
                        return true;
                } else {
                        return false;
                }

        }

        /**
         * If the scope list is not null or empty, then this client has been scoped.
         */
        @Override
        @Transient
        public boolean isScoped() {
                return getScope() != null && !getScope().isEmpty();
        }

        /**
         * @return the clientId
         */
        @Basic
        @Override
        @Column(name="client_id")
        public String getClientId() {
                return clientId;
        }

        /**
         * @param clientId The OAuth2 client_id, must be unique to this client
         */
        public void setClientId(String clientId) {
                this.clientId = clientId;
        }

        /**
         * @return the clientSecret
         */
        @Basic
        @Override
        @Column(name="client_secret")
        public String getClientSecret() {
                return clientSecret;
        }

        /**
         * @param clientSecret the OAuth2 client_secret (optional)
         */
        public void setClientSecret(String clientSecret) {
                this.clientSecret = clientSecret;
        }

        /**
         * @return the scope
         */
        @ElementCollection(fetch = FetchType.EAGER)
        @CollectionTable(
                        name="client_scope",
                        joinColumns=@JoinColumn(name="owner_id")
                        )
        @Override
        @Column(name="scope")
        public Set<String> getScope() {
                return scope;
        }

        /**
         * @param scope the set of scopes allowed to be issued to this client
         */
        public void setScope(Set<String> scope) {
                this.scope = scope;
        }

        /**
         * @return the authorizedGrantTypes
         */
        @ElementCollection(fetch = FetchType.EAGER)
        @CollectionTable(
                        name="client_grant_type",
                        joinColumns=@JoinColumn(name="owner_id")
                        )
        @Column(name="grant_type")
        public Set<String> getGrantTypes() {
                return grantTypes;
        }

        /**
         * @param authorizedGrantTypes the OAuth2 grant types that this client is allowed to use
         */
        public void setGrantTypes(Set<String> grantTypes) {
                this.grantTypes = grantTypes;
        }

        /**
         * passthrough for SECOAUTH api
         */
        @Override
        @Transient
        public Set<String> getAuthorizedGrantTypes() {
                return getGrantTypes();
        }

        /**
         * @return the authorities
         */
        @ElementCollection(fetch = FetchType.EAGER)
        @CollectionTable(
                        name="client_authority",
                        joinColumns=@JoinColumn(name="owner_id")
                        )
        @Override
        @Convert(converter = SimpleGrantedAuthorityStringConverter.class)
        @Column(name="authority")
        public Set<GrantedAuthority> getAuthorities() {
                return authorities;
        }

        /**
         * @param authorities the Spring Security authorities this client is given
         */
        public void setAuthorities(Set<GrantedAuthority> authorities) {
                this.authorities = authorities;
        }

        @Override
        @Basic
        @Column(name="access_token_validity_seconds")
        public Integer getAccessTokenValiditySeconds() {
                return accessTokenValiditySeconds;
        }

        /**
         * @param accessTokenTimeout the accessTokenTimeout to set
         */
        public void setAccessTokenValiditySeconds(Integer accessTokenValiditySeconds) {
                this.accessTokenValiditySeconds = accessTokenValiditySeconds;
        }

        @Override
        @Basic
        @Column(name="refresh_token_validity_seconds")
        public Integer getRefreshTokenValiditySeconds() {
                return refreshTokenValiditySeconds;
        }

        /**
         * @param refreshTokenTimeout Lifetime of refresh tokens, in seconds (optional - leave null for no timeout)
         */
        public void setRefreshTokenValiditySeconds(Integer refreshTokenValiditySeconds) {
                this.refreshTokenValiditySeconds = refreshTokenValiditySeconds;
        }

        /**
         * @return the registeredRedirectUri
         */
        @ElementCollection(fetch = FetchType.EAGER)
        @CollectionTable(
                        name="client_redirect_uri",
                        joinColumns=@JoinColumn(name="owner_id")
                        )
        @Column(name="redirect_uri")
        public Set<String> getRedirectUris() {
                return redirectUris;
        }

        /**
         * @param registeredRedirectUri the registeredRedirectUri to set
         */
        public void setRedirectUris(Set<String> redirectUris) {
                this.redirectUris = redirectUris;
        }

        /**
         * Pass-through method to fulfill the ClientDetails interface with a bad name
         */
        @Override
        @Transient
        public Set<String> getRegisteredRedirectUri() {
                return getRedirectUris();
        }

        /**
         * @return the resourceIds
         */
        @Override
        @ElementCollection(fetch = FetchType.EAGER)
        @CollectionTable(
                        name="client_resource",
                        joinColumns=@JoinColumn(name="owner_id")
                        )
        @Column(name="resource_id")
        public Set<String> getResourceIds() {
                return resourceIds;
        }

        /**
         * @param resourceIds the resourceIds to set
         */
        public void setResourceIds(Set<String> resourceIds) {
                this.resourceIds = resourceIds;
        }


        /**
         * This library does not make use of this field, so it is not
         * stored using our persistence layer.
         *
         * However, it's somehow required by SECOUATH.
         *
         * @return an empty map
         */
        @Override
        @Transient
        public Map<String, Object> getAdditionalInformation() {
                return this.additionalInformation;
        }




        @Enumerated(EnumType.STRING)
        @Column(name="application_type")
        public AppType getApplicationType() {
                return applicationType;
        }

        public void setApplicationType(AppType applicationType) {
                this.applicationType = applicationType;
        }

        @Basic
        @Column(name="client_name")
        public String getClientName() {
                return clientName;
        }

        public void setClientName(String clientName) {
                this.clientName = clientName;
        }

        @Enumerated(EnumType.STRING)
        @Column(name="token_endpoint_auth_method")
        public AuthMethod getTokenEndpointAuthMethod() {
                return tokenEndpointAuthMethod;
        }

        public void setTokenEndpointAuthMethod(AuthMethod tokenEndpointAuthMethod) {
                this.tokenEndpointAuthMethod = tokenEndpointAuthMethod;
        }

        @Enumerated(EnumType.STRING)
        @Column(name="subject_type")
        public SubjectType getSubjectType() {
                return subjectType;
        }

        public void setSubjectType(SubjectType subjectType) {
                this.subjectType = subjectType;
        }

        @ElementCollection(fetch = FetchType.EAGER)
        @CollectionTable(
                        name="client_contact",
                        joinColumns=@JoinColumn(name="owner_id")
                        )
        @Column(name="contact")
        public Set<String> getContacts() {
                return contacts;
        }

        public void setContacts(Set<String> contacts) {
                this.contacts = contacts;
        }

        @Basic
        @Column(name="logo_uri")
        public String getLogoUri() {
                return logoUri;
        }

        public void setLogoUri(String logoUri) {
                this.logoUri = logoUri;
        }

        @Basic
        @Column(name="policy_uri")
        public String getPolicyUri() {
                return policyUri;
        }

        public void setPolicyUri(String policyUri) {
                this.policyUri = policyUri;
        }

        /**
         * @return the clientUrl
         */
        @Basic
        @Column(name="client_uri")
        public String getClientUri() {
                return clientUri;
        }

        /**
         * @param clientUrl the clientUrl to set
         */
        public void setClientUri(String clientUri) {
                this.clientUri = clientUri;
        }

        /**
         * @return the tosUrl
         */
        @Basic
        @Column(name="tos_uri")
        public String getTosUri() {
                return tosUri;
        }

        /**
         * @param tosUrl the tosUrl to set
         */
        public void setTosUri(String tosUri) {
                this.tosUri = tosUri;
        }

        @Basic
        @Column(name="jwks_uri")
        public String getJwksUri() {
                return jwksUri;
        }

        public void setJwksUri(String jwksUri) {
                this.jwksUri = jwksUri;
        }

        /**
         * @return the jwks
         */
        @Basic
        @Column(name="jwks")
        @Convert(converter = JWKSetStringConverter.class)
        public JWKSet getJwks() {
                return jwks;
        }

        /**
         * @param jwks the jwks to set
         */
        public void setJwks(JWKSet jwks) {
                this.jwks = jwks;
        }

        @Basic
        @Column(name="sector_identifier_uri")
        public String getSectorIdentifierUri() {
                return sectorIdentifierUri;
        }

        public void setSectorIdentifierUri(String sectorIdentifierUri) {
                this.sectorIdentifierUri = sectorIdentifierUri;
        }

        @Basic
        @Column(name = "request_object_signing_alg")
        @Convert(converter = JWSAlgorithmStringConverter.class)
        public JWSAlgorithm getRequestObjectSigningAlg() {
                return requestObjectSigningAlg;
        }

        public void setRequestObjectSigningAlg(JWSAlgorithm requestObjectSigningAlg) {
                this.requestObjectSigningAlg = requestObjectSigningAlg;
        }

        @Basic
        @Column(name = "user_info_signed_response_alg")
        @Convert(converter = JWSAlgorithmStringConverter.class)
        public JWSAlgorithm getUserInfoSignedResponseAlg() {
                return userInfoSignedResponseAlg;
        }

        public void setUserInfoSignedResponseAlg(JWSAlgorithm userInfoSignedResponseAlg) {
                this.userInfoSignedResponseAlg = userInfoSignedResponseAlg;
        }

        @Basic
        @Column(name = "user_info_encrypted_response_alg")
        @Convert(converter = JWEAlgorithmStringConverter.class)
        public JWEAlgorithm getUserInfoEncryptedResponseAlg() {
                return userInfoEncryptedResponseAlg;
        }

        public void setUserInfoEncryptedResponseAlg(JWEAlgorithm userInfoEncryptedResponseAlg) {
                this.userInfoEncryptedResponseAlg = userInfoEncryptedResponseAlg;
        }

        @Basic
        @Column(name = "user_info_encrypted_response_enc")
        @Convert(converter = JWEEncryptionMethodStringConverter.class)
        public EncryptionMethod getUserInfoEncryptedResponseEnc() {
                return userInfoEncryptedResponseEnc;
        }

        public void setUserInfoEncryptedResponseEnc(EncryptionMethod userInfoEncryptedResponseEnc) {
                this.userInfoEncryptedResponseEnc = userInfoEncryptedResponseEnc;
        }

        @Basic
        @Column(name="id_token_signed_response_alg")
        @Convert(converter = JWSAlgorithmStringConverter.class)
        public JWSAlgorithm getIdTokenSignedResponseAlg() {
                return idTokenSignedResponseAlg;
        }

        public void setIdTokenSignedResponseAlg(JWSAlgorithm idTokenSignedResponseAlg) {
                this.idTokenSignedResponseAlg = idTokenSignedResponseAlg;
        }

        @Basic
        @Column(name = "id_token_encrypted_response_alg")
        @Convert(converter = JWEAlgorithmStringConverter.class)
        public JWEAlgorithm getIdTokenEncryptedResponseAlg() {
                return idTokenEncryptedResponseAlg;
        }

        public void setIdTokenEncryptedResponseAlg(JWEAlgorithm idTokenEncryptedResponseAlg) {
                this.idTokenEncryptedResponseAlg = idTokenEncryptedResponseAlg;
        }

        @Basic
        @Column(name = "id_token_encrypted_response_enc")
        @Convert(converter = JWEEncryptionMethodStringConverter.class)
        public EncryptionMethod getIdTokenEncryptedResponseEnc() {
                return idTokenEncryptedResponseEnc;
        }

        public void setIdTokenEncryptedResponseEnc(EncryptionMethod idTokenEncryptedResponseEnc) {
                this.idTokenEncryptedResponseEnc = idTokenEncryptedResponseEnc;
        }

        @Basic
        @Column(name="token_endpoint_auth_signing_alg")
        @Convert(converter = JWSAlgorithmStringConverter.class)
        public JWSAlgorithm getTokenEndpointAuthSigningAlg() {
                return tokenEndpointAuthSigningAlg;
        }

        public void setTokenEndpointAuthSigningAlg(JWSAlgorithm tokenEndpointAuthSigningAlg) {
                this.tokenEndpointAuthSigningAlg = tokenEndpointAuthSigningAlg;
        }

        @Basic
        @Column(name="default_max_age")
        public Integer getDefaultMaxAge() {
                return defaultMaxAge;
        }

        public void setDefaultMaxAge(Integer defaultMaxAge) {
                this.defaultMaxAge = defaultMaxAge;
        }

        @Basic
        @Column(name="require_auth_time")
        public Boolean getRequireAuthTime() {
                return requireAuthTime;
        }

        public void setRequireAuthTime(Boolean requireAuthTime) {
                this.requireAuthTime = requireAuthTime;
        }

        /**
         * @return the responseTypes
         */
        @ElementCollection(fetch = FetchType.EAGER)
        @CollectionTable(
                        name="client_response_type",
                        joinColumns=@JoinColumn(name="owner_id")
                        )
        @Column(name="response_type")
        public Set<String> getResponseTypes() {
                return responseTypes;
        }

        /**
         * @param responseTypes the responseTypes to set
         */
        public void setResponseTypes(Set<String> responseTypes) {
                this.responseTypes = responseTypes;
        }

        /**
         * @return the defaultACRvalues
         */
        @ElementCollection(fetch = FetchType.EAGER)
        @CollectionTable(
                        name="client_default_acr_value",
                        joinColumns=@JoinColumn(name="owner_id")
                        )
        @Column(name="default_acr_value")
        public Set<String> getDefaultACRvalues() {
                return defaultACRvalues;
        }

        /**
         * @param defaultACRvalues the defaultACRvalues to set
         */
        public void setDefaultACRvalues(Set<String> defaultACRvalues) {
                this.defaultACRvalues = defaultACRvalues;
        }

        /**
         * @return the initiateLoginUri
         */
        @Basic
        @Column(name="initiate_login_uri")
        public String getInitiateLoginUri() {
                return initiateLoginUri;
        }

        /**
         * @param initiateLoginUri the initiateLoginUri to set
         */
        public void setInitiateLoginUri(String initiateLoginUri) {
                this.initiateLoginUri = initiateLoginUri;
        }

        /**
         * @return the postLogoutRedirectUri
         */
        @ElementCollection(fetch = FetchType.EAGER)
        @CollectionTable(
                        name="client_post_logout_redirect_uri",
                        joinColumns=@JoinColumn(name="owner_id")
                        )
        @Column(name="post_logout_redirect_uri")
        public Set<String> getPostLogoutRedirectUris() {
                return postLogoutRedirectUris;
        }

        /**
         * @param postLogoutRedirectUri the postLogoutRedirectUri to set
         */
        public void setPostLogoutRedirectUris(Set<String> postLogoutRedirectUri) {
                this.postLogoutRedirectUris = postLogoutRedirectUri;
        }

        /**
         * @return the requestUris
         */
        @ElementCollection(fetch = FetchType.EAGER)
        @CollectionTable(
                        name="client_request_uri",
                        joinColumns=@JoinColumn(name="owner_id")
                        )
        @Column(name="request_uri")
        public Set<String> getRequestUris() {
                return requestUris;
        }

        /**
         * @param requestUris the requestUris to set
         */
        public void setRequestUris(Set<String> requestUris) {
                this.requestUris = requestUris;
        }

        /**
         * @return the createdAt
         */
        @Temporal(TemporalType.TIMESTAMP)
        @Column(name="created_at")
        public Date getCreatedAt() {
                return createdAt;
        }

        /**
         * @param createdAt the createdAt to set
         */
        public void setCreatedAt(Date createdAt) {
                this.createdAt = createdAt;
        }

        /**
         * Our framework doesn't use this construct, we use WhitelistedSites and ApprovedSites instead.
         */
        @Override
        public boolean isAutoApprove(String scope) {
                return false;
        }

        /**
         * @return the clearAccessTokensOnRefresh
         */
        @Basic
        @Column(name = "clear_access_tokens_on_refresh")
        public boolean isClearAccessTokensOnRefresh() {
                return clearAccessTokensOnRefresh;
        }

        /**
         * @param clearAccessTokensOnRefresh the clearAccessTokensOnRefresh to set
         */
        public void setClearAccessTokensOnRefresh(boolean clearAccessTokensOnRefresh) {
                this.clearAccessTokensOnRefresh = clearAccessTokensOnRefresh;
        }

        /**
         * @return the claimsRedirectUris
         */
        @ElementCollection(fetch = FetchType.EAGER)
        @CollectionTable(
                        name="client_claims_redirect_uri",
                        joinColumns=@JoinColumn(name="owner_id")
                        )
        @Column(name="redirect_uri")
        public Set<String> getClaimsRedirectUris() {
                return claimsRedirectUris;
        }

        /**
         * @param claimsRedirectUris the claimsRedirectUris to set
         */
        public void setClaimsRedirectUris(Set<String> claimsRedirectUris) {
                this.claimsRedirectUris = claimsRedirectUris;
        }

        /**
         * @return the softwareStatement
         */
        @Basic
        @Column(name = "software_statement")
        @Convert(converter = JWTStringConverter.class)
        public JWT getSoftwareStatement() {
                return softwareStatement;
        }

        /**
         * @param softwareStatement the softwareStatement to set
         */
        public void setSoftwareStatement(JWT softwareStatement) {
                this.softwareStatement = softwareStatement;
        }

        /**
         * @return the codeChallengeMethod
         */
        @Basic
        @Column(name = "code_challenge_method")
        @Convert(converter = PKCEAlgorithmStringConverter.class)
        public PKCEAlgorithm getCodeChallengeMethod() {
                return codeChallengeMethod;
        }

        /**
         * @param codeChallengeMethod the codeChallengeMethod to set
         */
        public void setCodeChallengeMethod(PKCEAlgorithm codeChallengeMethod) {
                this.codeChallengeMethod = codeChallengeMethod;
        }

        /**
         * @return the deviceCodeValiditySeconds
         */
        @Basic
        @Column(name="device_code_validity_seconds")
        public Integer getDeviceCodeValiditySeconds() {
                return deviceCodeValiditySeconds;
        }

        /**
         * @param deviceCodeValiditySeconds the deviceCodeValiditySeconds to set
         */
        public void setDeviceCodeValiditySeconds(Integer deviceCodeValiditySeconds) {
                this.deviceCodeValiditySeconds = deviceCodeValiditySeconds;
        }

        /**
         * @return the softwareId
         */
        @Basic
        @Column(name="software_id")
        public String getSoftwareId() {
                return softwareId;
        }

        /**
         * @param softwareId the softwareId to set
         */
        public void setSoftwareId(String softwareId) {
                this.softwareId = softwareId;
        }

        /**
         * @return the softwareVersion
         */
        @Basic
        @Column(name="software_version")
        public String getSoftwareVersion() {
                return softwareVersion;
        }

        /**
         * @param softwareVersion the softwareVersion to set
         */
        public void setSoftwareVersion(String softwareVersion) {
                this.softwareVersion = softwareVersion;
        }

}