API 직렬화 라이브러리를 Kotlin Serialization으로 통합 (#729)

* refactor: AcademicEvent API 수정

- DefaultResponse를 적용

* refactor: Department API 수정

- DefaultResponse를 적용
- Gson에서 Kotlin Serialization으로 마이그레이션

* refactor: Notice API 수정

- DefaultResponse를 적용
- Gson에서 Kotlin Serialization으로 마이그레이션

* refactor: User API 수정

- DefaultResponse 타입을 Nothing에서 Unit으로 변경
- Gson에서 Kotlin Serialization으로 마이그레이션

* refactor: NoticeComment API 수정

- DefaultResponse 타입을 Nothing에서 Unit으로 변경

* refactor: Report API 수정

- DefaultResponse 타입을 Nothing에서 Unit으로 변경

* refactor: Staff API 수정

- DefaultResponse를 적용
- Gson에서 Kotlin Serialization으로 마이그레이션

* refactor: Verification API 수정

- DefaultResponse 타입을 Nothing에서 Unit으로 변경
- Gson에서 Kotlin Serialization으로 마이그레이션

* refactor: Library API 수정

- Gson에서 Kotlin Serialization으로 마이그레이션

* refactor: AppVersion API 수정

- Gson에서 Kotlin Serialization으로 마이그레이션

* refactor: Gson 제거 및 NetworkModule 리팩토링

* refactor: Retrofit에 Qualifier 적용

* chore: 테스트 json 파일 수정

* chore: 잔여 Gson 코드를 정리

* fix: 테스트코드 수정

* fix: 리뷰 반영

* chore: 응답 클래스 필드에 SerialName 추가

* test: API 테스트 코드 추가

- 동아리 목록 및 동아리 정보
- 학과 목록
- 깃허브에 저장된 앱 최소 스펙
- 교수 목록
- 로그인 응답

* fix: 검색 응답 필드에 방어값 추가

Author: boiledeggg

build-logic/src/main/kotlin/com/ku_stacks/ku_ring/buildlogic/primitive/RetrofitPlugin.kt

@@ -13,7 +13,6 @@ class RetrofitPlugin: Plugin<Project> {
         dependencies {
             implementationPlatform(libs.library("retrofit-bom"))
             implementation(libs.library("retrofit"))
-            implementation(libs.library("retrofit-converter-gson"))
             implementation(libs.library("retrofit-converter-kotlinx-serialization"))
         }
     }

data/academicevent/src/main/java/com/ku_stacks/ku_ring/academicevent/repository/AcademicEventRepositoryImpl.kt

@@ -26,8 +26,9 @@ class AcademicEventRepositoryImpl @Inject constructor(
         endDate: String?,
     ): Result<Unit> = suspendRunCatching {
         val response = academicEventClient.fetchAcademicEvents(startDate, endDate)
-        val eventEntities = response.data.toEntity()
-        insertAcademicEventsIntoDB(eventEntities)
+        if (response.isSuccessAndDataExists) {
+            insertAcademicEventsIntoDB(response.data!!.toEntity())
+        }
     }
 
     private suspend fun insertAcademicEventsIntoDB(eventEntities: List<AcademicEventEntity>) =

data/academicevent/src/test/java/com/ku_stacks/ku_ring/academicevent/AcademicEventTestUtil.kt

@@ -1,12 +1,12 @@
 package com.ku_stacks.ku_ring.academicevent
 
-import com.ku_stacks.ku_ring.remote.academicevent.response.AcademicEventListResponse
 import com.ku_stacks.ku_ring.remote.academicevent.response.AcademicEventResponse
+import com.ku_stacks.ku_ring.remote.util.DefaultResponse
 
 object AcademicEventTestUtil {
-    fun mockAcademicEventListResponse() = AcademicEventListResponse(
-        code = 200,
-        message = "조회되었습니다.",
+    fun mockAcademicEventListResponse() = DefaultResponse(
+        resultCode = 200,
+        resultMsg = "조회되었습니다.",
         data = listOf(
             AcademicEventResponse(
                 id = 2417,

data/academicevent/src/test/java/com/ku_stacks/ku_ring/academicevent/AcademicRepositoryTest.kt

@@ -60,7 +60,7 @@ class AcademicRepositoryTest {
     fun `insert and get academic event test`() = runTest {
         //given
         val response = AcademicEventTestUtil.mockAcademicEventListResponse()
-        val entities = response.data.map { it.toEntity() }
+        val entities = requireNotNull(response.data?.map { it.toEntity() })
         academicEventDao.insertAcademicEvents(entities)
 
         //when

data/department/src/test/java/com/ku_stacks/ku_ring/department/repository/DepartmentRepositoryTest.kt

@@ -9,8 +9,8 @@ import com.ku_stacks.ku_ring.local.room.DepartmentDao
 import com.ku_stacks.ku_ring.local.room.KuRingDatabase
 import com.ku_stacks.ku_ring.preferences.PreferenceUtil
 import com.ku_stacks.ku_ring.remote.department.DepartmentClient
-import com.ku_stacks.ku_ring.remote.department.response.DepartmentListResponse
 import com.ku_stacks.ku_ring.remote.department.response.DepartmentResponse
+import com.ku_stacks.ku_ring.remote.util.DefaultResponse
 import junit.framework.Assert
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.ExperimentalCoroutinesApi
@@ -94,7 +94,13 @@ class DepartmentRepositoryTest {
                 )
             }
         Mockito.`when`(departmentClient.fetchDepartmentList())
-            .thenReturn(DepartmentListResponse(200, "success", updatedDepartmentsResponse))
+            .thenReturn(
+                DefaultResponse(
+                    200,
+                    "success",
+                    updatedDepartmentsResponse
+                )
+            )
         departmentRepository.updateDepartmentsFromRemote()
 
         // then

data/library/src/test/java/com/ku_stacks/ku_ring/library/LibraryTestUtil.kt

@@ -24,7 +24,6 @@ object LibraryTestUtil {
                         roomName = "열람실",
                         sortOrder = 1
                     ),
-                    awaitable = true,
                     isChargeable = true,
                     branch = LibraryRoomBranchResponse(
                         id = 1,

data/notice/src/main/java/com/ku_stacks/ku_ring/notice/mapper/ResponseToDomain.kt

@@ -1,60 +1,10 @@
 package com.ku_stacks.ku_ring.notice.mapper
 
 import com.ku_stacks.ku_ring.domain.Notice
-import com.ku_stacks.ku_ring.remote.notice.response.NoticeListResponse
-import com.ku_stacks.ku_ring.remote.notice.response.SearchNoticeListResponse
+import com.ku_stacks.ku_ring.remote.notice.response.SearchNoticeDataResponse
+import com.ku_stacks.ku_ring.remote.util.DefaultResponse
 
-fun NoticeListResponse.toNoticeList(type: String): List<Notice> {
-    return if (type == "lib") {
-        noticeResponse.map {
-            val transformedDate = it.postedDate.let { date ->
-                if (date.length == 19) { //도서관의 경우에는 특별하게 millisecond 단위로 나옴
-                    return@let date.substring(0, 4) + date.substring(5, 7) + date.substring(8, 10)
-                } else {
-                    return@let date
-                }
-            }
-
-            Notice(
-                postedDate = transformedDate,
-                subject = it.subject.trim(),
-                category = it.category,
-                url = it.url,
-                articleId = it.articleId,
-                id = it.id,
-                isNew = false,
-                isRead = false,
-                isSubscribing = false,
-                isSaved = false,
-                isReadOnStorage = false,
-                isImportant = it.isImportant,
-                tag = emptyList(),
-                commentCount = it.commentCount
-            )
-        }
-    } else {
-        noticeResponse.map {
-            Notice(
-                postedDate = it.postedDate,
-                subject = it.subject.trim(),
-                category = it.category,
-                url = it.url,
-                articleId = it.articleId,
-                id = it.id,
-                isNew = false,
-                isRead = false,
-                isSubscribing = false,
-                isSaved = false,
-                isReadOnStorage = false,
-                isImportant = it.isImportant,
-                tag = emptyList(),
-                commentCount = it.commentCount,
-            )
-        }
-    }
-}
-
-fun SearchNoticeListResponse.toNoticeList(): List<Notice> {
+fun DefaultResponse<SearchNoticeDataResponse>.toNoticeList(): List<Notice> {
     return data?.noticeList?.map {
         return@map Notice(
             postedDate = it.postedDate,

data/notice/src/main/java/com/ku_stacks/ku_ring/notice/repository/NoticeRepositoryImpl.kt

@@ -139,7 +139,11 @@ class NoticeRepositoryImpl @Inject constructor(
     }
 
     override suspend fun fetchSubscriptionFromRemote(token: String): List<String> {
-        return noticeClient.fetchSubscribe(token).categoryList.map { it.koreanName }
+        val response = noticeClient.fetchSubscribe(token)
+        return when {
+            response.isSuccessAndDataExists -> response.data!!.map { it.koreanName }
+            else -> throw IllegalStateException(response.resultMsg)
+        }
     }
 
     override suspend fun saveSubscriptionToRemote(
@@ -161,10 +165,12 @@ class NoticeRepositoryImpl @Inject constructor(
 
     override suspend fun getNoticeSearchResult(query: String): List<Notice> =
         withContext(Dispatchers.IO) {
-            val result = noticeClient.fetchNoticeList(query).takeIf { it.isSuccess }?.toNoticeList()
-                ?: emptyList()
+            val result =
+                noticeClient.fetchNoticeList(query).takeIf { it.isSuccess }?.toNoticeList()
+                    ?: emptyList()
 
-            val savedArticleIdSet = noticeDao.getSavedNoticeList(true).map { it.articleId }.toSet()
+            val savedArticleIdSet =
+                noticeDao.getSavedNoticeList(true).map { it.articleId }.toSet()
 
             result.map {
                 it.copy(isSaved = savedArticleIdSet.contains(it.articleId))

data/notice/src/main/java/com/ku_stacks/ku_ring/notice/source/CategoryNoticeMediator.kt

@@ -37,10 +37,13 @@ class CategoryNoticeMediator(
         }
 
         return suspendRunCatching {
-            val noticeResponse = noticeClient.fetchNoticeList(categoryShortName, page, ITEM_SIZE)
-            insertNotices(noticeResponse.noticeResponse)
+            val noticeResponses =
+                noticeClient.fetchNoticeList(categoryShortName, page, ITEM_SIZE).data
+                    ?: throw IllegalStateException("noticeResponse is null")
 
-            MediatorResult.Success(endOfPaginationReached = noticeResponse.noticeResponse.isEmpty())
+            insertNotices(noticeResponses)
+
+            MediatorResult.Success(endOfPaginationReached = noticeResponses.isEmpty())
         }.getOrElse {
             MediatorResult.Error(it)
         }

data/notice/src/main/java/com/ku_stacks/ku_ring/notice/source/DepartmentNoticeMediator.kt

@@ -43,12 +43,13 @@ class DepartmentNoticeMediator(
                 page = page,
                 size = ITEM_SIZE
             )
+            val data = noticeResponse.data ?: throw IllegalStateException("noticeResponse is null")
 
             val startDate = getAppStartedDate()
-            val entities = noticeResponse.data.toEntityList(shortName, startDate)
+            val entities = data.toEntityList(shortName, startDate)
             insertNotices(entities, page)
 
-            val isPageEnd = noticeResponse.data.isEmpty()
+            val isPageEnd = data.isEmpty()
             MediatorResult.Success(endOfPaginationReached = isPageEnd)
         } catch (e: Exception) {
             MediatorResult.Error(e)
@@ -62,9 +63,13 @@ class DepartmentNoticeMediator(
             size = ITEM_SIZE,
             important = true
         )
+        val data =
+            importNoticesResponse.data
+                ?: throw IllegalStateException("importNoticesResponse is null")
+
 
         val startDate = getAppStartedDate()
-        val entities = importNoticesResponse.data.toEntityList(shortName, startDate)
+        val entities = data.toEntityList(shortName, startDate)
         insertNotices(entities, 0)
     }