Merge branch 'dev' into 'main'

Practica finalizada con exito

See merge request !2

.idea/other.xml

@@ -256,6 +256,17 @@
           <option name="screenX" value="1812" />
           <option name="screenY" value="2176" />
         </PersistentDeviceSelectionData>
+        <PersistentDeviceSelectionData>
+          <option name="api" value="34" />
+          <option name="brand" value="samsung" />
+          <option name="codename" value="q6q" />
+          <option name="id" value="q6q" />
+          <option name="manufacturer" value="Samsung" />
+          <option name="name" value="SM-F956B" />
+          <option name="screenDensity" value="420" />
+          <option name="screenX" value="1856" />
+          <option name="screenY" value="2160" />
+        </PersistentDeviceSelectionData>
         <PersistentDeviceSelectionData>
           <option name="api" value="30" />
           <option name="brand" value="google" />

app/src/main/java/com/example/workouttracker/data/models/Ejercicio.kt

@@ -2,9 +2,11 @@ package com.example.workouttracker.data.models
 
 data class Ejercicio(
     val id: String = "",
-    val nombre: String = "",
-    val duracion: Int = 0,
+    val deporte: String = "",           // Nombre exacto del campo en Firebase
+    val duracion: String = "",          // Debe ser String si en Firebase está como cadena
     val intensidad: String = "",
-    val repeticiones: Int = 0,
-    val tipo: String = ""
+    val repeticiones: String = "",      // También debe ser String
+    val tipo: String = "",              // Ejemplo: "Gimnasio"
+    val ejercicio_gimnasio: String = "",// Nombre exacto del campo en Firebase
+    val usuario: String = ""            // Usuario asociado al ejercicio
 )

app/src/main/java/com/example/workouttracker/data/repositories/EjercicioRepository.kt

+package com.example.workouttracker.data.repository
+
+import com.example.workouttracker.FirebaseService
+import com.example.workouttracker.data.models.Ejercicio
+import kotlinx.coroutines.tasks.await
+
+class EjercicioRepository {
+
+    private val exercisesCollection = FirebaseService.firestore.collection("ejercicios")
+
+    // Obtener todos los ejercicios de un usuario específico
+    suspend fun getExercisesByUser(userEmail: String): List<Ejercicio> {
+        return try {
+            val snapshot = exercisesCollection
+                .whereEqualTo("usuario", userEmail)
+                .get()
+                .await()
+            snapshot.documents.mapNotNull { it.toObject(Ejercicio::class.java)?.copy(id = it.id) }
+        } catch (e: Exception) {
+            e.printStackTrace()
+            emptyList()
+        }
+    }
+
+    // Agregar un ejercicio nuevo
+    suspend fun addExercise(exercise: Ejercicio): Boolean {
+        return try {
+            val exerciseData = mapOf(
+                "deporte" to exercise.deporte,
+                "duración" to exercise.duracion,
+                "intensidad" to exercise.intensidad,
+                "repeticiones" to exercise.repeticiones,
+                "tipo" to exercise.tipo,
+                "ejercicio_gimnasio" to exercise.ejercicio_gimnasio,
+                "usuario" to exercise.usuario
+            )
+            exercisesCollection.add(exerciseData).await()
+            true
+        } catch (e: Exception) {
+            e.printStackTrace()
+            false
+        }
+    }
+
+    // Actualizar un ejercicio existente
+    suspend fun updateExercise(exerciseId: String, updates: Map<String, Any>): Boolean {
+        return try {
+            exercisesCollection.document(exerciseId).update(updates).await()
+            true
+        } catch (e: Exception) {
+            e.printStackTrace()
+            false
+        }
+    }
+
+    // Eliminar un ejercicio por ID
+    suspend fun deleteExercise(exerciseId: String): Boolean {
+        return try {
+            exercisesCollection.document(exerciseId).delete().await()
+            true
+        } catch (e: Exception) {
+            e.printStackTrace()
+            false
+        }
+    }
+
+    // Obtener un ejercicio específico por ID
+    suspend fun getExerciseById(exerciseId: String): Ejercicio? {
+        return try {
+            val document = exercisesCollection.document(exerciseId).get().await()
+            if (document.exists()) {
+                document.toObject(Ejercicio::class.java)?.copy(id = document.id)
+            } else {
+                null
+            }
+        } catch (e: Exception) {
+            e.printStackTrace()
+            null
+        }
+    }
+}

app/src/main/java/com/example/workouttracker/data/repositories/ExerciseRepository.kt

-package com.example.workouttracker.data.repositories
-
-class ExerciseRepository {
-
-}
\ No newline at end of file

app/src/main/java/com/example/workouttracker/data/repositories/UserRepository.kt

-package com.example.workouttracker.data.repositories
+package com.example.workouttracker.data.repository
+
+import com.example.workouttracker.FirebaseService
+import com.example.workouttracker.data.models.Usuario
+import kotlinx.coroutines.tasks.await
 
 class UserRepository {
+
+    private val usersCollection = FirebaseService.firestore.collection("usuarios")
+
+    suspend fun createUser(user: Usuario): Boolean {
+        return try {
+            usersCollection.document(user.id).set(user).await()
+            true
+        } catch (e: Exception) {
+            e.printStackTrace()
+            false
+        }
+    }
+
+    suspend fun getUserById(userId: String): Usuario? {
+        return try {
+            val document = usersCollection.document(userId).get().await()
+            document.toObject(Usuario::class.java)
+        } catch (e: Exception) {
+            e.printStackTrace()
+            null
+        }
+    }
+
+    suspend fun updateUser(userId: String, updates: Map<String, Any>): Boolean {
+        return try {
+            usersCollection.document(userId).update(updates).await()
+            true
+        } catch (e: Exception) {
+            e.printStackTrace()
+            false
+        }
+    }
+
+    suspend fun deleteUser(userId: String): Boolean {
+        return try {
+            usersCollection.document(userId).delete().await()
+            true
+        } catch (e: Exception) {
+            e.printStackTrace()
+            false
+        }
+    }
 }

app/src/main/java/com/example/workouttracker/data/service/FirebaseService.kt

+package com.example.workouttracker
+
+import com.google.firebase.auth.FirebaseAuth
+import com.google.firebase.firestore.FirebaseFirestore
+
+object FirebaseService {
+    val auth: FirebaseAuth by lazy { FirebaseAuth.getInstance() }
+    val firestore: FirebaseFirestore by lazy { FirebaseFirestore.getInstance() }
+}

app/src/main/java/com/example/workouttracker/interfaz/screen/DashboardActivity.kt

@@ -5,43 +5,48 @@ import android.os.Bundle
 import android.view.View
 import android.widget.*
 import androidx.activity.ComponentActivity
+import com.example.workouttracker.data.models.Ejercicio
+import com.example.workouttracker.data.repository.EjercicioRepository
 import com.google.firebase.auth.FirebaseAuth
-import com.google.firebase.firestore.FirebaseFirestore
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 
 class DashboardActivity : ComponentActivity() {
 
     private lateinit var auth: FirebaseAuth
-    private lateinit var firestore: FirebaseFirestore
+    private val ejercicioRepository = EjercicioRepository()
+    private val coroutineScope = CoroutineScope(Dispatchers.Main)
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         setContentView(R.layout.activity_dashboard)
 
         auth = FirebaseAuth.getInstance()
-        firestore = FirebaseFirestore.getInstance()
 
+        // Configuración de botones e íconos
         val userIcon = findViewById<ImageView>(R.id.iv_user_icon)
-
         userIcon.setOnClickListener {
-            val intent = Intent(this, UserSettingsActivity::class.java)
-            startActivity(intent)
+            startActivity(Intent(this, UserSettingsActivity::class.java))
         }
 
         val exerciseListButton = findViewById<ImageView>(R.id.iv_exercise_list)
         exerciseListButton.setOnClickListener {
-            val intent = Intent(this, ExerciseListActivity::class.java)
-            startActivity(intent)
+            startActivity(Intent(this, ExerciseListActivity::class.java))
         }
 
-        val currentUser = auth.currentUser
-        val userEmail = currentUser?.email ?: "Usuario no autenticado"
-
+        // Configuración del botón para agregar ejercicio
         val addExerciseButton = findViewById<Button>(R.id.btn_add_exercise)
-        val gymExerciseSpinner = findViewById<Spinner>(R.id.spinner_gym_exercise)
-        val repetitionsEditText = findViewById<EditText>(R.id.et_repetitions)
-        val gymExerciseLayout = findViewById<LinearLayout>(R.id.layout_gym_exercise)
-        val repetitionsLayout = findViewById<LinearLayout>(R.id.layout_repetitions)
+        addExerciseButton.setOnClickListener {
+            agregarEjercicio()
+        }
 
+        configurarSpinners() // Mantener la configuración de los spinners en un método separado
+    }
+
+    private fun configurarSpinners() {
+        // Configuración de spinners y visibilidad según el deporte
         val sportsSpinner = findViewById<Spinner>(R.id.spinner_sport)
         val sportsArray = resources.getStringArray(R.array.sports_array)
         val spinnerAdapter = ArrayAdapter(this, android.R.layout.simple_spinner_item, sportsArray)
@@ -54,18 +59,19 @@ class DashboardActivity : ComponentActivity() {
         intensityAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item)
         intensitySpinner.adapter = intensityAdapter
 
+        val gymExerciseSpinner = findViewById<Spinner>(R.id.spinner_gym_exercise)
         val gymExercisesArray = resources.getStringArray(R.array.gym_exercises_array)
         val gymSpinnerAdapter = ArrayAdapter(this, android.R.layout.simple_spinner_item, gymExercisesArray)
         gymSpinnerAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item)
         gymExerciseSpinner.adapter = gymSpinnerAdapter
 
-        gymExerciseLayout.visibility = View.GONE
-        repetitionsLayout.visibility = View.GONE
+        // Mostrar u ocultar layout de gimnasio según el deporte seleccionado
+        val gymExerciseLayout = findViewById<LinearLayout>(R.id.layout_gym_exercise)
+        val repetitionsLayout = findViewById<LinearLayout>(R.id.layout_repetitions)
 
         sportsSpinner.onItemSelectedListener = object : AdapterView.OnItemSelectedListener {
             override fun onItemSelected(parent: AdapterView<*>, view: View?, position: Int, id: Long) {
                 val selectedSport = parent.getItemAtPosition(position).toString()
-
                 if (selectedSport == "Gimnasio") {
                     gymExerciseLayout.visibility = View.VISIBLE
                     repetitionsLayout.visibility = View.VISIBLE
@@ -80,33 +86,46 @@ class DashboardActivity : ComponentActivity() {
                 repetitionsLayout.visibility = View.GONE
             }
         }
+    }
+
+    private fun agregarEjercicio() {
+        val sportsSpinner = findViewById<Spinner>(R.id.spinner_sport)
+        val intensitySpinner = findViewById<Spinner>(R.id.spinner_intensity)
+        val gymExerciseSpinner = findViewById<Spinner>(R.id.spinner_gym_exercise)
+        val repetitionsEditText = findViewById<EditText>(R.id.et_repetitions)
+        val durationEditText = findViewById<EditText>(R.id.et_duration)
 
-        addExerciseButton.setOnClickListener {
         val selectedSport = sportsSpinner.selectedItem.toString()
-            val duration = findViewById<EditText>(R.id.et_duration).text.toString()
+        val duration = durationEditText.text.toString().ifEmpty { "0" } // Convertimos a cadena
         val intensity = intensitySpinner.selectedItem.toString()
-
-            val exerciseData = mutableMapOf<String, Any>()
-            exerciseData["deporte"] = selectedSport
-            exerciseData["duración"] = duration
-            exerciseData["intensidad"] = intensity
-            exerciseData["usuario"] = userEmail
-
-            if (selectedSport == "Gimnasio") {
-                val selectedGymExercise = gymExerciseSpinner.selectedItem.toString()
-                val repetitions = repetitionsEditText.text.toString()
-
-                exerciseData["ejercicio_gimnasio"] = selectedGymExercise
-                exerciseData["repeticiones"] = repetitions
+        val email = auth.currentUser?.email ?: "Usuario no autenticado"
+        val repetitions = if (selectedSport == "Gimnasio") {
+            repetitionsEditText.text.toString().ifEmpty { "0" }
+        } else "0"
+        val gymExerciseName = if (selectedSport == "Gimnasio") {
+            gymExerciseSpinner.selectedItem.toString()
+        } else ""
+
+        // Crear un objeto Ejercicio usando los valores de los campos
+        val ejercicio = Ejercicio(
+            deporte = selectedSport,
+            duracion = duration,
+            intensidad = intensity,
+            tipo = if (selectedSport == "Gimnasio") "Gimnasio" else "Otro",
+            repeticiones = repetitions,
+            ejercicio_gimnasio = gymExerciseName,
+            usuario = email
+        )
+
+        // Guardar ejercicio en Firebase usando el repositorio
+        coroutineScope.launch {
+            val success = withContext(Dispatchers.IO) {
+                ejercicioRepository.addExercise(ejercicio)
             }
-
-            firestore.collection("ejercicios")
-                .add(exerciseData)
-                .addOnSuccessListener {
-                    Toast.makeText(this, "Ejercicio guardado con éxito", Toast.LENGTH_LONG).show()
-                }
-                .addOnFailureListener {
-                    Toast.makeText(this, "Error al guardar el ejercicio", Toast.LENGTH_LONG).show()
+            if (success) {
+                Toast.makeText(this@DashboardActivity, "Ejercicio guardado con éxito", Toast.LENGTH_LONG).show()
+            } else {
+                Toast.makeText(this@DashboardActivity, "Error al guardar el ejercicio", Toast.LENGTH_LONG).show()
             }
         }
     }

app/src/main/java/com/example/workouttracker/interfaz/screen/EditExerciseActivity.kt

@@ -10,99 +10,118 @@ import android.widget.Spinner
 import android.widget.TextView
 import android.widget.Toast
 import androidx.activity.ComponentActivity
-import com.google.firebase.firestore.FirebaseFirestore
+import com.example.workouttracker.data.models.Ejercicio
+import com.example.workouttracker.data.repository.EjercicioRepository
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 
 class EditExerciseActivity : ComponentActivity() {
 
-    private lateinit var firestore: FirebaseFirestore
+    private val ejercicioRepository = EjercicioRepository()
     private lateinit var documentId: String
     private lateinit var exerciseType: String
+    private val coroutineScope = CoroutineScope(Dispatchers.Main)
+
+    private lateinit var durationEditText: EditText
+    private lateinit var intensitySpinner: Spinner
+    private lateinit var gymExerciseLayout: LinearLayout
+    private lateinit var gymExerciseSpinner: Spinner
+    private lateinit var repetitionsEditText: EditText
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         setContentView(R.layout.activity_edit_exercise)
 
-        firestore = FirebaseFirestore.getInstance()
-
+        // Obtener el ID del documento y el tipo de ejercicio
         documentId = intent.getStringExtra("documentId").toString()
-        exerciseType = intent.getStringExtra("exercise").toString()
-        val duration = intent.getStringExtra("duration").toString()
-        val intensity = intent.getStringExtra("intensidad").toString()
-
-        val backButton = findViewById<Button>(R.id.btn_back)
-        val exerciseTypeTextView = findViewById<TextView>(R.id.tv_exercise_type)
-        val durationEditText = findViewById<EditText>(R.id.et_duration)
-        val intensitySpinner = findViewById<Spinner>(R.id.spinner_intensity)
-        val gymExerciseLayout = findViewById<LinearLayout>(R.id.gym_exercise_layout)
-        val gymExerciseSpinner = findViewById<Spinner>(R.id.spinner_gym_exercise)
-        val repetitionsEditText = findViewById<EditText>(R.id.et_repetitions)
-        val saveButton = findViewById<Button>(R.id.btn_save)
-
-        exerciseTypeTextView.text = "Tipo de ejercicio: $exerciseType"
-        durationEditText.setText(duration)
 
+        // Inicializar vistas
+        durationEditText = findViewById(R.id.et_duration)
+        intensitySpinner = findViewById(R.id.spinner_intensity)
+        gymExerciseLayout = findViewById(R.id.gym_exercise_layout)
+        gymExerciseSpinner = findViewById(R.id.spinner_gym_exercise)
+        repetitionsEditText = findViewById(R.id.et_repetitions)
+
+        configurarSpinners() // Configurar los spinners inicialmente
+
+        // Cargar datos del ejercicio
+        cargarDatosEjercicio()
+
+        findViewById<Button>(R.id.btn_back).setOnClickListener { finish() }
+        findViewById<Button>(R.id.btn_save).setOnClickListener { guardarCambiosEjercicio() }
+    }
+
+    private fun configurarSpinners() {
+        // Configurar opciones de intensidad
         val intensityOptions = arrayOf("Baja", "Media", "Alta")
         val intensityAdapter = ArrayAdapter(this, android.R.layout.simple_spinner_item, intensityOptions)
         intensityAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item)
         intensitySpinner.adapter = intensityAdapter
 
-        val intensityIndex = intensityOptions.indexOf(intensity)
-        if (intensityIndex != -1) {
-            intensitySpinner.setSelection(intensityIndex)
-        }
-
-        if (exerciseType == "Gimnasio") {
-            val gymExercise = intent.getStringExtra("ejercicio_gimnasio").toString()
-            val repetitions = intent.getStringExtra("repeticiones").toString()
-
-            gymExerciseLayout.visibility = View.VISIBLE
-
+        // Configurar opciones de ejercicios de gimnasio
         val gymExerciseOptions = resources.getStringArray(R.array.gym_exercises_array)
         val gymExerciseAdapter = ArrayAdapter(this, android.R.layout.simple_spinner_item, gymExerciseOptions)
         gymExerciseAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item)
         gymExerciseSpinner.adapter = gymExerciseAdapter
-
-            val gymExerciseIndex = gymExerciseOptions.indexOf(gymExercise)
-            if (gymExerciseIndex != -1) {
-                gymExerciseSpinner.setSelection(gymExerciseIndex)
     }
 
-            repetitionsEditText.setText(repetitions)
+    private fun cargarDatosEjercicio() {
+        coroutineScope.launch {
+            val ejercicio = withContext(Dispatchers.IO) {
+                ejercicioRepository.getExerciseById(documentId)
             }
 
-        backButton.setOnClickListener {
+            if (ejercicio != null) {
+                // Cargar los datos en los campos correspondientes
+                findViewById<TextView>(R.id.tv_exercise_type).text = "Tipo de ejercicio: ${ejercicio.tipo}"
+                durationEditText.setText(ejercicio.duracion)
+                intensitySpinner.setSelection(
+                    (intensitySpinner.adapter as ArrayAdapter<String>).getPosition(ejercicio.intensidad)
+                )
+
+                if (ejercicio.tipo == "Gimnasio") {
+                    gymExerciseLayout.visibility = View.VISIBLE
+                    gymExerciseSpinner.setSelection(
+                        (gymExerciseSpinner.adapter as ArrayAdapter<String>).getPosition(ejercicio.ejercicio_gimnasio)
+                    )
+                    repetitionsEditText.setText(ejercicio.repeticiones)
+                } else {
+                    gymExerciseLayout.visibility = View.GONE
+                }
+            } else {
+                // Mostrar un mensaje si el ejercicio no se pudo cargar
+                Toast.makeText(this@EditExerciseActivity, "Error al cargar el ejercicio. Verifica la conexión y vuelve a intentarlo.", Toast.LENGTH_SHORT).show()
                 finish()
             }
+        }
+    }
 
-        saveButton.setOnClickListener {
-            val updatedDuration = durationEditText.text.toString()
-            val updatedIntensity = intensitySpinner.selectedItem.toString()
 
+    private fun guardarCambiosEjercicio() {
+        val updatedDuration = durationEditText.text.toString().ifEmpty { "0" }
+        val updatedIntensity = intensitySpinner.selectedItem.toString()
         val updates = mutableMapOf<String, Any>(
             "duración" to updatedDuration,
             "intensidad" to updatedIntensity
         )
 
         if (exerciseType == "Gimnasio") {
-                val updatedGymExercise = gymExerciseSpinner.selectedItem.toString()
-                val updatedRepetitions = repetitionsEditText.text.toString()
-
-                updates["ejercicio_gimnasio"] = updatedGymExercise
-                updates["repeticiones"] = updatedRepetitions
+            updates["ejercicio_gimnasio"] = gymExerciseSpinner.selectedItem.toString()
+            updates["repeticiones"] = repetitionsEditText.text.toString().ifEmpty { "0" }
         }
 
-            saveExerciseUpdates(documentId, updates)
-        }
+        coroutineScope.launch {
+            val success = withContext(Dispatchers.IO) {
+                ejercicioRepository.updateExercise(documentId, updates)
             }
-
-    private fun saveExerciseUpdates(documentId: String, updates: Map<String, Any>) {
-        firestore.collection("ejercicios").document(documentId).update(updates)
-            .addOnSuccessListener {
-                Toast.makeText(this, "Ejercicio actualizado", Toast.LENGTH_SHORT).show()
+            if (success) {
+                Toast.makeText(this@EditExerciseActivity, "Ejercicio actualizado", Toast.LENGTH_SHORT).show()
                 finish()
+            } else {
+                Toast.makeText(this@EditExerciseActivity, "Error al actualizar el ejercicio", Toast.LENGTH_SHORT).show()
             }
-            .addOnFailureListener {
-                Toast.makeText(this, "Error al actualizar el ejercicio", Toast.LENGTH_SHORT).show()
         }
     }
 }

app/src/main/java/com/example/workouttracker/interfaz/screen/ExerciseListActivity.kt

@@ -2,19 +2,25 @@ package com.example.workouttracker
 
 import android.content.Intent
 import android.os.Bundle
+import android.util.Log
 import android.widget.Button
 import android.widget.Toast
 import androidx.activity.ComponentActivity
 import androidx.recyclerview.widget.LinearLayoutManager
 import androidx.recyclerview.widget.RecyclerView
+import com.example.workouttracker.data.repository.EjercicioRepository
 import com.google.firebase.auth.FirebaseAuth
-import com.google.firebase.firestore.FirebaseFirestore
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 
 class ExerciseListActivity : ComponentActivity() {
 
+    private val ejercicioRepository = EjercicioRepository()
     private lateinit var auth: FirebaseAuth
-    private lateinit var firestore: FirebaseFirestore
     private lateinit var exerciseRecyclerView: RecyclerView
+    private val coroutineScope = CoroutineScope(Dispatchers.Main)
     private var exerciseList = mutableListOf<Map<String, Any>>()
 
     override fun onCreate(savedInstanceState: Bundle?) {
@@ -22,67 +28,69 @@ class ExerciseListActivity : ComponentActivity() {
         setContentView(R.layout.activity_exercise_list)
 
         auth = FirebaseAuth.getInstance()
-        firestore = FirebaseFirestore.getInstance()
-
         exerciseRecyclerView = findViewById(R.id.exercise_list_view)
         exerciseRecyclerView.layoutManager = LinearLayoutManager(this)
 
-        val backButton = findViewById<Button>(R.id.btn_back)
-        backButton.setOnClickListener {
-            finish()
+        findViewById<Button>(R.id.btn_back).setOnClickListener { finish() }
+        cargarEjercicios()  // Cargar ejercicios al iniciar la actividad
     }
 
-        loadExercises()
+    private fun cargarEjercicios() {
+        val userId = auth.currentUser?.email ?: return
+        coroutineScope.launch {
+            val exercises = withContext(Dispatchers.IO) {
+                ejercicioRepository.getExercisesByUser(userId)
             }
-
-    private fun loadExercises() {
-        firestore.collection("ejercicios")
-            .whereEqualTo("usuario", auth.currentUser?.email)
-            .get()
-            .addOnSuccessListener { documents ->
+            if (exercises.isNotEmpty()) {
                 exerciseList.clear()
-                for (document in documents) {
-                    val exerciseData = document.data.toMutableMap()
-                    exerciseData["documentId"] = document.id
-                    exerciseList.add(exerciseData)
-                }
-
-                val adapter = ExerciseListAdapter(this, exerciseList,
-                    { documentId -> deleteExercise(documentId) },
-                    { documentId, exercise, duration -> editExercise(documentId, exercise, duration) }
+                exerciseList.addAll(exercises.map { exercise ->
+                    mapOf(
+                        "deporte" to exercise.deporte,
+                        "duración" to exercise.duracion,
+                        "intensidad" to exercise.intensidad,
+                        "repeticiones" to exercise.repeticiones,
+                        "tipo" to exercise.tipo,
+                        "ejercicio_gimnasio" to exercise.ejercicio_gimnasio,
+                        "usuario" to exercise.usuario,
+                        "documentId" to exercise.id
+                    )
+                })
+                val adapter = ExerciseListAdapter(this@ExerciseListActivity, exerciseList,
+                    { documentId -> eliminarEjercicio(documentId) },
+                    { documentId, deporte, duracion -> editarEjercicio(documentId, deporte, duracion) }
                 )
                 exerciseRecyclerView.adapter = adapter
+            } else {
+                Toast.makeText(this@ExerciseListActivity, "No se encontraron ejercicios", Toast.LENGTH_SHORT).show()
             }
-            .addOnFailureListener {
-                Toast.makeText(this, "Error al cargar los ejercicios", Toast.LENGTH_SHORT).show()
         }
     }
 
-    private fun deleteExercise(documentId: String) {
-        firestore.collection("ejercicios").document(documentId).delete()
-            .addOnSuccessListener {
-                Toast.makeText(this, "Ejercicio eliminado", Toast.LENGTH_SHORT).show()
-                loadExercises()
+    private fun eliminarEjercicio(documentId: String) {
+        coroutineScope.launch {
+            val success = withContext(Dispatchers.IO) {
+                ejercicioRepository.deleteExercise(documentId)
+            }
+            if (success) {
+                Toast.makeText(this@ExerciseListActivity, "Ejercicio eliminado", Toast.LENGTH_SHORT).show()
+                cargarEjercicios() // Recargar la lista después de la eliminación
+            } else {
+                Toast.makeText(this@ExerciseListActivity, "Error al eliminar el ejercicio", Toast.LENGTH_SHORT).show()
             }
-            .addOnFailureListener {
-                Toast.makeText(this, "Error al eliminar el ejercicio", Toast.LENGTH_SHORT).show()
         }
     }
 
-    private fun editExercise(documentId: String, exercise: String, duration: String) {
-        val intensity = exerciseList.find { it["documentId"] == documentId }?.get("intensidad").toString()
-        val gymExercise = exerciseList.find { it["documentId"] == documentId }?.get("ejercicio_gimnasio").toString()
-        val repetitions = exerciseList.find { it["documentId"] == documentId }?.get("repeticiones").toString()
-
+    private fun editarEjercicio(documentId: String, deporte: String, duracion: String) {
+        Log.d("EditExercise", "Document ID: $documentId")  // Agregar esta línea para verificar el ID
         val intent = Intent(this, EditExerciseActivity::class.java)
-        intent.putExtra("documentId", documentId)
-        intent.putExtra("exercise", exercise)
-        intent.putExtra("duration", duration)
-        intent.putExtra("intensidad", intensity)
-
-        if (exercise == "Gimnasio") {
-            intent.putExtra("ejercicio_gimnasio", gymExercise)
-            intent.putExtra("repeticiones", repetitions)
+        intent.putExtra("documentId", documentId)  // Asegúrate de que este ID esté correctamente configurado
+        intent.putExtra("exercise", deporte)
+        intent.putExtra("duration", duracion)
+        intent.putExtra("intensidad", exerciseList.find { it["documentId"] == documentId }?.get("intensidad").toString())
+
+        if (deporte == "Gimnasio") {
+            intent.putExtra("ejercicio_gimnasio", exerciseList.find { it["documentId"] == documentId }?.get("ejercicio_gimnasio").toString())
+            intent.putExtra("repeticiones", exerciseList.find { it["documentId"] == documentId }?.get("repeticiones").toString())
         }
 
         startActivity(intent)

app/src/main/java/com/example/workouttracker/interfaz/screen/ExerciseListAdapter.kt

@@ -29,29 +29,31 @@ class ExerciseListAdapter(
 
     override fun onBindViewHolder(holder: ExerciseViewHolder, position: Int) {
         val exerciseData = exerciseList[position]
-        val exercise = exerciseData["deporte"] as String
-        val duration = exerciseData["duración"] as String
-        val intensity = exerciseData["intensidad"] as String
-        val documentId = exerciseData["documentId"] as String
-
-        holder.exerciseTextView.text = "$exercise - Duración: $duration minutos, Intensidad: $intensity"
-
-        if (exercise == "Gimnasio") {
-            val gymExercise = exerciseData["ejercicio_gimnasio"] as String? ?: "Sin ejercicio"
-            val repetitions = exerciseData["repeticiones"] as String? ?: "N/A"
+        val deporte = exerciseData["deporte"] as? String ?: "Sin especificar"
+        val duracion = exerciseData["duración"] as? String ?: "N/A"
+        val intensidad = exerciseData["intensidad"] as? String ?: "N/A"
+        val repeticiones = exerciseData["repeticiones"] as? String ?: "N/A"
+        val tipo = exerciseData["tipo"] as? String ?: "Otro"
+        val ejercicioGimnasio = exerciseData["ejercicio_gimnasio"] as? String ?: "N/A"
+
+        // Texto a mostrar en el campo principal
+        holder.exerciseTextView.text = "$deporte - Duración: $duracion minutos, Intensidad: $intensidad"
+
+        // Mostrar información adicional para ejercicios de gimnasio
+        if (tipo == "Gimnasio") {
             holder.gymExerciseInfo.visibility = View.VISIBLE
-            holder.gymExerciseInfo.text = "Ejercicio: $gymExercise, Repeticiones: $repetitions"
+            holder.gymExerciseInfo.text = "Ejercicio: $ejercicioGimnasio, Repeticiones: $repeticiones"
         } else {
-
             holder.gymExerciseInfo.visibility = View.GONE
         }
 
+        // Configuración de botones de editar y borrar
+        val documentId = exerciseData["documentId"] as String
         holder.deleteButton.setOnClickListener {
             onDeleteExercise(documentId)
         }
-
         holder.editButton.setOnClickListener {
-            onEditExercise(documentId, exercise, duration)
+            onEditExercise(documentId, deporte, duracion)
         }
     }
 

app/src/main/java/com/example/workouttracker/interfaz/screen/UserSettingsActivity.kt

@@ -6,81 +6,81 @@ import android.widget.Button
 import android.widget.EditText
 import android.widget.Toast
 import androidx.activity.ComponentActivity
+import com.example.workouttracker.data.repository.UserRepository
 import com.google.firebase.auth.FirebaseAuth
-import com.google.firebase.firestore.FirebaseFirestore
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 
 class UserSettingsActivity : ComponentActivity() {
 
+    private val userRepository = UserRepository()
     private lateinit var auth: FirebaseAuth
-    private lateinit var firestore: FirebaseFirestore
     private lateinit var userId: String
+    private val coroutineScope = CoroutineScope(Dispatchers.Main)
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         setContentView(R.layout.activity_user_settings)
 
         auth = FirebaseAuth.getInstance()
-        firestore = FirebaseFirestore.getInstance()
-
-        userId = auth.currentUser?.uid ?: ""
+        userId = auth.currentUser?.uid ?: return  // Detenemos si no hay usuario autenticado
 
         val ageEditText = findViewById<EditText>(R.id.et_age)
         val weightEditText = findViewById<EditText>(R.id.et_weight)
         val heightEditText = findViewById<EditText>(R.id.et_height)
-        val saveButton = findViewById<Button>(R.id.btn_save)
 
-        val backButton = findViewById<Button>(R.id.btn_back)
-        backButton.setOnClickListener {
-            finish()
+        findViewById<Button>(R.id.btn_back).setOnClickListener { finish() }
+        findViewById<Button>(R.id.btn_logout).setOnClickListener { cerrarSesion() }
+        findViewById<Button>(R.id.btn_save).setOnClickListener { guardarCambiosUsuario(ageEditText, weightEditText, heightEditText) }
+
+        cargarDatosUsuario(ageEditText, weightEditText, heightEditText)  // Cargar datos al iniciar
     }
 
-        val logoutButton = findViewById<Button>(R.id.btn_logout)
-        logoutButton.setOnClickListener {
+    private fun cerrarSesion() {
         auth.signOut()
         val intent = Intent(this, LoginRegisterActivity::class.java)
         startActivity(intent)
         finish()
     }
 
-        loadUserData(ageEditText, weightEditText, heightEditText)
-
-        saveButton.setOnClickListener {
-            val age = ageEditText.text.toString().toIntOrNull() ?: 0
-            val weight = weightEditText.text.toString().toDoubleOrNull() ?: 0.0
-            val height = heightEditText.text.toString().toDoubleOrNull() ?: 0.0
-
-            saveUserData(age, weight, height)
+    private fun cargarDatosUsuario(ageEditText: EditText, weightEditText: EditText, heightEditText: EditText) {
+        coroutineScope.launch {
+            val usuario = withContext(Dispatchers.IO) {
+                userRepository.getUserById(userId)
             }
+            usuario?.let {
+                ageEditText.setText(it.edad.toString())
+                weightEditText.setText(it.peso.toString())
+                heightEditText.setText(it.altura.toString())
+            } ?: run {
+                Toast.makeText(this@UserSettingsActivity, "Error al cargar los datos del usuario", Toast.LENGTH_SHORT).show()
             }
-
-    private fun loadUserData(ageEditText: EditText, weightEditText: EditText, heightEditText: EditText) {
-        firestore.collection("usuarios").document(userId).get()
-            .addOnSuccessListener { document ->
-                if (document.exists()) {
-                    ageEditText.setText(document.getLong("edad")?.toString())
-                    weightEditText.setText(document.getDouble("peso")?.toString())
-                    heightEditText.setText(document.getDouble("altura")?.toString())
-                }
-            }
-            .addOnFailureListener {
-                Toast.makeText(this, "Error al cargar los datos del usuario", Toast.LENGTH_SHORT).show()
         }
     }
 
-    private fun saveUserData(age: Int, weight: Double, height: Double) {
-        val userUpdates = mapOf(
+    private fun guardarCambiosUsuario(ageEditText: EditText, weightEditText: EditText, heightEditText: EditText) {
+        val age = ageEditText.text.toString().toIntOrNull() ?: 0
+        val weight = weightEditText.text.toString().toDoubleOrNull() ?: 0.0
+        val height = heightEditText.text.toString().toDoubleOrNull() ?: 0.0
+
+        val updates = mapOf(
             "edad" to age,
             "peso" to weight,
             "altura" to height
         )
 
-        firestore.collection("usuarios").document(userId).update(userUpdates)
-            .addOnSuccessListener {
-                Toast.makeText(this, "Datos actualizados con éxito", Toast.LENGTH_SHORT).show()
-                finish() // Cerrar la actividad y volver al Dashboard
+        coroutineScope.launch {
+            val success = withContext(Dispatchers.IO) {
+                userRepository.updateUser(userId, updates)
+            }
+            if (success) {
+                Toast.makeText(this@UserSettingsActivity, "Datos actualizados con éxito", Toast.LENGTH_SHORT).show()
+                finish()
+            } else {
+                Toast.makeText(this@UserSettingsActivity, "Error al actualizar los datos", Toast.LENGTH_SHORT).show()
             }
-            .addOnFailureListener {
-                Toast.makeText(this, "Error al actualizar los datos", Toast.LENGTH_SHORT).show()
         }
     }
 }