Add gateway localization support

api/api-core/src/main/kotlin/co/nilin/opex/api/core/inout/GatewayLocalizationCommand.kt

@@ -0,0 +1,13 @@
+package co.nilin.opex.api.core.inout
+
+
+data class GatewayLocalizationCommand(
+    var id: Long? = null,
+    var depositDescription: String? = null,
+    var withdrawDescription: String? = null,
+    var language: String
+)
+
+
+
+

api/api-core/src/main/kotlin/co/nilin/opex/api/core/inout/GatewayLocalizationResponse.kt

@@ -0,0 +1,6 @@
+package co.nilin.opex.api.core.inout
+
+data class GatewayLocalizationResponse(
+    val gatewayUuid: String,
+    val localizations: List<GatewayLocalizationCommand>
+)

api/api-core/src/main/kotlin/co/nilin/opex/api/core/inout/TerminalCommand.kt

@@ -2,12 +2,12 @@ package co.nilin.opex.api.core.inout
 
 data class  TerminalCommand(
     var uuid: String?,
-    var owner: String,
+    var owner: String?=null,
     var identifier: String,
     var active: Boolean? = true,
     var type: TransferMethod,
     var metaData: String,
-    var description : String?,
+    var description : String?=null,
     var displayOrder: Int? = null,
 
 )

api/api-core/src/main/kotlin/co/nilin/opex/api/core/spi/BlockchainGatewayProxy.kt

@@ -4,11 +4,21 @@ import co.nilin.opex.api.core.inout.AssignAddressRequest
 import co.nilin.opex.api.core.inout.AssignResponse
 import co.nilin.opex.api.core.inout.ChainInfo
 import co.nilin.opex.api.core.inout.DepositDetails
+import co.nilin.opex.api.core.inout.GatewayLocalizationCommand
+import co.nilin.opex.api.core.inout.GatewayLocalizationResponse
 
 interface BlockchainGatewayProxy {
 
     suspend fun assignAddress(assignAddressRequest: AssignAddressRequest): AssignResponse?
     suspend fun getDepositDetails(refs: List<String>): List<DepositDetails>
     suspend fun getChainInfo(): List<ChainInfo>
 
+    suspend fun getOnChainGatewayLocalizations(token: String, gatewayUuid: String): GatewayLocalizationResponse
+    suspend fun saveOnChainGatewayLocalizations(
+        token: String,
+        gatewayUuid: String,
+        gatewayLocalizations: List<GatewayLocalizationCommand>
+    ): GatewayLocalizationResponse
+
+    suspend fun deleteOnChainGatewayLocalization(token: String, id: Long)
 }

api/api-core/src/main/kotlin/co/nilin/opex/api/core/spi/WalletProxy.kt

@@ -227,4 +227,39 @@ interface WalletProxy {
     ): TerminalLocalizationResponse
 
     suspend fun deleteTerminalLocalization(token: String, id: Long)
+
+    suspend fun getOffChainGatewayLocalizations(token: String, gatewayUuid: String): GatewayLocalizationResponse
+    suspend fun saveOffChainGatewayLocalizations(
+        token: String,
+        gatewayUuid: String,
+        gatewayLocalizations: List<GatewayLocalizationCommand>
+    ): GatewayLocalizationResponse
+
+    suspend fun deleteOffChainGatewayLocalization(token: String, id: Long)
+    suspend fun saveTerminal(token: String, terminal: TerminalCommand): TerminalCommand?
+    suspend fun updateTerminal(token: String, terminalUuid: String, terminal: TerminalCommand): TerminalCommand?
+    suspend fun deleteTerminal(token: String, terminalUuid: String)
+    suspend fun getTerminals(token: String): List<TerminalCommand>?
+    suspend fun getTerminal(token: String, terminalUuid: String): TerminalCommand?
+    suspend fun getAssignedGatewayToTerminal(token: String, terminalUuid: String): List<CurrencyGatewayCommand>?
+    suspend fun assignTerminalsToGateway(token: String, gatewayUuid: String, terminal: List<String>)
+    suspend fun revokeTerminalsToGateway(token: String, gatewayUuid: String, terminal: List<String>)
+    suspend fun addCurrencyToGateway(
+        token: String,
+        currencySymbol: String,
+        gatewayCommand: CurrencyGatewayCommand
+    ): CurrencyGatewayCommand?
+
+    suspend fun updateGateway(
+        token: String,
+        gatewayUuid: String,
+        currencySymbol: String,
+        gatewayCommand: CurrencyGatewayCommand
+    ): CurrencyGatewayCommand?
+
+    suspend fun getGateway(token: String, gatewayUuid: String, currencySymbol: String): CurrencyGatewayCommand?
+
+    suspend fun deleteGateway(token: String, gatewayUuid: String, currencySymbol: String)
+
+
 }

api/api-ports/api-opex-rest/src/main/kotlin/co/nilin/opex/api/ports/opex/controller/GatewayAdminController.kt

@@ -0,0 +1,63 @@
+package co.nilin.opex.api.ports.opex.controller
+
+import co.nilin.opex.api.core.inout.CurrencyGatewayCommand
+import co.nilin.opex.api.core.spi.WalletProxy
+import co.nilin.opex.api.ports.opex.util.jwtAuthentication
+import co.nilin.opex.api.ports.opex.util.tokenValue
+import org.springframework.security.core.annotation.CurrentSecurityContext
+import org.springframework.security.core.context.SecurityContext
+import org.springframework.web.bind.annotation.*
+
+@RestController
+@RequestMapping("/opex/v1/admin")
+class GatewayAdminController(
+    private val walletProxy: WalletProxy,
+) {
+    @PostMapping("/{currencySymbol}/gateway")
+    suspend fun addCurrencyToGateway(
+        @CurrentSecurityContext securityContext: SecurityContext,
+        @PathVariable("currencySymbol") currencySymbol: String,
+        @RequestBody body: CurrencyGatewayCommand,
+    ): CurrencyGatewayCommand? {
+        return walletProxy.addCurrencyToGateway(securityContext.jwtAuthentication().tokenValue(), currencySymbol, body)
+    }
+
+
+    @PutMapping("/{currencySymbol}/gateway/{uuid}")
+    suspend fun updateGateway(
+        @CurrentSecurityContext securityContext: SecurityContext,
+        @PathVariable("uuid") gatewayUuid: String,
+        @PathVariable("currencySymbol") currencySymbol: String,
+        @RequestBody body: CurrencyGatewayCommand
+    ): CurrencyGatewayCommand? {
+        return walletProxy.updateGateway(
+            securityContext.jwtAuthentication().tokenValue(),
+            gatewayUuid,
+            currencySymbol,
+            body
+        )
+    }
+
+    @GetMapping("/{currencySymbol}/gateway/{uuid}")
+    suspend fun getGateway(
+        @CurrentSecurityContext securityContext: SecurityContext,
+        @PathVariable("uuid") gatewayUuid: String,
+        @PathVariable("currencySymbol") currencySymbol: String,
+    ): CurrencyGatewayCommand? {
+        return walletProxy.getGateway(
+            securityContext.jwtAuthentication().tokenValue(),
+            gatewayUuid,
+            currencySymbol
+        )
+    }
+
+    @DeleteMapping("/{currencySymbol}/gateway/{uuid}")
+    suspend fun deleteGateway(
+        @CurrentSecurityContext securityContext: SecurityContext,
+        @PathVariable("uuid") gatewayUuid: String,
+        @PathVariable("currencySymbol") currencySymbol: String,
+    ) {
+        walletProxy.deleteGateway(securityContext.jwtAuthentication().tokenValue(), gatewayUuid, currencySymbol)
+    }
+
+}

api/api-ports/api-opex-rest/src/main/kotlin/co/nilin/opex/api/ports/opex/controller/LocalizationAdminController.kt

@@ -1,12 +1,11 @@
 package co.nilin.opex.api.ports.opex.controller
 
-import co.nilin.opex.api.core.inout.CurrencyLocalizationCommand
-import co.nilin.opex.api.core.inout.CurrencyLocalizationResponse
-import co.nilin.opex.api.core.inout.TerminalLocalizationCommand
-import co.nilin.opex.api.core.inout.TerminalLocalizationResponse
+import co.nilin.opex.api.core.inout.*
+import co.nilin.opex.api.core.spi.BlockchainGatewayProxy
 import co.nilin.opex.api.core.spi.WalletProxy
 import co.nilin.opex.api.ports.opex.util.jwtAuthentication
 import co.nilin.opex.api.ports.opex.util.tokenValue
+import co.nilin.opex.common.OpexError
 import org.springframework.security.core.annotation.CurrentSecurityContext
 import org.springframework.security.core.context.SecurityContext
 import org.springframework.web.bind.annotation.*
@@ -15,6 +14,7 @@ import org.springframework.web.bind.annotation.*
 @RequestMapping("/opex/v1/admin")
 class LocalizationAdminController(
     private val walletProxy: WalletProxy,
+    private val blockchainGatewayProxy: BlockchainGatewayProxy
 ) {
     @GetMapping("/currency/{currency}/localization")
     suspend fun getCurrencyLocalizations(
@@ -73,4 +73,61 @@ class LocalizationAdminController(
     ) {
         walletProxy.deleteTerminalLocalization(securityContext.jwtAuthentication().tokenValue(), id)
     }
+
+    @GetMapping("/gateway/{gatewayUuid}/localization")
+    suspend fun getGatewayLocalization(
+        @CurrentSecurityContext securityContext: SecurityContext,
+        @PathVariable("gatewayUuid") gatewayUuid: String
+    ): GatewayLocalizationResponse {
+        return if (gatewayUuid.startsWith("ofg")) {
+            walletProxy.getOffChainGatewayLocalizations(
+                securityContext.jwtAuthentication().tokenValue(),
+                gatewayUuid
+            )
+        } else if (gatewayUuid.startsWith("ong")) {
+            blockchainGatewayProxy.getOnChainGatewayLocalizations(
+                securityContext.jwtAuthentication().tokenValue(), gatewayUuid
+            )
+        } else throw OpexError.GatewayNotFount.exception()
+    }
+
+    @PostMapping("/gateway/{gatewayUuid}/localization")
+    suspend fun saveGatewayLocalizations(
+        @CurrentSecurityContext securityContext: SecurityContext,
+        @PathVariable("gatewayUuid") gatewayUuid: String,
+        @RequestBody gatewayLocalizations: List<GatewayLocalizationCommand>
+    ): GatewayLocalizationResponse {
+        return if (gatewayUuid.startsWith("ofg")) {
+            walletProxy.saveOffChainGatewayLocalizations(
+                securityContext.jwtAuthentication().tokenValue(),
+                gatewayUuid,
+                gatewayLocalizations
+            )
+        } else if (gatewayUuid.startsWith("ong")) {
+            blockchainGatewayProxy.saveOnChainGatewayLocalizations(
+                securityContext.jwtAuthentication().tokenValue(),
+                gatewayUuid,
+                gatewayLocalizations
+            )
+        } else throw OpexError.GatewayNotFount.exception()
+    }
+
+    @DeleteMapping("/gateway/{gatewayUuid}/localization/{id}")
+    suspend fun deleteGatewayLocalization(
+        @CurrentSecurityContext securityContext: SecurityContext,
+        @PathVariable("id") id: Long,
+        @PathVariable("gatewayUuid") gatewayUuid: String
+    ) {
+        return if (gatewayUuid.startsWith("ofg")) {
+            walletProxy.deleteOffChainGatewayLocalization(
+                securityContext.jwtAuthentication().tokenValue(),
+                id
+            )
+        } else if (gatewayUuid.startsWith("ong")) {
+            blockchainGatewayProxy.deleteOnChainGatewayLocalization(
+                securityContext.jwtAuthentication().tokenValue(),
+                id
+            )
+        } else throw OpexError.GatewayNotFount.exception()
+    }
 }

api/api-ports/api-opex-rest/src/main/kotlin/co/nilin/opex/api/ports/opex/controller/TerminalAdminController.kt

@@ -0,0 +1,91 @@
+package co.nilin.opex.api.ports.opex.controller
+
+import co.nilin.opex.api.core.inout.CurrencyGatewayCommand
+import co.nilin.opex.api.core.inout.TerminalCommand
+import co.nilin.opex.api.core.spi.WalletProxy
+import co.nilin.opex.api.ports.opex.util.jwtAuthentication
+import co.nilin.opex.api.ports.opex.util.tokenValue
+import org.springframework.security.core.annotation.CurrentSecurityContext
+import org.springframework.security.core.context.SecurityContext
+import org.springframework.web.bind.annotation.*
+
+@RestController
+@RequestMapping("/opex/v1/admin/terminal")
+class TerminalAdminController(
+    private val walletProxy: WalletProxy,
+) {
+    @PostMapping
+    suspend fun registerTerminal(
+        @CurrentSecurityContext securityContext: SecurityContext, @RequestBody body: TerminalCommand
+    ): TerminalCommand? {
+        return walletProxy.saveTerminal(securityContext.jwtAuthentication().tokenValue(), body)
+    }
+
+
+    @PutMapping("/{uuid}")
+    suspend fun updateTerminal(
+        @CurrentSecurityContext securityContext: SecurityContext,
+        @PathVariable("uuid") terminalUuid: String,
+        @RequestBody body: TerminalCommand
+    ): TerminalCommand? {
+        return walletProxy.updateTerminal(securityContext.jwtAuthentication().tokenValue(), terminalUuid, body)
+    }
+
+    @DeleteMapping("/{uuid}")
+    suspend fun deleteTerminal(
+        @CurrentSecurityContext securityContext: SecurityContext,
+        @PathVariable("uuid") terminalUuid: String,
+    ) {
+        walletProxy.deleteTerminal(securityContext.jwtAuthentication().tokenValue(), terminalUuid)
+    }
+
+    @GetMapping
+    suspend fun getTerminal(
+        @CurrentSecurityContext securityContext: SecurityContext,
+    ): List<TerminalCommand>? {
+        return walletProxy.getTerminals(securityContext.jwtAuthentication().tokenValue())
+    }
+
+    @GetMapping("/{uuid}")
+    suspend fun getTerminal(
+        @CurrentSecurityContext securityContext: SecurityContext,
+        @PathVariable("uuid") terminalUuid: String,
+    ): TerminalCommand? {
+        return walletProxy.getTerminal(securityContext.jwtAuthentication().tokenValue(), terminalUuid)
+    }
+
+    @GetMapping("/{uuid}/gateway")
+    suspend fun getGatewayTerminal(
+        @CurrentSecurityContext securityContext: SecurityContext,
+        @PathVariable("uuid") terminalUuid: String,
+    ): List<CurrencyGatewayCommand>? {
+        return walletProxy.getAssignedGatewayToTerminal(securityContext.jwtAuthentication().tokenValue(), terminalUuid)
+    }
+
+    @PostMapping("/gateway/{uuid}")
+    suspend fun assignTerminalToGateway(
+        @CurrentSecurityContext securityContext: SecurityContext,
+        @PathVariable("uuid") gatewayUuid: String,
+        @RequestBody terminal: List<String>,
+    ) {
+        return walletProxy.assignTerminalsToGateway(
+            securityContext.jwtAuthentication().tokenValue(),
+            gatewayUuid,
+            terminal
+        )
+    }
+
+    @DeleteMapping("/gateway/{uuid}")
+    suspend fun revokeTerminalFromGateway(
+        @CurrentSecurityContext securityContext: SecurityContext,
+        @PathVariable("uuid") gatewayUuid: String,
+        @RequestBody terminal: List<String>,
+    ) {
+        return walletProxy.revokeTerminalsToGateway(
+            securityContext.jwtAuthentication().tokenValue(),
+            gatewayUuid,
+            terminal
+        )
+    }
+
+}