[TNT-115] 트레이너, 트레이니 연결 기능 구현

core/designsystem/src/main/java/co/kr/tnt/designsystem/component/Dialog.kt

@@ -140,7 +140,7 @@ fun TnTSingleButtonPopupDialog(
                 )
                 TnTTextButton(
                     size = ButtonSize.Medium,
-                    type = ButtonType.Gray,
+                    type = ButtonType.Primary,
                     text = buttonText,
                     onClick = onButtonClick,
                     modifier = Modifier
@@ -230,6 +230,7 @@ fun TnTIconSingleButtonPopupDialog(
     topIcon: Painter,
     buttonText: String,
     modifier: Modifier = Modifier,
+    type: ButtonType = ButtonType.Gray,
     onButtonClick: () -> Unit,
     onDismiss: () -> Unit,
 ) {
@@ -273,7 +274,7 @@ fun TnTIconSingleButtonPopupDialog(
                 )
                 TnTTextButton(
                     size = ButtonSize.Medium,
-                    type = ButtonType.Gray,
+                    type = type,
                     text = buttonText,
                     onClick = onButtonClick,
                     modifier = Modifier

core/ui/src/main/res/values/strings.xml

@@ -17,6 +17,7 @@
     <string name="ok">확인</string>
 
     <string name="error_server_request_failed">서버 요청에 실패했어요</string>
+    <string name="entered_wrong_text">잘못된 수치를 입력했어요</string>
 
     <string name="trainee">트레이니</string>
     <string name="trainer">트레이너</string>

data/network/src/main/java/co/kr/data/network/di/NetworkModule.kt

@@ -21,7 +21,8 @@ import javax.inject.Singleton
 @Module
 @InstallIn(SingletonComponent::class)
 internal object NetworkModule {
-    private const val TIME_OUT_SECONDS: Long = 10
+    private const val CONNECT_TIMEOUT_SECONDS: Long = 10
+    private const val READ_WRITE_TIMEOUT_SECONDS: Long = 20
 
     @Provides
     @Singleton
@@ -43,8 +44,9 @@ internal object NetworkModule {
         loggingInterceptor: HttpLoggingInterceptor,
         authenticator: Authenticator,
     ): OkHttpClient = OkHttpClient.Builder()
-        .connectTimeout(TIME_OUT_SECONDS, TimeUnit.SECONDS)
-        .readTimeout(TIME_OUT_SECONDS, TimeUnit.SECONDS)
+        .connectTimeout(CONNECT_TIMEOUT_SECONDS, TimeUnit.SECONDS)
+        .readTimeout(READ_WRITE_TIMEOUT_SECONDS, TimeUnit.SECONDS)
+        .writeTimeout(READ_WRITE_TIMEOUT_SECONDS, TimeUnit.SECONDS)
         .addInterceptor(sessionInterceptor)
         .addInterceptor(loggingInterceptor)
         .authenticator(authenticator)

data/network/src/main/java/co/kr/data/network/model/ConnectRequest.kt

@@ -0,0 +1,11 @@
+package co.kr.data.network.model
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class ConnectRequest(
+    val invitationCode: String,
+    val startDate: String,
+    val totalPtCount: Int,
+    val finishedPtCount: Int,
+)

data/network/src/main/java/co/kr/data/network/model/ConnectRequestResponse.kt

@@ -0,0 +1,20 @@
+package co.kr.data.network.model
+
+import co.kr.tnt.domain.model.ConnectRequestResult
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class ConnectRequestResponse(
+    val trainerName: String,
+    val traineeName: String,
+    val trainerProfileImageUrl: String,
+    val traineeProfileImageUrl: String,
+)
+
+fun ConnectRequestResponse.toDomain(): ConnectRequestResult =
+    ConnectRequestResult(
+        trainerName = trainerName,
+        traineeName = traineeName,
+        trainerImage = trainerProfileImageUrl,
+        traineeImage = traineeProfileImageUrl,
+    )

data/network/src/main/java/co/kr/data/network/model/ConnectedTraineeResponse.kt

@@ -0,0 +1,30 @@
+package co.kr.data.network.model
+
+import co.kr.tnt.domain.model.ConnectedResult
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class ConnectedTraineeResponse(
+    val trainerName: String,
+    val traineeName: String,
+    val trainerProfileImageUrl: String?,
+    val traineeProfileImageUrl: String?,
+    val traineeAge: Int,
+    val height: Double,
+    val weight: Double,
+    val ptGoal: String,
+    val cautionNote: String?,
+)
+
+fun ConnectedTraineeResponse.toDomain(): ConnectedResult =
+    ConnectedResult(
+        trainerName = trainerName,
+        traineeName = traineeName,
+        trainerImage = trainerProfileImageUrl,
+        traineeImage = traineeProfileImageUrl,
+        age = traineeAge,
+        height = height,
+        weight = weight,
+        ptGoal = ptGoal,
+        cautionNote = cautionNote,
+    )

data/network/src/main/java/co/kr/data/network/model/InviteCodeResponse.kt

@@ -0,0 +1,15 @@
+package co.kr.data.network.model
+
+import co.kr.tnt.domain.model.InviteCodeResult
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class InviteCodeResponse(
+    val invitationCode: String,
+)
+
+fun InviteCodeResponse.toDomain(): InviteCodeResult {
+    return InviteCodeResult(
+        invitationCode = invitationCode,
+    )
+}

data/network/src/main/java/co/kr/data/network/model/VerifyCodeResponse.kt

@@ -0,0 +1,8 @@
+package co.kr.data.network.model
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class VerifyCodeResponse(
+    val isVerified: Boolean,
+)

data/network/src/main/java/co/kr/data/network/service/ApiService.kt

@@ -1,31 +1,64 @@
 package co.kr.data.network.service
 
 import co.kr.data.network.model.CheckSessionResponse
+import co.kr.data.network.model.ConnectRequest
+import co.kr.data.network.model.ConnectRequestResponse
+import co.kr.data.network.model.ConnectedTraineeResponse
+import co.kr.data.network.model.InviteCodeResponse
 import co.kr.data.network.model.LoginRequest
 import co.kr.data.network.model.LoginResponse
 import co.kr.data.network.model.SignUpResponse
+import co.kr.data.network.model.VerifyCodeResponse
 import co.kr.data.network.util.WithoutSessionCheckPath.CHECK_SESSION_PATH
 import okhttp3.MultipartBody
 import okhttp3.RequestBody
 import retrofit2.http.Body
 import retrofit2.http.GET
 import retrofit2.http.Multipart
 import retrofit2.http.POST
+import retrofit2.http.PUT
 import retrofit2.http.Part
+import retrofit2.http.Path
+import retrofit2.http.Query
 
 interface ApiService {
     @GET(CHECK_SESSION_PATH)
     suspend fun getCheckSession(): CheckSessionResponse
 
+    // Login
     @POST("/login")
     suspend fun postLogin(
         @Body request: LoginRequest,
     ): LoginResponse
 
+    // SignUp
     @Multipart
     @POST("/members/sign-up")
     suspend fun postSignUp(
         @Part profileImage: MultipartBody.Part?,
         @Part("request") request: RequestBody,
     ): SignUpResponse
+
+    // Connect
+    @GET("/trainers/invitation-code")
+    suspend fun getInviteCode(): InviteCodeResponse
+
+    @PUT("/trainers/invitation-code/reissue")
+    suspend fun regenerateInviteCode(): InviteCodeResponse
+
+    @GET("/trainers/invitation-code/verify/{code}")
+    suspend fun verifyInviteCode(
+        @Path("code") code: String,
+    ): VerifyCodeResponse
+
+    @POST("/trainees/connect-trainer")
+    suspend fun postConnectRequest(
+        @Body request: ConnectRequest,
+    ): ConnectRequestResponse
+
+    @GET("/trainers/first-connected-trainee")
+    suspend fun getConnectedTraineeInfo(
+        @Query("trainerId") trainerId: String,
+        @Query("traineeId") traineeId: String,
+    ): ConnectedTraineeResponse
 }

data/network/src/main/java/co/kr/data/network/source/ConnectRemoteDataSource.kt

@@ -0,0 +1,43 @@
+package co.kr.data.network.source
+
+import co.kr.data.network.model.ConnectRequest
+import co.kr.data.network.model.ConnectRequestResponse
+import co.kr.data.network.model.ConnectedTraineeResponse
+import co.kr.data.network.model.InviteCodeResponse
+import co.kr.data.network.model.VerifyCodeResponse
+import co.kr.data.network.service.ApiService
+import co.kr.data.network.util.networkHandler
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class ConnectRemoteDataSource @Inject constructor(
+    private val apiService: ApiService,
+) {
+    suspend fun getInviteCode(): InviteCodeResponse = networkHandler {
+        apiService.getInviteCode()
+    }
+
+    suspend fun regenerateInviteCode(): InviteCodeResponse = networkHandler {
+        apiService.regenerateInviteCode()
+    }
+
+    suspend fun verifyInviteCode(code: String): VerifyCodeResponse = networkHandler {
+        apiService.verifyInviteCode(code = code)
+    }
+
+    suspend fun connectRequest(connectRequest: ConnectRequest): ConnectRequestResponse =
+        networkHandler {
+            apiService.postConnectRequest(request = connectRequest)
+        }
+
+    suspend fun getConnectedTraineeInfo(
+        trainerId: String,
+        traineeId: String,
+    ): ConnectedTraineeResponse = networkHandler {
+        apiService.getConnectedTraineeInfo(
+            trainerId = trainerId,
+            traineeId = traineeId,
+        )
+    }
+}

data/repository/src/main/java/co/kr/data/repository/ConnectRepositoryImpl.kt

@@ -0,0 +1,63 @@
+package co.kr.data.repository
+
+import co.kr.data.network.model.ConnectRequest
+import co.kr.data.network.model.toDomain
+import co.kr.data.network.source.ConnectRemoteDataSource
+import co.kr.data.storage.source.UserLocalDataSource
+import co.kr.tnt.domain.model.ConnectRequestResult
+import co.kr.tnt.domain.model.ConnectedResult
+import co.kr.tnt.domain.model.InviteCodeResult
+import co.kr.tnt.domain.repository.ConnectRepository
+import javax.inject.Inject
+
+class ConnectRepositoryImpl @Inject constructor(
+    private val connectRemoteDataSource: ConnectRemoteDataSource,
+    private val userLocalDataSource: UserLocalDataSource,
+) : ConnectRepository {
+    override suspend fun getInviteCode(): InviteCodeResult {
+        val response = connectRemoteDataSource.getInviteCode()
+
+        return response.toDomain()
+    }
+
+    override suspend fun regenerateInviteCode(): InviteCodeResult {
+        val response = connectRemoteDataSource.regenerateInviteCode()
+
+        return response.toDomain()
+    }
+
+    override suspend fun verifyInviteCode(code: String): Boolean {
+        val response = connectRemoteDataSource.verifyInviteCode(code = code)
+
+        return response.isVerified
+    }
+
+    override suspend fun connectRequest(
+        invitationCode: String,
+        startDate: String,
+        totalPtCount: Int,
+        finishedPtCount: Int,
+    ): ConnectRequestResult {
+        val response = connectRemoteDataSource.connectRequest(
+            connectRequest = ConnectRequest(
+                invitationCode = invitationCode,
+                startDate = startDate,
+                totalPtCount = totalPtCount,
+                finishedPtCount = finishedPtCount,
+            ),
+        )
+        return response.toDomain()
+    }
+
+    override suspend fun getConnectedTraineeInfo(): ConnectedResult {
+        // TODO trainerId, traineeId 저장하기 (FCM, 알림 화면)
+        val trainerId = userLocalDataSource.getTrainerId()
+        val traineeId = userLocalDataSource.getTraineeId()
+
+        val response = connectRemoteDataSource.getConnectedTraineeInfo(
+            trainerId = trainerId,
+            traineeId = traineeId,
+        )
+        return response.toDomain()
+    }
+}

data/repository/src/main/java/co/kr/data/repository/di/RepositoryModule.kt

@@ -1,7 +1,9 @@
 package co.kr.data.repository.di
 
+import co.kr.data.repository.ConnectRepositoryImpl
 import co.kr.data.repository.LoginRepositoryImpl
 import co.kr.data.repository.SignUpRepositoryImpl
+import co.kr.tnt.domain.repository.ConnectRepository
 import co.kr.tnt.domain.repository.LoginRepository
 import co.kr.tnt.domain.repository.SignUpRepository
 import dagger.Binds
@@ -21,4 +23,9 @@ internal abstract class RepositoryModule {
     abstract fun bindsSignUpRepository(
         repository: SignUpRepositoryImpl,
     ): SignUpRepository
+
+    @Binds
+    abstract fun bindConnectRepository(
+        repository: ConnectRepositoryImpl,
+    ): ConnectRepository
 }

data/storage/src/main/java/co/kr/data/storage/di/StorageModule.kt

@@ -9,6 +9,7 @@ import dagger.Provides
 import dagger.hilt.InstallIn
 import dagger.hilt.android.qualifiers.ApplicationContext
 import dagger.hilt.components.SingletonComponent
+import javax.inject.Named
 import javax.inject.Singleton
 
 @Module
@@ -17,9 +18,20 @@ internal object StorageModule {
     private const val SESSION_STORAGE_NAME = "SESSION_STORAGE"
     private val Context.sessionDataStore by preferencesDataStore(name = SESSION_STORAGE_NAME)
 
+    private const val USER_STORAGE_NAME = "USER_STORAGE"
+    private val Context.userDataStore by preferencesDataStore(name = USER_STORAGE_NAME)
+
     @Provides
     @Singleton
+    @Named("Session")
     fun provideSessionDataStore(
         @ApplicationContext context: Context,
     ): DataStore<Preferences> = context.sessionDataStore
+
+    @Provides
+    @Singleton
+    @Named("User")
+    fun provideUserLocalDataStore(
+        @ApplicationContext context: Context,
+    ): DataStore<Preferences> = context.userDataStore
 }

data/storage/src/main/java/co/kr/data/storage/source/SessionLocalDataSource.kt

@@ -7,11 +7,12 @@ import androidx.datastore.preferences.core.stringPreferencesKey
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
 import javax.inject.Inject
+import javax.inject.Named
 import javax.inject.Singleton
 
 @Singleton
 class SessionLocalDataSource @Inject constructor(
-    private val sessionPreferences: DataStore<Preferences>,
+    @Named("Session") private val sessionPreferences: DataStore<Preferences>,
 ) {
     val sessionId: Flow<String> = sessionPreferences.data.map { preferences ->
         preferences[SESSION_ID] ?: ""