jorge/triviagmatico
3
0
Fork 0
Code Issues 5 Pull Requests 1 Actions Packages Projects Releases Wiki Activity

Merge branch 'backend'

Browse Source
This commit is contained in:
Victor Rodriguez
2026-09-24 14:10:27 +02:00
parent cb3b00fba3 22f86c2d6d
commit c52fab2d6c
11 changed files with 1469 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
clases/ClaseCategoria.php
+148
View File
@@ -0,0 +1,148 @@
<?php
require_once '../includes/conexionBD.php';
class Categoria{
public $idCategoria;
public $nombreCategoria;
function __construct($idCategoria=null, $nombreCategoria=null){
$this->idCategoria = $idCategoria;
$this->nombreCategoria = $nombreCategoria;
}
function crear(){
$conexion = conexionBD();
if(is_array($conexion)){
return $conexion;
}else{
try{
$consulta = $conexion->prepare("INSERT INTO categoria (nombreCategoria) VALUES (:nombreCategoria)");
$consulta->bindParam(':nombreCategoria', $this->nombreCategoria);
$consulta->execute();
$respuesta = [
'exito' => 'Categoría creada correctamente',
'exito_tecnico' => $this->nombreCategoria
];
return $respuesta;
}catch(PDOException $error){
$respuesta = [
'error' => 'Ocurrió un error al guardar la categoría.',
'error_tecnico' => $error->getMessage()
];
$conexion = null;
return $respuesta;
}
}
}
function listar(){
$conexion = conexionBD();
if(is_array($conexion)){
return $conexion;
}else{
try{
$sql = 'SELECT * FROM categoria';
$consulta = $conexion->prepare($sql);
$consulta->execute();
$resultado = $consulta->fetchAll(PDO::FETCH_ASSOC);
return $resultado;
}catch(PDOException $error){
$respuesta = [
'error' => 'Ocurrió un error al obtener el listado de categorías.',
'error_tecnico' => $error->getMessage()
];
$conexion = null;
return $respuesta;
}
}
}
function buscar(){
$conexion = conexionBD();
if(is_array($conexion)){
return $conexion;
}else{
try{
$consulta = $conexion->prepare("SELECT * FROM categoria WHERE idCategoria = :idCategoria");
$consulta->bindParam(':idCategoria', $this->idCategoria);
$consulta->execute();
$resultado = $consulta->fetch(PDO::FETCH_ASSOC);
return $resultado;
}catch(PDOException $error){
$respuesta = [
'error' => 'Ocurrió un error al buscar la categoría.',
'error_tecnico' => $error->getMessage()
];
$conexion = null;
return $respuesta;
}
}
}
function borrar(){
$conexion = conexionBD();
if(is_array($conexion)){
return $conexion;
}else{
try{
$consulta = $conexion->prepare("DELETE FROM categoria WHERE idCategoria = :idCategoria");
$consulta->bindParam(':idCategoria', $this->idCategoria);
$consulta->execute();
if($consulta->rowCount() > 0){
$respuesta = [
'exito' => 'Se eliminó correctamente la categoría',
'exito_tecnico' => $this->idCategoria
];
}else{
$respuesta = [
'error' => 'No existe ninguna categoría con ese ID.',
'error_tecnico' => $this->idCategoria
];
}
return $respuesta;
}catch(PDOException $error){
$respuesta = [
'error' => 'Ocurrió un error al eliminar la categoría.',
'error_tecnico' => $error->getMessage()
];
$conexion = null;
return $respuesta;
}
}
}
}
?>
clases/ClaseEquipo.php
+148
View File
@@ -0,0 +1,148 @@
<?php
require_once '../includes/conexionBD.php';
class Equipo{
public $idEquipo;
public $nombreEquipo;
function __construct($idEquipo=null, $nombreEquipo=null){
$this->idEquipo = $idEquipo;
$this->nombreEquipo = $nombreEquipo;
}
function crear(){
$conexion = conexionBD();
if(is_array($conexion)){
return $conexion;
}else{
try{
$consulta = $conexion->prepare("INSERT INTO equipo (nombreEquipo) VALUES (:nombreEquipo)");
$consulta->bindParam(':nombreEquipo', $this->nombreEquipo);
$consulta->execute();
$respuesta = [
'exito' => 'Equipo creado correctamente',
'exito_tecnico' => $this->nombreEquipo
];
return $respuesta;
}catch(PDOException $error){
$respuesta = [
'error' => 'Ocurrió un error al guardar el equipo.',
'error_tecnico' => $error->getMessage()
];
$conexion = null;
return $respuesta;
}
}
}
function listar(){
$conexion = conexionBD();
if(is_array($conexion)){
return $conexion;
}else{
try{
$sql = 'SELECT * FROM equipo';
$consulta = $conexion->prepare($sql);
$consulta->execute();
$resultado = $consulta->fetchAll(PDO::FETCH_ASSOC);
return $resultado;
}catch(PDOException $error){
$respuesta = [
'error' => 'Ocurrió un error al obtener el listado de equipos.',
'error_tecnico' => $error->getMessage()
];
$conexion = null;
return $respuesta;
}
}
}
function buscar(){
$conexion = conexionBD();
if(is_array($conexion)){
return $conexion;
}else{
try{
$consulta = $conexion->prepare("SELECT * FROM equipo WHERE idEquipo = :idEquipo");
$consulta->bindParam(':idEquipo', $this->idEquipo);
$consulta->execute();
$resultado = $consulta->fetch(PDO::FETCH_ASSOC);
return $resultado;
}catch(PDOException $error){
$respuesta = [
'error' => 'Ocurrió un error al buscar el equipo.',
'error_tecnico' => $error->getMessage()
];
$conexion = null;
return $respuesta;
}
}
}
function borrar(){
$conexion = conexionBD();
if(is_array($conexion)){
return $conexion;
}else{
try{
$consulta = $conexion->prepare("DELETE FROM equipo WHERE idEquipo = :idEquipo");
$consulta->bindParam(':idEquipo', $this->idEquipo);
$consulta->execute();
if($consulta->rowCount() > 0){
$respuesta = [
'exito' => 'Se eliminó correctamente el equipo',
'exito_tecnico' => $this->idEquipo
];
}else{
$respuesta = [
'error' => 'No existe ningún equipo con ese ID.',
'error_tecnico' => $this->idEquipo
];
}
return $respuesta;
}catch(PDOException $error){
$respuesta = [
'error' => 'Ocurrió un error al eliminar el equipo.',
'error_tecnico' => $error
];
$conexion = null;
return $respuesta;
}
}
}
}
?>
clases/ClaseEquipoxUsuario.php
+58
View File
@@ -0,0 +1,58 @@
<?php
require_once '../includes/conexionBD.php';
class EquipoxUsuario {
public $idEquipoxUsuario;
public $idUsuario;
public $idEquipo;
public function __construct($idEquipoxUsuario = null, $idUsuario = null, $idEquipo = null) {
$this->idEquipoxUsuario = $idEquipoxUsuario;
$this->idUsuario = $idUsuario;
$this->idEquipo = $idEquipo;
}
public function registrarUsuarioEnEquipo() {
$conexion = conexionBD();
if (is_array($conexion)) return $conexion;
try {
$sql = "INSERT INTO equipoxusuario (idUsuario, idEquipo) VALUES (:idUsuario, :idEquipo)";
$consulta = $conexion->prepare($sql);
$consulta->bindParam(':idUsuario', $this->idUsuario);
$consulta->bindParam(':idEquipo', $this->idEquipo);
$consulta->execute();
return [
'exito' => 'Usuario vinculado al equipo correctamente.',
'exito_tecnico' => $conexion->lastInsertId()
];
} catch (PDOException $error) {
return [
'error' => 'Ocurrió un error al unir al usuario con el equipo.',
'error_tecnico' => $error->getMessage()
];
}
}
public static function listarUsuariosPorEquipo($idEquipo) {
$conexion = conexionBD();
if (is_array($conexion)) return $conexion;
try {
$sql = "SELECT u.* FROM equipoxusuario exu
INNER JOIN usuario u ON exu.idUsuario = u.idUsuario
WHERE exu.idEquipo = :idEquipo";
$consulta = $conexion->prepare($sql);
$consulta->bindParam(':idEquipo', $idEquipo);
$consulta->execute();
return $consulta->fetchAll(PDO::FETCH_ASSOC);
} catch (PDOException $error) {
return [
'error' => 'Ocurrió un error al obtener los miembros del equipo.',
'error_tecnico' => $error->getMessage()
];
}
}
}
clases/ClasePartida.php
+452
View File
@@ -0,0 +1,452 @@
<?php
require_once '../includes/conexionBD.php';
class Partida
{
public $idPartida;
public $nombrePartida;
public $idUsuario;
public function __construct(
$idPartida = null,
$nombrePartida = null,
$idUsuario = null
) {
$this->idPartida = $idPartida;
$this->nombrePartida = $nombrePartida;
$this->idUsuario = $idUsuario;
}
public function insertar()
{
$conexion = conexionBD();
if (is_array($conexion)) {
return $conexion;
}
try {
$consulta = $conexion->prepare("
INSERT INTO partida
(nombrePartida,idUsuario)
VALUES
(:nombrePartida,:idUsuario)
");
$consulta->bindParam(":nombrePartida", $this->nombrePartida);
$consulta->bindParam(":idUsuario", $this->idUsuario);
$consulta->execute();
return [
"exito" => "La partida se creó correctamente.",
"exito_tecnico" => $conexion->lastInsertId()
];
} catch (PDOException $error) {
return [
"error" => "Ocurrió un error al guardar la partida.",
'error_tecnico' => $error->getMessage()
];
}
}
public function listar()
{
$conexion = conexionBD();
if (is_array($conexion)) {
return $conexion;
}
try {
$consulta = $conexion->prepare("SELECT * FROM partida");
$consulta->execute();
return $consulta->fetchAll(PDO::FETCH_ASSOC);
} catch (PDOException $error) {
return [
"error" => "Ocurrió un error al obtener el listado.",
'error_tecnico' => $error->getMessage()
];
}
}
public function buscar()
{
$conexion = conexionBD();
if (is_array($conexion)) {
return $conexion;
}
try {
$consulta = $conexion->prepare("
SELECT *
FROM partida
WHERE idPartida=:idPartida
");
$consulta->bindParam(":idPartida", $this->idPartida);
$consulta->execute();
return $consulta->fetch(PDO::FETCH_ASSOC);
} catch (PDOException $error) {
return [
"error" => "Ocurrió un error al buscar la partida.",
'error_tecnico' => $error->getMessage()
];
}
}
public function editar()
{
$conexion = conexionBD();
if (is_array($conexion)) {
return $conexion;
}
try {
$consulta = $conexion->prepare("
UPDATE partida
SET
nombrePartida=:nombrePartida,
idUsuario=:idUsuario
WHERE idPartida=:idPartida
");
$consulta->bindParam(":idPartida", $this->idPartida);
$consulta->bindParam(":nombrePartida", $this->nombrePartida);
$consulta->bindParam(":idUsuario", $this->idUsuario);
$consulta->execute();
return [
"exito" => "La partida se editó correctamente.",
"exito_tecnico" => $this->idPartida
];
} catch (PDOException $error) {
return [
"error" => "Ocurrió un error al editar la partida.",
'error_tecnico' => $error->getMessage()
];
}
}
public function eliminar()
{
$conexion = conexionBD();
if (is_array($conexion)) {
return $conexion;
}
try {
$consulta = $conexion->prepare("
DELETE FROM partida
WHERE idPartida=:idPartida
");
$consulta->bindParam(":idPartida", $this->idPartida);
$consulta->execute();
return [
"exito" => "La partida se eliminó correctamente.",
"exito_tecnico" => $this->idPartida
];
} catch (PDOException $error) {
return [
"error" => "No se pudo eliminar la partida.",
'error_tecnico' => $error->getMessage()
];
}
}
/**
* Devuelve las preguntas asignadas a la partida, junto con el
* idPartidaxPregunta (necesario para guardar respuestas después).
*/
public function getPreguntas()
{
$conexion = conexionBD();
if (is_array($conexion)) {
return $conexion;
}
try {
$consulta = $conexion->prepare("
SELECT
pxp.idPartidaxPregunta,
p.*
FROM partidaxpregunta pxp
INNER JOIN pregunta p
ON pxp.idPregunta=p.idPregunta
WHERE pxp.idPartida=:idPartida
ORDER BY pxp.idPartidaxPregunta
");
$consulta->bindParam(":idPartida", $this->idPartida);
$consulta->execute();
return $consulta->fetchAll(PDO::FETCH_ASSOC);
} catch (PDOException $error) {
return [
"error" => "Ocurrió un error al recuperar las preguntas de la partida.",
'error_tecnico' => $error->getMessage()
];
}
}
/**
* Asocia una pregunta ya existente a esta partida.
*/
public function asignarPregunta($idPregunta)
{
$conexion = conexionBD();
if (is_array($conexion)) {
return $conexion;
}
try {
$consulta = $conexion->prepare("
INSERT INTO partidaxpregunta
(idPartida,idPregunta)
VALUES
(:idPartida,:idPregunta)
");
$consulta->bindParam(":idPartida", $this->idPartida);
$consulta->bindParam(":idPregunta", $idPregunta);
$consulta->execute();
return [
"exito" => "La pregunta se asignó correctamente.",
"exito_tecnico" => $conexion->lastInsertId()
];
} catch (PDOException $error) {
return [
"error" => "Ocurrió un error al asignar la pregunta.",
'error_tecnico' => $error->getMessage()
];
}
}
//Cuenta cuántas preguntas tiene la partida en total. Es la primera mitad de la comprobación "¿ha terminado el usuario de jugar?".
public function contarPreguntasAsignadas()
{
$conexion = conexionBD();
if (is_array($conexion)) {
return $conexion;
}
try {
$consulta = $conexion->prepare("
SELECT COUNT(*) AS total
FROM partidaxpregunta
WHERE idPartida=:idPartida
");
$consulta->bindParam(":idPartida", $this->idPartida);
$consulta->execute();
$fila = $consulta->fetch(PDO::FETCH_ASSOC);
return (int)$fila["total"];
} catch (PDOException $error) {
return [
"error" => "Ocurrió un error al contar las preguntas.",
'error_tecnico' => $error->getMessage()
];
}
}
public function contarRespuestasUsuario($idUsuario)
{
$conexion = conexionBD();
if (is_array($conexion)) {
return $conexion;
}
try {
$consulta = $conexion->prepare("
SELECT COUNT(*) AS total
FROM respuestaalmacenada ra
INNER JOIN partidaxpregunta pxp
ON ra.idPartidaxPregunta=pxp.idPartidaxPregunta
WHERE pxp.idPartida=:idPartida
AND ra.idUsuario=:idUsuario
");
$consulta->bindParam(":idPartida", $this->idPartida);
$consulta->bindParam(":idUsuario", $idUsuario);
$consulta->execute();
$fila = $consulta->fetch(PDO::FETCH_ASSOC);
return (int)$fila["total"];
} catch (PDOException $error) {
return [
"error" => "Ocurrió un error al contar las respuestas del usuario.",
'error_tecnico' => $error->getMessage()
];
}
}
/**
* Sustituye al antiguo campo `terminada`: compara cuántas preguntas
* tiene la partida contra cuántas ha respondido este usuario.
*/
public function estaFinalizadaParaUsuario($idUsuario)
{
$totalPreguntas = $this->contarPreguntasAsignadas();
if (is_array($totalPreguntas)) {
return $totalPreguntas;
}
$totalRespondidas = $this->contarRespuestasUsuario($idUsuario);
if (is_array($totalRespondidas)) {
return $totalRespondidas;
}
return $totalPreguntas > 0 && $totalPreguntas === $totalRespondidas;
}
/**
* Partidas creadas por un usuario, de más reciente a más antigua.
*/
public function listarDelUsuario()
{
$conexion = conexionBD();
if (is_array($conexion)) {
return $conexion;
}
try {
$consulta = $conexion->prepare("
SELECT *
FROM partida
WHERE idUsuario=:idUsuario
ORDER BY idPartida DESC
");
$consulta->bindParam(":idUsuario", $this->idUsuario);
$consulta->execute();
return $consulta->fetchAll(PDO::FETCH_ASSOC);
} catch (PDOException $error) {
return [
"error" => "Ocurrió un error al recuperar las partidas del usuario.",
'error_tecnico' => $error->getMessage()
];
}
}
public function preguntaAsignada($idPregunta)
{
$conexion = conexionBD();
if (is_array($conexion)) {
return $conexion;
}
try {
$consulta = $conexion->prepare("
SELECT COUNT(*) AS total
FROM partidaxpregunta
WHERE idPartida=:idPartida
AND idPregunta=:idPregunta
");
$consulta->bindParam(":idPartida", $this->idPartida);
$consulta->bindParam(":idPregunta", $idPregunta);
$consulta->execute();
$fila = $consulta->fetch(PDO::FETCH_ASSOC);
return (int)$fila["total"] > 0;
} catch (PDOException $error) {
return [
"error" => "Ocurrió un error al comprobar la pregunta.",
'error_tecnico' => $error->getMessage()
];
}
}
/**
* Vincula un equipo a esta partida en la tabla intermedia 'equipoxpartida'.
* Permite registrar qué grupos están participando en este torneo.
*/
public function registrarEquipoEnPartida($idEquipo) {
$conexion = conexionBD(); // Obtenemos la conexión modular del proyecto
if (is_array($conexion)) {
return $conexion; // Si hay error en la conexión, lo devuelve
}
try {
// Preparamos la consulta para insertar la relación en la tabla intermedia real
$consulta = $conexion->prepare("
INSERT INTO equipoxpartida
(idPartida, idEquipo)
VALUES
(:idPartida, :idEquipo)
");
// Vinculamos los parámetros con el objeto de la partida actual y el equipo recibido
$consulta->bindParam(":idPartida", $this->idPartida);
$consulta->bindParam(":idEquipo", $idEquipo);
$consulta->execute();
return [
"exito" => "El equipo se vinculó a la partida correctamente.",
"exito_tecnico" => $conexion->lastInsertId()
];
} catch (PDOException $error) {
// Capturamos el error extrayendo solo el mensaje de texto limpio
return [
"error" => "Ocurrió un error al asignar el equipo a la partida.",
"error_tecnico" => $error->getMessage()
];
}
}
/**
* Obtiene todos los equipos que están compitiendo en esta partida.
* Es útil para mostrar la lista de rivales antes de empezar a responder.
*/
public function getEquiposParticipantes() {
$conexion = conexionBD();
if (is_array($conexion)) {
return $conexion;
}
try {
// Hacemos un INNER JOIN para traer los nombres de los equipos desde la tabla intermedia
$consulta = $conexion->prepare("
SELECT
exp.idEquipoxPartida,
e.idEquipo,
e.nombreEquipo
FROM equipoxpartida exp
INNER JOIN equipo e
ON exp.idEquipo = e.idEquipo
WHERE exp.idPartida = :idPartida
ORDER BY e.nombreEquipo ASC
");
$consulta->bindParam(":idPartida", $this->idPartida);
$consulta->execute();
return $consulta->fetchAll(PDO::FETCH_ASSOC); // Devuelve el array con los equipos rivales
} catch (PDOException $error) {
return [
"error" => "Ocurrió un error al recuperar los equipos de la partida.",
"error_tecnico" => $error->getMessage()
];
}
}
/**
* Obtiene todos los jugadores reales (Usuarios) que están jugando en esta partida.
* Utiliza la tabla 'equipoxusuario' en SQL para cruzar los datos.
*/
public function getJugadoresDeLaPartida() {
$conexion = conexionBD();
if (is_array($conexion)) {
return $conexion;
}
try {
// Cruza la partida con los equipos, y luego los equipos con los usuarios
// para saber los nombres de todas las personas que están jugando el torneo.
$consulta = $conexion->prepare("
SELECT DISTINCT
u.idUsuario,
u.nombreUsuario,
u.email,
e.nombreEquipo
FROM equipoxpartida exp
INNER JOIN equipoxusuario exu
ON exp.idEquipo = exu.idEquipo
INNER JOIN usuario u
ON exu.idUsuario = u.idUsuario
INNER JOIN equipo e
ON exu.idEquipo = e.idEquipo
WHERE exp.idPartida = :idPartida
");
$consulta->bindParam(":idPartida", $this->idPartida);
$consulta->execute();
return $consulta->fetchAll(PDO::FETCH_ASSOC);
} catch (PDOException $error) {
return [
"error" => "Ocurrió un error al obtener la lista de jugadores.",
"error_tecnico" => $error->getMessage()
];
}
}
}
clases/ClasePregunta.php
+112
View File
@@ -0,0 +1,112 @@
<?php
require_once '../includes/conexionBD.php';
class Pregunta {
private ?int $idPregunta;
private int $idCategoria;
private string $nombrePregunta;
private array $respuestas;
public function __construct(int $idCategoria = 0, string $nombrePregunta = "", ?int $idPregunta = null) {
$this->idPregunta = $idPregunta;
$this->idCategoria = $idCategoria;
$this->nombrePregunta = $nombrePregunta;
$this->respuestas = [];
}
public function getIdPregunta(): ?int { return $this->idPregunta; }
public function getIdCategoria(): int { return $this->idCategoria; }
public function setIdCategoria(int $idCategoria): void { $this->idCategoria = $idCategoria; }
public function getNombrePregunta(): string { return $this->nombrePregunta; }
public function setNombrePregunta(string $nombrePregunta): void { $this->nombrePregunta = $nombrePregunta; }
public function getRespuestas(): array { return $this->respuestas; }
public function guardar() {
$conexion = conexionBD();
if (is_array($conexion)) {
return $conexion;
}
try {
$sql = "INSERT INTO pregunta (idCategoria, nombrePregunta) VALUES (:idCat, :texto)";
$stmt = $conexion->prepare($sql);
$stmt->execute([
':idCat' => $this->idCategoria,
':texto' => $this->nombrePregunta
]);
$this->idPregunta = (int)$conexion->lastInsertId();
return [
'exito' => 'Pregunta guardada correctamente',
'exito_tecnico' => $this->idPregunta
];
} catch (PDOException $error) {
return [
'error' => 'Ocurrió un error al guardar la pregunta.',
'error_tecnico' => $error->getMessage()
];
}
}
public function cargarRespuestas() {
if ($this->idPregunta === null) return;
$conexion = conexionBD();
if (is_array($conexion)) {
return $conexion;
}
try {
$sql = "SELECT idRespuesta, nombreRespuesta, correcta FROM respuesta WHERE idPregunta = :idPreg";
$stmt = $conexion->prepare($sql);
$stmt->execute([':idPreg' => $this->idPregunta]);
$this->respuestas = $stmt->fetchAll(PDO::FETCH_ASSOC);
} catch (PDOException $error) {
return [
'error' => 'Ocurrió un error al cargar las respuestas.',
'error_tecnico' => $error->getMessage()
];
}
}
public static function obtenerPorCategoria(int $idCategoria, int $limite = 10) {
$conexion = conexionBD();
if (is_array($conexion)) {
return $conexion;
}
try {
$sql = "SELECT * FROM pregunta WHERE idCategoria = :idCat ORDER BY RAND() LIMIT :limite";
$stmt = $conexion->prepare($sql);
$stmt->bindValue(':idCat', $idCategoria, PDO::PARAM_INT);
$stmt->bindValue(':limite', $limite, PDO::PARAM_INT);
$stmt->execute();
$preguntas = [];
while ($datos = $stmt->fetch(PDO::FETCH_ASSOC)) {
$preg = new Pregunta((int)$datos['idCategoria'], $datos['nombrePregunta'], (int)$datos['idPregunta']);
$preg->cargarRespuestas();
$preguntas[] = $preg;
}
return $preguntas;
} catch (PDOException $error) {
return [
'error' => 'Ocurrió un error al obtener las preguntas aleatorias.',
'error_tecnico' => $error->getMessage()
];
}
}
}
clases/ClaseRespuesta.php
+168
View File
@@ -0,0 +1,168 @@
<?php
require_once '../includes/conexionBD.php';
class Respuesta{
public $idRespuesta;
public $idPregunta;
public $nombreRespuesta;
public $correcta;
public function __construct($idRespuesta=null, $idPregunta=null, $nombreRespuesta=null, $correcta=null){
$this->idRespuesta=$idRespuesta;
$this->idPregunta=$idPregunta;
$this->nombreRespuesta=$nombreRespuesta;
$this->correcta=$correcta;
}//fin constructor
public function insertar(){
$conexion = conexionBD();
if(is_array($conexion)){
return $conexion;
}else{
try{
$consulta = $conexion->prepare("INSERT INTO respuesta (idPregunta, nombreRespuesta, correcta) VALUES (:idPregunta, :nombreRespuesta, :correcta)");
$consulta->bindParam(':idPregunta', $this->idPregunta);
$consulta->bindParam(':nombreRespuesta', $this->nombreRespuesta);
$consulta->bindParam(':correcta', $this->correcta);
$consulta->execute();
$respuesta = [
'exito' => 'La respuesta se guardó correctamente.',
'exito_tecnico' => $conexion->lastInsertId()
];
return $respuesta;
}catch(PDOException $error){
$respuesta = [
'error' => 'Ocurrió un error al guardar la respuesta.',
'error_tecnico' => $error->getMessage()
];
$conexion = null;
return $respuesta;
}
}
}//fin método insertar
public function listar(){
$conexion = conexionBD();
if(is_array($conexion)){
return $conexion;
}else{
try{
$consulta = $conexion->prepare("SELECT * FROM respuesta");
$consulta->execute();
return $consulta->fetchAll(PDO::FETCH_ASSOC);
}catch(PDOException $error){
$respuesta = [
'error' => 'Ocurrió un error al obtener el listado.',
'error_tecnico' => $error->getMessage()
];
$conexion = null;
return $respuesta;
}
}
}//fin método listar
public function eliminar(){
$conexion = conexionBD();
if(is_array($conexion)){
return $conexion;
}else{
try{
$consulta = $conexion->prepare("DELETE FROM respuesta WHERE idRespuesta=:idRespuesta");
$consulta->bindParam(':idRespuesta', $this->idRespuesta);
$consulta->execute();
$respuesta = [
'exito' => 'La respuesta se eliminó correctamente.',
'exito_tecnico' => $this->idRespuesta
];
return $respuesta;
}catch(PDOException $error){
$respuesta = [
'error' => 'No se pudo eliminar la respuesta.',
'error_tecnico' => $error->getMessage()
];
$conexion = null;
return $respuesta;
}
}
}//fin método eliminar
public function editar(){
$conexion = conexionBD();
if(is_array($conexion)){
return $conexion;
}else{
try{
$consulta = $conexion->prepare("UPDATE respuesta SET idPregunta=:idPregunta, nombreRespuesta=:nombreRespuesta, correcta=:correcta WHERE idRespuesta=:idRespuesta");
$consulta->bindParam(':idRespuesta', $this->idRespuesta);
$consulta->bindParam(':idPregunta', $this->idPregunta);
$consulta->bindParam(':nombreRespuesta', $this->nombreRespuesta);
$consulta->bindParam(':correcta', $this->correcta);
$consulta->execute();
$respuesta = [
'exito' => 'La respuesta se editó correctamente.',
'exito_tecnico' => $this->idRespuesta
];
return $respuesta;
}catch(PDOException $error){
$respuesta = [
'error' => 'Ocurrió un error al editar la respuesta.',
'error_tecnico' => $error->getMessage()
];
$conexion = null;
return $respuesta;
}
}
}//fin método editar
public function buscar(){
$conexion = conexionBD();
if(is_array($conexion)){
return $conexion;
}else{
try{
$consulta = $conexion->prepare("SELECT * FROM respuesta WHERE idRespuesta=:idRespuesta");
$consulta->bindParam(':idRespuesta', $this->idRespuesta);
$consulta->execute();
return $consulta->fetchAll(PDO::FETCH_ASSOC);
}catch(PDOException $error){
$respuesta = [
'error' => 'Ocurrió un error al buscar la respuesta.',
'error_tecnico' => $error->getMessage()
];
$conexion = null;
return $respuesta;
}
}
}//fin método buscar
public function listarPorPregunta(){//trae todas las respuestas posibles de una pregunta
$conexion = conexionBD();
if(is_array($conexion)){
return $conexion;
}else{
try{
$consulta = $conexion->prepare("SELECT * FROM respuesta WHERE idPregunta=:idPregunta");
$consulta->bindParam(':idPregunta', $this->idPregunta);
$consulta->execute();
$resultado = $consulta->fetchAll(PDO::FETCH_ASSOC);
if(!isset($resultado[0])){
$respuesta = [
'error' => 'La pregunta no tiene respuestas.'
];
return $respuesta;
}else{
return $resultado;
}
}catch(PDOException $error){
$respuesta = [
'error' => 'Ocurrió un error al obtener las respuestas de la pregunta.',
'error_tecnico' => $error->getMessage()
];
$conexion = null;
return $respuesta;
}
}
}//fin método listarPorPregunta
}//fin clase
?>
clases/ClaseRespuestaAlmacenada.php
+79
View File
@@ -0,0 +1,79 @@
<?php
require_once '../includes/conexionBD.php';
// Clase encargada de registrar las respuestas de los jugadores en tiempo real durante la partida
class RespuestaAlmacenada {
public $idRespuestaAlmacenada;
public $idPartidaxPregunta;
public $idUsuario;
public $idRespuesta;
public $primero; // Indica con 1 o 0 si fue el más rápido en responder correctamente
public function __construct($idRespuestaAlmacenada = null, $idPartidaxPregunta = null, $idUsuario = null, $idRespuesta = null, $primero = 0) {
$this->idRespuestaAlmacenada = $idRespuestaAlmacenada;
$this->idPartidaxPregunta = $idPartidaxPregunta;
$this->idUsuario = $idUsuario;
$this->idRespuesta = $idRespuesta;
$this->primero = $primero;
}
/**
* Guarda la respuesta que ha seleccionado un usuario en una pregunta de la partida.
*/
public function guardarRespuesta() {
$conexion = conexionBD();
if (is_array($conexion)) return $conexion;
try {
$sql = "INSERT INTO respuestaalmacenada (idPartidaxPregunta, idUsuario, idRespuesta, primero)
VALUES (:idPartidaxPregunta, :idUsuario, :idRespuesta, :primero)";
$consulta = $conexion->prepare($sql);
$consulta->bindParam(':idPartidaxPregunta', $this->idPartidaxPregunta);
$consulta->bindParam(':idUsuario', $this->idUsuario);
$consulta->bindParam(':idRespuesta', $this->idRespuesta);
$consulta->bindParam(':primero', $this->primero, PDO::PARAM_INT);
$consulta->execute();
return [
'exito' => 'Respuesta del usuario almacenada correctamente.',
'exito_tecnico' => $conexion->lastInsertId()
];
} catch (PDOException $error) {
return [
'error' => 'Ocurrió un error al guardar la respuesta del jugador.',
'error_tecnico' => $error->getMessage()
];
}
}
/**
* Obtiene los aciertos totales de un usuario en una partida específica.
* Útil para calcular las estadísticas individuales al terminar el juego.
*/
public static function obtenerAciertosUsuarioEnPartida($idPartida, $idUsuario) {
$conexion = conexionBD();
if (is_array($conexion)) return $conexion;
try {
$sql = "SELECT COUNT(*) AS aciertos
FROM respuestaalmacenada ra
INNER JOIN partidaxpregunta pxp ON ra.idPartidaxPregunta = pxp.idPartidaxPregunta
INNER JOIN respuesta r ON ra.idRespuesta = r.idRespuesta
WHERE pxp.idPartida = :idPartida AND ra.idUsuario = :idUsuario AND r.correcta = 1";
$consulta = $conexion->prepare($sql);
$consulta->bindParam(':idPartida', $idPartida);
$consulta->bindParam(':idUsuario', $idUsuario);
$consulta->execute();
$resultado = $consulta->fetch(PDO::FETCH_ASSOC);
return (int)$resultado['aciertos'];
} catch (PDOException $error) {
return [
'error' => 'Ocurrió un error al calcular los aciertos.',
'error_tecnico' => $error->getMessage()
];
}
}
}
clases/ClaseUsuario.php
+142
View File
@@ -0,0 +1,142 @@
<?php
require_once '../includes/conexionBD.php';
class Usuario {
private ?int $idUsuario;
private string $nombreUsuario;
private string $contrasena;
private string $email;
private ?string $avatar;
private ?string $cookie;
private int $aciertos;
private int $victorias;
private int $derrotas;
public function __construct(
string $nombreUsuario = "",
string $contrasena = "",
string $email = "",
?string $avatar = null,
?string $cookie = null,
int $aciertos = 0,
int $victorias = 0,
int $derrotas = 0,
?int $idUsuario = null
) {
$this->idUsuario = $idUsuario;
$this->nombreUsuario = $nombreUsuario;
$this->contrasena = $contrasena;
$this->email = $email;
$this->avatar = $avatar;
$this->cookie = $cookie;
$this->aciertos = $aciertos;
$this->victorias = $victorias;
$this->derrotas = $derrotas;
}
public function getIdUsuario(): ?int { return $this->idUsuario; }
public function getNombreUsuario(): string { return $this->nombreUsuario; }
public function setNombreUsuario(string $nombreUsuario): void { $this->nombreUsuario = $nombreUsuario; }
public function getContrasena(): string { return $this->contrasena; }
public function setContrasena(string $contrasena): void { $this->contrasena = $contrasena; }
public function getEmail(): string { return $this->email; }
public function setEmail(string $email): void { $this->email = $email; }
public function getAvatar(): ?string { return $this->avatar; }
public function setAvatar(?string $avatar): void { $this->avatar = $avatar; }
public function getCookie(): ?string { return $this->cookie; }
public function setCookie(?string $cookie): void { $this->cookie = $cookie; }
public function getAciertos(): int { return $this->aciertos; }
public function setAciertos(int $aciertos): void { $this->aciertos = $aciertos; }
public function getVictorias(): int { return $this->victorias; }
public function setVictorias(int $victorias): void { $this->victorias = $victorias; }
public function getDerrotas(): int { return $this->derrotas; }
public function setDerrotas(int $derrotas): void { $this->derrotas = $derrotas; }
public function registrar() {
$conexion = conexionBD();
if (is_array($conexion)) {
return $conexion;
}
try {
$sql = "INSERT INTO usuario (nombreUsuario, contrasena, email, avatar, cookie, aciertos, victorias, derrotas)
VALUES (:nombre, :pass, :email, :avatar, :cookie, :aciertos, :victorias, :derrotas)";
$stmt = $conexion->prepare($sql);
$passHash = password_hash($this->contrasena, PASSWORD_BCRYPT);
$stmt->execute([
':nombre' => $this->nombreUsuario,
':pass' => $passHash,
':email' => $this->email,
':avatar' => $this->avatar,
':cookie' => $this->cookie,
':aciertos' => $this->aciertos,
':victorias' => $this->victorias,
':derrotas' => $this->derrotas
]);
$this->idUsuario = (int)$conexion->lastInsertId();
return [
'exito' => 'Usuario registrado correctamente',
'exito_tecnico' => $this->idUsuario
];
} catch (PDOException $error) {
return [
'error' => 'Ocurrió un error al registrar el usuario.',
'error_tecnico' => $error->getMessage()
];
}
}
public static function buscarPorId($id) {
$conexion = conexionBD();
if (is_array($conexion)) {
return $conexion;
}
try {
$sql = "SELECT * FROM usuario WHERE idUsuario = :id";
$stmt = $conexion->prepare($sql);
$stmt->execute([':id' => $id]);
$datos = $stmt->fetch(PDO::FETCH_ASSOC);
if ($datos) {
return new Usuario(
$datos['nombreUsuario'],
$datos['contrasena'],
$datos['email'],
$datos['avatar'],
$datos['cookie'],
(int)$datos['aciertos'],
(int)$datos['victorias'],
(int)$datos['derrotas'],
(int)$datos['idUsuario']
);
}
return [
'error' => 'No se encontró ningún usuario con ese ID.'
];
} catch (PDOException $error) {
return [
'error' => 'Ocurrió un error al buscar el usuario.',
'error_tecnico' => $error->getMessage()
];
}
}
}
controladores/controladorEquipoxUsuario.php
+47
View File
@@ -0,0 +1,47 @@
<?php
session_start();
require_once '../clases/ClaseEquipoxUsuario.php';
switch($_POST['orden']){
case 'registrarUsuarioEnEquipo':
if (!isset($_SESSION['idUsuario'])) {
echo json_encode([
'error' => 'No hay una sesión activa de usuario. Por favor, inicie sesión.'
]);
break;
}
$idUsuario = $_SESSION['idUsuario'];
$idEquipo = intval($_POST['idEquipo'] ?? 0);
break;
if ($idEquipo <= 0) {
echo json_encode([
'error' => 'El ID del equipo proporcionado no es válido.'
]);
break;
}
$equipoxusuario = new EquipoxUsuario();
$resultado = $equipoxusuario->registrarUsuarioEnEquipo($idEquipo, $idUsuario);
echo json_encode($resultado);
break;
case 'listarUsuariosPorEquipo':
$idEquipo = intval($_POST['idEquipo'] ?? 0);
if ($idEquipo <= 0) {
echo json_encode(['error' => 'ID de equipo no válido']);
break;
}
$equipoxusuario = new EquipoxUsuario();
$listado = $equipoxusuario->listarUsuariosPorEquipo($idEquipo);
break;
echo json_encode($listado);
break;
}
?>
controladores/controladorUsuario.php
+86
View File
@@ -0,0 +1,86 @@
<?php
session_start();
require_once '../clases/Usuario.php';
switch ($_POST['orden']) {
case 'registrarUsuario':
$nombreUsuario = trim($_POST['nombreUsuario'] ?? '');
$email = trim($_POST['email'] ?? '');
$contrasena = $_POST['contrasena'] ?? '';
if ($nombreUsuario == '' || $email == '' || $contrasena == '') {
echo json_encode([
'error' => 'Todos los campos son obligatorios'
]);
break;
}
$usuarioExistente = Usuario::buscarPorEmail($email);
if ($usuarioExistente instanceof Usuario) {
echo json_encode([
'error' => 'Ya existe una cuenta con ese correo electrónico'
]);
break;
}
$usuario = new Usuario(
$nombreUsuario,
$contrasena,
$email
);
$resultado = $usuario->registrar();
echo json_encode($resultado);
break;
case 'comprobarUsuario':
$email = trim($_POST['email'] ?? '');
$contrasena = $_POST['contrasena'] ?? '';
$resultado = Usuario::login($email, $contrasena);
if ($resultado instanceof Usuario) {
$_SESSION['idUsuario'] = $resultado->getIdUsuario();
$_SESSION['email'] = $resultado->getEmail();
$_SESSION['nombreUsuario'] = $resultado->getNombreUsuario();
echo json_encode([
'exito' => 'Login correcto',
'idUsuario' => $resultado->getIdUsuario(),
'nombreUsuario' => $resultado->getNombreUsuario()
]);
} else {
echo json_encode([
'error' => 'Usuario o contraseña incorrectos'
]);
}
break;
case 'cerrarSesion':
session_destroy();
echo json_encode([
'exito' => 'Sesión cerrada'
]);
break;
}
includes/conexionBD.php
+29
View File
@@ -0,0 +1,29 @@
<?php
function conexionBD() {
// Configuración para Laragon
$servidor = "localhost";
$bd = "triviagmatico"; // Asegúrate de que este sea el nombre de tu BD en HeidiSQL / phpMyAdmin
$usuario = "root";
$pass = ""; // Laragon deja la contraseña de root vacía por defecto
$puerto = "3306";
try {
$dsn = "mysql:host=$servidor;port=$puerto;dbname=$bd;charset=utf8mb4";
$opciones = [
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
PDO::ATTR_EMULATE_PREPARES => false,
];
return new PDO($dsn, $usuario, $pass, $opciones);
} catch (PDOException $error) {
return [
'error' => 'No se pudo conectar a la base de datos.',
'error_tecnico' => $error->getMessage()
];
}
}
?>