se añadio websocket para terminar el remate

2025-11-29 10:46:26 -04:00
commit f1077c108c
53 changed files with 2932 additions and 0 deletions
--- a/src/main/java/com/example/fercoganbackend/FercoganbackendApplication.java
+++ b/src/main/java/com/example/fercoganbackend/FercoganbackendApplication.java
@@ -0,0 +1,13 @@
+package com.example.fercoganbackend;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class FercoganbackendApplication {
+
+	public static void main(String[] args) {
+		SpringApplication.run(FercoganbackendApplication.class, args);
+	}
+
+}
--- a/src/main/java/com/example/fercoganbackend/component/ContadorWebSocketHandler.java
+++ b/src/main/java/com/example/fercoganbackend/component/ContadorWebSocketHandler.java
@@ -0,0 +1,126 @@
+package com.example.fercoganbackend.component;
+
+import com.example.fercoganbackend.service.ContadorService;
+import org.springframework.stereotype.Component;
+import org.springframework.web.socket.*;
+import org.springframework.web.socket.handler.TextWebSocketHandler;
+import java.io.IOException;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.Set;
+import java.util.concurrent.CopyOnWriteArraySet;
+
+@Component
+public class ContadorWebSocketHandler extends TextWebSocketHandler {
+
+    private final Map<String, Set<WebSocketSession>> sesionesPorLote = new ConcurrentHashMap<>();
+    private final ContadorService contadorService;
+
+    public ContadorWebSocketHandler(ContadorService contadorService) {
+        this.contadorService = contadorService;
+    }
+
+    // En ContadorWebSocketHandler
+    public void notificarFinRemate(String remate, String lote) {
+        String message = "{\"estado\":\"finalizado\"}";
+        broadcastToRoom(remate, lote, message);
+    }
+
+
+    @Override
+    public void afterConnectionEstablished(WebSocketSession session) throws Exception {
+        String roomKey = extraerRoomKey(session);
+
+        System.out.println("=== NUEVA CONEXIÓN WEBSOCKET ===");
+        System.out.println("Session ID: " + session.getId());
+        System.out.println("URI: " + session.getUri());
+        System.out.println("Room Key: " + roomKey);
+        System.out.println("Sesiones activas en " + roomKey + ": " +
+                (sesionesPorLote.get(roomKey) != null ? sesionesPorLote.get(roomKey).size() : 0));
+
+        // Agregar sesión a la sala correspondiente
+        sesionesPorLote.computeIfAbsent(roomKey, k -> new CopyOnWriteArraySet<>()).add(session);
+
+        // Enviar valor actual del contador para este lote
+        int valorActual = contadorService.getContador(roomKey);
+        session.sendMessage(new TextMessage(String.valueOf(valorActual)));
+
+        System.out.println("Valor inicial enviado: " + valorActual);
+        System.out.println("=== CONEXIÓN ESTABLECIDA ===");
+    }
+
+    @Override
+    public void afterConnectionClosed(WebSocketSession session, CloseStatus status) {
+        String roomKey = extraerRoomKey(session);
+        Set<WebSocketSession> sesiones = sesionesPorLote.get(roomKey);
+        if (sesiones != null) {
+            sesiones.remove(session);
+            if (sesiones.isEmpty()) {
+                sesionesPorLote.remove(roomKey);
+            }
+        }
+        System.out.println("Conexión cerrada para: " + roomKey + " - " + status);
+    }
+
+    @Override
+    public void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
+        String roomKey = extraerRoomKey(session);
+        String payload = message.getPayload();
+
+        System.out.println("Mensaje recibido de " + roomKey + ": " + payload);
+
+        if ("incrementar".equals(payload)) {
+            int nuevoValor = contadorService.incrementar(roomKey);
+            System.out.println("Incrementando " + roomKey + " a: " + nuevoValor);
+            broadcastToRoom(roomKey, String.valueOf(nuevoValor));
+        }
+    }
+
+    // Broadcast a una sala específica
+    public void broadcastToRoom(String remate, String lote, String message) {
+        String roomKey = generarRoomKey(remate, lote);
+        System.out.println("Broadcast a room: " + roomKey + " - Mensaje: " + message);
+        broadcastToRoom(roomKey, message);
+    }
+
+    private void broadcastToRoom(String roomKey, String message) {
+        Set<WebSocketSession> sesiones = sesionesPorLote.get(roomKey);
+        System.out.println("Buscando sesiones para: " + roomKey);
+        System.out.println("Sesiones encontradas: " + (sesiones != null ? sesiones.size() : 0));
+
+        if (sesiones != null) {
+            for (WebSocketSession session : sesiones) {
+                try {
+                    if (session.isOpen()) {
+                        System.out.println("Enviando a session: " + session.getId());
+                        session.sendMessage(new TextMessage(message));
+                    } else {
+                        System.out.println("Session cerrada: " + session.getId());
+                    }
+                } catch (IOException e) {
+                    System.err.println("Error enviando mensaje a " + session.getId() + ": " + e.getMessage());
+                }
+            }
+        } else {
+            System.out.println("No hay sesiones activas para: " + roomKey);
+        }
+    }
+
+    private String extraerRoomKey(WebSocketSession session) {
+        String path = session.getUri().getPath();
+        String[] segments = path.split("/");
+
+        // Para /ws/remate1/lote1 los segmentos son: ["", "ws", "remate1", "lote1"]
+        if (segments.length >= 4) {
+            String remate = segments[2];  // índice 2 = remate1
+            String lote = segments[3];    // índice 3 = lote1
+            return generarRoomKey(remate, lote);
+        }
+
+        return "default-default";
+    }
+
+    private String generarRoomKey(String remate, String lote) {
+        return remate + "-" + lote;
+    }
+}
--- a/src/main/java/com/example/fercoganbackend/component/EventoWebSocketHandler.java
+++ b/src/main/java/com/example/fercoganbackend/component/EventoWebSocketHandler.java
@@ -0,0 +1,52 @@
+package com.example.fercoganbackend.component;
+
+import org.springframework.stereotype.Component;
+import org.springframework.web.socket.CloseStatus;
+import org.springframework.web.socket.TextMessage;
+import org.springframework.web.socket.WebSocketSession;
+import org.springframework.web.socket.handler.TextWebSocketHandler;
+
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CopyOnWriteArraySet;
+
+@Component
+public class EventoWebSocketHandler extends TextWebSocketHandler {
+
+    private final Map<String, Set<WebSocketSession>> sesionesPorRemate = new ConcurrentHashMap<>();
+
+    @Override
+    public void afterConnectionEstablished(WebSocketSession session) {
+        String remateId = session.getUri().getPath().split("/")[3];
+
+        sesionesPorRemate
+                .computeIfAbsent(remateId, k -> new CopyOnWriteArraySet<>())
+                .add(session);
+
+        System.out.println("[EVENTOS] Cliente conectado al remate: " + remateId);
+    }
+
+    @Override
+    public void afterConnectionClosed(WebSocketSession session, CloseStatus status) {
+        String remateId = session.getUri().getPath().split("/")[3];
+        sesionesPorRemate.getOrDefault(remateId, Set.of()).remove(session);
+        System.out.println("[EVENTOS] Cliente desconectado: " + remateId);
+    }
+
+    public void enviarEvento(String remateId, String mensaje) {
+        Set<WebSocketSession> sesiones = sesionesPorRemate.get(remateId);
+        if (sesiones == null) return;
+
+        for (WebSocketSession session : sesiones) {
+            try {
+                if (session.isOpen()) {
+                    session.sendMessage(new TextMessage(mensaje));
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+}
+
--- a/src/main/java/com/example/fercoganbackend/configuration/CorsConfig.java
+++ b/src/main/java/com/example/fercoganbackend/configuration/CorsConfig.java
@@ -0,0 +1,23 @@
+package com.example.fercoganbackend.configuration;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.servlet.config.annotation.CorsRegistry;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+
+@Configuration
+public class CorsConfig {
+
+    @Bean
+    public WebMvcConfigurer corsConfigurer() {
+        return new WebMvcConfigurer() {
+            @Override
+            public void addCorsMappings(CorsRegistry registry) {
+                registry.addMapping("/**") // permite todos los endpoints
+                        .allowedOrigins("*") // permite todas las apps cliente
+                        .allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS") // métodos permitidos
+                        .allowedHeaders("*"); // cabeceras permitidas
+            }
+        };
+    }
+}
--- a/src/main/java/com/example/fercoganbackend/configuration/SecurityConfig.java
+++ b/src/main/java/com/example/fercoganbackend/configuration/SecurityConfig.java
@@ -0,0 +1,63 @@
+package com.example.fercoganbackend.configuration;
+
+import com.example.fercoganbackend.service.UsuarioDetailsService;
+import jakarta.servlet.http.HttpServletResponse;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.security.authentication.AuthenticationManager;
+import org.springframework.security.config.annotation.authentication.configuration.AuthenticationConfiguration;
+import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.config.annotation.web.configuration.WebSecurityCustomizer;
+import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.security.web.SecurityFilterChain;
+
+@Configuration
+public class SecurityConfig {
+
+    private final UsuarioDetailsService usuarioDetailsService;
+
+    public SecurityConfig(UsuarioDetailsService usuarioDetailsService) {
+        this.usuarioDetailsService = usuarioDetailsService;
+    }
+
+    @Bean
+    public PasswordEncoder passwordEncoder() {
+        return new BCryptPasswordEncoder();
+    }
+
+    @Bean
+    public AuthenticationManager authenticationManager(AuthenticationConfiguration authConfig) throws Exception {
+        return authConfig.getAuthenticationManager();
+    }
+
+    @Bean
+    public WebSecurityCustomizer webSecurityCustomizer() {
+        return (web) -> web.ignoring().requestMatchers("/ws/**");
+    }
+
+    @Bean
+    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
+        http
+                .csrf(AbstractHttpConfigurer::disable)
+                .authorizeHttpRequests(auth -> auth
+                        .requestMatchers("/auth/**").permitAll()
+                        .requestMatchers("/favicon.ico", "/error", "/static/**","/contador/**", "/api/**").permitAll()
+                        .requestMatchers("/ws/**").permitAll() // permitir WS sin auth
+                        .requestMatchers("/admin/**").hasAnyAuthority("SUPER_USUARIO","ADMIN")
+                        .anyRequest().authenticated()
+                )
+                .httpBasic(httpBasic -> httpBasic
+                        .authenticationEntryPoint((request, response, authException) -> {
+                            // Log del fallo de autenticación
+                            System.out.println("Fallo de autenticación: " + authException.getMessage());
+                            response.sendError(HttpServletResponse.SC_UNAUTHORIZED, authException.getMessage());
+                        })
+                );
+        return http.build();
+    }
+
+}
+
+
--- a/src/main/java/com/example/fercoganbackend/configuration/WebSocketConfig.java
+++ b/src/main/java/com/example/fercoganbackend/configuration/WebSocketConfig.java
@@ -0,0 +1,30 @@
+package com.example.fercoganbackend.configuration;
+
+import com.example.fercoganbackend.component.ContadorWebSocketHandler;
+import com.example.fercoganbackend.component.EventoWebSocketHandler;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.socket.config.annotation.EnableWebSocket;
+import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
+import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;
+
+@Configuration
+@EnableWebSocket
+public class WebSocketConfig implements WebSocketConfigurer {
+
+    private final ContadorWebSocketHandler webSocketHandler;
+    private final EventoWebSocketHandler eventoWebSocketHandler;
+
+    public WebSocketConfig(ContadorWebSocketHandler webSocketHandler, EventoWebSocketHandler eventoWebSocketHandler) {
+        this.webSocketHandler = webSocketHandler;
+        this.eventoWebSocketHandler = eventoWebSocketHandler;
+    }
+
+    @Override
+    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
+        registry.addHandler(webSocketHandler, "/ws/{remate}/{lote}")
+                .setAllowedOrigins("*");
+        registry.addHandler(eventoWebSocketHandler, "/ws/eventos/{remate}")
+                .setAllowedOrigins("*");
+
+    }
+}
--- a/src/main/java/com/example/fercoganbackend/controller/AppController.java
+++ b/src/main/java/com/example/fercoganbackend/controller/AppController.java
@@ -0,0 +1,79 @@
+package com.example.fercoganbackend.controller;
+
+import com.example.fercoganbackend.component.ContadorWebSocketHandler;
+import com.example.fercoganbackend.entity.Rol;
+import com.example.fercoganbackend.entity.Usuario;
+import com.example.fercoganbackend.otros.ConfirmadoTF;
+import com.example.fercoganbackend.service.ContadorService;
+import com.example.fercoganbackend.service.UsuarioService;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+import java.util.Set;
+import java.util.List;
+
+@RestController
+public class AppController {
+
+    private final UsuarioService usuarioService;
+    private final ContadorService contadorService;
+    private final ContadorWebSocketHandler webSocketHandler;
+
+    public AppController(UsuarioService usuarioService, ContadorService contadorService, ContadorWebSocketHandler webSocketHandler) {
+        this.usuarioService = usuarioService;
+        this.contadorService = contadorService;
+        this.webSocketHandler = webSocketHandler;
+    }
+
+    // Registro
+    @PostMapping("/auth/registrar")
+    public ResponseEntity<String> registrar(@RequestParam String username,
+                                            @RequestParam String password) {
+        if (usuarioService.estaRegistrado(username)) {
+            return ResponseEntity.status(HttpStatus.CONFLICT).body("Usuario ya existe ❌");
+        }
+
+        usuarioService.registrarUsuario(username, password, Set.of(Rol.CLIENTE));
+        return ResponseEntity.ok("Usuario registrado, pendiente de aprobación ✅");
+    }
+
+
+
+    // Verificar si aprobado
+    @GetMapping("/auth/verificar/{username}")
+    public ConfirmadoTF verificar(@PathVariable String username) {
+        ConfirmadoTF aprobado = usuarioService.registradoYAprobado(username);
+        return aprobado;
+    }
+
+    @GetMapping("/auth/existe/{username}")
+    public ResponseEntity<ConfirmadoTF> existe(@PathVariable String username) {
+        ConfirmadoTF aprobado = usuarioService.registradoYAprobado(username);
+
+        if (aprobado == null) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
+        }
+
+        if (!aprobado.isConfirmed()) { // supongamos que ConfirmadoTF tiene isAprobado()
+            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
+        }
+
+        return ResponseEntity.ok(aprobado);
+    }
+
+
+    // Listar pendientes (solo admin/super)
+    @GetMapping("/admin/pendientes")
+    public List<Usuario> pendientes() {
+        return usuarioService.listarPendientes();
+    }
+
+    // Aceptar usuario (solo admin/super)
+    @PostMapping("/admin/aceptar/{id}")
+    public String aceptar(@PathVariable Long id) {
+        usuarioService.aceptarUsuario(id);
+        return "Usuario aprobado ✅";
+    }
+
+}
+
--- a/src/main/java/com/example/fercoganbackend/controller/CabanaController.java
+++ b/src/main/java/com/example/fercoganbackend/controller/CabanaController.java
@@ -0,0 +1,55 @@
+package com.example.fercoganbackend.controller;
+
+import com.example.fercoganbackend.entity.Cabana;
+import com.example.fercoganbackend.service.CabanaService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("/api/cabanas")
+public class CabanaController {
+
+    @Autowired
+    private CabanaService cabanaService;
+
+    @GetMapping
+    public List<Cabana> getAll() {
+        return cabanaService.findAll();
+    }
+
+    @GetMapping("/{id}")
+    public ResponseEntity<Cabana> getById(@PathVariable Long id) {
+        return cabanaService.findById(id)
+                .map(ResponseEntity::ok)
+                .orElse(ResponseEntity.notFound().build());
+    }
+
+    @PostMapping
+    public Cabana create(@RequestBody Cabana cabana) {
+        return cabanaService.save(cabana);
+    }
+
+    @PutMapping("/{id}")
+    public ResponseEntity<Cabana> update(@PathVariable Long id, @RequestBody Cabana cabana) {
+        return cabanaService.findById(id)
+                .map(existing -> {
+                    // Actualiza solo los campos necesarios
+                    existing.setNombre(cabana.getNombre());
+                    existing.setTelefono(cabana.getTelefono());
+                    existing.setVisible(cabana.getVisible());
+
+                    Cabana updated = cabanaService.save(existing);
+                    return ResponseEntity.ok(updated);
+                })
+                .orElse(ResponseEntity.notFound().build());
+    }
+
+    @DeleteMapping("/{id}")
+    public ResponseEntity<Void> delete(@PathVariable Long id) {
+        cabanaService.delete(id);
+        return ResponseEntity.noContent().build();
+    }
+}
--- a/src/main/java/com/example/fercoganbackend/controller/ContadorController.java
+++ b/src/main/java/com/example/fercoganbackend/controller/ContadorController.java
@@ -0,0 +1,47 @@
+package com.example.fercoganbackend.controller;
+
+import com.example.fercoganbackend.component.ContadorWebSocketHandler;
+import com.example.fercoganbackend.service.ContadorService;
+import org.springframework.web.bind.annotation.*;
+
+@RestController
+@RequestMapping("/contador")
+public class ContadorController {
+    private final ContadorService contadorService;
+    private final ContadorWebSocketHandler webSocketHandler;
+
+    public ContadorController(ContadorService contadorService,
+                              ContadorWebSocketHandler webSocketHandler) {
+        this.contadorService = contadorService;
+        this.webSocketHandler = webSocketHandler;
+    }
+
+    @PostMapping("/incrementar/{remate}/{lote}")
+    public int incrementar(@PathVariable String remate, @PathVariable String lote) {
+        String roomKey = remate + "-" + lote;
+        int nuevoValor = contadorService.incrementar(roomKey);
+
+        System.out.println("=== INCREMENTAR VIA REST ===");
+        System.out.println("Remate: " + remate + ", Lote: " + lote);
+        System.out.println("Room Key: " + roomKey);
+        System.out.println("Nuevo valor: " + nuevoValor);
+
+        webSocketHandler.broadcastToRoom(remate, lote, String.valueOf(nuevoValor));
+        return nuevoValor;
+    }
+
+    @GetMapping("/{remate}/{lote}")
+    public int getContador(@PathVariable String remate, @PathVariable String lote) {
+        return contadorService.getContador(remate + "-" + lote);
+    }
+
+    @PostMapping("/reset/{remate}/{lote}")
+    public int resetContador(@PathVariable String remate, @PathVariable String lote,
+                             @RequestParam(defaultValue = "200") int valorInicial) {
+        String roomKey = remate + "-" + lote;
+        contadorService.setContador(roomKey, valorInicial);
+        int valor = contadorService.getContador(roomKey);
+        webSocketHandler.broadcastToRoom(remate, lote, String.valueOf(valor));
+        return valor;
+    }
+}
--- a/src/main/java/com/example/fercoganbackend/controller/HistorialLotesController.java
+++ b/src/main/java/com/example/fercoganbackend/controller/HistorialLotesController.java
@@ -0,0 +1,31 @@
+package com.example.fercoganbackend.controller;
+
+import com.example.fercoganbackend.dto.PujaRequest;
+import com.example.fercoganbackend.dto.PujaResponse;
+import com.example.fercoganbackend.entity.HistorialLotes;
+import com.example.fercoganbackend.service.HistorialLotesService;
+
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("/api/HistorialPujas")
+public class HistorialLotesController {
+
+    private final HistorialLotesService historialLote;
+
+    public HistorialLotesController(HistorialLotesService historialLote) {
+        this.historialLote = historialLote;
+    }
+
+    @PostMapping
+    public PujaResponse realizarPuja(@RequestBody PujaRequest request) {
+        return historialLote.registrarPuja(request);
+    }
+
+    @GetMapping
+    public List<HistorialLotes> getHistorialLote(){
+        return historialLote.getHistorialLoteAll();
+    }
+}
--- a/src/main/java/com/example/fercoganbackend/controller/LoteController.java
+++ b/src/main/java/com/example/fercoganbackend/controller/LoteController.java
@@ -0,0 +1,51 @@
+package com.example.fercoganbackend.controller;
+
+import com.example.fercoganbackend.entity.Lote;
+import com.example.fercoganbackend.service.LoteService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("/api/lotes")
+public class LoteController {
+
+    @Autowired
+    private LoteService loteService;
+
+    @GetMapping
+    public List<Lote> getAll() {
+        return loteService.findAll();
+    }
+
+    @GetMapping("/{id}")
+    public ResponseEntity<Lote> getById(@PathVariable Long id) {
+        return loteService.findById(id)
+                .map(ResponseEntity::ok)
+                .orElse(ResponseEntity.notFound().build());
+    }
+
+    @PostMapping
+    public Lote create(@RequestBody Lote remate) {
+        return loteService.save(remate);
+    }
+
+    @PutMapping("/{id}")
+    public ResponseEntity<Lote> update(@PathVariable Long id, @RequestBody Lote remate) {
+        return loteService.findById(id)
+                .map(r -> {
+                    remate.setId(id);
+                    return ResponseEntity.ok(loteService.save(remate));
+                })
+                .orElse(ResponseEntity.notFound().build());
+    }
+
+    @DeleteMapping("/{id}")
+    public ResponseEntity<Void> delete(@PathVariable Long id) {
+        loteService.delete(id);
+        return ResponseEntity.noContent().build();
+    }
+}
+
--- a/src/main/java/com/example/fercoganbackend/controller/LoteControllerWebFlux.java
+++ b/src/main/java/com/example/fercoganbackend/controller/LoteControllerWebFlux.java
@@ -0,0 +1,90 @@
+package com.example.fercoganbackend.controller;
+
+import com.example.fercoganbackend.entity.Lote;
+import com.example.fercoganbackend.service.LoteServiceWebFlux;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+import reactor.core.publisher.Flux;
+
+import java.util.List;
+import java.util.Optional;
+
+@RestController
+@RequestMapping("/api/webflux/lotes")
+public class LoteControllerWebFlux {
+
+    @Autowired
+    private LoteServiceWebFlux loteService;
+
+    @GetMapping
+    public java.util.List<Lote> getAll() {
+        return loteService.findAll();
+    }
+
+    @GetMapping("/{id}")
+    public ResponseEntity<Lote> getById(@PathVariable Long id) {
+        return loteService.findById(id)
+                .map(ResponseEntity::ok)
+                .orElse(ResponseEntity.notFound().build());
+    }
+
+    @PostMapping
+    public Lote create(@RequestBody Lote remate) {
+        return loteService.save(remate);
+    }
+
+    @PutMapping("/{id}")
+    public ResponseEntity<Lote> update(@PathVariable Long id, @RequestBody Lote remate) {
+        return loteService.findById(id)
+                .map(r -> {
+                    remate.setId(id);
+                    Lote updated = loteService.save(remate);
+                    return ResponseEntity.ok(updated);
+                })
+                .orElse(ResponseEntity.notFound().build());
+    }
+
+    @DeleteMapping("/{id}")
+    public ResponseEntity<Void> delete(@PathVariable Long id) {
+        loteService.delete(id);
+        return ResponseEntity.noContent().build();
+    }
+
+    // -------------------- NUEVO: SSE por LOTE --------------------
+    // Endpoint que devuelve el flujo de actualizaciones solo para ese lote (id).
+    @GetMapping(value = "/stream/{id}", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
+    public Flux<Lote> streamLoteById(@PathVariable Long id) {
+        // flujo de futuras actualizaciones (todos los lotes, luego filtramos por id)
+        Flux<Lote> updates = loteService.getSink().asFlux()
+                .filter(l -> l != null && l.getId() != null && l.getId().equals(id));
+
+        // enviamos primero el estado actual (si existe), luego las actualizaciones
+        Optional<Lote> current = loteService.findById(id);
+        if (current.isPresent()) {
+            return Flux.concat(Flux.just(current.get()), updates);
+        } else {
+            // si no existe ahora, devolvemos solo futuras actualizaciones (por ejemplo creación posterior)
+            return updates;
+        }
+    }
+
+    @GetMapping(value = "/stream/cabanaid/{cabanaId}", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
+    public Flux<Lote> streamLote(@PathVariable Long cabanaId) {
+        // Flujo de futuras actualizaciones (todos los lotes, luego filtramos por cabanaId)
+        Flux<Lote> updates = loteService.getSink().asFlux()
+                .filter(lote -> lote.getCabana().getId().equals(cabanaId));
+
+        // Enviamos primero el estado actual (todos los lotes de la cabaña), luego las actualizaciones
+        List<Lote> currentLotes = loteService.findByCabanaId(cabanaId);
+
+        if (!currentLotes.isEmpty()) {
+            return Flux.concat(Flux.fromIterable(currentLotes), updates);
+        } else {
+            // Si no existen lotes ahora, devolvemos solo futuras actualizaciones
+            return updates;
+        }
+    }
+}
+
--- a/src/main/java/com/example/fercoganbackend/controller/PujaController.java
+++ b/src/main/java/com/example/fercoganbackend/controller/PujaController.java
@@ -0,0 +1,65 @@
+package com.example.fercoganbackend.controller;
+
+import com.example.fercoganbackend.entity.Puja;
+import com.example.fercoganbackend.service.PujaService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("/api/pujas")
+public class PujaController {
+
+    @Autowired
+    private PujaService pujaService;
+
+    @GetMapping
+    public List<Puja> getAll() {
+        return pujaService.findAll();
+    }
+
+    @GetMapping("/id/{id}")
+    public ResponseEntity<Puja> getById(@PathVariable Long id) {
+        return pujaService.findById(id)
+                .map(ResponseEntity::ok)
+                .orElse(ResponseEntity.notFound().build());
+    }
+    
+    @GetMapping("/informe/{remateId}")
+    public List<Puja> getForInforme(@PathVariable Long remateId){
+        return pujaService.fingForReporte(remateId);
+    }
+    @GetMapping("/remate/{id}")
+    public List<Puja> getForRemate(@PathVariable Long id){
+        return pujaService.findForRemtae(id);
+    }
+
+    //get coincidir con lote y remate
+    @GetMapping("/loteyremate/{loteId}/{remateId}")
+    public List<Puja> getForLoteAndRemate(@PathVariable Long loteId,@PathVariable Long remateId){
+        return pujaService.findForLoteAndRemate(loteId,remateId);
+    }
+
+    @PostMapping
+    public Puja create(@RequestBody Puja puja) {
+        return pujaService.save(puja);
+    }
+
+    @PutMapping("/{id}")
+    public ResponseEntity<Puja> update(@PathVariable Long id, @RequestBody Puja remate) {
+        return pujaService.findById(id)
+                .map(r -> {
+                    remate.setId(id);
+                    return ResponseEntity.ok(pujaService.save(remate));
+                })
+                .orElse(ResponseEntity.notFound().build());
+    }
+
+    @DeleteMapping("/{id}")
+    public ResponseEntity<Void> delete(@PathVariable Long id) {
+        pujaService.delete(id);
+        return ResponseEntity.noContent().build();
+    }
+}
--- a/src/main/java/com/example/fercoganbackend/controller/RemateController.java
+++ b/src/main/java/com/example/fercoganbackend/controller/RemateController.java
@@ -0,0 +1,80 @@
+package com.example.fercoganbackend.controller;
+
+import com.example.fercoganbackend.component.ContadorWebSocketHandler;
+import com.example.fercoganbackend.entity.Remate;
+import com.example.fercoganbackend.repository.RemateRepository;
+import com.example.fercoganbackend.service.RemateService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.io.IOException;
+import java.util.List;
+
+@RestController
+@RequestMapping("/api/remates")
+public class RemateController {
+
+    @Autowired
+    private RemateService remateService;
+
+    @GetMapping
+    public List<Remate> getAll() {
+        return remateService.findAll();
+    }
+
+    private final RemateRepository remateRepository;
+    private final ContadorWebSocketHandler webSocketHandler;
+
+    @Autowired
+    public RemateController(RemateRepository remateRepository,
+                            ContadorWebSocketHandler webSocketHandler) {
+        this.remateRepository = remateRepository;
+        this.webSocketHandler = webSocketHandler;
+    }
+
+    @GetMapping("/{id}")
+    public ResponseEntity<Remate> getById(@PathVariable Long id) {
+        return remateService.findById(id)
+                .map(ResponseEntity::ok)
+                .orElse(ResponseEntity.notFound().build());
+    }
+
+    @PostMapping
+    public Remate create(@RequestBody Remate remate) {
+        return remateService.save(remate);
+    }
+
+    @PutMapping("/{id}")
+    public ResponseEntity<Remate> update(@PathVariable Long id, @RequestBody Remate remate) {
+        return remateService.findById(id)
+                .map(r -> {
+                    remate.setId(id);
+                    return ResponseEntity.ok(remateService.save(remate));
+                })
+                .orElse(ResponseEntity.notFound().build());
+    }
+
+    @DeleteMapping("/{id}")
+    public ResponseEntity<Void> delete(@PathVariable Long id) {
+        remateService.delete(id);
+        return ResponseEntity.noContent().build();
+    }
+
+    @PutMapping("/{remateId}/finalizar/{loteId}")
+    public ResponseEntity<String> finalizarRemate(
+            @PathVariable Long remateId,
+            @PathVariable Long loteId
+    ) {
+        remateRepository.actualizarEstado(remateId, "finalizado");
+
+        remateService.finalizarRemate(remateId,
+                String.valueOf(loteId)
+        );
+
+        return ResponseEntity.ok("Remate finalizado y notificado");
+    }
+
+
+}
+
--- a/src/main/java/com/example/fercoganbackend/controller/UserController.java
+++ b/src/main/java/com/example/fercoganbackend/controller/UserController.java
@@ -0,0 +1,112 @@
+package com.example.fercoganbackend.controller;
+
+import com.example.fercoganbackend.entity.Rol;
+import com.example.fercoganbackend.entity.Usuario;
+import com.example.fercoganbackend.otros.ConfirmadoTF;
+import com.example.fercoganbackend.service.UsuarioService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.Set;
+
+@RestController
+@RequestMapping("/api/usuarios")
+public class UserController {
+
+    @Autowired
+    private UsuarioService service;
+
+
+    // ✅ Obtener todos los usuarios
+    @GetMapping
+    public List<Usuario> getAllUsuarios() {
+        return service.getAll();
+    }
+
+    // ✅ Registrar nuevo usuario
+    @PostMapping("/registrar")
+    public Usuario registrarUsuario(@RequestBody UsuarioRequest request) {
+        return service.registrarUsuario(request.getUsername(), request.getPassword(), request.getRoles());
+    }
+
+    // ✅ Listar usuarios pendientes (no aprobados)
+    @GetMapping("/pendientes")
+    public List<Usuario> listarPendientes() {
+        return service.listarPendientes();
+    }
+
+    // ✅ Aceptar usuario (cambiar a aprobado = true)
+    @PatchMapping("/aceptar/{id}")
+    public Usuario aceptarUsuario(@PathVariable Long id) {
+        return service.aceptarUsuario(id);
+    }
+
+    // ✅ Verificar si un usuario está aprobado
+    @GetMapping("/aprobado/{username}")
+    public boolean estaAprobado(@PathVariable String username) {
+        return service.estaAprobado(username);
+    }
+
+    // ✅ Verificar si un usuario está registrado
+    @GetMapping("/registrado/{username}")
+    public boolean estaRegistrado(@PathVariable String username) {
+        return service.estaRegistrado(username);
+    }
+
+    // ✅ Confirmar si está registrado y aprobado
+    @GetMapping("/confirmado/{username}")
+    public ConfirmadoTF registradoYAprobado(@PathVariable String username) {
+        return service.registradoYAprobado(username);
+    }
+
+    // ✅ Actualizar usuario (por id)
+    @PutMapping("/{id}")
+    public Usuario actualizarUsuario(@PathVariable Long id, @RequestBody Usuario usuario) {
+        return service.actualizarUsuario(id, usuario);
+    }
+
+
+    // ✅ Eliminar usuario
+    @DeleteMapping("/{id}")
+    public ResponseEntity<String> eliminarUsuario(@PathVariable Long id) {
+        service.eliminarUsuario(id);
+        return ResponseEntity.ok("Usuario eliminado correctamente");
+    }
+
+
+    // ✅ DTO interno para registro
+    public static class UsuarioRequest {
+        private String username;
+        private String password;
+        private Set<Rol> roles;
+
+        public String getUsername() {
+            return username;
+        }
+
+        public void setUsername(String username) {
+            this.username = username;
+        }
+
+        public String getPassword() {
+            return password;
+        }
+
+        public void setPassword(String password) {
+            this.password = password;
+        }
+
+        public Set<Rol> getRoles() {
+            return roles;
+        }
+
+        public void setRoles(Set<Rol> roles) {
+            this.roles = roles;
+        }
+    }
+}
--- a/src/main/java/com/example/fercoganbackend/dto/PujaRequest.java
+++ b/src/main/java/com/example/fercoganbackend/dto/PujaRequest.java
@@ -0,0 +1,29 @@
+package com.example.fercoganbackend.dto;
+
+import java.time.LocalDateTime;
+
+public class PujaRequest {
+    private LocalDateTime fecha;
+    private Double monto;
+    private Boolean visible;
+
+    private Long usuarioId;
+    private Long cabanaId;
+    private Long loteId;
+    private Long remateId;
+
+    public Long getRemateId(){
+        return remateId;
+    }
+    public Long getUsuarioId() {
+        return usuarioId;
+    }
+
+    public Long getLoteId() {
+        return loteId;
+    }
+
+    public Double getMonto() {
+        return monto;
+    }
+}
--- a/src/main/java/com/example/fercoganbackend/dto/PujaResponse.java
+++ b/src/main/java/com/example/fercoganbackend/dto/PujaResponse.java
@@ -0,0 +1,53 @@
+package com.example.fercoganbackend.dto;
+
+import java.time.LocalDateTime;
+
+public class PujaResponse {
+
+    private Long pujaId;
+    private Long loteId;
+    private Long remateId;
+    private Long usuarioId;
+
+    private Double montoPujado;
+    private LocalDateTime fecha;
+    private String estado;
+
+    public PujaResponse(Long pujaId, Long loteId, Long usuarioId,Long remateId,
+                        Double montoPujado, LocalDateTime fecha, String estado) {
+        this.pujaId = pujaId;
+        this.loteId = loteId;
+        this.remateId = remateId;
+        this.usuarioId = usuarioId;
+        this.montoPujado = montoPujado;
+        this.fecha = fecha;
+        this.estado = estado;
+    }
+    public Long getRemateId(){
+        return remateId;
+    }
+
+    public Long getPujaId() {
+        return pujaId;
+    }
+
+    public Long getLoteId() {
+        return loteId;
+    }
+
+    public Long getUsuarioId() {
+        return usuarioId;
+    }
+
+    public Double getMontoPujado() {
+        return montoPujado;
+    }
+
+    public LocalDateTime getFecha() {
+        return fecha;
+    }
+
+    public String getEstado() {
+        return estado;
+    }
+}
--- a/src/main/java/com/example/fercoganbackend/entity/Cabana.java
+++ b/src/main/java/com/example/fercoganbackend/entity/Cabana.java
@@ -0,0 +1,49 @@
+package com.example.fercoganbackend.entity;
+
+import jakarta.persistence.*;
+
+// Cabaña
+@Entity
+@Table(name = "cabanas")
+public class Cabana {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    private String nombre;
+    private Integer telefono;
+    private Boolean visible = true;
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public Integer getTelefono() {
+        return telefono;
+    }
+
+    public void setTelefono(Integer telefono) {
+        this.telefono = telefono;
+    }
+
+    public String getNombre() {
+        return nombre;
+    }
+
+    public void setNombre(String nombre) {
+        this.nombre = nombre;
+    }
+
+    public Boolean getVisible() {
+        return visible;
+    }
+
+    public void setVisible(Boolean visible) {
+        this.visible = visible;
+    }
+}
+
--- a/src/main/java/com/example/fercoganbackend/entity/HistorialLotes.java
+++ b/src/main/java/com/example/fercoganbackend/entity/HistorialLotes.java
@@ -0,0 +1,107 @@
+package com.example.fercoganbackend.entity;
+
+
+import jakarta.persistence.*;
+
+import java.time.LocalDateTime;
+
+@Entity
+@Table(name = "historial_lotes")
+public class HistorialLotes {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    // Usuario que realizó la puja
+    @ManyToOne
+    @JoinColumn(name = "usuario_id", nullable = false)
+    private Usuario usuario;
+
+    // Lote al que pertenece la puja
+    @ManyToOne
+    @JoinColumn(name = "lote_id", nullable = false)
+    private Lote lote;
+
+    @ManyToOne
+    @JoinColumn(name= "remate_id",nullable = false)
+    private Remate remate;
+
+    // Monto pujado
+    @Column(nullable = false)
+    private Double monto;
+
+    // Fecha y hora de la puja
+    @Column(nullable = false)
+    private LocalDateTime fecha;
+
+    // Estado de la puja (opcional)
+    private String estado;
+
+    public HistorialLotes() {}
+
+    public HistorialLotes(Usuario usuario, Lote lote, Double monto, LocalDateTime fecha, String estado, Remate remate) {
+        this.usuario = usuario;
+        this.lote = lote;
+        this.remate = remate;
+        this.monto = monto;
+        this.fecha = fecha;
+        this.estado = estado;
+    }
+
+    public Remate getRemate() {
+        return remate;
+    }
+
+    public void setRemate(Remate remate) {
+        this.remate = remate;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public Usuario getUsuario() {
+        return usuario;
+    }
+
+    public void setUsuario(Usuario usuario) {
+        this.usuario = usuario;
+    }
+
+    public Lote getLote() {
+        return lote;
+    }
+
+    public void setLote(Lote lote) {
+        this.lote = lote;
+    }
+
+    public Double getMonto() {
+        return monto;
+    }
+
+    public void setMonto(Double monto) {
+        this.monto = monto;
+    }
+
+    public LocalDateTime getFecha() {
+        return fecha;
+    }
+
+    public void setFecha(LocalDateTime fecha) {
+        this.fecha = fecha;
+    }
+
+    public String getEstado() {
+        return estado;
+    }
+
+    public void setEstado(String estado) {
+        this.estado = estado;
+    }
+}
--- a/src/main/java/com/example/fercoganbackend/entity/Lote.java
+++ b/src/main/java/com/example/fercoganbackend/entity/Lote.java
@@ -0,0 +1,126 @@
+package com.example.fercoganbackend.entity;
+
+import jakarta.persistence.*;
+
+// Lote
+@Entity
+@Table(name = "lotes")
+public class Lote {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    private String nombre;
+    private Double precio;
+    private String raza;
+    private Double prelance;
+    private Double puja;
+    private String estado;
+    private Boolean visible = true;
+    private String video;
+    private int numLote;
+
+    @ManyToOne
+    @JoinColumn(name = "remate_id")
+    private Remate remate;
+
+    @ManyToOne
+    @JoinColumn(name = "cabana_id")
+    private Cabana cabana;
+
+    public int getNumLote() {
+        return numLote;
+    }
+
+    public void setNumLote(int numLote) {
+        this.numLote = numLote;
+    }
+
+    public String getVideo() {
+        return video;
+    }
+
+    public void setVideo(String video) {
+        this.video = video;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getNombre() {
+        return nombre;
+    }
+
+    public void setNombre(String nombre) {
+        this.nombre = nombre;
+    }
+
+    public Double getPrecio() {
+        return precio;
+    }
+
+    public void setPrecio(Double precio) {
+        this.precio = precio;
+    }
+
+    public String getRaza() {
+        return raza;
+    }
+
+    public void setRaza(String raza) {
+        this.raza = raza;
+    }
+
+    public Double getPrelance() {
+        return prelance;
+    }
+
+    public void setPrelance(Double prelance) {
+        this.prelance = prelance;
+    }
+
+    public Double getPuja() {
+        return puja;
+    }
+
+    public void setPuja(Double puja) {
+        this.puja = puja;
+    }
+
+    public String getEstado() {
+        return estado;
+    }
+
+    public void setEstado(String estado) {
+        this.estado = estado;
+    }
+
+    public Boolean getVisible() {
+        return visible;
+    }
+
+    public void setVisible(Boolean visible) {
+        this.visible = visible;
+    }
+
+    public Remate getRemate() {
+        return remate;
+    }
+
+    public void setRemate(Remate remate) {
+        this.remate = remate;
+    }
+
+    public Cabana getCabana() {
+        return cabana;
+    }
+
+    public void setCabana(Cabana cabana) {
+        this.cabana = cabana;
+    }
+}
--- a/src/main/java/com/example/fercoganbackend/entity/Puja.java
+++ b/src/main/java/com/example/fercoganbackend/entity/Puja.java
@@ -0,0 +1,87 @@
+package com.example.fercoganbackend.entity;
+
+import jakarta.persistence.*;
+
+import java.time.LocalDateTime;
+
+// Puja
+@Entity
+@Table(name = "pujas")
+public class Puja {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    private LocalDateTime fecha;
+    private Double monto;
+    private Boolean visible;
+
+    @ManyToOne
+    @JoinColumn(name = "usuario_id")
+    private Usuario usuario; // ya lo tienes
+
+    @ManyToOne
+    @JoinColumn(name = "cabana_id")
+    private Cabana cabana;
+
+    @ManyToOne
+    @JoinColumn(name = "lote_id")
+    private Lote lote;
+
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public LocalDateTime getFecha() {
+        return fecha;
+    }
+
+    public void setFecha(LocalDateTime fecha) {
+        this.fecha = fecha;
+    }
+
+    public Double getMonto() {
+        return monto;
+    }
+
+    public void setMonto(Double monto) {
+        this.monto = monto;
+    }
+
+    public Boolean getVisible() {
+        return visible;
+    }
+
+    public void setVisible(Boolean visible) {
+        this.visible = visible;
+    }
+
+    public Usuario getUsuario() {
+        return usuario;
+    }
+
+    public void setUsuario(Usuario usuario) {
+        this.usuario = usuario;
+    }
+
+    public Cabana getCabana() {
+        return cabana;
+    }
+
+    public void setCabana(Cabana cabana) {
+        this.cabana = cabana;
+    }
+
+    public Lote getLote() {
+        return lote;
+    }
+
+    public void setLote(Lote lote) {
+        this.lote = lote;
+    }
+}
--- a/src/main/java/com/example/fercoganbackend/entity/Remate.java
+++ b/src/main/java/com/example/fercoganbackend/entity/Remate.java
@@ -0,0 +1,81 @@
+package com.example.fercoganbackend.entity;
+
+import jakarta.persistence.*;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+
+// Remate
+@Entity
+@Table(name = "remates")
+public class Remate {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+    private LocalDateTime fechaFin;
+    private String nombre;
+    private LocalDateTime fecha;
+    private String urlListaLotes;
+    private String estado;
+    private Boolean visible = true;
+
+    @ManyToOne
+    @JoinColumn(name = "cabana_id")
+    private Cabana cabana;
+    //getter and setter
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getNombre() {
+        return nombre;
+    }
+
+    public void setNombre(String nombre) {
+        this.nombre = nombre;
+    }
+
+    public LocalDateTime getFecha() {
+        return fecha;
+    }
+
+    public void setFecha(LocalDateTime fecha) {
+        this.fecha = fecha;
+    }
+
+    public String getUrlListaLotes() {
+        return urlListaLotes;
+    }
+
+    public void setUrlListaLotes(String urlListaLotes) {
+        this.urlListaLotes = urlListaLotes;
+    }
+
+    public String getEstado() {
+        return estado;
+    }
+
+    public void setEstado(String estado) {
+        this.estado = estado;
+    }
+
+    public Boolean getVisible() {
+        return visible;
+    }
+
+    public void setVisible(Boolean visible) {
+        this.visible = visible;
+    }
+
+    public Cabana getCabana() {
+        return cabana;
+    }
+
+    public void setCabana(Cabana cabana) {
+        this.cabana = cabana;
+    }
+}
--- a/src/main/java/com/example/fercoganbackend/entity/Rol.java
+++ b/src/main/java/com/example/fercoganbackend/entity/Rol.java
@@ -0,0 +1,6 @@
+package com.example.fercoganbackend.entity;
+
+
+public enum Rol {
+    SUPER_USUARIO, ADMIN, COLABORADOR, CLIENTE
+}
--- a/src/main/java/com/example/fercoganbackend/entity/Usuario.java
+++ b/src/main/java/com/example/fercoganbackend/entity/Usuario.java
@@ -0,0 +1,74 @@
+package com.example.fercoganbackend.entity;
+
+import jakarta.persistence.*;
+import java.util.Set;
+
+@Entity
+public class Usuario {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    private String username;
+    private String password;
+
+    @Column(nullable = false)
+    private Boolean aprobado = false;
+
+    @ElementCollection(fetch = FetchType.EAGER)
+    @Enumerated(EnumType.STRING)
+    private Set<Rol> roles; // aquí consumes el enum
+
+    private Boolean visible = true;
+
+    // getters y setters
+
+
+    public Boolean getVisible() {
+        return visible;
+    }
+
+    public void setVisible(Boolean visible) {
+        this.visible = visible;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getUsername() {
+        return username;
+    }
+
+    public void setUsername(String username) {
+        this.username = username;
+    }
+
+    public String getPassword() {
+        return password;
+    }
+
+    public void setPassword(String password) {
+        this.password = password;
+    }
+
+    public boolean isAprobado() {
+        return aprobado;
+    }
+
+    public void setAprobado(boolean aprobado) {
+        this.aprobado = aprobado;
+    }
+
+    public Set<Rol> getRoles() {
+        return roles;
+    }
+
+    public void setRoles(Set<Rol> roles) {
+        this.roles = roles;
+    }
+}
--- a/src/main/java/com/example/fercoganbackend/otros/ConfirmadoTF.java
+++ b/src/main/java/com/example/fercoganbackend/otros/ConfirmadoTF.java
@@ -0,0 +1,25 @@
+package com.example.fercoganbackend.otros;
+
+public class ConfirmadoTF {
+    private  boolean  authenticated;
+    private  boolean confirmed;
+
+    public ConfirmadoTF(){
+    }
+
+    public boolean isAuthenticated() {
+        return authenticated;
+    }
+
+    public void setAuthenticated(boolean authenticated) {
+        this.authenticated = authenticated;
+    }
+
+    public boolean isConfirmed() {
+        return confirmed;
+    }
+
+    public void setConfirmed(boolean confirmed) {
+        this.confirmed = confirmed;
+    }
+}
--- a/src/main/java/com/example/fercoganbackend/otros/UsuarioPrincipal.java
+++ b/src/main/java/com/example/fercoganbackend/otros/UsuarioPrincipal.java
@@ -0,0 +1,54 @@
+package com.example.fercoganbackend.otros;
+
+import com.example.fercoganbackend.entity.Usuario;
+import org.springframework.security.core.GrantedAuthority;
+import org.springframework.security.core.authority.SimpleGrantedAuthority;
+import org.springframework.security.core.userdetails.UserDetails;
+import java.util.Collection;
+import java.util.stream.Collectors;
+
+public class UsuarioPrincipal implements UserDetails {
+    private final Usuario usuario;
+
+    public UsuarioPrincipal(Usuario usuario) {
+        this.usuario = usuario;
+    }
+
+    @Override
+    public Collection<? extends GrantedAuthority> getAuthorities() {
+        return usuario.getRoles().stream()
+                .map(r -> new SimpleGrantedAuthority("ROLE_" + r.name()))
+                .collect(Collectors.toList());
+    }
+
+    @Override
+    public String getPassword() {
+        return usuario.getPassword();
+    }
+
+    @Override
+    public String getUsername() {
+        return usuario.getUsername();
+    }
+
+    @Override
+    public boolean isAccountNonExpired() {
+        return true;
+    }
+
+    @Override
+    public boolean isAccountNonLocked() {
+        return true;
+    }
+
+    @Override
+    public boolean isCredentialsNonExpired() {
+        return true;
+    }
+
+    @Override
+    public boolean isEnabled() {
+        return usuario.isAprobado(); // aquí usamos tu booleano
+    }
+}
+
--- a/src/main/java/com/example/fercoganbackend/repository/CabanaRepository.java
+++ b/src/main/java/com/example/fercoganbackend/repository/CabanaRepository.java
@@ -0,0 +1,7 @@
+package com.example.fercoganbackend.repository;
+
+import com.example.fercoganbackend.entity.Cabana;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface CabanaRepository extends JpaRepository<Cabana, Long> {}
+
--- a/src/main/java/com/example/fercoganbackend/repository/HistorialLotesRepository.java
+++ b/src/main/java/com/example/fercoganbackend/repository/HistorialLotesRepository.java
@@ -0,0 +1,30 @@
+package com.example.fercoganbackend.repository;
+
+import com.example.fercoganbackend.entity.HistorialLotes;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+@Repository
+public interface HistorialLotesRepository extends JpaRepository<HistorialLotes, Long> {
+
+    List<HistorialLotes> findByLoteIdOrderByFechaDesc(Long loteId);
+
+    HistorialLotes findFirstByLoteIdOrderByFechaDesc(Long loteId);
+
+    List<HistorialLotes> findByLote_Remate_Id(Long remateId);
+
+    List<HistorialLotes> findByLote_IdAndLote_Remate_Id(Long loteId, Long remateId);
+
+    List<HistorialLotes> findByLote_IdAndLote_Remate_IdAndFechaAfter(
+            Long loteId,
+            Long remateId,
+            LocalDateTime fecha
+    );
+    List<HistorialLotes> findByLote_Remate_IdAndFechaAfter(
+            Long remateId,
+            LocalDateTime fecha
+    );
+}
--- a/src/main/java/com/example/fercoganbackend/repository/LoteRepository.java
+++ b/src/main/java/com/example/fercoganbackend/repository/LoteRepository.java
@@ -0,0 +1,16 @@
+package com.example.fercoganbackend.repository;
+
+import com.example.fercoganbackend.entity.Lote;
+import org.springframework.data.domain.Page;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.List;
+
+public interface LoteRepository extends JpaRepository<Lote, Long> {
+    // Con ordenamiento
+    //List<Lote> findByCabanaIdOrderByNumeroLote(Long cabanaId);
+
+    // Para paginación
+    List<Lote> findByCabanaId(Long cabanaId);
+
+}
--- a/src/main/java/com/example/fercoganbackend/repository/PujaRepository.java
+++ b/src/main/java/com/example/fercoganbackend/repository/PujaRepository.java
@@ -0,0 +1,35 @@
+package com.example.fercoganbackend.repository;
+
+import com.example.fercoganbackend.entity.HistorialLotes;
+import com.example.fercoganbackend.entity.Puja;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+public interface PujaRepository extends JpaRepository<Puja, Long> {
+
+    List<Puja> findByLote_Remate_Id(Long remateId);
+
+    List<Puja> findByLote_IdAndLote_Remate_Id(Long loteId, Long remateId);
+
+    List<Puja> findByLote_IdAndLote_Remate_IdAndFechaAfter(
+            Long loteId,
+            Long remateId,
+            LocalDateTime fecha
+    );
+    List<Puja> findByLote_Remate_IdAndFechaAfter(Long id,LocalDateTime fecha);
+
+    @Query(value = """
+       SELECT p.* FROM pujas p
+       INNER JOIN (
+           SELECT lote_id, MAX(monto) AS max_monto
+           FROM pujas
+           WHERE lote_id IN (SELECT id FROM lotes WHERE remate_id = :remateId)
+           GROUP BY lote_id
+       ) pm ON p.lote_id = pm.lote_id AND p.monto = pm.max_monto
+       """, nativeQuery = true)
+    List<Puja> findMayorPujaPorLotePorRemateNative(Long remateId);
+
+}
--- a/src/main/java/com/example/fercoganbackend/repository/RemateRepository.java
+++ b/src/main/java/com/example/fercoganbackend/repository/RemateRepository.java
@@ -0,0 +1,15 @@
+package com.example.fercoganbackend.repository;
+
+import com.example.fercoganbackend.entity.Remate;
+import jakarta.transaction.Transactional;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+
+public interface RemateRepository extends JpaRepository<Remate, Long> {
+
+    @Modifying
+    @Transactional
+    @Query("UPDATE Remate r SET r.estado = :estado WHERE r.id = :id")
+    int actualizarEstado(Long id, String estado);
+}
--- a/src/main/java/com/example/fercoganbackend/repository/UsuarioRepository.java
+++ b/src/main/java/com/example/fercoganbackend/repository/UsuarioRepository.java
@@ -0,0 +1,9 @@
+package com.example.fercoganbackend.repository;
+
+import com.example.fercoganbackend.entity.Usuario;
+import org.springframework.data.jpa.repository.JpaRepository;
+import java.util.Optional;
+
+public interface UsuarioRepository extends JpaRepository<Usuario, Long> {
+    Optional<Usuario> findByUsername(String username);
+}
--- a/src/main/java/com/example/fercoganbackend/service/CabanaService.java
+++ b/src/main/java/com/example/fercoganbackend/service/CabanaService.java
@@ -0,0 +1,32 @@
+package com.example.fercoganbackend.service;
+
+import com.example.fercoganbackend.entity.Cabana;
+import com.example.fercoganbackend.repository.CabanaRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+import java.util.Optional;
+
+@Service
+public class CabanaService {
+
+    @Autowired
+    private CabanaRepository cabanaRepository;
+
+    public List<Cabana> findAll() {
+        return cabanaRepository.findAll();
+    }
+
+    public Optional<Cabana> findById(Long id) {
+        return cabanaRepository.findById(id);
+    }
+
+    public Cabana save(Cabana remate) {
+        return cabanaRepository.save(remate);
+    }
+
+    public void delete(Long id) {
+        cabanaRepository.deleteById(id);
+    }
+}
--- a/src/main/java/com/example/fercoganbackend/service/ContadorService.java
+++ b/src/main/java/com/example/fercoganbackend/service/ContadorService.java
@@ -0,0 +1,49 @@
+package com.example.fercoganbackend.service;
+
+import org.springframework.stereotype.Service;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+@Service
+public class ContadorService {
+    private final Map<String, AtomicInteger> contadoresPorLote = new ConcurrentHashMap<>();
+    private final Map<String, Boolean> switchesPorLote = new ConcurrentHashMap<>();
+
+    public int incrementar(String roomKey) {
+        AtomicInteger contador = contadoresPorLote.computeIfAbsent(roomKey,
+                k -> new AtomicInteger(200));
+        boolean sw = switchesPorLote.computeIfAbsent(roomKey, k -> true);
+
+        int valorActual = contador.get();
+        int incremento = calcularIncremento(valorActual, sw);
+
+        // Alternar el switch para este lote
+        switchesPorLote.put(roomKey, !sw);
+
+        return contador.addAndGet(incremento);
+    }
+
+    public int getContador(String roomKey) {
+        AtomicInteger contador = contadoresPorLote.get(roomKey);
+        return contador != null ? contador.get() : 200; // Valor por defecto
+    }
+
+    public void setContador(String roomKey, int valor) {
+        AtomicInteger contador = contadoresPorLote.computeIfAbsent(roomKey,
+                k -> new AtomicInteger(valor));
+        contador.set(valor);
+    }
+
+    private int calcularIncremento(int valorActual, boolean sw) {
+        if (valorActual < 300) {
+            return sw ? 20 : 30;
+        } else if (valorActual < 1000) {
+            return 50;
+        } else if (valorActual < 2000) {
+            return 100;
+        } else {
+            return 500;
+        }
+    }
+}
--- a/src/main/java/com/example/fercoganbackend/service/HistorialLotesService.java
+++ b/src/main/java/com/example/fercoganbackend/service/HistorialLotesService.java
@@ -0,0 +1,72 @@
+package com.example.fercoganbackend.service;
+
+import com.example.fercoganbackend.dto.PujaRequest;
+import com.example.fercoganbackend.dto.PujaResponse;
+import com.example.fercoganbackend.entity.HistorialLotes;
+import com.example.fercoganbackend.entity.Remate;
+import com.example.fercoganbackend.entity.Usuario;
+import com.example.fercoganbackend.entity.Lote;
+import com.example.fercoganbackend.repository.HistorialLotesRepository;
+import com.example.fercoganbackend.repository.RemateRepository;
+import com.example.fercoganbackend.repository.UsuarioRepository;
+import com.example.fercoganbackend.repository.LoteRepository;
+
+import org.springframework.stereotype.Service;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+@Service
+public class HistorialLotesService {
+
+    private final HistorialLotesRepository historialRepo;
+    private final UsuarioRepository usuarioRepo;
+    private final LoteRepository loteRepo;
+    private final RemateRepository remateRepo;
+
+    public HistorialLotesService(HistorialLotesRepository historialRepo,
+                       UsuarioRepository usuarioRepo,
+                       LoteRepository loteRepo, RemateRepository remateRepo) {
+        this.historialRepo = historialRepo;
+        this.remateRepo = remateRepo;
+        this.usuarioRepo = usuarioRepo;
+        this.loteRepo = loteRepo;
+    }
+
+    public List<HistorialLotes> getHistorialLoteAll(){
+        return historialRepo.findAll();
+    }
+
+    public PujaResponse registrarPuja(PujaRequest request) {
+
+        Usuario usuario = usuarioRepo.findById(request.getUsuarioId())
+                .orElseThrow(() -> new RuntimeException("Usuario no encontrado"));
+
+        Lote lote = loteRepo.findById(request.getLoteId())
+                .orElseThrow(() -> new RuntimeException("Lote no encontrado"));
+
+        Remate remate = remateRepo.findById(request.getRemateId())
+                .orElseThrow(() -> new RuntimeException("No se encontro el remate"));
+
+        HistorialLotes nuevaPuja = new HistorialLotes(
+                usuario,
+                lote,
+                request.getMonto(),
+                LocalDateTime.now(),
+                "ACEPTADA",
+                remate
+        );
+
+        historialRepo.save(nuevaPuja);
+
+        return new PujaResponse(
+                nuevaPuja.getId(),
+                lote.getId(),
+                usuario.getId(),
+                remate.getId(),
+                nuevaPuja.getMonto(),
+                nuevaPuja.getFecha(),
+                nuevaPuja.getEstado()
+        );
+    }
+}
--- a/src/main/java/com/example/fercoganbackend/service/LoteService.java
+++ b/src/main/java/com/example/fercoganbackend/service/LoteService.java
@@ -0,0 +1,32 @@
+package com.example.fercoganbackend.service;
+
+import com.example.fercoganbackend.entity.Lote;
+import com.example.fercoganbackend.repository.LoteRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+import java.util.Optional;
+
+@Service
+public class LoteService {
+
+    @Autowired
+    private LoteRepository loteRepository;
+
+    public List<Lote> findAll() {
+        return loteRepository.findAll();
+    }
+
+    public Optional<Lote> findById(Long id) {
+        return loteRepository.findById(id);
+    }
+
+    public Lote save(Lote remate) {
+        return loteRepository.save(remate);
+    }
+
+    public void delete(Long id) {
+        loteRepository.deleteById(id);
+    }
+}
--- a/src/main/java/com/example/fercoganbackend/service/LoteServiceWebFlux.java
+++ b/src/main/java/com/example/fercoganbackend/service/LoteServiceWebFlux.java
@@ -0,0 +1,71 @@
+package com.example.fercoganbackend.service;
+
+
+import com.example.fercoganbackend.entity.Lote;
+import com.example.fercoganbackend.repository.LoteRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import reactor.core.publisher.Sinks;
+
+import java.util.List;
+import java.util.Optional;
+
+@Service
+public class LoteServiceWebFlux {
+
+    private final LoteRepository repo;
+    private final Sinks.Many<Lote> sink; // canal que emite actualizaciones por lote
+
+    public LoteServiceWebFlux(LoteRepository repo) {
+        this.repo = repo;
+        // replay().latest() guarda el último emitido (por si alguien se suscribe tarde)
+        this.sink = Sinks.many().replay().latest();
+    }
+
+    public List<Lote> findAll() {
+        return repo.findAll();
+    }
+
+    public List<Lote> findByCabanaId(Long id) {
+        return repo.findByCabanaId(id);
+    }
+
+    public Optional<Lote> findById(Long id) {
+        return repo.findById(id);
+    }
+
+    @Transactional
+    public Lote save(Lote lote) {
+        Lote saved = repo.save(lote);
+        emitChange(saved); // notificamos a los suscriptores el lote actualizado
+        return saved;
+    }
+
+    @Transactional
+    public void delete(Long id) {
+        // Intentamos obtener el lote antes de borrar para poder notificar su eliminación
+        Optional<Lote> maybe = repo.findById(id);
+        repo.deleteById(id);
+        // Emitimos un "evento de eliminación": un Lote con id y visible = false
+        Lote tombstone = maybe.orElseGet(() -> {
+            Lote t = new Lote();
+            t.setId(id);
+            return t;
+        });
+        // Si tu entidad Lote tiene campo visible, marcalo; si no, sigue emitiendo el id.
+        try {
+            tombstone.setVisible(false);
+        } catch (Exception ignored) {}
+        emitChange(tombstone);
+    }
+
+    private void emitChange(Lote lote) {
+        // emitimos el objeto lote al sink; los controladores filtran por id
+        sink.tryEmitNext(lote);
+    }
+
+    public Sinks.Many<Lote> getSink() {
+        return sink;
+    }
+}
--- a/src/main/java/com/example/fercoganbackend/service/PujaService.java
+++ b/src/main/java/com/example/fercoganbackend/service/PujaService.java
@@ -0,0 +1,94 @@
+package com.example.fercoganbackend.service;
+
+import com.example.fercoganbackend.entity.Puja;
+import com.example.fercoganbackend.entity.Remate;
+import com.example.fercoganbackend.repository.PujaRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import com.example.fercoganbackend.repository.UsuarioRepository;
+import com.example.fercoganbackend.repository.CabanaRepository;
+import com.example.fercoganbackend.repository.LoteRepository;
+import com.example.fercoganbackend.repository.RemateRepository;
+
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Optional;
+
+@Service
+public class PujaService {
+    @Autowired
+    private UsuarioRepository usuarioRepository;
+
+    @Autowired
+    private CabanaRepository cabanaRepository;
+
+    @Autowired
+    private LoteRepository loteRepository;
+
+    @Autowired
+    private RemateRepository remateRepository;
+
+    @Autowired
+    private PujaRepository pujaRepository;
+
+    public List<Puja> findAll() {
+        return pujaRepository.findAll();
+    }
+
+    public List<Puja> findForRemtae(Long id){
+        return pujaRepository.findByLote_Remate_Id(id);
+    }
+
+    public List<Puja> findForLoteAndRemate(Long loteId, Long remateId){
+        return pujaRepository.findByLote_IdAndLote_Remate_Id(loteId,remateId);
+    }
+
+    public List<Puja> findForLoteAndRemateAndDate(Long loteId, Long remateId, LocalDateTime fecha){
+        return pujaRepository.findByLote_IdAndLote_Remate_IdAndFechaAfter(loteId, remateId, fecha);
+    }
+    public List<Puja> fingForReporte(Long id){
+        return  pujaRepository.findMayorPujaPorLotePorRemateNative(id);
+    }
+    public Optional<Puja> findById(Long id) {
+        return pujaRepository.findById(id);
+    }
+
+    public Puja save(Puja puja) {
+
+        // Validar USUARIO
+        if (puja.getUsuario() == null || puja.getUsuario().getId() == null) {
+            throw new RuntimeException("El usuario es obligatorio");
+        }
+        var usuario = usuarioRepository.findById(puja.getUsuario().getId())
+                .orElseThrow(() -> new RuntimeException("Usuario no encontrado"));
+
+        // Validar CABAÑA
+        if (puja.getCabana() == null || puja.getCabana().getId() == null) {
+            throw new RuntimeException("La cabaña es obligatoria");
+        }
+        var cabana = cabanaRepository.findById(puja.getCabana().getId())
+                .orElseThrow(() -> new RuntimeException("Cabaña no encontrada"));
+
+        // Validar LOTE
+        if (puja.getLote() == null || puja.getLote().getId() == null) {
+            throw new RuntimeException("El lote es obligatorio");
+        }
+        var lote = loteRepository.findById(puja.getLote().getId())
+                .orElseThrow(() -> new RuntimeException("Lote no encontrado"));
+
+
+        // Asignar entidades reales para que JPA las maneje correctamente
+        puja.setUsuario(usuario);
+        puja.setCabana(cabana);
+        puja.setLote(lote);
+
+        return pujaRepository.save(puja);
+    }
+
+
+    public void delete(Long id) {
+        pujaRepository.deleteById(id);
+    }
+}
+
--- a/src/main/java/com/example/fercoganbackend/service/RemateService.java
+++ b/src/main/java/com/example/fercoganbackend/service/RemateService.java
@@ -0,0 +1,50 @@
+package com.example.fercoganbackend.service;
+
+import com.example.fercoganbackend.component.ContadorWebSocketHandler;
+import com.example.fercoganbackend.component.EventoWebSocketHandler;
+import com.example.fercoganbackend.entity.Remate;
+import com.example.fercoganbackend.repository.RemateRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+import java.util.Optional;
+
+@Service
+public class RemateService {
+
+    @Autowired
+    private RemateRepository remateRepository;
+    @Autowired
+    private EventoWebSocketHandler webSocketHandler;
+
+    public List<Remate> findAll() {
+        return remateRepository.findAll();
+    }
+
+    public Optional<Remate> findById(Long id) {
+        return remateRepository.findById(id);
+    }
+
+    public Remate save(Remate remate) {
+        return remateRepository.save(remate);
+    }
+
+    public void delete(Long id) {
+        remateRepository.deleteById(id);
+    }
+
+
+    public void finalizarRemate(Long remateId, String loteId) {
+        // 1. Cambiar estado en la base de datos
+        remateRepository.actualizarEstado(remateId, "FINALIZADO");
+
+        // 2. Notificar a todos los clientes conectados
+        webSocketHandler.enviarEvento(
+                String.valueOf(remateId),
+                "FIN_REMATE"
+        );
+    }
+
+}
+
--- a/src/main/java/com/example/fercoganbackend/service/UsuarioDetailsService.java
+++ b/src/main/java/com/example/fercoganbackend/service/UsuarioDetailsService.java
@@ -0,0 +1,50 @@
+package com.example.fercoganbackend.service;
+
+import com.example.fercoganbackend.entity.Usuario;
+import com.example.fercoganbackend.otros.UsuarioPrincipal;
+import com.example.fercoganbackend.repository.UsuarioRepository;
+import org.springframework.security.core.authority.SimpleGrantedAuthority;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.security.core.userdetails.UserDetailsService;
+import org.springframework.security.core.userdetails.UsernameNotFoundException;
+import org.springframework.stereotype.Service;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.List;
+
+
+@Service
+public class UsuarioDetailsService implements UserDetailsService {
+
+    private final UsuarioRepository usuarioRepository;
+    private final Logger logger = LoggerFactory.getLogger(UsuarioDetailsService.class);
+
+
+    public UsuarioDetailsService(UsuarioRepository usuarioRepository) {
+        this.usuarioRepository = usuarioRepository;
+    }
+
+    @Override
+    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
+        logger.info("Intentando autenticar usuario: {}", username);
+
+        Usuario usuario = usuarioRepository.findByUsername(username)
+                .orElseThrow(() -> {
+                    logger.warn("Usuario no encontrado: {}", username);
+                    return new UsernameNotFoundException("Usuario no encontrado");
+                });
+
+        logger.info("Usuario encontrado: {}, aprobado: {}", usuario.getUsername(), usuario.isAprobado());
+        logger.info("Roles del usuario: {}", usuario.getRoles());
+
+        return new org.springframework.security.core.userdetails.User(
+                usuario.getUsername(),
+                usuario.getPassword(),
+                usuario.isAprobado(), true, true, true,
+                usuario.getRoles().stream()
+                        .map(r -> new SimpleGrantedAuthority(r.name()))
+                        .toList()
+        );
+    }
+}
--- a/src/main/java/com/example/fercoganbackend/service/UsuarioService.java
+++ b/src/main/java/com/example/fercoganbackend/service/UsuarioService.java
@@ -0,0 +1,78 @@
+package com.example.fercoganbackend.service;
+import com.example.fercoganbackend.entity.Rol;
+import com.example.fercoganbackend.entity.Usuario;
+import com.example.fercoganbackend.otros.ConfirmadoTF;
+import com.example.fercoganbackend.repository.UsuarioRepository;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.stereotype.Service;
+import java.util.List;
+import java.util.Set;
+
+@Service
+public class UsuarioService {
+    private final UsuarioRepository repo;
+    private final PasswordEncoder encoder;
+
+    public List<Usuario> getAll(){
+        return repo.findAll();
+    }
+    public UsuarioService(UsuarioRepository repo, PasswordEncoder encoder) {
+        this.repo = repo;
+        this.encoder = encoder;
+    }
+
+    public Usuario registrarUsuario(String username, String password, Set<Rol> roles) {
+        Usuario u = new Usuario();
+        u.setUsername(username);
+        u.setPassword(encoder.encode(password));
+        u.setRoles(roles);
+        u.setAprobado(false); // no aprobado hasta aceptación
+        return repo.save(u);
+    }
+
+    public Usuario actualizarUsuario(Long id, Usuario usuario) {
+        Usuario existente = repo.findById(id)
+                .orElseThrow(() -> new RuntimeException("Usuario no encontrado"));
+
+        existente.setUsername(usuario.getUsername());
+        existente.setPassword(encoder.encode(usuario.getPassword()));
+        existente.setRoles(usuario.getRoles());
+        existente.setAprobado(usuario.isAprobado());
+        existente.setVisible(usuario.getVisible());
+
+        return repo.save(existente); // <-- Aquí sí se actualiza el existente
+    }
+
+    public List<Usuario> listarPendientes() {
+        return repo.findAll().stream().filter(u -> !u.isAprobado()).toList();
+    }
+
+    public Usuario aceptarUsuario(Long id) {
+        Usuario u = repo.findById(id).orElseThrow();
+        u.setAprobado(true);
+        return repo.save(u);
+    }
+
+    public boolean estaAprobado(String username) {
+        return repo.findByUsername(username).map(Usuario::isAprobado).orElse(false);
+    }
+    public boolean estaRegistrado(String username) {
+        return repo.findByUsername(username).isPresent();
+    }
+
+    public ConfirmadoTF registradoYAprobado(String username){
+        ConfirmadoTF confirmadotf =  new ConfirmadoTF();
+        confirmadotf.setAuthenticated(estaRegistrado(username));
+        confirmadotf.setConfirmed(estaAprobado(username));
+        return confirmadotf;
+    }
+
+    public void eliminarUsuario(Long id) {
+        if (!repo.existsById(id)) {
+            throw new RuntimeException("Usuario no encontrado");
+        }
+        repo.deleteById(id);
+    }
+
+
+}