SaFi Bank Space : How to create sync endpoints in slacker manager service

The Slacker service is a bridge between SaFi microservices and the risk engine. This page describes its features providing synchronous operations for the microservices.

1: Create service configuration file

Add below configuration file in application.yml file. it includes the topics which should listen and publish messages to. this is the risk engine service url(https://slacker-transaction-intrabank-sync-6dp53idjvq-ew.a.run.app) which can help to check the transactions.

slacker-manager:
  pub-sub:
    enabled: true
    topics:
      dlq-command: slacker-manager-dlq-commands
    subscriptions:
      command: slacker-manager-commands-sub-dev
      dlq-command: slacker-manager-dlq-commands-sub-dev
  rest:
    endpoint:
      transaction:
        - 'https://slacker-transaction-intrabank-sync-6dp53idjvq-ew.a.run.app'

Create configuration entity object in package ph.safibank.slackermanager.property,this is map of the configuration file. then you can get the value from this entity class. e.g. slackerManagerConfiguration.pubSub.subscriptions.command will be slacker-manager-commands-sub-dev

@ConfigurationProperties("slacker-manager")
class SlackerManagerConfiguration {
    @Inject
    lateinit var pubSub: PubSub

    @ConfigurationProperties("pub-sub")
    class PubSub {
        lateinit var enabled: String

        @Inject
        lateinit var topics: Topics

        @ConfigurationProperties("topics")
        class Topics {
            @Property(name = "dlq-command")
            lateinit var dlqCommand: String
        }

        @Inject
        lateinit var subscriptions: Subscriptions

        @ConfigurationProperties("subscriptions")
        class Subscriptions {
            lateinit var command: String

            @Property(name = "dlq-command")
            lateinit var dlqCommand: String
        }
    }

    @Inject
    lateinit var rest: Rest

    @ConfigurationProperties("rest.endpoint")
    class Rest {
        lateinit var transaction: Array<String>
    }
}

2: Create an entity object in model package to define the business logic.

@Introspected
@Schema(name = "TransactionDetailsDto")
data class TransactionDetailsDto(
    @field:Schema(description = "Transaction ID.")
    @NotBlank val transactionId: UUID,

    @field:Schema(description = "Account ID.")
    @NotBlank val accountId: UUID
    ......
)

Entity object defines all fields you need, please add the constraint for each filed e.g. @NotBlack, @Email you can find these annotations in package javax.validation.constraints.* . Above annotations can help you to validate the user input and make sure all fields are in correct format.

3: After defining the entity, create a controller class to handle the request e.g.

@Controller("/slacker/transaction")
@Tag(name = "Transaction")
class TransactionController(private val transactionService: TransactionService) {

    private val log = getLogger()

    @Post(uri = "/validate", produces = ["application/json"])
    @ApiResponses(
        ApiResponse(
            responseCode = "200", description = "Transaction status",
            content = [
                Content(
                    mediaType = "application/json",
                    schema = Schema(implementation = TransactionStatusDto::class)
                )
            ]
        ),
        ApiResponse(
            responseCode = "400",
            description = "Bad request when at least one of parameters is missing, or any parameter is out of constrains."
        ),
        ApiResponse(responseCode = "401", description = "Unauthorized"),
        ApiResponse(responseCode = "5XX", description = "Unexpected Error")
    )
    suspend fun validateTransaction(@Body @Valid transactionDetailsDto: TransactionDetailsDto): HttpResponse<TransactionStatusDto> {
       ...... To Do
    }
}

The @Controller annotation defines the class as a controller mapped to the path /slacker/transaction, if the request url end with /slacker/transaction if will handle by the class.

By default, a controller action consumes request with Content-Type of type application/json. if add @Post annotation above the method, it only response which the http method is POST

4: Create a service to handle the request dto object.

e.g. below code will check the request body whether the transaction is validate and exist in database.

transactionService.validateTransaction(transactionDetailsDto)

5: Create a rest service to call risk engine service(GCP Cloud Function) or Safibank service

Risk engine service is deployed on GCP cloud, it provides a lot of services that help to check the transaction or other requests. We use reactive api which depends on Kotlin coroutines to implement. For querying the risk engine services, firstly, we need to acquire a GCP auth token. After that, set http authorization header with this token. And then we can access the risk engine services.

  override suspend fun <I : BaseDto, O : BaseDto> reactivePost(functionUrl: String, requestBody: I, responseType: Class<O>): O {
        val token = getAuthToken(functionUrl)
        log.info("Initializing POST request to $functionUrl")

        val response = httpClient.retrieve(
            HttpRequest.POST(functionUrl, requestBody)
                .header("Authorization", "Bearer $token")
                .contentType(MediaType.APPLICATION_JSON_TYPE),
            Argument.of(responseType)
        ).awaitFirst()

        log.info("Finalised POST request")
        return response
    }

SaFi Bank Space : How to create sync endpoints in slacker manager service

Attachments: