class Authlete::Model::Client

Attributes

applicationType[RW]
application_type[RW]
application_type=[RW]
attributes[RW]
authTimeRequired[RW]
auth_time_required[RW]
auth_time_required=[RW]
authorizationDetailsTypes[RW]
authorizationEncryptionAlg[RW]
authorizationEncryptionEnc[RW]
authorizationSignAlg[RW]
authorization_details_types[RW]
authorization_details_types=[RW]
authorization_encryption_alg[RW]
authorization_encryption_alg=[RW]
authorization_encryption_enc[RW]
authorization_encryption_enc=[RW]
authorization_sign_alg[RW]
authorization_sign_alg=[RW]
automaticallyRegistered[RW]
automatically_registered[RW]
automatically_registered=[RW]
bcDeliveryMode[RW]
bcNotificationEndpoint[RW]
bcRequestSignAlg[RW]
bcUserCodeRequired[RW]
bc_delivery_mode[RW]
bc_delivery_mode=[RW]
bc_notification_endpoint[RW]
bc_notification_endpoint=[RW]
bc_request_sign_alg[RW]
bc_request_sign_alg=[RW]
bc_user_code_required[RW]
bc_user_code_required=[RW]
clientId[RW]
clientIdAlias[RW]
clientIdAliasEnabled[RW]
clientName[RW]
clientNames[RW]
clientSecret[RW]
clientType[RW]
clientUri[RW]
clientUris[RW]
client_id[RW]
client_id=[RW]
client_id_alias[RW]
client_id_alias=[RW]
client_id_alias_enabled[RW]
client_id_alias_enabled=[RW]
client_name[RW]
client_name=[RW]
client_names[RW]
client_names=[RW]
client_secret[RW]
client_secret=[RW]
client_type[RW]
client_type=[RW]
client_uri[RW]
client_uri=[RW]
client_uris[RW]
client_uris=[RW]
contacts[RW]
createdAt[RW]
created_at[RW]
created_at=[RW]
customMetadata[RW]
custom_metadata[RW]
custom_metadata=[RW]
defaultAcrs[RW]
defaultMaxAge[RW]
default_acrs[RW]
default_acrs=[RW]
default_max_age[RW]
default_max_age=[RW]
derivedSectorIdentifier[RW]
derived_sector_identifier[RW]
derived_sector_identifier=[RW]
description[RW]
descriptions[RW]
developer[RW]
digestAlgorithm[RW]
digest_algorithm[RW]
digest_algorithm=[RW]
dpopRequired[RW]
dpop_required[RW]
dpop_required=[RW]
dynamicallyRegistered[RW]
dynamically_registered[RW]
dynamically_registered=[RW]
explicitlyRegistered[RW]
explicitly_registered[RW]
explicitly_registered=[RW]
extension[RW]
frontChannelRequestObjectEncryptionRequired[RW]
front_channel_request_object_encryption_required[RW]
front_channel_request_object_encryption_required=[RW]
grantTypes[RW]
grant_types[RW]
grant_types=[RW]
idTokenEncryptionAlg[RW]
idTokenEncryptionEnc[RW]
idTokenSignAlg[RW]
id_token_encryption_alg[RW]
id_token_encryption_alg=[RW]
id_token_encryption_enc[RW]
id_token_encryption_enc=[RW]
id_token_sign_alg[RW]
id_token_sign_alg=[RW]
jwks[RW]
jwksUri[RW]
jwks_uri[RW]
jwks_uri=[RW]
loginUri[RW]
login_uri[RW]
login_uri=[RW]
logoUri[RW]
logoUris[RW]
logo_uri[RW]
logo_uri=[RW]
logo_uris[RW]
logo_uris=[RW]
modifiedAt[RW]
modified_at[RW]
modified_at=[RW]
number[RW]
parRequired[RW]
par_required[RW]
par_required=[RW]
pkceRequired[RW]
pkceS256Required[RW]
pkce_required[RW]
pkce_required=[RW]
pkce_s256_required[RW]
pkce_s256_required=[RW]
policyUri[RW]
policyUris[RW]
policy_uri[RW]
policy_uri=[RW]
policy_uris[RW]
policy_uris=[RW]
redirectUris[RW]
redirect_uris[RW]
redirect_uris=[RW]
registrationAccessTokenHash[RW]
registration_access_token_hash[RW]
registration_access_token_hash=[RW]
requestEncryptionAlg[RW]
requestEncryptionEnc[RW]
requestObjectEncryptionAlgMatchRequired[RW]
requestObjectEncryptionEncMatchRequired[RW]
requestObjectRequired[RW]
requestSignAlg[RW]
requestUris[RW]
request_encryption_alg[RW]
request_encryption_alg=[RW]
request_encryption_enc[RW]
request_encryption_enc=[RW]
request_object_encryption_alg_match_required[RW]
request_object_encryption_alg_match_required=[RW]
request_object_encryption_enc_match_required[RW]
request_object_encryption_enc_match_required=[RW]
request_object_required[RW]
request_object_required=[RW]
request_sign_alg[RW]
request_sign_alg=[RW]
request_uris[RW]
request_uris=[RW]
responseTypes[RW]
response_types[RW]
response_types=[RW]
sectorIdentifierUri[RW]
sector_identifier_uri[RW]
sector_identifier_uri=[RW]
selfSignedCertificateKeyId[RW]
self_signed_certificate_key_id[RW]
self_signed_certificate_key_id=[RW]
serviceNumber[RW]
service_number[RW]
service_number=[RW]
singleAccessTokenPerSubject[RW]
single_access_token_per_subject[RW]
single_access_token_per_subject=[RW]
softwareId[RW]
softwareVersion[RW]
software_id[RW]
software_id=[RW]
software_version[RW]
software_version=[RW]
subjectType[RW]
subject_type[RW]
subject_type=[RW]
tlsClientAuthSanDns[RW]
tlsClientAuthSanEmail[RW]
tlsClientAuthSanIp[RW]
tlsClientAuthSanUri[RW]
tlsClientAuthSubjectDn[RW]
tlsClientCertificateBoundAccessTokens[RW]
tls_client_auth_san_dns[RW]
tls_client_auth_san_dns=[RW]
tls_client_auth_san_email[RW]
tls_client_auth_san_email=[RW]
tls_client_auth_san_ip[RW]
tls_client_auth_san_ip=[RW]
tls_client_auth_san_uri[RW]
tls_client_auth_san_uri=[RW]
tls_client_auth_subject_dn[RW]
tls_client_auth_subject_dn=[RW]
tls_client_certificate_bound_access_tokens[RW]
tls_client_certificate_bound_access_tokens=[RW]
tokenAuthMethod[RW]
tokenAuthSignAlg[RW]
token_auth_method[RW]
token_auth_method=[RW]
token_auth_sign_alg[RW]
token_auth_sign_alg=[RW]
tosUri[RW]
tosUris[RW]
tos_uri[RW]
tos_uri=[RW]
tos_uris[RW]
tos_uris=[RW]
userInfoEncryptionAlg[RW]
userInfoEncryptionEnc[RW]
userInfoSignAlg[RW]
user_info_encryption_alg[RW]
user_info_encryption_alg=[RW]
user_info_encryption_enc[RW]
user_info_encryption_enc=[RW]
user_info_sign_alg[RW]
user_info_sign_alg=[RW]

Public Instance Methods

standard_metadata(delete_zero = true, delete_false = true, delete_nil = true) click to toggle source
# File lib/authlete/model/client.rb, line 529
def standard_metadata(delete_zero = true, delete_false = true, delete_nil = true)
  metadata = {
    client_id:                                      "#{@clientId}",
    redirect_uris:                                  @redirectUris,
    response_types:                                 standard_response_types(@responseTypes),
    grant_types:                                    standard_grant_types(@grantTypes),
    application_type:                               from_application_type(@applicationType),
    contacts:                                       @contacts,
    client_name:                                    @clientName,
    logo_uri:                                       @logoUri,
    client_uri:                                     @clientUri,
    policy_uri:                                     @policyUri,
    tos_uri:                                        @tosUri,
    jwks_uri:                                       @jwksUri,
    jwks:                                           json_parse(@jwks),
    sector_identifier_uri:                          @sectorIdentifierUri,
    subject_type:                                   from_subject_type(@subjectType),
    id_token_signed_response_alg:                   from_jwsalg(@idTokenSignAlg),
    id_token_encrypted_response_alg:                from_jwealg(@idTokenEncryptionAlg),
    id_token_encrypted_response_enc:                from_jweenc(@idTokenEncryptionEnc),
    userinfo_signed_response_alg:                   from_jwsalg(@userInfoSignAlg),
    userinfo_encrypted_response_alg:                from_jwealg(@userInfoEncryptionAlg),
    userinfo_encrypted_response_enc:                from_jweenc(@userInfoEncryptionEnc),
    request_object_signing_alg:                     from_jwsalg(@requestSignAlg),
    request_object_encryption_alg:                  from_jwealg(@requestEncryptionAlg),
    request_object_encryption_enc:                  from_jweenc(@requestEncryptionEnc),
    token_endpoint_auth_method:                     from_client_auth_method(@tokenAuthMethod),
    token_endpoint_auth_signing_alg:                from_jwsalg(@tokenAuthSignAlg),
    default_max_age:                                @defaultMaxAge,
    default_acr_values:                             @defaultAcrs,
    require_auth_time:                              @authTimeRequired,
    initiate_login_uri:                             @loginUri,
    request_uris:                                   @requestUris,
    tls_client_auth_subject_dn:                     @tlsClientAuthSubjectDn,
    tls_client_auth_san_dns:                        @tlsClientAuthSanDns,
    tls_client_auth_san_uri:                        @tlsClientAuthSanUri,
    tls_client_auth_san_ip:                         @tlsClientAuthSanIp,
    tls_client_auth_san_email:                      @tlsClientAuthSanEmail,
    tls_client_certificate_bound_access_tokens:     @tlsClientCertificateBoundAccessTokens,
    software_id:                                    @softwareId,
    software_version:                               @softwareVersion,
    authorization_signed_response_alg:              from_jwsalg(@authorizationSignAlg),
    authorization_encrypted_response_alg:           from_jwealg(@authorizationEncryptionAlg),
    authorization_encrypted_response_enc:           from_jweenc(@authorizationEncryptionEnc),
    backchannel_token_delivery_mode:                from_delivery_mode(@bcDeliveryMode),
    backchannel_client_notification_endpoint:       @bcNotificationEndpoint,
    backchannel_authentication_request_signing_alg: from_jwsalg(@bcRequestSignAlg),
    backchannel_user_code_parameter:                @bcUserCodeRequired,
    authorization_details_types:                    @authorizationDetailsTypes,
    digest_algorithm:                               @digestAlgorithm
  }

  if delete_nil
    metadata.compact!
  end

  if delete_false
    metadata = metadata.delete_if {|key, value| value == false}
  end

  if delete_zero
    metadata = metadata.delete_if {|key, value| value == 0}
  end

  metadata
end

Private Instance Methods

defaults() click to toggle source
# File lib/authlete/model/client.rb, line 341
def defaults
  {
    number:                                      0,
    serviceNumber:                               0,
    developer:                                   nil,
    clientId:                                    0,
    clientIdAlias:                               nil,
    clientIdAliasEnabled:                        false,
    clientSecret:                                nil,
    clientType:                                  nil,
    redirectUris:                                nil,
    responseTypes:                               nil,
    grantTypes:                                  nil,
    applicationType:                             nil,
    contacts:                                    nil,
    clientName:                                  nil,
    clientNames:                                 nil,
    logoUri:                                     nil,
    logoUris:                                    nil,
    clientUri:                                   nil,
    clientUris:                                  nil,
    policyUri:                                   nil,
    policyUris:                                  nil,
    tosUri:                                      nil,
    tosUris:                                     nil,
    jwksUri:                                     nil,
    jwks:                                        nil,
    derivedSectorIdentifier:                     nil,
    sectorIdentifierUri:                         nil,
    subjectType:                                 nil,
    idTokenSignAlg:                              nil,
    idTokenEncryptionAlg:                        nil,
    idTokenEncryptionEnc:                        nil,
    userInfoSignAlg:                             nil,
    userInfoEncryptionAlg:                       nil,
    userInfoEncryptionEnc:                       nil,
    requestSignAlg:                              nil,
    requestEncryptionAlg:                        nil,
    requestEncryptionEnc:                        nil,
    tokenAuthMethod:                             nil,
    tokenAuthSignAlg:                            nil,
    defaultMaxAge:                               0,
    defaultAcrs:                                 nil,
    authTimeRequired:                            false,
    loginUri:                                    nil,
    requestUris:                                 nil,
    description:                                 nil,
    descriptions:                                nil,
    createdAt:                                   0,
    modifiedAt:                                  0,
    extension:                                   nil,
    tlsClientAuthSubjectDn:                      nil,
    tlsClientAuthSanDns:                         nil,
    tlsClientAuthSanUri:                         nil,
    tlsClientAuthSanIp:                          nil,
    tlsClientAuthSanEmail:                       nil,
    tlsClientCertificateBoundAccessTokens:       false,
    selfSignedCertificateKeyId:                  nil,
    softwareId:                                  nil,
    softwareVersion:                             nil,
    authorizationSignAlg:                        nil,
    authorizationEncryptionAlg:                  nil,
    authorizationEncryptionEnc:                  nil,
    bcDeliveryMode:                              nil,
    bcNotificationEndpoint:                      nil,
    bcRequestSignAlg:                            nil,
    bcUserCodeRequired:                          false,
    dynamicallyRegistered:                       false,
    registrationAccessTokenHash:                 nil,
    authorizationDetailsTypes:                   nil,
    parRequired:                                 false,
    requestObjectRequired:                       false,
    attributes:                                  nil,
    customMetadata:                              nil,
    frontChannelRequestObjectEncryptionRequired: false,
    requestObjectEncryptionAlgMatchRequired:     false,
    requestObjectEncryptionEncMatchRequired:     false,
    digestAlgorithm:                             nil,
    singleAccessTokenPerSubject:                 false,
    pkceRequired:                                false,
    pkceS256Required:                            false,
    automaticallyRegistered:                     false,
    explicitlyRegistered:                        false,
    dpopRequired:                                false,
  }
end
from_application_type(constant_name) click to toggle source
# File lib/authlete/model/client.rb, line 614
def from_application_type(constant_name)
  Authlete::Types::ApplicationType::constant_get(constant_name)
end
from_client_auth_method(constant_name) click to toggle source
# File lib/authlete/model/client.rb, line 618
def from_client_auth_method(constant_name)
  Authlete::Types::ClientAuthMethod::constant_get(constant_name)
end
from_delivery_mode(constant_name) click to toggle source
# File lib/authlete/model/client.rb, line 622
def from_delivery_mode(constant_name)
  Authlete::Types::DeliveryMode::constant_get(constant_name)
end
from_jwealg(constant_name) click to toggle source
# File lib/authlete/model/client.rb, line 626
def from_jwealg(constant_name)
  Authlete::Types::JWEAlg::constant_get(constant_name)
end
from_jweenc(constant_name) click to toggle source
# File lib/authlete/model/client.rb, line 630
def from_jweenc(constant_name)
  Authlete::Types::JWEEnc::constant_get(constant_name)
end
from_jwsalg(constant_name) click to toggle source
# File lib/authlete/model/client.rb, line 634
def from_jwsalg(constant_name)
  Authlete::Types::JWSAlg::constant_get(constant_name)
end
from_subject_type(constant_name) click to toggle source
# File lib/authlete/model/client.rb, line 638
def from_subject_type(constant_name)
  Authlete::Types::SubjectType::constant_get(constant_name)
end
json_parse(json) click to toggle source
# File lib/authlete/model/client.rb, line 610
def json_parse(json)
  json.nil? ? nil : JSON.parse(json)
end
set_params(hash) click to toggle source
# File lib/authlete/model/client.rb, line 428
def set_params(hash)
  @number                                      = hash[:number]
  @serviceNumber                               = hash[:serviceNumber]
  @developer                                   = hash[:developer]
  @clientId                                    = hash[:clientId]
  @clientIdAlias                               = hash[:clientIdAlias]
  @clientIdAliasEnabled                        = hash[:clientIdAliasEnabled]
  @clientSecret                                = hash[:clientSecret]
  @clientType                                  = hash[:clientType]
  @redirectUris                                = hash[:redirectUris]
  @responseTypes                               = hash[:responseTypes]
  @grantTypes                                  = hash[:grantTypes]
  @applicationType                             = hash[:applicationType]
  @contacts                                    = hash[:contacts]
  @clientName                                  = hash[:clientName]
  @clientNames                                 = get_parsed_array(hash[:clientNames]) { |e| Authlete::Model::TaggedValue.parse(e) }
  @logoUri                                     = hash[:logoUri]
  @logoUris                                    = get_parsed_array(hash[:logoUris]) { |e| Authlete::Model::TaggedValue.parse(e) }
  @clientUri                                   = hash[:clientUri]
  @clientUris                                  = get_parsed_array(hash[:clientUris]) { |e| Authlete::Model::TaggedValue.parse(e) }
  @policyUri                                   = hash[:policyUri]
  @policyUris                                  = get_parsed_array(hash[:policyUris]) { |e| Authlete::Model::TaggedValue.parse(e) }
  @tosUri                                      = hash[:tosUri]
  @tosUris                                     = get_parsed_array(hash[:tosUris]) { |e| Authlete::Model::TaggedValue.parse(e) }
  @jwksUri                                     = hash[:jwksUri]
  @jwks                                        = hash[:jwks]
  @derivedSectorIdentifier                     = hash[:derivedSectorIdentifier]
  @sectorIdentifierUri                         = hash[:sectorIdentifierUri]
  @subjectType                                 = hash[:subjectType]
  @idTokenSignAlg                              = hash[:idTokenSignAlg]
  @idTokenEncryptionAlg                        = hash[:idTokenEncryptionAlg]
  @idTokenEncryptionEnc                        = hash[:idTokenEncryptionEnc]
  @userInfoSignAlg                             = hash[:userInfoSignAlg]
  @userInfoEncryptionAlg                       = hash[:userInfoEncryptionAlg]
  @userInfoEncryptionEnc                       = hash[:userInfoEncryptionEnc]
  @requestSignAlg                              = hash[:requestSignAlg]
  @requestEncryptionAlg                        = hash[:requestEncryptionAlg]
  @requestEncryptionEnc                        = hash[:requestEncryptionEnc]
  @tokenAuthMethod                             = hash[:tokenAuthMethod]
  @tokenAuthSignAlg                            = hash[:tokenAuthSignAlg]
  @defaultMaxAge                               = hash[:defaultMaxAge]
  @defaultAcrs                                 = hash[:defaultAcrs]
  @authTimeRequired                            = hash[:authTimeRequired]
  @loginUri                                    = hash[:loginUri]
  @requestUris                                 = hash[:requestUris]
  @description                                 = hash[:description]
  @descriptions                                = get_parsed_array(hash[:descriptions]) { |e| Authlete::Model::TaggedValue.parse(e) }
  @createdAt                                   = hash[:createdAt]
  @modifiedAt                                  = hash[:modifiedAt]
  @extension                                   = Authlete::Model::ClientExtension.parse(hash[:extension])
  @tlsClientAuthSubjectDn                      = hash[:tlsClientAuthSubjectDn]
  @tlsClientAuthSanDns                         = hash[:tlsClientAuthSanDns]
  @tlsClientAuthSanUri                         = hash[:tlsClientAuthSanUri]
  @tlsClientAuthSanIp                          = hash[:tlsClientAuthSanIp]
  @tlsClientAuthSanEmail                       = hash[:tlsClientAuthSanEmail]
  @tlsClientCertificateBoundAccessTokens       = hash[:tlsClientCertificateBoundAccessTokens]
  @selfSignedCertificateKeyId                  = hash[:selfSignedCertificateKeyId]
  @softwareId                                  = hash[:softwareId]
  @softwareVersion                             = hash[:softwareVersion]
  @authorizationSignAlg                        = hash[:authorizationSignAlg]
  @authorizationEncryptionAlg                  = hash[:authorizationEncryptionAlg]
  @authorizationEncryptionEnc                  = hash[:authorizationEncryptionEnc]
  @bcDeliveryMode                              = hash[:bcDeliveryMode]
  @bcNotificationEndpoint                      = hash[:bcNotificationEndpoint]
  @bcRequestSignAlg                            = hash[:bcRequestSignAlg]
  @bcUserCodeRequired                          = hash[:bcUserCodeRequired]
  @dynamicallyRegistered                       = hash[:dynamicallyRegistered]
  @registrationAccessTokenHash                 = hash[:registrationAccessTokenHash]
  @authorizationDetailsTypes                   = hash[:authorizationDetailsTypes]
  @parRequired                                 = hash[:parRequired]
  @requestObjectRequired                       = hash[:requestObjectRequired]
  @attributes                                  = get_parsed_array(hash[:attributes]) { |e| Authlete::Model::Pair.parse(e) }
  @customMetadata                              = hash[:customMetadata]
  @frontChannelRequestObjectEncryptionRequired = hash[:frontChannelRequestObjectEncryptionRequired]
  @requestObjectEncryptionAlgMatchRequired     = hash[:requestObjectEncryptionAlgMatchRequired]
  @requestObjectEncryptionEncMatchRequired     = hash[:requestObjectEncryptionEncMatchRequired]
  @digestAlgorithm                             = hash[:digestAlgorithm]
  @singleAccessTokenPerSubject                 = hash[:singleAccessTokenPerSubject]
  @pkceRequired                                = hash[:pkceRequired]
  @pkceS256Required                            = hash[:pkceS256Required]
  @automaticallyRegistered                     = hash[:automaticallyRegistered]
  @explicitlyRegistered                        = hash[:explicitlyRegistered]
  @dpopRequired                                = hash[:dpopRequired]
end
standard_grant_types(array) click to toggle source
# File lib/authlete/model/client.rb, line 604
def standard_grant_types(array)
  array.nil? ? nil : array.map do |element|
    Authlete::Types::GrantType::constant_get(element)
  end
end
standard_response_types(array) click to toggle source
# File lib/authlete/model/client.rb, line 598
def standard_response_types(array)
  array.nil? ? nil : array.map do |element|
    Authlete::Types::ResponseType::constant_get(element)
  end
end
to_hash_value(key, var) click to toggle source
# File lib/authlete/model/client.rb, line 513
def to_hash_value(key, var)
  raw_val = instance_variable_get(var)

  case key
    when :clientNames, :logoUris, :clientUris, :policyUris, :tosUris,
         :descriptions, :attributes
      raw_val&.map { |e| e.to_hash }
    when :extension
      raw_val&.to_hash
    else
      raw_val
  end
end