Sabores en red: los datos ya no son tuyos

{
  "id": 1,
  "name": "La Chinampa",
  "cuisine": "Mexicana",
  "address": "Av. Garza Sada 300",
  "description": "Cocina de mercado: tacos de guisado, sopes y agua del día.",
  "priceLevel": 1,
  "emoji": "🌮",
  "ratingCount": 2,
  "ratingAverage": 4.5
}

[versions]
retrofit = "3.0.0"
serializationJson = "1.9.0"
okhttp = "4.12.0"

[libraries]
retrofit = { group = "com.squareup.retrofit2", name = "retrofit", version.ref = "retrofit" }
retrofit-kotlinx-serialization = { group = "com.squareup.retrofit2", name = "converter-kotlinx-serialization", version.ref = "retrofit" }
kotlinx-serialization-json = { group = "org.jetbrains.kotlinx", name = "kotlinx-serialization-json", version.ref = "serializationJson" }
okhttp-logging = { group = "com.squareup.okhttp3", name = "logging-interceptor", version.ref = "okhttp" }

[plugins]
kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }

plugins {
    alias(libs.plugins.android.application)
    alias(libs.plugins.kotlin.compose)
    alias(libs.plugins.kotlin.serialization)
}

dependencies {
    implementation(libs.retrofit)
    implementation(libs.retrofit.kotlinx.serialization)
    implementation(libs.kotlinx.serialization.json)
    implementation(libs.okhttp.logging)
}

<manifest xmlns:android="http://schemas.android.com/apk/res/android">

    <uses-permission android:name="android.permission.INTERNET" />

    <application …>

package mx.tec.sabores.data.remote

import kotlinx.serialization.Serializable

/** Lo que el servidor manda. No es el dominio: es su envoltura de transporte. */
@Serializable
data class RestaurantDto(
    val id: Int,
    val name: String,
    val cuisine: String,
    val address: String,
    val description: String,
    val priceLevel: Int,
    val emoji: String,
    val ratingAverage: Double = 0.0,
    val ratingCount: Int = 0
)

@Serializable
data class ReviewDto(
    val id: Int,
    val restaurantId: Int,
    val author: String,
    val stars: Int,
    val comment: String,
    val createdAt: String
)

/** Lo que se manda al crear. Sin id ni autor: esos los pone el servidor. */
@Serializable
data class NewReviewBody(
    val restaurantId: Int,
    val stars: Int,
    val comment: String
)

@Serializable
data class EditReviewBody(
    val stars: Int? = null,
    val comment: String? = null
)

data class Review(
    val id: Int,
    val restaurantId: Int,
    val author: String,
    val stars: Int,
    val comment: String
)

package mx.tec.sabores.data.remote

import mx.tec.sabores.domain.Restaurant
import mx.tec.sabores.domain.Review

fun RestaurantDto.toDomain() = Restaurant(
    id = id,
    name = name,
    cuisine = cuisine,
    address = address,
    description = description,
    priceLevel = priceLevel,
    emoji = emoji
)

fun ReviewDto.toDomain() = Review(
    id = id,
    restaurantId = restaurantId,
    author = author,
    stars = stars,
    comment = comment
)

package mx.tec.sabores.data.remote

import retrofit2.Response
import retrofit2.http.*

interface SaboresApi {

    @GET("restaurants")
    suspend fun getRestaurants(): List<RestaurantDto>

    @GET("restaurants/{id}")
    suspend fun getRestaurant(@Path("id") id: Int): RestaurantDto

    @GET("reviews")
    suspend fun getReviews(@Query("restaurantId") restaurantId: Int): List<ReviewDto>

    @GET("me/reviews")
    suspend fun getMyReviews(): List<ReviewDto>

    @POST("reviews")
    suspend fun createReview(@Body body: NewReviewBody): ReviewDto

    @PATCH("reviews/{id}")
    suspend fun editReview(@Path("id") id: Int, @Body body: EditReviewBody): ReviewDto

    // Response<Unit> para poder leer el código: 204 si era tuya, 403 si no.
    @DELETE("reviews/{id}")
    suspend fun deleteReview(@Path("id") id: Int): Response<Unit>
}

package mx.tec.sabores.data.remote

import kotlinx.serialization.json.Json
import okhttp3.Interceptor
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient
import okhttp3.logging.HttpLoggingInterceptor
import retrofit2.Retrofit
import retrofit2.converter.kotlinx.serialization.asConverterFactory

object Network {

    private const val BASE_URL = "https://startdroid.com/api/"

    /** ⚠️ Cambia esto por TU matrícula antes de correr la app. */
    var alumno: String = "a01234567"

    private val json = Json {
        ignoreUnknownKeys = true
        explicitNulls = false
    }

    /** Firma cada petición. Así es como viajan las credenciales de verdad. */
    private val identidad = Interceptor { chain ->
        val request = chain.request().newBuilder()
            .addHeader("X-Alumno", alumno)
            .build()
        chain.proceed(request)
    }

    private val client = OkHttpClient.Builder()
        .addInterceptor(identidad)
        .addInterceptor(HttpLoggingInterceptor().apply {
            level = HttpLoggingInterceptor.Level.BASIC
        })
        .build()

    val api: SaboresApi = Retrofit.Builder()
        .baseUrl(BASE_URL)
        .client(client)
        .addConverterFactory(json.asConverterFactory("application/json".toMediaType()))
        .build()
        .create(SaboresApi::class.java)
}

package mx.tec.sabores.data

import mx.tec.sabores.data.remote.Network
import mx.tec.sabores.data.remote.SaboresApi
import mx.tec.sabores.data.remote.toDomain
import mx.tec.sabores.domain.Restaurant
import mx.tec.sabores.domain.Review

class RestaurantRepository(private val api: SaboresApi = Network.api) {

    suspend fun getAll(): List<Restaurant> =
        api.getRestaurants().map { it.toDomain() }

    suspend fun getById(id: Int): Restaurant =
        api.getRestaurant(id).toDomain()

    suspend fun getReviews(restaurantId: Int): List<Review> =
        api.getReviews(restaurantId).map { it.toDomain() }

    suspend fun getMyReviews(): List<Review> =
        api.getMyReviews().map { it.toDomain() }
}

package mx.tec.sabores.domain

/**
 * Un restaurante con su calificación, tal como se muestra en la lista.
 * Vive en el dominio, no en ui/: si viviera en ui/, la capa de datos tendría
 * que importar de la capa de arriba para poder devolverlo.
 */
data class RestaurantEnLista(
    val restaurant: Restaurant,
    val summary: RatingSummary
)

import mx.tec.sabores.domain.RatingSummary

/** El promedio que el servidor ya calculó, en la forma que entiende el dominio. */
fun RestaurantDto.toSummary() = RatingSummary(average = ratingAverage, count = ratingCount)

import mx.tec.sabores.data.remote.toSummary   // ← junto a los otros imports
import mx.tec.sabores.domain.RestaurantEnLista

suspend fun getAllForList(): List<RestaurantEnLista> =
    api.getRestaurants().map { RestaurantEnLista(it.toDomain(), it.toSummary()) }

package mx.tec.sabores.ui.state

/** Los tres estados de cualquier pantalla que dependa de la red. */
sealed interface UiState<out T> {
    data object Cargando : UiState<Nothing>
    data class Exito<T>(val datos: T) : UiState<T>
    data class Error(val mensaje: String) : UiState<Nothing>
}

class SaboresViewModel(
    private val repository: RestaurantRepository = RestaurantRepository()
) : ViewModel() {

    var restaurantes by mutableStateOf<UiState<List<Restaurant>>>(UiState.Cargando)
        private set

    init { cargarRestaurantes() }

    fun cargarRestaurantes() {
        viewModelScope.launch {
            restaurantes = UiState.Cargando
            restaurantes = try {
                UiState.Exito(repository.getAll())
            } catch (e: IOException) {
                UiState.Error("No hay conexión. Revisa tu internet.")
            } catch (e: HttpException) {
                UiState.Error("El servidor respondió ${e.code()}.")
            }
        }
    }
}

when (val estado = viewModel.restaurantes) {
    is UiState.Cargando -> Box(Modifier.fillMaxSize(), Alignment.Center) {
        CircularProgressIndicator()
    }
    is UiState.Error -> ErrorView(
        mensaje = estado.mensaje,
        onReintentar = { viewModel.cargarRestaurantes() }
    )
    is UiState.Exito -> LazyColumn { /* lo que ya tenías */ }
}

@Composable
fun ErrorView(mensaje: String, onReintentar: () -> Unit, modifier: Modifier = Modifier) {
    Column(
        modifier = modifier.fillMaxSize().padding(24.dp),
        verticalArrangement = Arrangement.Center,
        horizontalAlignment = Alignment.CenterHorizontally
    ) {
        Text(mensaje, style = MaterialTheme.typography.bodyLarge)
        Spacer(Modifier.height(16.dp))
        Button(onClick = onReintentar) { Text("Reintentar") }
    }
}

suspend fun addReview(restaurantId: Int, stars: Int, comment: String): Review =
    api.createReview(NewReviewBody(restaurantId, stars, comment)).toDomain()

package mx.tec.sabores.ui.state

import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.launch
import mx.tec.sabores.data.RestaurantRepository
import mx.tec.sabores.domain.ReviewError
import mx.tec.sabores.domain.ReviewValidator
import retrofit2.HttpException
import java.io.IOException

data class NewReviewUiState(
    val stars: Int = 0,
    val comment: String = "",
    val guardando: Boolean = false,
    val errorAlGuardar: String? = null
) {
    // Estado DERIVADO: se calcula, no se guarda.
    val commentError: ReviewError? =
        if (comment.isEmpty()) null else ReviewValidator.validateComment(comment)

    // Con la red de por medio, "puedo guardar" incluye "no estoy guardando ya".
    val canSave: Boolean = ReviewValidator.isValid(stars, comment) && !guardando

    val charactersLeft: Int = ReviewValidator.COMMENT_MAX - comment.trim().length
}

class NewReviewViewModel(
    private val repository: RestaurantRepository = RestaurantRepository()
) : ViewModel() {

    var uiState by mutableStateOf(NewReviewUiState())
        private set

    fun onStarsChange(stars: Int) {
        uiState = uiState.copy(stars = stars, errorAlGuardar = null)
    }

    fun onCommentChange(text: String) {
        if (text.length <= ReviewValidator.COMMENT_MAX) {
            uiState = uiState.copy(comment = text, errorAlGuardar = null)
        }
    }

    fun publicar(restaurantId: Int, alTerminar: () -> Unit) {
        if (!uiState.canSave) return
        viewModelScope.launch {
            uiState = uiState.copy(guardando = true, errorAlGuardar = null)
            try {
                repository.addReview(restaurantId, uiState.stars, uiState.comment)
                uiState = uiState.copy(guardando = false)
                alTerminar()
            } catch (e: IOException) {
                uiState = uiState.copy(
                    guardando = false,
                    errorAlGuardar = "No hay conexión. Tu reseña no se publicó."
                )
            } catch (e: HttpException) {
                uiState = uiState.copy(guardando = false, errorAlGuardar = mensajeDe(e))
            }
        }
    }
}

// El error del servidor: un 422 que tu validación no atrapó, o una caída de
// red. Se muestra aquí y la pantalla NO se cierra.
val errorDelServidor = uiState.errorAlGuardar
if (errorDelServidor != null) {
    Text(
        text = errorDelServidor,
        color = MaterialTheme.colorScheme.error,
        style = MaterialTheme.typography.bodyMedium
    )
}

Button(
    onClick = onSave,
    enabled = uiState.canSave,
    modifier = Modifier.fillMaxWidth()
) { Text(if (uiState.guardando) "Publicando…" else "Publicar reseña") }

onSave = {
    // El popBackStack ya no es inmediato: ocurre cuando el servidor confirma.
    // Si falla, la pantalla se queda y el error se ve.
    formViewModel.publicar(id) { nav.popBackStack() }
},

{ "error": "comment debe tener al menos 15 caracteres", "field": "comment" }

fun mensajeDe(e: HttpException): String {
    val cuerpo = e.response()?.errorBody()?.string()
    val mensaje = cuerpo
        ?.let { runCatching { Json.parseToJsonElement(it) }.getOrNull() }
        ?.jsonObject?.get("error")?.jsonPrimitive?.contentOrNull

    return when (e.code()) {
        401 -> "Falta tu matrícula en Network.alumno."
        403 -> mensaje ?: "Esa reseña no es tuya."
        404 -> "Eso ya no existe. Actualiza la lista."
        422 -> mensaje ?: "Los datos no son válidos."
        else -> "El servidor respondió ${e.code()}."
    }
}

data class Detalle(
    val restaurant: Restaurant,
    val reviews: List<Review>
) {
    // La regla del dominio sigue viva: el promedio se calcula aquí, no se hereda
    // del servidor, para que cambie al instante al publicar tu reseña.
    val summary: RatingSummary = RatingSummary.from(reviews)
}

var detalle by mutableStateOf<UiState<Detalle>>(UiState.Cargando)
    private set

fun cargarDetalle(id: Int) {
    viewModelScope.launch {
        detalle = UiState.Cargando
        detalle = pedir { Detalle(repository.getById(id), repository.getReviews(id)) }
    }
}

private suspend fun <T> pedir(block: suspend () -> T): UiState<T> = try {
    UiState.Exito(block())
} catch (e: IOException) {
    UiState.Error("No hay conexión. Revisa tu internet.")
} catch (e: HttpException) {
    UiState.Error(mensajeDe(e))
}

LaunchedEffect(id) { viewModel.cargarDetalle(id) }

suspend fun editReview(id: Int, stars: Int? = null, comment: String? = null): Review =
    api.editReview(id, EditReviewBody(stars, comment)).toDomain()

/** true si se borró, false si el servidor dijo que no era tuya. */
suspend fun deleteReview(id: Int): Boolean {
    val response = api.deleteReview(id)
    return when (response.code()) {
        204 -> true
        403 -> false
        else -> throw HttpException(response)
    }
}