authlete 1.0.20 → 1.1.0

data/lib/authlete/model/response/developer-authentication-callback-response.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,42 +15,47 @@
 # limitations under the License.
 
 
+require 'json'
+
+
 module Authlete
   module Model
     module Response
-      # == Authlete::Model::Response::DeveloperAuthenticationCallbackResponse class
-      #
-      # This class represents a response from a developer authentication callback endpoint.
-      class DeveloperAuthenticationCallbackResponse
+      class DeveloperAuthenticationCallbackResponse < Authlete::Model::Base
         include Authlete::Utility
-        # True when the developer has been authenticated (= is a valid developer).
+
         attr_accessor :authenticated
 
-        # The unique identifier of the developer.
         attr_accessor :subject
 
-        # The display name of the developer.
         attr_accessor :displayName
         alias_method  :display_name,  :displayName
         alias_method  :display_name=, :displayName=
 
-        # The constructor which takes a hash that represents a JSON response
-        # from a developer authentication callback endpoint.
-        def initialize(hash = {})
-          @authenticated = extract_boolean_value(hash, :authenticated)
-          @subject       = extract_value(hash, :subject)
-          @displayName   = extract_value(hash, :displayName)
+        private
+
+        def defaults
+          {
+            authenticated: false,
+            subject:       nil,
+            displayName:   nil
+          }
+        end
+
+        def set_params(hash)
+          @authenticated = hash[:authenticated]
+          @subject       = hash[:subject]
+          @displayName   = hash[:displayName]
         end
 
-        # Generate an array which is usable as a Rack response from this instance.
         def to_rack_response
           to_rack_response_json(200, JSON.generate(
-            :authenticated => @authenticated,
-            :subject       => @subject,
-            :displayName   => @displayName
+            authenticated: @authenticated,
+            subject:       @subject,
+            displayNam:    @displayName
           ))
         end
       end
     end
   end
-end
+end

data/lib/authlete/model/response/device-authorization-response.rb

@@ -0,0 +1,134 @@
+# :nodoc:
+#
+# 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.
+# 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.
+
+
+module Authlete
+  module Model
+    module Response
+      class DeviceAuthorizationResponse < Authlete::Model::Result
+        include Authlete::Utility
+
+        attr_accessor :action
+
+        attr_accessor :responseContent
+        alias_method  :response_content,  :responseContent
+        alias_method  :response_content=, :responseContent=
+
+        attr_accessor :clientId
+        alias_method  :client_id,  :clientId
+        alias_method  :client_id=, :clientId=
+
+        attr_accessor :clientIdAlias
+        alias_method  :client_id_alias,  :clientIdAlias
+        alias_method  :client_id_alias=, :clientIdAlias=
+
+        attr_accessor :clientIdAliasUsed
+        alias_method  :client_id_alias_used,  :clientIdAliasUsed
+        alias_method  :client_id_alias_used=, :clientIdAliasUsed=
+
+        attr_accessor :clientName
+        alias_method  :client_name,  :clientName
+        alias_method  :client_name=, :clientName=
+
+        attr_accessor :clientAuthMethod
+        alias_method  :client_auth_method,  :clientAuthMethod
+        alias_method  :client_auth_method=, :clientAuthMethod=
+
+        attr_accessor :scopes
+
+        attr_accessor :clientNames
+        alias_method  :client_names,  :clientNames
+        alias_method  :client_names=, :clientNames=
+
+        attr_accessor :acrs
+
+        attr_accessor :deviceCode
+        alias_method  :device_code,  :deviceCode
+        alias_method  :device_code=, :deviceCode=
+
+        attr_accessor :userCode
+        alias_method  :user_code,  :userCode
+        alias_method  :user_code=, :userCode=
+
+        attr_accessor :verificationUri
+        alias_method  :verification_uri,  :verificationUri
+        alias_method  :verification_uri=, :verificationUri=
+
+        attr_accessor :verificationUriComplete
+        alias_method  :verification_uri_complete,  :verificationUriComplete
+        alias_method  :verification_uri_complete=, :verificationUriComplete=
+
+        attr_accessor :expiresIn
+        alias_method  :expires_in,  :expiresIn
+        alias_method  :expires_in=, :expiresIn=
+
+        attr_accessor :interval
+
+        attr_accessor :resources
+
+        attr_accessor :warnings
+
+        private
+
+        def defaults
+          super.merge(
+            action:                  nil,
+            responseContent:         nil,
+            clientId:                0,
+            clientIdAlias:           nil,
+            clientIdAliasUsed:       false,
+            clientName:              nil,
+            clientAuthMethod:        nil,
+            scopes:                  nil,
+            clientNames:             nil,
+            acrs:                    nil,
+            deviceCode:              nil,
+            userCode:                nil,
+            verificationUri:         nil,
+            verificationUriComplete: nil,
+            expiresIn:               0,
+            interval:                0,
+            resources:               nil,
+            warnings:                nil
+          )
+        end
+
+        def set_params(hash)
+          super(hash)
+
+          @action                  = hash[:action]
+          @responseContent         = hash[:responseContent]
+          @clientId                = hash[:clientId]
+          @clientIdAlias           = hash[:clientIdAlias]
+          @clientIdAliasUsed       = hash[:clientIdAliasUsed]
+          @clientName              = hash[:clientName]
+          @clientAuthMethod        = hash[:clientAuthMethod]
+          @scopes                  = get_parsed_array(hash[:scopes]) { |e| Authlete::Model::Scope.parse(e) }
+          @clientNames             = hash[:clientNames]
+          @acrs                    = hash[:acrs]
+          @deviceCode              = hash[:deviceCode]
+          @userCode                = hash[:userCode]
+          @verificationUri         = hash[:verificationUri]
+          @verificationUriComplete = hash[:verificationUriComplete]
+          @expiresIn               = hash[:expiresIn]
+          @interval                = hash[:interval]
+          @resources               = hash[:resources]
+          @warnings                = hash[:warnings]
+        end
+      end
+    end
+  end
+end

data/lib/authlete/model/response/device-complete-response.rb

@@ -0,0 +1,39 @@
+# :nodoc:
+#
+# 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.
+# 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.
+
+
+module Authlete
+  module Model
+    module Response
+      class DeviceCompleteResponse < Authlete::Model::Result
+
+        attr_accessor :action
+
+        private
+
+        def defaults
+          super.merge(action: nil)
+        end
+
+        def set_params(hash)
+          super(hash)
+
+          @action = hash[:action]
+        end
+      end
+    end
+  end
+end

data/lib/authlete/model/response/device-verification-response.rb

@@ -0,0 +1,96 @@
+# :nodoc:
+#
+# 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.
+# 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.
+
+
+module Authlete
+  module Model
+    module Response
+      class DeviceVerificationResponse < Authlete::Model::Result
+        include Authlete::Utility
+
+        attr_accessor :action
+
+        attr_accessor :responseContent
+        alias_method  :response_content,  :responseContent
+        alias_method  :response_content=, :responseContent=
+
+        attr_accessor :clientId
+        alias_method  :client_id,  :clientId
+        alias_method  :client_id=, :clientId=
+
+        attr_accessor :clientIdAlias
+        alias_method  :client_id_alias,  :clientIdAlias
+        alias_method  :client_id_alias=, :clientIdAlias=
+
+        attr_accessor :clientIdAliasUsed
+        alias_method  :client_id_alias_used,  :clientIdAliasUsed
+        alias_method  :client_id_alias_used=, :clientIdAliasUsed=
+
+        attr_accessor :clientName
+        alias_method  :client_name,  :clientName
+        alias_method  :client_name=, :clientName=
+
+        attr_accessor :scopes
+
+        attr_accessor :clientNames
+        alias_method  :client_names,  :clientNames
+        alias_method  :client_names=, :clientNames=
+
+        attr_accessor :acrs
+
+        attr_accessor :expiresAt
+        alias_method  :expires_at,  :expiresAt
+        alias_method  :expires_at=, :expiresAt=
+
+        attr_accessor :resources
+
+        private
+
+        def defaults
+          super.merge(
+            action:            nil,
+            responseContent:   nil,
+            clientId:          0,
+            clientIdAlias:     nil,
+            clientIdAliasUsed: false,
+            clientName:        nil,
+            scopes:            nil,
+            clientNames:       nil,
+            acrs:              nil,
+            expiresAt:         0,
+            resources:         nil
+          )
+        end
+
+        def set_params(hash)
+          super(hash)
+
+          @action            = hash[:action]
+          @responseContent   = hash[:responseContent]
+          @clientId          = hash[:clientId]
+          @clientIdAlias     = hash[:clientIdAlias]
+          @clientIdAliasUsed = hash[:clientIdAliasUsed]
+          @clientName        = hash[:clientName]
+          @scopes            = get_parsed_array(hash[:scopes]) { |e| Authlete::Model::Scope.parse(e) }
+          @clientNames       = hash[:clientNames]
+          @acrs              = hash[:acrs]
+          @expiresAt         = hash[:expiresAt]
+          @resources         = hash[:resources]
+        end
+      end
+    end
+  end
+end

data/lib/authlete/model/response/granted-scopes-get-response.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.
@@ -18,46 +18,54 @@
 module Authlete
   module Model
     module Response
-      # == Authlete::Model::Response::GrantedScopesGetResponse class
-      #
-      # A class that represents a response from Authlete's
-      # /api/client/granted_scopes/get/{clientId} API.
       class GrantedScopesGetResponse < Authlete::Model::Result
-        # Service API key. (Integer)
+
         attr_accessor :serviceApiKey
         alias_method  :service_api_key, :serviceApiKey
         alias_method  :service_api_key=, :serviceApiKey=
 
-        # Client ID.. (Integer)
         attr_accessor :clientId
         alias_method  :client_id,  :clientId
         alias_method  :client_id=, :clientId=
 
-        # Unique User ID. (String)
         attr_accessor :subject
 
-        # Scopes granted by the last authorization process. (String array)
         attr_accessor :latestGrantedScopes
         alias_method  :latest_granted_scopes,  :latestGrantedScopes
         alias_method  :latest_granted_scopes=, :latestGrantedScopes=
 
-        # All scopes granted so far. (String array)
         attr_accessor :mergedGrantedScopes
         alias_method  :merged_granted_scopes,  :mergedGrantedScopes
         alias_method  :merged_granted_scopes=, :mergedGrantedScopes=
 
-        # The constructor which takes a hash that represents a JSON response
-        # from /api/client/granted_scopes/get/{clientId} API.
-        def initialize(hash = {})
+        attr_accessor :modifiedAt
+        alias_method  :modified_at,  :modifiedAt
+        alias_method  :modified_at=, :modifiedAt=
+
+        private
+
+        def defaults
+          super.merge(
+            serviceApiKey:       nil,
+            clientId:            0,
+            subject:             nil,
+            latestGrantedScopes: nil,
+            mergedGrantedScopes: nil,
+            modifiedAt:          0
+          )
+        end
+
+        def set_params(hash)
           super(hash)
 
-          @serviceApiKey       = extract_integer_value(hash, :serviceApiKey)
-          @clientId            = extract_integer_value(hash, :clientId)
-          @subject             = extract_value(hash, :subject)
-          @latestGrantedScopes = extract_value(hash, :latestGrantedScopes)
-          @mergedGrantedScopes = extract_value(hash, :mergedGrantedScopes)
+          @serviceApiKey       = hash[:serviceApiKey]
+          @clientId            = hash[:clientId]
+          @subject             = hash[:subject]
+          @latestGrantedScopes = hash[:latestGrantedScopes]
+          @mergedGrantedScopes = hash[:mergedGrantedScopes]
+          @modifiedAt          = hash[:modifiedAt]
         end
       end
     end
   end
-end
+end

data/lib/authlete/model/response/introspection-response.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.
@@ -18,102 +18,108 @@
 module Authlete
   module Model
     module Response
-      # == Authlete::Model::Response::IntrospectionResponse class
-      #
-      # A class that represents a response from Authlete's
-      # /api/auth/introspection API.
       class IntrospectionResponse < Authlete::Model::Result
-        # The next action which the caller of the API should take next.
-        # (String)
+        include Authlete::Utility
+
         attr_accessor :action
 
-        # The ID of the client application which is associated with
-        # the access token. (Integer)
         attr_accessor :clientId
         alias_method  :client_id,  :clientId
         alias_method  :client_id=, :clientId=
 
-        # The flag which indicates whether the client ID alias was used when
-        # the authorization request for the access token was made. (String)
         attr_accessor :clientIdAlias
         alias_method  :client_id_alias,  :clientIdAlias
         alias_method  :client_id_alias=, :clientIdAlias=
 
-        # The flag which indicates whether the client ID alias was used when
-        # the authorization request or the token request for the access token
-        # was made. (Boolean)
         attr_accessor :clientIdAliasUsed
         alias_method  :client_id_alias_used,  :clientIdAliasUsed
         alias_method  :client_id_alias_used=, :clientIdAliasUsed=
 
-        # The time at which the access token expires. (Integer)
         attr_accessor :expiresAt
         alias_method  :expires_at, :expiresAt
         alias_method  :expires_at=, :expiresAt=
 
-        # The subject which is associated with the access token.
-        # This is <tt>nil</tt> if the access token was created
-        # through {Client Credentials Flow}[https://tools.ietf.org/html/rfc6749#section-4.4].
-        # (String)
         attr_accessor :subject
 
-        # The scopes which is associated with the access token. (String array)
         attr_accessor :scopes
 
-        # True when the access token exists. (Boolean)
         attr_accessor :existent
+        alias_method  :existent?, :existent
+        alias_method  :exists,    :existent
+        alias_method  :exists?,   :existent
+        alias_method  :exist,     :existent
+        alias_method  :exist?,    :existent
 
-        # True when the access token is usable (= exists and has not expired).
-        # (Boolean)
         attr_accessor :usable
+        alias_method  :usable?, :usable
 
-        # True when the access token covers all the scopes (if specified).
-        # (Boolean)
         attr_accessor :sufficient
+        alias_method  :sufficient?, :sufficient
 
-        # True when the access token can be refreshed using its corresponding
-        # refresh token. (Boolean)
         attr_accessor :refreshable
+        alias_method  :refreshable?, :refreshable
 
-        # The content of the error response that the service implementation
-        # should return to the client application. (String)
-        attr_accessor :response_content
+        attr_accessor :responseContent
         alias_method  :response_content,  :responseContent
         alias_method  :response_content=, :responseContent=
 
-        # Extra properties associated with the access token. (Property array)
         attr_accessor :properties
 
-        # The constructor which takes a hash that represents a JSON response
-        # from /api/auth/introspection API.
-        def initialize(hash = {})
+        attr_accessor :certificateThumbprint
+        alias_method  :certificate_thumbprint,  :certificateThumbprint
+        alias_method  :certificate_thumbprint=, :certificateThumbprint=
+
+        attr_accessor :resources
+
+        attr_accessor :accessTokenResources
+        alias_method  :access_token_resources,  :accessTokenResources
+        alias_method  :access_token_resources=, :accessTokenResources=
+
+        private
+
+        def defaults
+          super.merge(
+            action:                nil,
+            clientId:              0,
+            clientIdAlias:         nil,
+            clientIdAliasUsed:     false,
+            expiresAt:             0,
+            subject:               nil,
+            scopes:                nil,
+            existent:              false,
+            usable:                false,
+            sufficient:            false,
+            refreshable:           false,
+            responseContent:       nil,
+            properties:            nil,
+            certificateThumbprint: nil,
+            resources:             nil,
+            accessTokenResources:  nil
+          )
+        end
+
+        def set_params(hash)
           super(hash)
 
-          @action            = extract_value(hash, :action)
-          @clientId          = extract_value(hash, :clientId)
-          @clientIdAlias     = extract_value(hash, :clientIdAlias)
-          @clientIdAliasUsed = extract_boolean_value(hash, :clientIdAliasUsed)
-          @expiresAt         = extract_integer_value(hash, :expiresAt)
-          @subject           = extract_value(hash, :subject)
-          @scopes            = extract_value(hash, :scopes)
-          @existent          = extract_boolean_value(hash, :existent)
-          @usable            = extract_boolean_value(hash, :usable)
-          @sufficient        = extract_boolean_value(hash, :sufficient)
-          @refreshable       = extract_boolean_value(hash, :refreshable)
-          @responseContent   = extract_value(hash, :responseContent)
-          @properties        = extract_array_value(hash, :scopes) do |element|
-            Authlete::Model::Property.parse(element)
-          end
+          @action                = hash[:action]
+          @clientId              = hash[:clientId]
+          @clientIdAlias         = hash[:clientIdAlias]
+          @clientIdAliasUsed     = hash[:clientIdAliasUsed]
+          @expiresAt             = hash[:expiresAt]
+          @subject               = hash[:subject]
+          @scopes                = hash[:scopes]
+          @existent              = hash[:existent]
+          @usable                = hash[:usable]
+          @sufficient            = hash[:sufficient]
+          @refreshable           = hash[:refreshable]
+          @responseContent       = hash[:responseContent]
+          @properties            = get_parsed_array(hash[:properties]) { |e| Authlete::Model::Property.parse(e) }
+          @certificateThumbprint = hash[:certificateThumbprint]
+          @resources             = hash[:resources]
+          @accessTokenResources  = hash[:accessTokenResources]
         end
 
-        alias_method :existent?,    :existent
-        alias_method :exists,       :existent
-        alias_method :exists?,      :existent
-        alias_method :exist,        :existent
-        alias_method :exist?,       :existent
-        alias_method :usable?,      :usable
-        alias_method :sufficient?,  :sufficient
-        alias_method :refreshable?, :refreshable
+        public
 
         # Generate an array which is usable as a Rack response from this instance.
         # When <tt>action</tt> method returns other value than 'OK', the array
@@ -161,4 +167,4 @@ module Authlete
       end
     end
   end
-end
+end