update api caller service

src/main/java/com/ffii/fpsms/api/service/ApiCallerService.kt

@@ -6,9 +6,11 @@ import org.springframework.http.HttpHeaders
 import org.springframework.http.MediaType
 import org.springframework.stereotype.Service
 import org.springframework.util.LinkedMultiValueMap
+import org.springframework.util.MultiValueMap
 import org.springframework.web.reactive.function.client.WebClient
 import org.springframework.web.reactive.function.client.bodyToMono
 import reactor.core.publisher.Mono
+import kotlin.reflect.full.memberProperties
 
 @Service
 open class ApiCallerService(
@@ -16,15 +18,20 @@ open class ApiCallerService(
     private val m18Config: M18Config
 ) {
 
-    private val webClient: WebClient = WebClient.builder()
+    val webClient: WebClient = WebClient.builder()
         .baseUrl(baseUrl)
         .defaultHeaders { headers ->
             headers.set(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
             headers.set(HttpHeaders.AUTHORIZATION, "Bearer ${m18Config.ACCESS_TOKEN}")
+            headers.set("client_id", m18Config.CLIENT_ID)
         }
         .build()
 
-    fun get(urlPath: String, params: Map<String, String>?, customHeaders: Map<String, String>?): Mono<String> {
+    inline fun <reified T : Any> get(
+        urlPath: String,
+        params: MultiValueMap<String, String>,
+        customHeaders: Map<String, String>?
+    ): Mono<T> {
 
         return webClient.get()
             .uri { uriBuilder ->
@@ -33,15 +40,7 @@ open class ApiCallerService(
                         path(urlPath)
 
                         // convert to multiValueMap
-                        params?.let { params ->
-                            queryParams(
-                                LinkedMultiValueMap<String, String>().apply {
-                                    params.forEach { (key, values) ->
-                                        add(key, values)
-                                    }
-                                }
-                            )
-                        }
+                        queryParams(params)
                     }
                     .build()
             }
@@ -49,6 +48,51 @@ open class ApiCallerService(
                 customHeaders?.forEach { (k, v) -> headers.set(k, v) }
             }
             .retrieve()
-            .bodyToMono(String::class.java)
+            .bodyToMono(T::class.java)
+    }
+
+    inline fun <reified T : Any> get(
+        urlPath: String,
+        params: Map<String, Any>?,
+        customHeaders: Map<String, String>?
+    ): Mono<T> {
+
+        // convert to multiValueMap<String, String>
+        val queryParams = params?.let { paramMap ->
+            LinkedMultiValueMap<String, String>().apply {
+                paramMap.forEach { (key, value) ->
+                    when (value) {
+                        is Collection<*> -> addAll(key, value.map { it.toString() })
+                        else -> add(key, value.toString())
+                    }
+                }
+            }
+        } ?: LinkedMultiValueMap<String, String>()
+
+        return get<T>(urlPath, queryParams, customHeaders)
+    }
+
+    // T: Response, U: Request
+    inline fun <reified T : Any, reified U : Any> get(
+        urlPath: String,
+        params: U?,
+        customHeaders: Map<String, String>?
+    ): Mono<T> {
+
+        // convert to multiValueMap<String, String>
+        val queryParams = params?.let {
+            LinkedMultiValueMap<String, String>().apply {
+                U::class.memberProperties.forEach { property ->
+                    val key = property.name
+                    val value = property.get(params)
+                    when (value) {
+                        is Collection<*> -> value.forEach { item -> add(key, item.toString()) }
+                        else -> add(key, value.toString())
+                    }
+                }
+            }
+        } ?: LinkedMultiValueMap<String, String>()
+
+        return get<T>(urlPath, queryParams, customHeaders)
     }
 }

src/main/java/com/ffii/fpsms/m18/modals/TokenRequest.kt → src/main/java/com/ffii/fpsms/m18/modals/M18TokenRequest.kt

@@ -1,6 +1,6 @@
 package com.ffii.fpsms.m18.modals
 
-data class TokenRequest(
+data class M18TokenRequest(
     val grant_type: String,
     val client_id: String,
     val client_secret: String,

src/main/java/com/ffii/fpsms/m18/modals/TokenResponse.kt → src/main/java/com/ffii/fpsms/m18/modals/M18TokenResponse.kt

@@ -1,6 +1,6 @@
 package com.ffii.fpsms.m18.modals
 
-data class TokenResponse(
+data class M18TokenResponse(
     val access_token: String,
     val refresh_token: String,
     val uid: Long,

src/main/java/com/ffii/fpsms/m18/service/M18TokenService.kt

@@ -2,33 +2,45 @@ package com.ffii.fpsms.m18.service
 
 import com.ffii.fpsms.api.service.ApiCallerService
 import com.ffii.fpsms.m18.M18Config
+import com.ffii.fpsms.m18.modals.M18TokenRequest
+import com.ffii.fpsms.m18.modals.M18TokenResponse
+import jakarta.annotation.PostConstruct
 import org.springframework.context.annotation.Bean
 import org.springframework.stereotype.Component
 import org.springframework.stereotype.Service
 
 
 @Service
-@Component
 open class M18TokenService(
     private val apiCallerService: ApiCallerService,
     private val m18Config: M18Config
 ) {
 
-    @Bean
+    @PostConstruct
      fun run() {
-        println("abcdasds")
-        val params: MutableMap<String, String> = mutableMapOf(
-            "grant_type" to m18Config.GRANT_TYPE,
-            "client_id" to m18Config.CLIENT_ID,
-            "client_secret" to m18Config.CLIENT_SECRET,
-            "username" to m18Config.USERNAME,
-            "password" to m18Config.PASSWORD
+//        val params: MutableMap<String, String> = mutableMapOf(
+//            "grant_type" to m18Config.GRANT_TYPE,
+//            "client_id" to m18Config.CLIENT_ID,
+//            "client_secret" to m18Config.CLIENT_SECRET,
+//            "username" to m18Config.USERNAME,
+//            "password" to m18Config.PASSWORD
+//        )
+//
+        val params = M18TokenRequest(
+            grant_type = m18Config.GRANT_TYPE,
+            client_id = m18Config.CLIENT_ID,
+            client_secret = m18Config.CLIENT_SECRET,
+            username = m18Config.USERNAME,
+            password = m18Config.PASSWORD
         )
 
         apiCallerService
-            .get("/oauth/token", params, null)
+            .get<M18TokenResponse, M18TokenRequest>("/oauth/token", params, null)
             .subscribe(
-                { response -> println("WebClient Response stored: $response") },
+                { response ->
+                    m18Config.ACCESS_TOKEN = response.access_token
+                    println("WebClient Response stored: $response")
+                },
                 { error -> println("WebClient Error: ${error.message}") }
             )
     }