Merge pull request #48 from DavidGarzonDev/odeb

añadiendo vista y logica del sorteo

Author: Zay-M3

backend/src/controllers/auth.controllers.js

@@ -128,3 +128,33 @@ export const login = async (req, res) => {
     return res.status(400).send("Error en login: " + error.message);
   }
 };
+
+export const getUserByUidController = async (req, res) => {
+  const { token, uid } = req.body;
+
+  if (!token || !uid) {
+    return res.status(400).json({ error: "Token y UID son requeridos" });
+  }
+
+  try {
+    // Verificar el token primero para asegurar que la solicitud es legítima
+    await admin.auth().verifyIdToken(token);
+
+    // Obtener el usuario por UID
+    const userData = await getUserByUid(uid);
+    
+    if (!userData || !userData.data) {
+      return res.status(404).json({ error: "Usuario no encontrado" });
+    }
+
+    // Enviamos los datos directamente para evitar anidamientos innecesarios
+    return res.status(200).json(userData);
+  } catch (error) {
+    console.error("Error al obtener usuario por UID:", error);
+    return res.status(500).json({ error: "Error interno del servidor" });
+  }
+};
+
+
+
+

backend/src/controllers/rifa.controllers.js

@@ -1,6 +1,8 @@
-import { createRifa, getRifasUser, getRifa, updateRifa, decrementRifaTickets} from "../models/rifa.model.js";
+import { createRifa, getRifasUser, getRifa, updateRifa, decrementRifaTickets, rifaModel} from "../models/rifa.model.js";
+import { ticketModel } from "../models/ticket.models.js";
 import admin from "../firebase.js";
 import { supabase } from "../db.js";
+import { getUserByUid } from "../models/user.model.js";
 
 
 export const createRifas = async (req, res) => {
@@ -141,4 +143,143 @@ export const decrementRifaTicket = async (req, res) => {
         res.status(500).json({ error: "Error interno del servidor" });
     }
 
-}
+}
+
+// Función para generar un número aleatorio verificable
+function generateVerifiableRandom(seed, max) {
+    // Usamos un algoritmo simple pero verificable
+    // En producción se puede usar un algoritmo más robusto
+    let hash = 0;
+    for (let i = 0; i < seed.length; i++) {
+        hash = ((hash << 5) - hash) + seed.charCodeAt(i);
+        hash |= 0; // Convertir a entero de 32 bits
+    }
+    
+    // Convertimos a positivo y tomamos el módulo para el rango requerido
+    const positiveHash = Math.abs(hash);
+    return positiveHash % max;
+}
+
+// Controlador para verificar si una rifa está lista para sorteo
+export const checkRifaForDraw = async (req, res) => {
+    try {
+        const { rifaId } = req.params;
+        const { token } = req.body;
+        
+        if (!token) {
+            return res.status(401).json({ error: "Autenticación requerida" });
+        }
+        
+        // Verificar que el usuario sea el creador de la rifa
+        const decoded = await admin.auth().verifyIdToken(token);
+        const { uid } = decoded;
+        
+        const { data: rifa } = await rifaModel.getRifa(rifaId);
+        if (!rifa || rifa.userID !== uid) {
+            return res.status(403).json({ error: "No tienes permiso para realizar el sorteo de esta rifa" });
+        }
+        
+        const { isReady, reason } = await rifaModel.isRifaReadyForDraw(rifaId);
+        
+        return res.status(200).json({ 
+            isReady,
+            reason: !isReady ? reason : null,
+            message: isReady ? "La rifa está lista para sorteo" : "La rifa no está lista para sorteo"
+        });
+        
+    } catch (error) {
+        console.error("Error al verificar rifa para sorteo:", error);
+        return res.status(500).json({ error: "Error interno al verificar la rifa" });
+    }
+};
+
+// Controlador para realizar el sorteo
+export const realizarSorteo = async (req, res) => {
+    try {
+        const { rifaId } = req.params;
+        const { token } = req.body;
+        
+        if (!token) {
+            return res.status(401).json({ error: "Autenticación requerida" });
+        }
+        
+        // Verificar que el usuario sea el creador de la rifa
+        const decoded = await admin.auth().verifyIdToken(token);
+        const { uid } = decoded;
+        
+        const { data: rifa } = await rifaModel.getRifa(rifaId);
+        if (!rifa || rifa.userID !== uid) {
+            return res.status(403).json({ error: "No tienes permiso para realizar el sorteo de esta rifa" });
+        }
+        
+        // Verificar si la rifa está lista para sorteo
+        const { isReady, reason } = await rifaModel.isRifaReadyForDraw(rifaId);
+        if (!isReady) {
+            return res.status(400).json({ error: reason || "Esta rifa no está lista para sorteo" });
+        }
+        
+        // Obtener todos los tickets vendidos
+        const tickets = await ticketModel.getTicketsByRifaId(rifaId);
+        
+        if (!tickets || tickets.length === 0) {
+            return res.status(400).json({ error: "No hay tickets vendidos para esta rifa" });
+        }
+        
+        // Generar número aleatorio usando un seed verificable
+        const timestamp = Date.now();
+        const seed = `${timestamp}-${rifaId}-${uid}`;
+        
+        // Seleccionar un índice aleatorio entre todos los boletos vendidos
+        const randomIndex = generateVerifiableRandom(seed, tickets.length);
+        
+        // Seleccionar ganador
+        const ganador = tickets[randomIndex];
+        
+        // Verificamos que el ticket tenga un número de boleto válido
+        if (!ganador.numero_boleto) {
+            // Si no tiene número de boleto, generamos uno con formato correcto
+            ganador.numero_boleto = `#${String(ganador.id).padStart(4, '0')}`;
+            
+            // En un entorno real, podríamos actualizar el boleto en la base de datos
+            // pero para esta implementación solo lo usaremos para mostrar
+        }
+        
+        // Actualizar estado de la rifa y guardar ganador
+        await rifaModel.updateRifaStatus(rifaId, 'Cerrada');
+        await rifaModel.setRifaWinner(rifaId, ganador.id_user, ganador.id);
+        
+
+        const user = await getUserByUid(ganador.id_user);
+
+        if (!user) {
+            return res.status(404).json({ error: "Usuario del ganador no encontrado" });
+        }
+
+        const ganadorInfo = {
+            ticketId: ganador.id,
+            ticketNumber: ganador.numero_boleto,
+            userId: user.data.uid,
+            nombre: user.data.name ? user.data.name : 'Usuario',
+            email: user.data.email ? user.data.email : '',
+        };
+        
+        return res.status(200).json({ 
+            success: true,
+            message: 'Sorteo realizado con éxito',
+            timestamp,
+            seed,
+            randomIndex,
+            totalTickets: tickets.length,
+            ganador: ganadorInfo,
+            rifa: {
+                id: rifa.id,
+                title: rifa.title,
+                prize: rifa.prize
+            }
+        });
+        
+    } catch (error) {
+        console.error("Error al realizar sorteo:", error);
+        return res.status(500).json({ error: "Error interno al realizar el sorteo" });
+    }
+};

backend/src/controllers/ticket.controllers.js

@@ -1,4 +1,4 @@
-import { createTicket, getAllTicketsModel } from "../models/ticket.models.js";
+import { createTicket, getAllTicketsModel, getTicketsByRifaId, ticketModel } from "../models/ticket.models.js";
 import admin from "../firebase.js";
 
 
@@ -45,8 +45,54 @@ export const getAllTickets = async (req, res) => {
 
         res.status(200).json({ tickets: data });
     } catch (error) {
-        console.error("Error en la peticion de tdoas las rifas", error)
+        console.error("Error en la peticion de todas las rifas", error)
         res.status(400).json({error : "Error interno del servidor"})
     }
-    
+}
+
+// Nuevo controlador para obtener tickets por ID de rifa
+export const getTicketsByRifaIdController = async (req, res) => {
+    try {
+        const { rifaId } = req.params;
+        
+        if (!rifaId) {
+            return res.status(400).json({ error: "ID de rifa no proporcionado" });
+        }
+        
+        // Utiliza el modelo para obtener los tickets
+        const tickets = await getTicketsByRifaId(rifaId);
+        
+        res.status(200).json(tickets);
+    } catch (error) {
+        console.error("Error al obtener tickets por ID de rifa:", error);
+        res.status(500).json({ error: "Error interno del servidor" });
+    }
+}
+
+// Controlador para obtener un ticket específico por su ID
+export const getTicketByIdController = async (req, res) => {
+    try {
+        const { ticketId } = req.params;
+        
+        if (!ticketId) {
+            return res.status(400).json({ error: "ID de ticket no proporcionado" });
+        }
+        
+        // Utiliza el modelo para obtener el ticket
+        const { data, error } = await ticketModel.getTicketById(ticketId);
+        
+        if (error) {
+            console.error("Error al obtener ticket por ID:", error);
+            return res.status(500).json({ error: "Error al obtener ticket" });
+        }
+        
+        if (!data) {
+            return res.status(404).json({ error: "Ticket no encontrado" });
+        }
+        
+        res.status(200).json({ ticket: data });
+    } catch (error) {
+        console.error("Error al obtener ticket por ID:", error);
+        res.status(500).json({ error: "Error interno del servidor" });
+    }
 }

backend/src/models/rifa.model.js

@@ -94,4 +94,68 @@ export async function decrementRifaTickets(rifaId, amount){
 
     if (error) throw error;
     return { data, error };
-}
+}
+
+// Nuevas funciones para el sorteo de rifas
+
+export async function updateRifaStatus(rifaId, status) {
+    const { data, error } = await supabase
+        .from('rifas')
+        .update({ state: status })
+        .eq('id', rifaId);
+    
+    if (error) throw error;
+    return { data, error };
+}
+
+export async function setRifaWinner(rifaId, userId, ticketId) {
+    const { data, error } = await supabase
+        .from('rifas')
+        .update({ 
+            winner_user_id: userId,
+            winner_ticket_id: ticketId,
+            draw_date: new Date().toISOString()
+        })
+        .eq('id', rifaId);
+    
+    if (error) throw error;
+    return { data, error };
+}
+
+// Verifica si una rifa está lista para sorteo
+export async function isRifaReadyForDraw(rifaId) {
+    const { data: rifa, error } = await supabase
+        .from('rifas')
+        .select('*')
+        .eq('id', rifaId)
+        .single();
+    
+    if (error) throw error;
+    
+    // Una rifa está lista si:
+    
+    // 2. No tiene ganador todavía
+    // 3. Tiene al menos un ticket vendido
+    const hasNoWinner = !rifa.winner_user_id;
+    const hasTicketsSold = rifa.total_tickets_sold > 0;
+    
+    return { 
+        isReady: hasNoWinner && hasTicketsSold,
+        rifa,
+        reason: !hasTicketsSold ? 'No hay tickets vendidos' : 
+                !hasNoWinner ? 'Esta rifa ya tiene un ganador' : null
+    };
+}
+
+// Exportamos también un objeto con todas las funciones para facilitar las importaciones
+export const rifaModel = {
+    createRifa,
+    getRifasUser,
+    getRifa,
+    updateRifa,
+    deleteRifa,
+    decrementRifaTickets,
+    updateRifaStatus,
+    setRifaWinner,
+    isRifaReadyForDraw
+};

backend/src/models/ticket.models.js

@@ -2,6 +2,7 @@ import { supabase } from "../db.js";
 
 
 export async function createTicket(ticket){
+   
     const { data, error } = await supabase
     .from('tickets')
     .insert([
@@ -24,20 +25,55 @@ export async function createTicket(ticket){
 
 
 export async function getTicketsByRifaId(rifaId) {
+  
     const { data, error } = await supabase
     .from('tickets')
-    .select('*')
-    .eq('rifaId', rifaId); 
+    .select("*")
+    .eq('id_rifa', rifaId);
+    
     if (error) throw error;
-    return { data, error };
+
+    const processedData = data.map(ticket => {
+        if (!ticket.numero_boleto) {
+            ticket.numero_boleto = `#${String(ticket.id).padStart(4, '0')}`;
+        }
+        return ticket;
+    });
+    
+    return processedData; // Retornamos los datos procesados
 }
 
 export async function getAllTicketsModel(userId) {
     const { data, error } = await supabase
     .from('tickets')
     .select('*')
-    .eq('id_user', userId)
+    .eq('id_user', userId);
 
     if (error) throw error;
     return { data, error };
-}
+}
+
+export async function getTicketById(ticketId) {
+    const { data, error } = await supabase
+    .from('tickets')
+    .select('*')
+    .eq('id', ticketId)
+    .single();
+    
+    if (error) throw error;
+    
+    // Procesamos el número de boleto si no existe
+    if (data && !data.numero_boleto) {
+        data.numero_boleto = `#${String(data.id).padStart(4, '0')}`;
+    }
+    
+    return { data, error };
+}
+
+// Exportamos las funciones en un objeto
+export const ticketModel = {
+    createTicket,
+    getTicketsByRifaId,
+    getAllTicketsModel,
+    getTicketById
+};