authlete 1.0.21 → 1.2.0

data/lib/authlete/model/request/revocation-request.rb

@@ -1,6 +1,6 @@
 # :nodoc:
 #
-# Copyright (C) 2014-2018 Authlete, Inc.
+# Copyright (C) 2014-2020 Authlete, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -15,111 +15,37 @@
 # limitations under the License.
 
 
-require 'set'
-
-
 module Authlete
   module Model
     module Request
-      # == Authlete::Model::Request::RevocationRequest class
-      #
-      # This class represents a request to Authlete's /api/auth/revocation API.
-      class RevocationRequest < Authlete::Model::Hashable
-        # The OAuth 2.0 revocation request parameters. (String)
+      class RevocationRequest < Authlete::Model::Request::Base
+
         attr_accessor :parameters
 
-        # Client ID. (String)
         attr_accessor :clientId
         alias_method  :client_id, :clientId
         alias_method  :client_id=, :clientId=
 
-        # Client Secret. (String)
         attr_accessor :clientSecret
         alias_method  :client_secret, :clientSecret
         alias_method  :client_secret=, :clientSecret=
 
         private
 
-        # String attributes.
-        STRING_ATTRIBUTES = ::Set.new([ :parameters, :clientId, :clientSecret ])
-
-        # Mapping from snake cases to camel cases.
-        SNAKE_TO_CAMEL = {
-          :client_id     => :clientId,
-          :client_secret => :clientSecret
-        }
-
-        # The constructor which takes a hash that represents a JSON request to
-        # Authlete's /api/auth/revocation API.
-        def initialize(hash = nil)
-          # Set default values to string attributes.
-          STRING_ATTRIBUTES.each do |attr|
-            send("#{attr}=", nil)
-          end
-
-          # Set attribute values using the given hash.
-          authlete_model_update(hash)
-        end
-
-        def authlete_model_convert_key(key)
-          key = key.to_sym
-
-          # Convert snakecase to camelcase, if necessary.
-          if SNAKE_TO_CAMEL.has_key?(key)
-            key = SNAKE_TO_CAMEL[key]
-          end
-
-          key
-        end
-
-        def authlete_model_simple_attribute?(key)
-          STRING_ATTRIBUTES.include?(key)
+        def defaults
+          {
+            parameters:   nil,
+            clientId:     nil,
+            clientSecret: nil
+          }
         end
 
-        def authlete_model_update(hash)
-          return if hash.nil?
-
-          hash.each do |key, value|
-            key = authlete_model_convert_key(key)
-
-            if authlete_model_simple_attribute?(key)
-              send("#{key}=", value)
-            end
-          end
-
-          self
-        end
-
-        public
-
-        # Construct an instance from the given hash.
-        #
-        # If the given argument is nil or is not a Hash, nil is returned.
-        # Otherwise, RevocationRequest.new(hash) is returned.
-        def self.parse(hash)
-          if hash.nil? or (hash.kind_of?(Hash) == false)
-            return nil
-          end
-
-          return RevocationRequest.new(hash)
-        end
-
-        # Convert this object into a hash.
-        def to_hash
-          hash = {}
-
-          instance_variables.each do |var|
-            key = var.to_s.delete("@").to_sym
-            val = instance_variable_get(var)
-
-            if authlete_model_simple_attribute?(key) or val.nil?
-              hash[key] = val
-            end
-          end
-
-          hash
+        def set_params(hash)
+          @parameters   = hash[:parameters]
+          @clientId     = hash[:clientId]
+          @clientSecret = hash[:clientSecret]
         end
       end
     end
   end
-end
+end

data/lib/authlete/model/request/standard-introspection-request.rb

@@ -1,6 +1,6 @@
 # :nodoc:
 #
-# Copyright (C) 2014-2018 Authlete, Inc.
+# Copyright (C) 2014-2020 Authlete, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -15,88 +15,23 @@
 # limitations under the License.
 
 
-require 'set'
-
-
 module Authlete
   module Model
     module Request
-      # == Authlete::Model::Request::StandardIntrospectionRequest class
-      #
-      # This class represents a request to Authlete's /api/auth/introspection/standard API.
-      class StandardIntrospectionRequest < Authlete::Model::Hashable
-        # The OAuth 2.0 introspection request parameters. (String)
+      class StandardIntrospectionRequest < Authlete::Model::Request::Base
+
         attr_accessor :parameters
 
         private
 
-        # String attributes.
-        STRING_ATTRIBUTES = ::Set.new([ :parameters ])
-
-        # The constructor which takes a hash that represents a JSON request to
-        # Authlete's /api/auth/introspection/standard API.
-        def initialize(hash = nil)
-          # Set default values to string attributes.
-          STRING_ATTRIBUTES.each do |attr|
-            send("#{attr}=", nil)
-          end
-
-          # Set attribute values using the given hash.
-          authlete_model_update(hash)
+        def defaults
+          { parameters: nil }
         end
 
-        def authlete_model_convert_key(key)
-          key.to_sym
-        end
-
-        def authlete_model_simple_attribute?(key)
-          STRING_ATTRIBUTES.include?(key)
-        end
-
-        def authlete_model_update(hash)
-          return if hash.nil?
-
-          hash.each do |key, value|
-            key = authlete_model_convert_key(key)
-
-            if authlete_model_simple_attribute?(key)
-              send("#{key}=", value)
-            end
-          end
-
-          self
-        end
-
-        public
-
-        # Construct an instance from the given hash.
-        #
-        # If the given argument is nil or is not a Hash, nil is returned.
-        # Otherwise, StandardIntrospectionRequest.new(hash) is returned.
-        def self.parse(hash)
-          if hash.nil? or (hash.kind_of?(Hash) == false)
-            return nil
-          end
-
-          return StandardIntrospectionRequest.new(hash)
-        end
-
-        # Convert this object into a hash.
-        def to_hash
-          hash = {}
-
-          instance_variables.each do |var|
-            key = var.to_s.delete("@").to_sym
-            val = instance_variable_get(var)
-
-            if authlete_model_simple_attribute?(key) or val.nil?
-              hash[key] = val
-            end
-          end
-
-          hash
+        def set_params(hash)
+          @parameters = hash[:parameters]
         end
       end
     end
   end
-end
+end

data/lib/authlete/model/request/token-create-request.rb

@@ -1,6 +1,6 @@
 # :nodoc:
 #
-# Copyright (C) 2014-2018 Authlete, Inc.
+# Copyright (C) 2014-2020 Authlete, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -15,236 +15,105 @@
 # limitations under the License.
 
 
-require 'set'
-
-
 module Authlete
   module Model
     module Request
-      # == Authlete::Model::Request::TokenCreateRequest class
-      #
-      # This class represents a request to Authlete's /api/auth/token/create API.
-      class TokenCreateRequest < Authlete::Model::Hashable
-        # The grant type for a newly created access token. One of the following.
-        # "REFRESH_TOKEN" is not allowed.
-        #
-        #   "AUTHORIZATION_CODE"
-        #   "IMPLICIT"
-        #   "PASSWORD"
-        #   "CLINET_CREDENTIALS"
-        #
-        # When "grantType" is either "IMPLICIT" or "CLIENT_CREDENTIALS", a
-        # refresh token is not issued. (String)
+      class TokenCreateRequest < Authlete::Model::Request::Base
+        include Authlete::Utility
+
         attr_accessor :grantType
         alias_method  :grant_type,  :grantType
         alias_method  :grant_type=, :grantType=
 
-        # The ID of the client application which will be associated with a
-        # newly created access token. (Integer)
         attr_accessor :clientId
         alias_method  :client_id, :clientId
         alias_method  :client_id=, :clientId=
 
-        # The subject (= unique identifier) of the user who will be associated
-        # with a newly created access token. This parameter is required unless
-        # the grant type is CLIENT_CREDENTIALS. (String)
         attr_accessor :subject
 
-        # The scopes which will be associated with a newly created access token.
-        # Scopes that are not supported by the service cannot be specified and
-        # requesting them will cause an error. (String array)
         attr_accessor :scopes
 
-        # The duration of a newly created access token in seconds. If the value
-        # is 0, the duration is determined according to the settings of the
-        # service. (Integer)
         attr_accessor :accessTokenDuration
         alias_method  :access_token_duration,  :accessTokenDuration
         alias_method  :access_token_duration=, :accessTokenDuration=
 
-        # The duration of a newly created refresh token in seconds. If the value
-        # is 0, the duration is determined according to the settings of the
-        # service.
-        # A refresh token is not created (1) if the service does not support
-        # "REFRESH_TOKEN", or (2) if the specified grant type is either "IMPLICIT"
-        # or "CLIENT_CREDENTIALS". (Integer)
         attr_accessor :refreshTokenDuration
         alias_method  :refresh_token_duration,  :refreshTokenDuration
         alias_method  :refresh_token_duration=, :refreshTokenDuration=
 
-        # Extra properties to associate with a newly created access token.
-        # (Property array)
         attr_accessor :properties
 
-        # A boolean request parameter which indicates whether to emulate that
-        # the client ID alias is used instead of the original numeric client
-        # ID when a new access token is created.
-        # This has an effect only on the value of the "aud" claim in a response
-        # from UserInfo endpoint. When you access the UserInfo endpoint
-        # (which is expected to be implemented using Authlete's /api/auth/userinfo
-        # API and /api/auth/userinfo/issue API) with an access token which
-        # has been created using Authlete's /api/auth/token/create API with
-        # this property (clientIdAliasUsed) "true", the client ID alias is used
-        # as the value of the "aud" claim in a response from the UserInfo endpoint.
-        # Note that if a client ID alias is not assigned to the client when
-        # Authlete's /api/auth/token/create API is called, this property
-        # (clientIdAliasUsed) has no effect (it is always regarded as "false").
-        # (String)
         attr_accessor :clientIdAlias
         alias_method  :client_id_alias,  :clientIdAlias
         alias_method  :client_id_alias=, :clientIdAlias=
 
-        # The value of the new access token.
-        # The /api/auth/token/create API generates an access token. Therefore,
-        # callers of the API do not have to specify values of newly created
-        # access tokens. However, in some cases, for example, if you want to
-        # migrate existing access tokens from an old system to Authlete, you
-        # may want to specify values of access tokens. In such a case, you
-        # can specify the value of a newly created access token by passing
-        # a non-nil value as the value of accessToken request parameter.
-        # The implementation of the /api/auth/token/create uses the value of
-        # the accessToken request parameter instead of generating a new value
-        # when the request parameter holds a non-nil value.
-        # Note that if the hash value of the specified access token already
-        # exists in Authlete's database, the access token cannot be inserted
-        # and the /api/auth/token/create API will report an error.
-        # (String)
         attr_accessor :accessToken
         alias_method  :access_token,  :accessToken
         alias_method  :access_token=, :accessToken=
 
-        # The value of the new refresh token.
-        # The /api/auth/token/create API may generate a refresh token. Therefore,
-        # callers of the API do not have to specify values of newly created
-        # refresh tokens. However, in some cases, for example, if you want
-        # to migrate existing refresh tokens from an old system to Authlete,
-        # you may want to specify values of refresh tokens. In such a case,
-        # you can specify the value of a newly created refresh token by passing
-        # a non-nil value as the value of refreshToken request parameter.
-        # The implementation of the /api/auth/token/create uses the value of
-        # the refreshToken request parameter instead of generating a new value
-        # when the request parameter holds a non-nil value.
-        # Note that if the hash value of the specified refresh token already
-        # exists in Authlete's database, the refresh token cannot be inserted
-        # and the /api/auth/token/create API will report an error.
-        # (String)
         attr_accessor :refreshToken
         alias_method  :refresh_token,  :refreshToken
         alias_method  :refresh_token=, :refreshToken=
 
-        private
-
-        # Integer attributes.
-        INTEGER_ATTRIBUTES = ::Set.new([ :accessTokenDuration, :clientId, :refreshTokenDuration ])
-
-        # String attributes.
-        STRING_ATTRIBUTES = ::Set.new([ :accessToken, :refreshToken, :grantType, :subject, :clientIdAlias ])
-
-        # String array attributes.
-        STRING_ARRAY_ATTRIBUTES = ::Set.new([ :scopes ])
-
-        # Mapping from snake cases to camel cases.
-        SNAKE_TO_CAMEL = {
-          :access_token           => :accessToken,
-          :access_token_duration  => :accessTokenDuration,
-          :client_id              => :clientId,
-          :client_id_alias        => :clientIdAlias,
-          :grant_type             => :grantType,
-          :refresh_token          => :refreshToken,
-          :refresh_token_duration => :refreshTokenDuration
-        }
-
-        # The constructor which takes a hash that represents a JSON request to
-        # Authlete's /api/auth/token/create API.
-        def initialize(hash = nil)
-          # Set default values to integer attributes.
-          INTEGER_ATTRIBUTES.each do |attr|
-            send("#{attr}=", 0)
-          end
-
-          # Set default values to string attributes.
-          STRING_ATTRIBUTES.each do |attr|
-            send("#{attr}=", nil)
-          end
-
-          # Set default values to string array attributes.
-          STRING_ARRAY_ATTRIBUTES.each do |attr|
-            send("#{attr}=", nil)
-          end
+        attr_accessor :accessTokenPersistent
+        alias_method  :access_token_persistent,  :accessTokenPersistent
+        alias_method  :access_token_persistent=, :accessTokenPersistent=
 
-          @properties = nil
+        attr_accessor :certificateThumbprint
+        alias_method  :certificate_thumbprint,  :certificateThumbprint
+        alias_method  :certificate_thumbprint=, :certificateThumbprint=
 
-          # Set attribute values using the given hash.
-          authlete_model_update(hash)
-        end
-
-        def authlete_model_convert_key(key)
-          key = key.to_sym
-
-          # Convert snakecase to camelcase, if necessary.
-          if SNAKE_TO_CAMEL.has_key?(key)
-            key = SNAKE_TO_CAMEL[key]
-          end
+        attr_accessor :dpopKeyThumbprint
+        alias_method  :dpop_key_thumbprint,  :dpopKeyThumbprint
+        alias_method  :dpop_key_thumbprint=, :dpopKeyThumbprint=
 
-          key
-        end
-
-        def authlete_model_simple_attribute?(key)
-          INTEGER_ATTRIBUTES.include?(key) or
-          STRING_ATTRIBUTES.include?(key) or
-          STRING_ARRAY_ATTRIBUTES.include?(key)
-        end
-
-        def authlete_model_update(hash)
-          return if hash.nil?
-
-          hash.each do |key, value|
-            key = authlete_model_convert_key(key)
-
-            if authlete_model_simple_attribute?(key)
-              send("#{key}=", value)
-            elsif key == :properties
-              @properties = get_parsed_array(value) do |element|
-                Authlete::Model::Property.parse(element)
-              end
-            end
-          end
+        private
 
-          self
+        def defaults
+          {
+            grantType:             nil,
+            clientId:              0,
+            subject:               nil,
+            scopes:                nil,
+            accessTokenDuration:   0,
+            refreshTokenDuration:  0,
+            properties:            nil,
+            clientIdAlias:         nil,
+            accessToken:           nil,
+            refreshToken:          nil,
+            accessTokenPersistent: false,
+            certificateThumbprint: nil,
+            dpopKeyThumbprint:     nil
+          }
         end
 
-        public
-
-        # Construct an instance from the given hash.
-        #
-        # If the given argument is nil or is not a Hash, nil is returned.
-        # Otherwise, TokenCreateRequest.new(hash) is returned.
-        def self.parse(hash)
-          if hash.nil? or (hash.kind_of?(Hash) == false)
-            return nil
-          end
-
-          return TokenCreateRequest.new(hash)
+        def set_params(hash)
+          @grantType             = hash[:grantType]
+          @clientId              = hash[:clientId]
+          @subject               = hash[:subject]
+          @scopes                = hash[:scopes]
+          @accessTokenDuration   = hash[:accessTokenDuration]
+          @refreshTokenDuration  = hash[:refreshTokenDuration]
+          @properties            = get_parsed_array(hash[:properties]) { |e| Authlete::Model::Property.parse(e) }
+          @clientIdAlias         = hash[:clientIdAlias]
+          @accessToken           = hash[:accessToken]
+          @refreshToken          = hash[:refreshToken]
+          @accessTokenPersistent = hash[:accessTokenPersistent]
+          @certificateThumbprint = hash[:certificateThumbprint]
+          @dpopKeyThumbprint     = hash[:dpopKeyThumbprint]
         end
 
-        # Convert this object into a hash.
-        def to_hash
-          hash = {}
-
-          instance_variables.each do |var|
-            key = var.to_s.delete("@").to_sym
-            val = instance_variable_get(var)
+        def to_hash_value(key, var)
+          raw_val = instance_variable_get(var)
 
-            if authlete_model_simple_attribute?(key) or val.nil?
-              hash[key] = val
-            elsif key == :properties
-              hash[key] = val.map { |element| element.to_hash }
-            end
+          case key
+            when :properties
+              raw_val&.map { |e| e.to_hash }
+            else
+              raw_val
           end
-
-          hash
         end
       end
     end
   end
-end
+end