de.adorsys.ledgers.oba.rest.api.resource

Interface AISApi

public interface AISApi

Field Summary

Fields

Modifier and Type	Field and Description
static String	BASE_PATH

Method Summary

Modifier and Type	Method and Description
org.springframework.http.ResponseEntity<AuthorizeResponse>	aisAuth(String redirectId, String encryptedConsentId)
org.springframework.http.ResponseEntity<ConsentAuthorizeResponse>	aisDone(String encryptedConsentId, String authorisationId, String consentAndaccessTokenCookieString, Boolean forgetConsent, Boolean backToTpp) This call provides the server with the opportunity to close this session and redirect the PSU to the TPP or close the application window.
org.springframework.http.ResponseEntity<ConsentAuthorizeResponse>	authrizedConsent(String encryptedConsentId, String authorisationId, String consentAndaccessTokenCookieString, String authCode) Provides a TAN for the validation of an authorization
org.springframework.http.ResponseEntity<List<de.adorsys.ledgers.middleware.api.domain.account.AccountDetailsTO>>	getListOfAccounts(String accessTokenCookieString) Return the list of accounts linked with the current customer.
org.springframework.http.ResponseEntity<PIISConsentCreateResponse>	grantPiisConsent(String consentAndaccessTokenCookieString, CreatePiisConsentRequestTO piisConsentTO)
org.springframework.http.ResponseEntity<ConsentAuthorizeResponse>	login(String encryptedConsentId, String authorisationId, String login, String pin, String consentCookieString) Identifies the user by login an pin.
org.springframework.http.ResponseEntity<ConsentAuthorizeResponse>	revokeConsent(String encryptedConsentId, String authorisationId, String cookieString) Fails AIS Consent authorisation object by its ID.
org.springframework.http.ResponseEntity<ConsentAuthorizeResponse>	selectMethod(String encryptedConsentId, String authorisationId, String scaMethodId, String consentAndaccessTokenCookieString) Selects the SCA Method for use.
org.springframework.http.ResponseEntity<ConsentAuthorizeResponse>	startConsentAuth(String encryptedConsentId, String authorisationId, String consentAndaccessTokenCookieString, de.adorsys.ledgers.middleware.api.domain.um.AisConsentTO aisConsent) Start the consent process.

Field Detail

BASE_PATH

static final String BASE_PATH

See Also:

Constant Field Values

Method Detail

aisAuth

@GetMapping(path="/auth",
            params={"redirectId","encryptedConsentId"})
org.springframework.http.ResponseEntity<AuthorizeResponse> aisAuth(@RequestParam(name="redirectId")
                                                                                                                                                     String redirectId,
                                                                                                                                                     @RequestParam(name="encryptedConsentId")
                                                                                                                                                     String encryptedConsentId)

login

@PostMapping(path="/{encryptedConsentId}/authorisation/{authorisationId}/login")
org.springframework.http.ResponseEntity<ConsentAuthorizeResponse> login(@PathVariable(value="encryptedConsentId")
                                                                                                                                                         String encryptedConsentId,
                                                                                                                                                         @PathVariable(value="authorisationId")
                                                                                                                                                         String authorisationId,
                                                                                                                                                         @RequestParam(value="login")
                                                                                                                                                         String login,
                                                                                                                                                         @RequestParam(value="pin")
                                                                                                                                                         String pin,
                                                                                                                                                         @RequestHeader(name="Cookie",required=false)
                                                                                                                                                         String consentCookieString)

Identifies the user by login an pin.

The returned object contains:

• A list of accounts

  This is supposed to be used to display the list of accounts to the psu

• An AisConsent object

  This consent is initialized, but might not contain any more information

Parameters:

encryptedConsentId - the encryptedConsentId

authorisationId - the auth id

login - the login

pin - the password

consentCookieString - the cosent cookie

Returns:

ConsentAuthorizeResponse

startConsentAuth

@PostMapping(value="/{encryptedConsentId}/authorisation/{authorisationId}/start")
org.springframework.http.ResponseEntity<ConsentAuthorizeResponse> startConsentAuth(@PathVariable(value="encryptedConsentId")
                                                                                                                                                                     String encryptedConsentId,
                                                                                                                                                                     @PathVariable(value="authorisationId")
                                                                                                                                                                     String authorisationId,
                                                                                                                                                                     @RequestHeader(name="Cookie",required=false)
                                                                                                                                                                     String consentAndaccessTokenCookieString,
                                                                                                                                                                     @RequestBody
                                                                                                                                                                     de.adorsys.ledgers.middleware.api.domain.um.AisConsentTO aisConsent)

Start the consent process. By sending the customer request consent to the core banking.

Parameters:

encryptedConsentId - the encrypted consent id

authorisationId - the authorization id

consentAndaccessTokenCookieString - the consent cookie

aisConsent - the consent request object

Returns:

ConsentAuthorizeResponse

selectMethod

@PostMapping(value="/{encryptedConsentId}/authorisation/{authorisationId}/methods/{scaMethodId}")
org.springframework.http.ResponseEntity<ConsentAuthorizeResponse> selectMethod(@PathVariable(value="encryptedConsentId")
                                                                                                                                                                                 String encryptedConsentId,
                                                                                                                                                                                 @PathVariable(value="authorisationId")
                                                                                                                                                                                 String authorisationId,
                                                                                                                                                                                 @PathVariable(value="scaMethodId")
                                                                                                                                                                                 String scaMethodId,
                                                                                                                                                                                 @RequestHeader(name="Cookie",required=false)
                                                                                                                                                                                 String consentAndaccessTokenCookieString)

Selects the SCA Method for use.

Parameters:

encryptedConsentId - the sca id

authorisationId - the auth id

scaMethodId - sca

consentAndaccessTokenCookieString - the cosent cookie

Returns:

ConsentAuthorizeResponse

authrizedConsent

@PostMapping(path="/{encryptedConsentId}/authorisation/{authorisationId}/authCode",
             params="authCode")
org.springframework.http.ResponseEntity<ConsentAuthorizeResponse> authrizedConsent(@PathVariable(value="encryptedConsentId")
                                                                                                                                                                                                       String encryptedConsentId,
                                                                                                                                                                                                       @PathVariable(value="authorisationId")
                                                                                                                                                                                                       String authorisationId,
                                                                                                                                                                                                       @RequestHeader(name="Cookie",required=false)
                                                                                                                                                                                                       String consentAndaccessTokenCookieString,
                                                                                                                                                                                                       @RequestParam(value="authCode")
                                                                                                                                                                                                       String authCode)

Provides a TAN for the validation of an authorization

Parameters:

encryptedConsentId - the sca id

authorisationId - the auth id

consentAndaccessTokenCookieString - the cosent cookie

authCode - the auth code

Returns:

ConsentAuthorizeResponse

grantPiisConsent

@PostMapping(path="/piis")
org.springframework.http.ResponseEntity<PIISConsentCreateResponse> grantPiisConsent(@RequestHeader(name="Cookie",required=false)
                                                                                                               String consentAndaccessTokenCookieString,
                                                                                                               @RequestBody
                                                                                                               CreatePiisConsentRequestTO piisConsentTO)

getListOfAccounts

@GetMapping(path="/accounts")
org.springframework.http.ResponseEntity<List<de.adorsys.ledgers.middleware.api.domain.account.AccountDetailsTO>> getListOfAccounts(@RequestHeader(name="Cookie",required=false)
                                                                                                                                                                 String accessTokenCookieString)
                                                                                                                                                          throws de.adorsys.ledgers.middleware.rest.exception.ForbiddenRestException

Return the list of accounts linked with the current customer.

Returns:

: the list of accounts linked with the current customer.

Throws:

de.adorsys.ledgers.middleware.rest.exception.ForbiddenRestException

aisDone

@GetMapping(path="/{encryptedConsentId}/authorisation/{authorisationId}/done",
            params={"forgetConsent","backToTpp"})
org.springframework.http.ResponseEntity<ConsentAuthorizeResponse> aisDone(@PathVariable(value="encryptedConsentId")
                                                                                                                                                                                                           String encryptedConsentId,
                                                                                                                                                                                                           @PathVariable(value="authorisationId")
                                                                                                                                                                                                           String authorisationId,
                                                                                                                                                                                                           @RequestHeader(name="Cookie",required=false)
                                                                                                                                                                                                           String consentAndaccessTokenCookieString,
                                                                                                                                                                                                           @RequestParam(name="forgetConsent",required=false)
                                                                                                                                                                                                           Boolean forgetConsent,
                                                                                                                                                                                                           @RequestParam(name="backToTpp",required=false)
                                                                                                                                                                                                           Boolean backToTpp)

This call provides the server with the opportunity to close this session and redirect the PSU to the TPP or close the application window.

In any case, the session of the user will be closed and cookies will be deleted.

Parameters:

encryptedConsentId -

authorisationId -

Returns:

revokeConsent

@DeleteMapping(path="/{encryptedConsentId}/{authorisationId}")
org.springframework.http.ResponseEntity<ConsentAuthorizeResponse> revokeConsent(@PathVariable(value="encryptedConsentId")
                                                                                                                                               String encryptedConsentId,
                                                                                                                                               @PathVariable(value="authorisationId")
                                                                                                                                               String authorisationId,
                                                                                                                                               @RequestHeader(name="Cookie",required=false)
                                                                                                                                               String cookieString)

Fails AIS Consent authorisation object by its ID.

Parameters:

encryptedConsentId - ID of Consent

Returns:

true if consent authorisation was found and failed. false otherwise.