test data

app/src/main/java/ru/myitschool/work/data/repo/AuthRepository.kt

@@ -6,28 +6,24 @@ import ru.myitschool.work.util.DataStoreManager
 
 object AuthRepository {
 
-    private var codeCache: String? = null
-
     suspend fun checkAndSaveCode(code: String): MyResult<Unit> {
-        return when (val result = NetworkDataSource.checkAuth(code)) {
+        /*return when (val result = NetworkDataSource.checkAuth(code)) {
             is MyResult.Success -> {
                 if (result.data) {
                     DataStoreManager.saveAuthCode(code)
-                    codeCache = code
                     MyResult.Success(Unit)
                 } else {
                     MyResult.Error("Неверный код")
                 }
             }
-            is MyResult.Error -> {
-                MyResult.Error(result.error)
-            }
-        }
+            is MyResult.Error -> result
+        }*/
+        DataStoreManager.saveAuthCode(code)
+        return MyResult.Success(Unit)
     }
     suspend fun logOut(): MyResult<Unit> {
         return try {
             DataStoreManager.clearAuthCode()
-            codeCache = null
             MyResult.Success(Unit)
         } catch (e: Exception) {
             MyResult.Error("Ошибка при выходе")
@@ -36,4 +32,7 @@ object AuthRepository {
 
     suspend fun checkCode(code: String): MyResult<Boolean> =
         NetworkDataSource.checkAuth(code)
+
+    suspend fun getSavedCode(): String? =
+        DataStoreManager.getAuthCode()
 }

app/src/main/java/ru/myitschool/work/data/repo/UserRepository.kt

@@ -1,5 +1,6 @@
 package ru.myitschool.work.data.repo
 
+import ru.myitschool.work.data.dto.UserInfoResponse
 import ru.myitschool.work.data.source.NetworkDataSource
 import ru.myitschool.work.domain.MyResult
 import ru.myitschool.work.domain.user.User
@@ -7,17 +8,26 @@ import ru.myitschool.work.domain.user.User
 object UserRepository {
 
     suspend fun getUserInfo(code: String): MyResult<User> {
-        return when (val result = NetworkDataSource.getUserInfo(code)) {
-            is MyResult.Success -> {
-                val dto = result.data
-                val user = User(
-                    name = dto.name,
-                    imageUrl = dto.photoUrl
+        /*return when (val result = NetworkDataSource.getUserInfo(code)) {
+            is MyResult.Success -> MyResult.Success(result.data.toUser())
+            is MyResult.Error -> result
+        }*/
+        return MyResult.Success(
+            User(
+                "kio",
+                "https://catalog-cdn.detmir.st/media/2fe02057f9915e72a378795d32c79ea9.jpeg",
+                mapOf(
+                    "15.12.2025" to "Кабинет 305",
+                    "20.12.2025" to "Аудитория 101",
+                    "01.01.2026" to "Лаборатория 12"
                 )
-                MyResult.Success(user)
-            }
-
-            is MyResult.Error -> MyResult.Error(result.error)
-        }
+            )
+        )
     }
+
+    private fun UserInfoResponse.toUser() = User(
+        name = name,
+        imageUrl = photoUrl,
+        bookings = booking.mapValues { it.value.place }
+    )
 }

app/src/main/java/ru/myitschool/work/domain/auth/CheckAndSaveAuthCodeUseCase.kt

@@ -8,7 +8,6 @@ class CheckAndSaveAuthCodeUseCase(
     private val repository: AuthRepository,
 ) {
     suspend operator fun invoke(code: String): MyResult<Unit> {
-       // return repository.checkAndSaveCode(code)
-        return MyResult.Success(Unit)
+        return repository.checkAndSaveCode(code)
     }
 }

app/src/main/java/ru/myitschool/work/domain/user/GetUserUseCase.kt

@@ -1,4 +1,12 @@
 package ru.myitschool.work.domain.user
 
-class GetUserUseCase {
+import ru.myitschool.work.data.repo.UserRepository
+import ru.myitschool.work.domain.MyResult
+
+class GetUserUseCase(
+    private val repository: UserRepository
+) {
+    suspend operator fun invoke(code: String): MyResult<User> {
+        return repository.getUserInfo(code)
+    }
 }

app/src/main/java/ru/myitschool/work/domain/user/User.kt

@@ -2,5 +2,6 @@ package ru.myitschool.work.domain.user
 
 data class User(
     val name: String,
-    val imageUrl: String
-)
+    val imageUrl: String,
+    val bookings: Map<String, String> = emptyMap()
+)

app/src/main/java/ru/myitschool/work/ui/main/BookingItem.kt

@@ -0,0 +1,48 @@
+package ru.myitschool.work.ui.main
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.Card
+import androidx.compose.material3.CardDefaults
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.unit.dp
+import ru.myitschool.work.core.TestIds
+
+@Composable
+fun BookingItem(
+    booking: BookingDisplayItem,
+    index: Int
+) {
+    Card(
+        modifier = Modifier
+            .fillMaxWidth()
+            .testTag(TestIds.Main.getIdItemByPosition(index)),
+        elevation = CardDefaults.cardElevation(defaultElevation = 2.dp)
+    ) {
+        Column(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(16.dp)
+        ) {
+            Text(
+                text = booking.date,
+                modifier = Modifier.testTag(TestIds.Main.ITEM_DATE),
+                style = MaterialTheme.typography.titleMedium
+            )
+            Spacer(modifier = Modifier.height(4.dp))
+            Text(
+                text = booking.place,
+                modifier = Modifier.testTag(TestIds.Main.ITEM_PLACE),
+                style = MaterialTheme.typography.bodyMedium,
+                color = MaterialTheme.colorScheme.onSurfaceVariant
+            )
+        }
+    }
+}

app/src/main/java/ru/myitschool/work/ui/main/MainIntent.kt

@@ -3,4 +3,5 @@ package ru.myitschool.work.ui.main
 sealed interface MainIntent {
     data object LogOut: MainIntent
     data object Refresh: MainIntent
+    data object AddBooking: MainIntent
 }

app/src/main/java/ru/myitschool/work/ui/main/MainScreen.kt

@@ -1,21 +1,38 @@
 package ru.myitschool.work.ui.main
 
+import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.itemsIndexed
+import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.material3.Button
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Scaffold
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
+import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
 import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.unit.dp
 import androidx.lifecycle.viewmodel.compose.viewModel
 import androidx.navigation.NavController
 import coil3.compose.AsyncImage
 import ru.myitschool.work.core.TestIds
+import ru.myitschool.work.data.dto.BookingItem
 import ru.myitschool.work.ui.Screen
 
 @Composable
@@ -29,31 +46,183 @@ fun MainScreen(
             when (event) {
                 MainViewModel.NavigationEvent.ToAuth -> {
                     navController.navigate(Screen.Auth) {
-                        popUpTo(navController.graph.startDestinationId) { inclusive = true }
+                        popUpTo(Screen.Auth) { inclusive = true }
                         launchSingleTop = true
                     }
                 }
+
+                MainViewModel.NavigationEvent.ToBooking -> {
+                    navController.navigate(Screen.Book)
+                }
             }
         }
     }
 
-    Scaffold() { padding ->
-        Column(Modifier.padding(padding)){
-            AsyncImage(model = state.user.imageUrl, contentDescription = null, modifier = Modifier.testTag(
-                TestIds.Main.PROFILE_IMAGE))
-            Text(text = state.user.name)
+    Scaffold { padding ->
+        Box(
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(padding)
+        ) {
+            when {
+                state.error != null -> {
+                    ErrorContent(
+                        error = state.error!!,
+                        onRefresh = { viewModel.onIntent(MainIntent.Refresh) }
+                    )
+                }
+                state.isLoading -> {
+                    CircularProgressIndicator(
+                        modifier = Modifier.align(Alignment.Center)
+                    )
+                }
+                state.user != null -> {
+                    MainContent(
+                        state = state,
+                        onLogout = { viewModel.onIntent(MainIntent.LogOut) },
+                        onRefresh = { viewModel.onIntent(MainIntent.Refresh) },
+                        onAddBooking = { viewModel.onIntent(MainIntent.AddBooking) }
+                    )
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun ErrorContent(
+    error: String,
+    onRefresh: () -> Unit
+) {
+    Column(
+        modifier = Modifier
+            .fillMaxSize()
+            .padding(16.dp),
+        horizontalAlignment = Alignment.CenterHorizontally,
+        verticalArrangement = Arrangement.Center
+    ) {
+        Text(
+            text = error,
+            modifier = Modifier.testTag(TestIds.Main.ERROR),
+            style = MaterialTheme.typography.bodyLarge,
+            color = MaterialTheme.colorScheme.error
+        )
+        Spacer(modifier = Modifier.height(16.dp))
+        Button(
+            onClick = onRefresh,
+            modifier = Modifier.testTag(TestIds.Main.REFRESH_BUTTON)
+        ) {
+            Text("Обновить")
+        }
+    }
+}
+
+@Composable
+private fun MainContent(
+    state: MainState,
+    onLogout: () -> Unit,
+    onRefresh: () -> Unit,
+    onAddBooking: () -> Unit
+) {
+    Column(
+        modifier = Modifier
+            .fillMaxSize()
+            .padding(16.dp)
+    ) {
+        Row(
+            modifier = Modifier.fillMaxWidth(),
+            verticalAlignment = Alignment.CenterVertically,
+            horizontalArrangement = Arrangement.SpaceBetween
+        ) {
+            Row(
+                verticalAlignment = Alignment.CenterVertically,
+                modifier = Modifier.weight(1f)
+            ) {
+                AsyncImage(
+                    model = state.user?.imageUrl,
+                    contentDescription = null,
+                    modifier = Modifier
+                        .size(64.dp)
+                        .clip(CircleShape)
+                        .testTag(TestIds.Main.PROFILE_IMAGE)
+                )
+                Spacer(modifier = Modifier.width(16.dp))
+                Text(
+                    text = state.user?.name ?: "",
+                    modifier = Modifier.testTag(TestIds.Main.PROFILE_NAME),
+                    style = MaterialTheme.typography.headlineSmall
+                )
+            }
+        }
+
+        Spacer(modifier = Modifier.height(16.dp))
+
+        Row(
+            modifier = Modifier.fillMaxWidth(),
+            horizontalArrangement = Arrangement.spacedBy(8.dp)
+        ) {
             Button(
-                modifier = Modifier.testTag(TestIds.Main.REFRESH_BUTTON),
-                onClick = { viewModel.onIntent(MainIntent.Refresh)}
+                onClick = onRefresh,
+                modifier = Modifier
+                    .weight(1f)
+                    .testTag(TestIds.Main.REFRESH_BUTTON)
             ) {
                 Text("Обновить")
             }
             Button(
-                modifier = Modifier.testTag(TestIds.Main.LOGOUT_BUTTON),
-                onClick = { viewModel.onIntent(MainIntent.LogOut) }
+                onClick = onLogout,
+                modifier = Modifier
+                    .weight(1f)
+                    .testTag(TestIds.Main.LOGOUT_BUTTON)
             ) {
                 Text("Выйти")
             }
         }
+
+        Spacer(modifier = Modifier.height(16.dp))
+
+        Button(
+            onClick = onAddBooking,
+            modifier = Modifier
+                .fillMaxWidth()
+                .testTag(TestIds.Main.ADD_BUTTON)
+        ) {
+            Text("Забронировать")
+        }
+
+        Spacer(modifier = Modifier.height(16.dp))
+
+        Text(
+            text = "Мои бронирования",
+            style = MaterialTheme.typography.titleLarge
+        )
+
+        Spacer(modifier = Modifier.height(8.dp))
+
+        if (state.bookings.isEmpty()) {
+            Box(
+                modifier = Modifier.fillMaxSize(),
+                contentAlignment = Alignment.Center
+            ) {
+                Text(
+                    text = "У вас пока нет бронирований",
+                    style = MaterialTheme.typography.bodyMedium,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant
+                )
+            }
+        } else {
+            LazyColumn(
+                modifier = Modifier.fillMaxSize(),
+                verticalArrangement = Arrangement.spacedBy(8.dp)
+            ) {
+                itemsIndexed(state.bookings) { index, booking ->
+                    BookingItem(
+                        booking = booking,
+                        index = index
+                    )
+                }
+            }
+        }
     }
-}
+}
+

app/src/main/java/ru/myitschool/work/ui/main/MainState.kt

@@ -3,5 +3,15 @@ package ru.myitschool.work.ui.main
 import ru.myitschool.work.domain.user.User
 
 data class MainState(
-    val user: User
-)
+    val user: User? = null,
+    val bookings: List<BookingDisplayItem> = emptyList(),
+    val isLoading: Boolean = false,
+    val error: String? = null
+)
+
+data class BookingDisplayItem(
+    val date: String, // dd.MM.yyyy
+    val place: String,
+    val originalDate: String
+)
+

app/src/main/java/ru/myitschool/work/ui/main/MainViewModel.kt

@@ -1,5 +1,6 @@
 package ru.myitschool.work.ui.main
 
+import android.util.Log
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import kotlinx.coroutines.flow.MutableSharedFlow
@@ -7,40 +8,117 @@ import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharedFlow
 import kotlinx.coroutines.flow.asSharedFlow
 import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 import ru.myitschool.work.data.repo.AuthRepository
+import ru.myitschool.work.data.repo.UserRepository
 import ru.myitschool.work.domain.MyResult
 import ru.myitschool.work.domain.auth.LogOutUseCase
-import ru.myitschool.work.domain.user.User
+import ru.myitschool.work.domain.user.GetUserUseCase
+import ru.myitschool.work.util.DataStoreManager
+import java.text.SimpleDateFormat
+import java.util.Locale
 
-class MainViewModel: ViewModel() {
+class MainViewModel : ViewModel() {
     private val logOutUseCase = LogOutUseCase(AuthRepository)
+    private val getUserUseCase = GetUserUseCase(UserRepository)
 
-    private val _mainState = MutableStateFlow(MainState(User("", "")))
+    private val _mainState = MutableStateFlow(MainState())
     val mainState = _mainState.asStateFlow()
 
     private val _navigationEvent = MutableSharedFlow<NavigationEvent>(extraBufferCapacity = 1)
     val navigationEvent: SharedFlow<NavigationEvent> = _navigationEvent.asSharedFlow()
 
+    init {
+        loadUser()
+    }
 
     sealed class NavigationEvent {
         data object ToAuth : NavigationEvent()
+        data object ToBooking : NavigationEvent()
     }
 
-
-    fun onIntent(intent: MainIntent){
-        when(intent){
+    fun onIntent(intent: MainIntent) {
+        when (intent) {
             MainIntent.LogOut -> logOut()
-            MainIntent.Refresh -> TODO()
+            MainIntent.Refresh -> loadUser()
+            MainIntent.AddBooking -> navigateToBooking()
+        }
+    }
+
+    private fun loadUser() {
+        viewModelScope.launch {
+            _mainState.update { it.copy(isLoading = true, error = null) }
+
+            val code = DataStoreManager.getAuthCode()
+            if (code.isNullOrBlank()) {
+                _navigationEvent.emit(NavigationEvent.ToAuth)
+                return@launch
+            }
+
+            when (val result = getUserUseCase(code)) {
+                is MyResult.Success -> {
+                    val bookings = convertBookingsToDisplayItems(result.data.bookings)
+                    _mainState.update {
+                        it.copy(
+                            user = result.data,
+                            bookings = bookings,
+                            isLoading = false,
+                            error = null
+                        )
+                    }
+                }
+
+                is MyResult.Error -> {
+                    _mainState.update {
+                        it.copy(
+                            isLoading = false,
+                            error = result.error,
+                            user = null,
+                            bookings = emptyList()
+                        )
+                    }
+                }
+            }
         }
     }
 
 
+    private fun convertBookingsToDisplayItems(bookings: Map<String, String>): List<BookingDisplayItem> {
+        val dateFormat = SimpleDateFormat("dd.MM.yyyy", Locale.getDefault())
+
+        return bookings.map { (date, place) ->
+            BookingDisplayItem(
+                date = date,
+                place = place,
+                originalDate = date
+            )
+        }.sortedBy { item ->
+            try {
+                dateFormat.parse(item.originalDate)?.time ?: 0L
+            } catch (e: Exception) {
+                0L
+            }
+        }
+    }
 
     private fun logOut() {
         viewModelScope.launch {
-            logOutUseCase()
-            _navigationEvent.emit(NavigationEvent.ToAuth)
+            when (logOutUseCase()) {
+                is MyResult.Success -> {
+                    _mainState.update { MainState() }
+                    _navigationEvent.emit(NavigationEvent.ToAuth)
+                }
+                is MyResult.Error -> {
+                    _mainState.update { it.copy(error = "Ошибка при выходе") }
+                }
+            }
         }
     }
-}
+
+    private fun navigateToBooking() {
+        viewModelScope.launch {
+            _navigationEvent.emit(NavigationEvent.ToBooking)
+        }
+    }
+}