Authentication by api key in synchronization

idea-plugin/src/main/kotlin/fr/enedis/chutney/idea/settings/AuthMethodEnum.kt

@@ -0,0 +1,14 @@
+/*
+ * SPDX-FileCopyrightText: 2017-2026 Enedis
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ */
+
+package fr.enedis.chutney.idea.settings
+
+enum class AuthMethodEnum {
+  BASIC,
+  BEARER,
+  API_KEY
+}

idea-plugin/src/main/kotlin/fr/enedis/chutney/idea/settings/ChutneySettings.kt

@@ -24,7 +24,7 @@ class ChutneySettings : PersistentStateComponent<ChutneySettings.ChutneySettings
 
     class ChutneySettingsState(
       var url: String = "",
-      var basicAuth: Boolean = true,
+      var auth: AuthMethodEnum,
       var user: String? = "",
       var password: String? = "",
       var token: String? = "",
@@ -37,8 +37,11 @@ class ChutneySettings : PersistentStateComponent<ChutneySettings.ChutneySettings
                 return try {
                     ChutneyServerInfo(
                         url = url,
-                      if(basicAuth) AuthMethod.Basic(user.orEmpty(), password.orEmpty())
-                        else AuthMethod.Bearer(token.orEmpty()),
+                        when(auth) {
+                          AuthMethodEnum.BASIC -> AuthMethod.Basic(user.orEmpty(), password.orEmpty())
+                          AuthMethodEnum.BEARER -> AuthMethod.Bearer(token.orEmpty())
+                          AuthMethodEnum.API_KEY -> AuthMethod.ApiKey(token.orEmpty())
+                        },
                         proxyUrl = proxyUrl.takeIf { ! it.isNullOrBlank() },
                         proxyUser = proxyUser.takeIf { ! it.isNullOrBlank() },
                         proxyPassword = proxyPassword.takeIf { ! it.isNullOrBlank() }

idea-plugin/src/main/kotlin/fr/enedis/chutney/idea/settings/ChutneySettingsConfigurable.kt

@@ -43,7 +43,8 @@ class ChutneySettingsConfigurable :
 
     val authModeLabel: JLabel = JLabel("Authentication mode")
     val basicAuthButton = JBRadioButton("Basic")
-    val tokenAuthButton = JBRadioButton("Token")
+    val bearerAuthButton = JBRadioButton("Bearer")
+    val apiKeyAuthButton = JBRadioButton("API Key")
     val authButtonsGroup = ButtonGroup()
 
     val chutneySettings: ChutneySettings = ChutneySettings.getInstance()
@@ -88,7 +89,8 @@ class ChutneySettingsConfigurable :
 
   private fun stateFromFields() = ChutneySettings.ChutneySettingsState(
         url = url.text,
-        basicAuth = basicAuthButton.isSelected,
+        auth = if(basicAuthButton.isSelected) AuthMethodEnum.BASIC
+        else if(bearerAuthButton.isSelected) AuthMethodEnum.BEARER else AuthMethodEnum.API_KEY ,
         user = user.text,
         password = String(password.password),
         token = token.text,
@@ -100,16 +102,21 @@ class ChutneySettingsConfigurable :
     private fun initFields() {
         val serverInfo = chutneySettings.state.serverInfo()
         url.text = serverInfo?.url
-        basicAuthButton.isSelected = chutneySettings.state.basicAuth == true
-        tokenAuthButton.isSelected = chutneySettings.state.basicAuth == false
+        basicAuthButton.isSelected = chutneySettings.state.auth == AuthMethodEnum.BASIC
+        bearerAuthButton.isSelected = chutneySettings.state.auth == AuthMethodEnum.BEARER
+        apiKeyAuthButton.isSelected = chutneySettings.state.auth == AuthMethodEnum.API_KEY
         user.text = if(serverInfo?.auth is AuthMethod.Basic) (serverInfo.auth as AuthMethod.Basic).user else ""
         password.text = if(serverInfo?.auth is AuthMethod.Basic) (serverInfo.auth as AuthMethod.Basic).password else ""
-        token.text = if(serverInfo?.auth is AuthMethod.Bearer) (serverInfo.auth as AuthMethod.Bearer).token else ""
+        if(serverInfo?.auth is AuthMethod.Bearer) {
+          token.text = (serverInfo.auth as AuthMethod.Bearer).token
+        } else if(serverInfo?.auth is AuthMethod.ApiKey) {
+          token.text = (serverInfo.auth as AuthMethod.ApiKey).token
+        }
         proxyUrl.text = serverInfo?.proxyUrl
         proxyUser.text = serverInfo?.proxyUser
         proxyPassword.text = serverInfo?.proxyPassword
 
-        updateAuthFields(isBasic = basicAuthButton.isSelected, isToken = tokenAuthButton.isSelected)
+        updateAuthFields(isBasic = basicAuthButton.isSelected, isToken = bearerAuthButton.isSelected || apiKeyAuthButton.isSelected)
     }
 
     override fun createComponent(): JComponent {
@@ -123,7 +130,8 @@ class ChutneySettingsConfigurable :
                 val serverInfo = ChutneyServerInfo(
                     url.text,
                   if(basicAuthButton.isSelected) AuthMethod.Basic(user.text, String(password.password))
-                    else AuthMethod.Bearer(token.text),
+                    else if(bearerAuthButton.isSelected) AuthMethod.Bearer(token.text)
+                  else AuthMethod.ApiKey(token.text),
                     proxyUrl.text.ifBlank { null },
                     proxyUser.text.ifBlank { null },
                     String(proxyPassword.password).ifBlank { null }
@@ -139,11 +147,13 @@ class ChutneySettingsConfigurable :
         }
 
         authButtonsGroup.add(basicAuthButton)
-        authButtonsGroup.add(tokenAuthButton)
+        authButtonsGroup.add(bearerAuthButton)
+        authButtonsGroup.add(apiKeyAuthButton)
 
         val authButtonsPanel = JPanel(BorderLayout())
         authButtonsPanel.add(basicAuthButton, BorderLayout.WEST)
-        authButtonsPanel.add(tokenAuthButton, BorderLayout.CENTER)
+        authButtonsPanel.add(bearerAuthButton, BorderLayout.CENTER)
+        authButtonsPanel.add(apiKeyAuthButton, BorderLayout.EAST)
 
         val myWrapper = JPanel(BorderLayout())
         val centerPanel =
@@ -164,7 +174,8 @@ class ChutneySettingsConfigurable :
                         .panel
 
         basicAuthButton.addActionListener { basicButtonSelected() }
-        tokenAuthButton.addActionListener { tokenButtonSelected() }
+        bearerAuthButton.addActionListener { tokenButtonSelected() }
+        apiKeyAuthButton.addActionListener { tokenButtonSelected() }
 
         myWrapper.add(centerPanel, BorderLayout.NORTH)
         return myWrapper

kotlin-dsl/src/main/kotlin/fr/enedis/chutney/kotlin/authentication/AuthMethod.kt

@@ -13,4 +13,6 @@ sealed interface AuthMethod {
                      val password: String): AuthMethod
 
     data class Bearer(val token: String): AuthMethod
+
+    data class ApiKey(val token: String): AuthMethod
 }

kotlin-dsl/src/main/kotlin/fr/enedis/chutney/kotlin/util/ChutneyServerInfo.kt

@@ -70,6 +70,7 @@ data class ChutneyServerInfo(
 
     fun isBasicAuth(): Boolean = auth is AuthMethod.Basic
     fun isTokenAuth(): Boolean = auth is AuthMethod.Bearer
+    fun isApiKeyAuth(): Boolean = auth is AuthMethod.ApiKey
 }
 
 private enum class ProxyProtocol { http, https }

kotlin-dsl/src/main/kotlin/fr/enedis/chutney/kotlin/util/HttpClient.kt

@@ -159,6 +159,9 @@ object HttpClient {
         if(serverInfo.isTokenAuth()) {
             httpRequest.addHeader("Authorization", "Bearer " + (serverInfo.auth as AuthMethod.Bearer).token)
         }
+        if(serverInfo.isApiKeyAuth()) {
+            httpRequest.addHeader("X-API-KEY", (serverInfo.auth as AuthMethod.ApiKey).token)
+        }
 
         return httpRequest
     }