paypal-server-sdk 1.0.0 → 1.1.0

data/lib/paypal_server_sdk/controllers/payments_controller.rb

@@ -6,53 +6,6 @@
 module PaypalServerSdk
   # PaymentsController
   class PaymentsController < BaseController
-    # Shows details for an authorized payment, by ID.
-    # @param [String] authorization_id Required parameter: The ID of the
-    # authorized payment for which to show details.
-    # @param [String] paypal_mock_response Optional parameter: PayPal's REST API
-    # uses a request header to invoke negative testing in the sandbox. This
-    # header configures the sandbox into a negative testing state for
-    # transactions that include the merchant.
-    # @param [String] paypal_auth_assertion Optional parameter: An
-    # API-caller-provided JSON Web Token (JWT) assertion that identifies the
-    # merchant. For details, see
-    # [PayPal-Auth-Assertion](/docs/api/reference/api-requests/#paypal-auth-asse
-    # rtion). Note:For three party transactions in which a partner is managing
-    # the API calls on behalf of a merchant, the partner must identify the
-    # merchant using either a PayPal-Auth-Assertion header or an access token
-    # with target_subject.
-    # @return [ApiResponse]  the complete http response with raw body and status code.
-    def get_authorized_payment(options = {})
-      new_api_call_builder
-        .request(new_request_builder(HttpMethodEnum::GET,
-                                     '/v2/payments/authorizations/{authorization_id}',
-                                     Server::DEFAULT)
-                   .template_param(new_parameter(options['authorization_id'], key: 'authorization_id')
-                                    .should_encode(true))
-                   .header_param(new_parameter(options['paypal_mock_response'], key: 'PayPal-Mock-Response'))
-                   .header_param(new_parameter(options['paypal_auth_assertion'], key: 'PayPal-Auth-Assertion'))
-                   .header_param(new_parameter('application/json', key: 'accept'))
-                   .auth(Single.new('Oauth2')))
-        .response(new_response_handler
-                    .deserializer(APIHelper.method(:custom_type_deserializer))
-                    .deserialize_into(PaymentAuthorization.method(:from_hash))
-                    .is_api_response(true)
-                    .local_error('401',
-                                 'Authentication failed due to missing authorization header, or'\
-                                  ' invalid authentication credentials.',
-                                 ErrorException)
-                    .local_error('404',
-                                 'The request failed because the resource does not exist.',
-                                 ErrorException)
-                    .local_error('500',
-                                 'The request failed because an internal server error occurred.',
-                                 APIException)
-                    .local_error('default',
-                                 'The error response.',
-                                 ErrorException))
-        .execute
-    end
-
     # Captures an authorized payment, by ID.
     # @param [String] authorization_id Required parameter: The PayPal-generated
     # ID for the authorized payment to capture.
@@ -76,7 +29,8 @@ module PaypalServerSdk
     # the API calls on behalf of a merchant, the partner must identify the
     # merchant using either a PayPal-Auth-Assertion header or an access token
     # with target_subject.
-    # @param [CaptureRequest] body Optional parameter: Example:
+    # @param [CaptureRequest] body Optional parameter: TODO: type description
+    # here
     # @return [ApiResponse]  the complete http response with raw body and status code.
     def capture_authorized_payment(options = {})
       new_api_call_builder
@@ -130,6 +84,48 @@ module PaypalServerSdk
         .execute
     end
 
+    # Shows details for a captured payment, by ID.
+    # @param [String] capture_id Required parameter: The PayPal-generated ID for
+    # the captured payment for which to show details.
+    # @param [String] paypal_mock_response Optional parameter: PayPal's REST API
+    # uses a request header to invoke negative testing in the sandbox. This
+    # header configures the sandbox into a negative testing state for
+    # transactions that include the merchant.
+    # @return [ApiResponse]  the complete http response with raw body and status code.
+    def get_captured_payment(options = {})
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/v2/payments/captures/{capture_id}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(options['capture_id'], key: 'capture_id')
+                                    .should_encode(true))
+                   .header_param(new_parameter(options['paypal_mock_response'], key: 'PayPal-Mock-Response'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('Oauth2')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(CapturedPayment.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Authentication failed due to missing authorization header, or'\
+                                  ' invalid authentication credentials.',
+                                 ErrorException)
+                    .local_error('403',
+                                 'The request failed because the caller has insufficient'\
+                                  ' permissions.',
+                                 ErrorException)
+                    .local_error('404',
+                                 'The request failed because the resource does not exist.',
+                                 ErrorException)
+                    .local_error('500',
+                                 'The request failed because an internal server error occurred.',
+                                 APIException)
+                    .local_error('default',
+                                 'The error response.',
+                                 ErrorException))
+        .execute
+    end
+
     # Reauthorizes an authorized PayPal account payment, by ID. To ensure that
     # funds are still available, reauthorize a payment after its initial
     # three-day honor period expires. Within the 29-day authorization period,
@@ -161,7 +157,8 @@ module PaypalServerSdk
     # the API calls on behalf of a merchant, the partner must identify the
     # merchant using either a PayPal-Auth-Assertion header or an access token
     # with target_subject.
-    # @param [ReauthorizeRequest] body Optional parameter: Example:
+    # @param [ReauthorizeRequest] body Optional parameter: TODO: type
+    # description here
     # @return [ApiResponse]  the complete http response with raw body and status code.
     def reauthorize_payment(options = {})
       new_api_call_builder
@@ -277,48 +274,6 @@ module PaypalServerSdk
         .execute
     end
 
-    # Shows details for a captured payment, by ID.
-    # @param [String] capture_id Required parameter: The PayPal-generated ID for
-    # the captured payment for which to show details.
-    # @param [String] paypal_mock_response Optional parameter: PayPal's REST API
-    # uses a request header to invoke negative testing in the sandbox. This
-    # header configures the sandbox into a negative testing state for
-    # transactions that include the merchant.
-    # @return [ApiResponse]  the complete http response with raw body and status code.
-    def get_captured_payment(options = {})
-      new_api_call_builder
-        .request(new_request_builder(HttpMethodEnum::GET,
-                                     '/v2/payments/captures/{capture_id}',
-                                     Server::DEFAULT)
-                   .template_param(new_parameter(options['capture_id'], key: 'capture_id')
-                                    .should_encode(true))
-                   .header_param(new_parameter(options['paypal_mock_response'], key: 'PayPal-Mock-Response'))
-                   .header_param(new_parameter('application/json', key: 'accept'))
-                   .auth(Single.new('Oauth2')))
-        .response(new_response_handler
-                    .deserializer(APIHelper.method(:custom_type_deserializer))
-                    .deserialize_into(CapturedPayment.method(:from_hash))
-                    .is_api_response(true)
-                    .local_error('401',
-                                 'Authentication failed due to missing authorization header, or'\
-                                  ' invalid authentication credentials.',
-                                 ErrorException)
-                    .local_error('403',
-                                 'The request failed because the caller has insufficient'\
-                                  ' permissions.',
-                                 ErrorException)
-                    .local_error('404',
-                                 'The request failed because the resource does not exist.',
-                                 ErrorException)
-                    .local_error('500',
-                                 'The request failed because an internal server error occurred.',
-                                 APIException)
-                    .local_error('default',
-                                 'The error response.',
-                                 ErrorException))
-        .execute
-    end
-
     # Refunds a captured payment, by ID. For a full refund, include an empty
     # payload in the JSON request body. For a partial refund, include an amount
     # object in the JSON request body.
@@ -344,7 +299,8 @@ module PaypalServerSdk
     # the API calls on behalf of a merchant, the partner must identify the
     # merchant using either a PayPal-Auth-Assertion header or an access token
     # with target_subject.
-    # @param [RefundRequest] body Optional parameter: Example:
+    # @param [RefundRequest] body Optional parameter: TODO: type description
+    # here
     # @return [ApiResponse]  the complete http response with raw body and status code.
     def refund_captured_payment(options = {})
       new_api_call_builder
@@ -398,6 +354,53 @@ module PaypalServerSdk
         .execute
     end
 
+    # Shows details for an authorized payment, by ID.
+    # @param [String] authorization_id Required parameter: The ID of the
+    # authorized payment for which to show details.
+    # @param [String] paypal_mock_response Optional parameter: PayPal's REST API
+    # uses a request header to invoke negative testing in the sandbox. This
+    # header configures the sandbox into a negative testing state for
+    # transactions that include the merchant.
+    # @param [String] paypal_auth_assertion Optional parameter: An
+    # API-caller-provided JSON Web Token (JWT) assertion that identifies the
+    # merchant. For details, see
+    # [PayPal-Auth-Assertion](/docs/api/reference/api-requests/#paypal-auth-asse
+    # rtion). Note:For three party transactions in which a partner is managing
+    # the API calls on behalf of a merchant, the partner must identify the
+    # merchant using either a PayPal-Auth-Assertion header or an access token
+    # with target_subject.
+    # @return [ApiResponse]  the complete http response with raw body and status code.
+    def get_authorized_payment(options = {})
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/v2/payments/authorizations/{authorization_id}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(options['authorization_id'], key: 'authorization_id')
+                                    .should_encode(true))
+                   .header_param(new_parameter(options['paypal_mock_response'], key: 'PayPal-Mock-Response'))
+                   .header_param(new_parameter(options['paypal_auth_assertion'], key: 'PayPal-Auth-Assertion'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('Oauth2')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(PaymentAuthorization.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Authentication failed due to missing authorization header, or'\
+                                  ' invalid authentication credentials.',
+                                 ErrorException)
+                    .local_error('404',
+                                 'The request failed because the resource does not exist.',
+                                 ErrorException)
+                    .local_error('500',
+                                 'The request failed because an internal server error occurred.',
+                                 APIException)
+                    .local_error('default',
+                                 'The error response.',
+                                 ErrorException))
+        .execute
+    end
+
     # Shows details for a refund, by ID.
     # @param [String] refund_id Required parameter: The PayPal-generated ID for
     # the refund for which to show details.

data/lib/paypal_server_sdk/controllers/vault_controller.rb

@@ -6,27 +6,19 @@
 module PaypalServerSdk
   # VaultController
   class VaultController < BaseController
-    # Creates a Payment Token from the given payment source and adds it to the
-    # Vault of the associated customer.
-    # @param [PaymentTokenRequest] body Required parameter: Payment Token
-    # creation with a financial instrument and an optional customer_id.
-    # @param [String] paypal_request_id Optional parameter: The server stores
-    # keys for 3 hours.
+    # Delete the payment token associated with the payment token id.
+    # @param [String] id Required parameter: ID of the payment token.
     # @return [ApiResponse]  the complete http response with raw body and status code.
-    def create_payment_token(options = {})
+    def delete_payment_token(id)
       new_api_call_builder
-        .request(new_request_builder(HttpMethodEnum::POST,
-                                     '/v3/vault/payment-tokens',
+        .request(new_request_builder(HttpMethodEnum::DELETE,
+                                     '/v3/vault/payment-tokens/{id}',
                                      Server::DEFAULT)
-                   .header_param(new_parameter('application/json', key: 'Content-Type'))
-                   .body_param(new_parameter(options['body']))
-                   .header_param(new_parameter(options['paypal_request_id'], key: 'PayPal-Request-Id'))
-                   .header_param(new_parameter('application/json', key: 'accept'))
-                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
                    .auth(Single.new('Oauth2')))
         .response(new_response_handler
-                    .deserializer(APIHelper.method(:custom_type_deserializer))
-                    .deserialize_into(PaymentTokenResponse.method(:from_hash))
+                    .is_response_void(true)
                     .is_api_response(true)
                     .local_error('400',
                                  'Request is not well-formed, syntactically incorrect, or'\
@@ -35,45 +27,34 @@ module PaypalServerSdk
                     .local_error('403',
                                  'Authorization failed due to insufficient permissions.',
                                  ErrorException)
-                    .local_error('404',
-                                 'Request contains reference to resources that do not exist.',
-                                 ErrorException)
-                    .local_error('422',
-                                 'The requested action could not be performed, semantically'\
-                                  ' incorrect, or failed business validation.',
-                                 ErrorException)
                     .local_error('500',
                                  'An internal server error has occurred.',
                                  ErrorException))
         .execute
     end
 
-    # Returns all payment tokens for a customer.
-    # @param [String] customer_id Required parameter: A unique identifier
-    # representing a specific customer in merchant's/partner's system or
-    # records.
-    # @param [Integer] page_size Optional parameter: A non-negative, non-zero
-    # integer indicating the maximum number of results to return at one time.
-    # @param [Integer] page Optional parameter: A non-negative, non-zero integer
-    # representing the page of the results.
-    # @param [TrueClass | FalseClass] total_required Optional parameter: A
-    # boolean indicating total number of items (total_items) and pages
-    # (total_pages) are expected to be returned in the response.
+    # Creates a Setup Token from the given payment source and adds it to the
+    # Vault of the associated customer.
+    # @param [SetupTokenRequest] body Required parameter: Setup Token creation
+    # with a instrument type optional financial instrument details and
+    # customer_id.
+    # @param [String] paypal_request_id Optional parameter: The server stores
+    # keys for 3 hours.
     # @return [ApiResponse]  the complete http response with raw body and status code.
-    def list_customer_payment_tokens(options = {})
+    def create_setup_token(options = {})
       new_api_call_builder
-        .request(new_request_builder(HttpMethodEnum::GET,
-                                     '/v3/vault/payment-tokens',
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/v3/vault/setup-tokens',
                                      Server::DEFAULT)
-                   .query_param(new_parameter(options['customer_id'], key: 'customer_id'))
-                   .query_param(new_parameter(options['page_size'], key: 'page_size'))
-                   .query_param(new_parameter(options['page'], key: 'page'))
-                   .query_param(new_parameter(options['total_required'], key: 'total_required'))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(options['body']))
+                   .header_param(new_parameter(options['paypal_request_id'], key: 'PayPal-Request-Id'))
                    .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
                    .auth(Single.new('Oauth2')))
         .response(new_response_handler
                     .deserializer(APIHelper.method(:custom_type_deserializer))
-                    .deserialize_into(CustomerVaultPaymentTokensResponse.method(:from_hash))
+                    .deserialize_into(SetupTokenResponse.method(:from_hash))
                     .is_api_response(true)
                     .local_error('400',
                                  'Request is not well-formed, syntactically incorrect, or'\
@@ -82,20 +63,24 @@ module PaypalServerSdk
                     .local_error('403',
                                  'Authorization failed due to insufficient permissions.',
                                  ErrorException)
+                    .local_error('422',
+                                 'The requested action could not be performed, semantically'\
+                                  ' incorrect, or failed business validation.',
+                                 ErrorException)
                     .local_error('500',
                                  'An internal server error has occurred.',
                                  ErrorException))
         .execute
     end
 
-    # Returns a readable representation of vaulted payment source associated
-    # with the payment token id.
-    # @param [String] id Required parameter: ID of the payment token.
+    # Returns a readable representation of temporarily vaulted payment source
+    # associated with the setup token id.
+    # @param [String] id Required parameter: ID of the setup token.
     # @return [ApiResponse]  the complete http response with raw body and status code.
-    def get_payment_token(id)
+    def get_setup_token(id)
       new_api_call_builder
         .request(new_request_builder(HttpMethodEnum::GET,
-                                     '/v3/vault/payment-tokens/{id}',
+                                     '/v3/vault/setup-tokens/{id}',
                                      Server::DEFAULT)
                    .template_param(new_parameter(id, key: 'id')
                                     .should_encode(true))
@@ -103,7 +88,7 @@ module PaypalServerSdk
                    .auth(Single.new('Oauth2')))
         .response(new_response_handler
                     .deserializer(APIHelper.method(:custom_type_deserializer))
-                    .deserialize_into(PaymentTokenResponse.method(:from_hash))
+                    .deserialize_into(SetupTokenResponse.method(:from_hash))
                     .is_api_response(true)
                     .local_error('403',
                                  'Authorization failed due to insufficient permissions.',
@@ -121,19 +106,27 @@ module PaypalServerSdk
         .execute
     end
 
-    # Delete the payment token associated with the payment token id.
-    # @param [String] id Required parameter: ID of the payment token.
+    # Creates a Payment Token from the given payment source and adds it to the
+    # Vault of the associated customer.
+    # @param [PaymentTokenRequest] body Required parameter: Payment Token
+    # creation with a financial instrument and an optional customer_id.
+    # @param [String] paypal_request_id Optional parameter: The server stores
+    # keys for 3 hours.
     # @return [ApiResponse]  the complete http response with raw body and status code.
-    def delete_payment_token(id)
+    def create_payment_token(options = {})
       new_api_call_builder
-        .request(new_request_builder(HttpMethodEnum::DELETE,
-                                     '/v3/vault/payment-tokens/{id}',
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/v3/vault/payment-tokens',
                                      Server::DEFAULT)
-                   .template_param(new_parameter(id, key: 'id')
-                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(options['body']))
+                   .header_param(new_parameter(options['paypal_request_id'], key: 'PayPal-Request-Id'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
                    .auth(Single.new('Oauth2')))
         .response(new_response_handler
-                    .is_response_void(true)
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(PaymentTokenResponse.method(:from_hash))
                     .is_api_response(true)
                     .local_error('400',
                                  'Request is not well-formed, syntactically incorrect, or'\
@@ -142,34 +135,45 @@ module PaypalServerSdk
                     .local_error('403',
                                  'Authorization failed due to insufficient permissions.',
                                  ErrorException)
+                    .local_error('404',
+                                 'Request contains reference to resources that do not exist.',
+                                 ErrorException)
+                    .local_error('422',
+                                 'The requested action could not be performed, semantically'\
+                                  ' incorrect, or failed business validation.',
+                                 ErrorException)
                     .local_error('500',
                                  'An internal server error has occurred.',
                                  ErrorException))
         .execute
     end
 
-    # Creates a Setup Token from the given payment source and adds it to the
-    # Vault of the associated customer.
-    # @param [SetupTokenRequest] body Required parameter: Setup Token creation
-    # with a instrument type optional financial instrument details and
-    # customer_id.
-    # @param [String] paypal_request_id Optional parameter: The server stores
-    # keys for 3 hours.
+    # Returns all payment tokens for a customer.
+    # @param [String] customer_id Required parameter: A unique identifier
+    # representing a specific customer in merchant's/partner's system or
+    # records.
+    # @param [Integer] page_size Optional parameter: A non-negative, non-zero
+    # integer indicating the maximum number of results to return at one time.
+    # @param [Integer] page Optional parameter: A non-negative, non-zero integer
+    # representing the page of the results.
+    # @param [TrueClass | FalseClass] total_required Optional parameter: A
+    # boolean indicating total number of items (total_items) and pages
+    # (total_pages) are expected to be returned in the response.
     # @return [ApiResponse]  the complete http response with raw body and status code.
-    def create_setup_token(options = {})
+    def list_customer_payment_tokens(options = {})
       new_api_call_builder
-        .request(new_request_builder(HttpMethodEnum::POST,
-                                     '/v3/vault/setup-tokens',
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/v3/vault/payment-tokens',
                                      Server::DEFAULT)
-                   .header_param(new_parameter('application/json', key: 'Content-Type'))
-                   .body_param(new_parameter(options['body']))
-                   .header_param(new_parameter(options['paypal_request_id'], key: 'PayPal-Request-Id'))
+                   .query_param(new_parameter(options['customer_id'], key: 'customer_id'))
+                   .query_param(new_parameter(options['page_size'], key: 'page_size'))
+                   .query_param(new_parameter(options['page'], key: 'page'))
+                   .query_param(new_parameter(options['total_required'], key: 'total_required'))
                    .header_param(new_parameter('application/json', key: 'accept'))
-                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
                    .auth(Single.new('Oauth2')))
         .response(new_response_handler
                     .deserializer(APIHelper.method(:custom_type_deserializer))
-                    .deserialize_into(SetupTokenResponse.method(:from_hash))
+                    .deserialize_into(CustomerVaultPaymentTokensResponse.method(:from_hash))
                     .is_api_response(true)
                     .local_error('400',
                                  'Request is not well-formed, syntactically incorrect, or'\
@@ -178,24 +182,20 @@ module PaypalServerSdk
                     .local_error('403',
                                  'Authorization failed due to insufficient permissions.',
                                  ErrorException)
-                    .local_error('422',
-                                 'The requested action could not be performed, semantically'\
-                                  ' incorrect, or failed business validation.',
-                                 ErrorException)
                     .local_error('500',
                                  'An internal server error has occurred.',
                                  ErrorException))
         .execute
     end
 
-    # Returns a readable representation of temporarily vaulted payment source
-    # associated with the setup token id.
-    # @param [String] id Required parameter: ID of the setup token.
+    # Returns a readable representation of vaulted payment source associated
+    # with the payment token id.
+    # @param [String] id Required parameter: ID of the payment token.
     # @return [ApiResponse]  the complete http response with raw body and status code.
-    def get_setup_token(id)
+    def get_payment_token(id)
       new_api_call_builder
         .request(new_request_builder(HttpMethodEnum::GET,
-                                     '/v3/vault/setup-tokens/{id}',
+                                     '/v3/vault/payment-tokens/{id}',
                                      Server::DEFAULT)
                    .template_param(new_parameter(id, key: 'id')
                                     .should_encode(true))
@@ -203,7 +203,7 @@ module PaypalServerSdk
                    .auth(Single.new('Oauth2')))
         .response(new_response_handler
                     .deserializer(APIHelper.method(:custom_type_deserializer))
-                    .deserialize_into(SetupTokenResponse.method(:from_hash))
+                    .deserialize_into(PaymentTokenResponse.method(:from_hash))
                     .is_api_response(true)
                     .local_error('403',
                                  'Authorization failed due to insufficient permissions.',

data/lib/paypal_server_sdk/exceptions/error_exception.rb

@@ -31,8 +31,8 @@ module PaypalServerSdk
     attr_accessor :links
 
     # The constructor.
-    # @param [String] The reason for raising an exception.
-    # @param [HttpResponse] The HttpReponse of the API call.
+    # @param [String] reason The reason for raising an exception.
+    # @param [HttpResponse] response The HttpReponse of the API call.
     def initialize(reason, response)
       super(reason, response)
       hash = APIHelper.json_deserialize(@response.raw_body)
@@ -40,9 +40,11 @@ module PaypalServerSdk
     end
 
     # Populates this object by extracting properties from a hash.
-    # @param [Hash] The deserialized response sent by the server in the
+    # @param [Hash] hash The deserialized response sent by the server in the
     # response body.
     def unbox(hash)
+      return nil unless hash
+
       @name = hash.key?('name') ? hash['name'] : nil
       @message = hash.key?('message') ? hash['message'] : nil
       @debug_id = hash.key?('debug_id') ? hash['debug_id'] : nil

data/lib/paypal_server_sdk/exceptions/o_auth_provider_exception.rb

@@ -27,8 +27,8 @@ module PaypalServerSdk
     attr_accessor :error_uri
 
     # The constructor.
-    # @param [String] The reason for raising an exception.
-    # @param [HttpResponse] The HttpReponse of the API call.
+    # @param [String] reason The reason for raising an exception.
+    # @param [HttpResponse] response The HttpReponse of the API call.
     def initialize(reason, response)
       super(reason, response)
       hash = APIHelper.json_deserialize(@response.raw_body)
@@ -36,9 +36,11 @@ module PaypalServerSdk
     end
 
     # Populates this object by extracting properties from a hash.
-    # @param [Hash] The deserialized response sent by the server in the
+    # @param [Hash] hash The deserialized response sent by the server in the
     # response body.
     def unbox(hash)
+      return nil unless hash
+
       @error = hash.key?('error') ? hash['error'] : nil
       @error_description =
         hash.key?('error_description') ? hash['error_description'] : SKIP

data/lib/paypal_server_sdk/models/apple_pay_attributes.rb

@@ -9,7 +9,8 @@ module PaypalServerSdk
     SKIP = Object.new
     private_constant :SKIP
 
-    # The details about a customer in PayPal's system of record.
+    # This object represents a merchant’s customer, allowing them to store
+    # contact details, and track all payments associated with the same customer.
     # @return [CustomerInformation]
     attr_accessor :customer
 

data/lib/paypal_server_sdk/models/apple_pay_experience_context.rb

@@ -0,0 +1,68 @@
+# paypal_server_sdk
+#
+# This file was automatically generated by APIMATIC v2.0
+# ( https://apimatic.io ).
+
+module PaypalServerSdk
+  # Customizes the payer experience during the approval process for the payment.
+  class ApplePayExperienceContext < BaseModel
+    SKIP = Object.new
+    private_constant :SKIP
+
+    # Describes the URL.
+    # @return [String]
+    attr_accessor :return_url
+
+    # Describes the URL.
+    # @return [String]
+    attr_accessor :cancel_url
+
+    # A mapping from model property names to API property names.
+    def self.names
+      @_hash = {} if @_hash.nil?
+      @_hash['return_url'] = 'return_url'
+      @_hash['cancel_url'] = 'cancel_url'
+      @_hash
+    end
+
+    # An array for optional fields
+    def self.optionals
+      []
+    end
+
+    # An array for nullable fields
+    def self.nullables
+      []
+    end
+
+    def initialize(return_url:, cancel_url:)
+      @return_url = return_url
+      @cancel_url = cancel_url
+    end
+
+    # Creates an instance of the object from a hash.
+    def self.from_hash(hash)
+      return nil unless hash
+
+      # Extract variables from the hash.
+      return_url = hash.key?('return_url') ? hash['return_url'] : nil
+      cancel_url = hash.key?('cancel_url') ? hash['cancel_url'] : nil
+
+      # Create object from extracted values.
+      ApplePayExperienceContext.new(return_url: return_url,
+                                    cancel_url: cancel_url)
+    end
+
+    # Provides a human-readable string representation of the object.
+    def to_s
+      class_name = self.class.name.split('::').last
+      "<#{class_name} return_url: #{@return_url}, cancel_url: #{@cancel_url}>"
+    end
+
+    # Provides a debugging-friendly string with detailed object information.
+    def inspect
+      class_name = self.class.name.split('::').last
+      "<#{class_name} return_url: #{@return_url.inspect}, cancel_url: #{@cancel_url.inspect}>"
+    end
+  end
+end