Se agrega la autenticación por el usuario

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Controller/UzyTPerfilController.java

 package ec.edu.espe.movilidad.MovilidadWS.Controller;
 
-import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTPerfil;
-import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTPerfilMenu;
+import ec.edu.espe.movilidad.MovilidadWS.Dto.DtoUzyTPerfil;
+import ec.edu.espe.movilidad.MovilidadWS.Dto.DtoUzyTProvincia;
 import ec.edu.espe.movilidad.MovilidadWS.Service.UzyTPerfil.IServiceUzyTPerfil;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.HttpStatus;
@@ -14,32 +14,33 @@ import static ec.edu.espe.movilidad.MovilidadWS.Constant.GlobalConstants.V1_API_
 
 @RestController
 @CrossOrigin(origins = "*")
-@RequestMapping(V1_API_VERSION+"/perfil")
+@RequestMapping(V1_API_VERSION + "/perfil")
 public class UzyTPerfilController {
+
+    private final IServiceUzyTPerfil serviceUzyTPerfil;
+
     @Autowired
-    IServiceUzyTPerfil serviceUzyTPerfil;
+    public UzyTPerfilController(IServiceUzyTPerfil serviceUzyTPerfil) {
+        this.serviceUzyTPerfil = serviceUzyTPerfil;
+    }
 
     @GetMapping("/exampleFindId/{id}")
-    public ResponseEntity<ModelUzyTPerfil> ListarPorID(@PathVariable Long id) {
-        return new ResponseEntity<>(serviceUzyTPerfil.ListarPorID(id), HttpStatus.OK);
-    }
 
+    public ResponseEntity<DtoUzyTPerfil> ListarPorID(@PathVariable Long id) {
+        DtoUzyTPerfil dto = serviceUzyTPerfil.ListarPorID(id);
+        return ResponseEntity.ok(dto);
+    }
 
     @GetMapping("/getAll")
-    public ResponseEntity<List<ModelUzyTPerfil>> ListarRegistros() {
-        return new ResponseEntity<>(serviceUzyTPerfil.ListarRegistros(), HttpStatus.OK);
+    public ResponseEntity<List<DtoUzyTPerfil>> ListarRegistros() {
+        List<DtoUzyTPerfil> dtos = serviceUzyTPerfil.ListarRegistros();
+        return ResponseEntity.ok(dtos);
     }
 
-
     @PostMapping("/guardar")
-    public ResponseEntity<ModelUzyTPerfil> guardar(@RequestBody ModelUzyTPerfil modelUzyTPerfil) {
-        return new  ResponseEntity<>(serviceUzyTPerfil.guardar(modelUzyTPerfil), HttpStatus.OK);
-    }
-
-
-    @PutMapping("/editar/{id}")
-    public ResponseEntity<ModelUzyTPerfil> editar(@PathVariable Long id, @RequestBody ModelUzyTPerfil modelUzyTPerfil) {
-        return new  ResponseEntity<>(serviceUzyTPerfil.editar(id, modelUzyTPerfil), HttpStatus.OK);
+    public ResponseEntity<DtoUzyTPerfil> guardar(@RequestBody DtoUzyTPerfil dtoUzyTPerfil) {
+        DtoUzyTPerfil savedDto = serviceUzyTPerfil.guardar(dtoUzyTPerfil);
+        return ResponseEntity.ok(savedDto);
     }
 
 
@@ -48,4 +49,13 @@ public class UzyTPerfilController {
         serviceUzyTPerfil.eliminar(id);
         return ResponseEntity.ok().build();
     }
+
+    @PutMapping("/editar/{id}")
+    public ResponseEntity<DtoUzyTPerfil> editar(@PathVariable Long id,
+                                                @RequestBody DtoUzyTPerfil dtoUzyTPerfil) {
+        DtoUzyTPerfil editedDto = serviceUzyTPerfil.editar(id, dtoUzyTPerfil);
+        return ResponseEntity.ok(editedDto);
+    }
+
+
 }

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Controller/UzyTPerfilMenuController.java

 package ec.edu.espe.movilidad.MovilidadWS.Controller;
 
+import ec.edu.espe.movilidad.MovilidadWS.Dto.DtoUzyTPerfil;
+import ec.edu.espe.movilidad.MovilidadWS.Dto.DtoUzyTPerfilMenu;
 import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTLineaOperativa;
 import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTPerfil;
-import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTPerfilMenu;
 import ec.edu.espe.movilidad.MovilidadWS.Service.UzyTPerfilMenu.IServiceUzyTPerfilMenu;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.HttpStatus;
@@ -15,39 +16,46 @@ import static ec.edu.espe.movilidad.MovilidadWS.Constant.GlobalConstants.V1_API_
 
 @RestController
 @CrossOrigin(origins = "*")
-@RequestMapping(V1_API_VERSION+"/perfilmenu")
+@RequestMapping(V1_API_VERSION + "/perfilmenu")
 public class UzyTPerfilMenuController {
 
+    private final IServiceUzyTPerfilMenu serviceUzyTPerfilMenu;
+
     @Autowired
-    IServiceUzyTPerfilMenu serviceUzyTPerfilMenu;
+    public UzyTPerfilMenuController(IServiceUzyTPerfilMenu serviceUzyTPerfilMenu) {
+        this.serviceUzyTPerfilMenu = serviceUzyTPerfilMenu;
+    }
 
     @GetMapping("/exampleFindId/{id}")
-    public ResponseEntity<ModelUzyTPerfilMenu> ListarPorID(@PathVariable Long id) {
-        return new ResponseEntity<>(serviceUzyTPerfilMenu.ListarPorID(id), HttpStatus.OK);
-    }
 
+    public ResponseEntity<DtoUzyTPerfilMenu> ListarPorID(@PathVariable Long id) {
+        DtoUzyTPerfilMenu dto = serviceUzyTPerfilMenu.ListarPorID(id);
+        return ResponseEntity.ok(dto);
+    }
 
     @GetMapping("/getAll")
-    public ResponseEntity<List<ModelUzyTPerfilMenu>> ListarRegistros() {
-        return new ResponseEntity<>(serviceUzyTPerfilMenu.ListarRegistros(), HttpStatus.OK);
+    public ResponseEntity<List<DtoUzyTPerfilMenu>> ListarRegistros() {
+        List<DtoUzyTPerfilMenu> dtos = serviceUzyTPerfilMenu.ListarRegistros();
+        return ResponseEntity.ok(dtos);
     }
 
-
     @PostMapping("/guardar")
-    public ResponseEntity<ModelUzyTPerfilMenu> guardar(@RequestBody ModelUzyTPerfilMenu modelUzyTPerfilMenu) {
-        return new  ResponseEntity<>(serviceUzyTPerfilMenu.guardar(modelUzyTPerfilMenu), HttpStatus.OK);
-    }
-
-
-    @PutMapping("/editar/{id}")
-    public ResponseEntity<ModelUzyTPerfilMenu> editar(@PathVariable Long id, @RequestBody ModelUzyTPerfilMenu modelUzyTPerfilMenu) {
-        return new  ResponseEntity<>(serviceUzyTPerfilMenu.editar(id, modelUzyTPerfilMenu), HttpStatus.OK);
+    public ResponseEntity<DtoUzyTPerfilMenu> guardar(@RequestBody DtoUzyTPerfilMenu dtoUzyTPerfilMenu) {
+        DtoUzyTPerfilMenu savedDto = serviceUzyTPerfilMenu.guardar(dtoUzyTPerfilMenu);
+        return ResponseEntity.ok(savedDto);
     }
 
-
     @DeleteMapping("/eliminar/{id}")
     public ResponseEntity<Void> eliminar(@PathVariable Long id) {
         serviceUzyTPerfilMenu.eliminar(id);
         return ResponseEntity.ok().build();
     }
+
+    @PutMapping("/editar/{id}")
+    public ResponseEntity<DtoUzyTPerfilMenu> editar(@PathVariable Long id,
+                                                    @RequestBody DtoUzyTPerfilMenu dtoUzyTPerfilMenu) {
+        DtoUzyTPerfilMenu editedDto = serviceUzyTPerfilMenu.editar(id, dtoUzyTPerfilMenu);
+        return ResponseEntity.ok(editedDto);
+    }
+
 }

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Controller/UzyTPlanificacionController.java

 package ec.edu.espe.movilidad.MovilidadWS.Controller;
 
-import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTPlanificacion;
+import ec.edu.espe.movilidad.MovilidadWS.Dto.DtoUzyTCanton;
+import ec.edu.espe.movilidad.MovilidadWS.Dto.DtoUzyTPerfil;
+import ec.edu.espe.movilidad.MovilidadWS.Dto.DtoUzyTPlanificacion;
+import ec.edu.espe.movilidad.MovilidadWS.Service.UzyTPerfil.IServiceUzyTPerfil;
 import ec.edu.espe.movilidad.MovilidadWS.Service.UzyTPlanificacion.IServiceUzyTPlanificacion;
+
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
 
+import javax.validation.Valid;
 import java.util.List;
 
 import static ec.edu.espe.movilidad.MovilidadWS.Constant.GlobalConstants.V1_API_VERSION;
 
 @RestController
 @CrossOrigin(origins = "*")
-@RequestMapping(V1_API_VERSION+"/planificacion")
+@RequestMapping(V1_API_VERSION + "/planificacion")
 
 public class UzyTPlanificacionController {
-    @Autowired
-    IServiceUzyTPlanificacion serviceUzyTPlanificacion;
+
+    private final IServiceUzyTPlanificacion serviceUzyTPlanificacion;
+
+    public UzyTPlanificacionController(IServiceUzyTPlanificacion serviceUzyTPlanificacion) {
+        this.serviceUzyTPlanificacion = serviceUzyTPlanificacion;
+    }
+
     @GetMapping("/exampleFindId/{id}")
-    public ResponseEntity<ModelUzyTPlanificacion> ListarPorID(@PathVariable Long id) {
+    public ResponseEntity<DtoUzyTPlanificacion> ListarPorID(@PathVariable Long id) {
         return new ResponseEntity<>(serviceUzyTPlanificacion.ListarPorID(id), HttpStatus.OK);
     }
 
     @GetMapping("/getAll")
-    public ResponseEntity<List<ModelUzyTPlanificacion>> ListarRegistros() {
+    public ResponseEntity<List<DtoUzyTPlanificacion>> ListarRegistros() {
         return new ResponseEntity<>(serviceUzyTPlanificacion.ListarRegistros(), HttpStatus.OK);
     }
 
-
     @PostMapping("/guardar")
-    public ResponseEntity<ModelUzyTPlanificacion> guardar(@RequestBody ModelUzyTPlanificacion modelUzyTPlanificacion) {
-        return new  ResponseEntity<>(serviceUzyTPlanificacion.guardar(modelUzyTPlanificacion), HttpStatus.OK);
+    public ResponseEntity<DtoUzyTPlanificacion> guardar(@RequestBody DtoUzyTPlanificacion dtoUzyTPlanificacion) {
+        DtoUzyTPlanificacion savedDto = serviceUzyTPlanificacion.guardar(dtoUzyTPlanificacion);
+        return ResponseEntity.ok(savedDto);
     }
 
-
     @PutMapping("/editar/{id}")
-    public ResponseEntity<ModelUzyTPlanificacion> editar(@PathVariable Long id, @RequestBody ModelUzyTPlanificacion modelUzyTPlanificacion) {
-        return new  ResponseEntity<>(serviceUzyTPlanificacion.editar(id, modelUzyTPlanificacion), HttpStatus.OK);
+    public ResponseEntity<DtoUzyTPlanificacion> editar(@PathVariable Long id,
+                                                       @RequestBody DtoUzyTPlanificacion dtoUzyTPlanificacion) {
+        DtoUzyTPlanificacion editedDto = serviceUzyTPlanificacion.editar(id, dtoUzyTPlanificacion);
+        return ResponseEntity.ok(editedDto);
     }
 
-
     @DeleteMapping("/eliminar/{id}")
     public ResponseEntity<Void> eliminar(@PathVariable Long id) {
         serviceUzyTPlanificacion.eliminar(id);
         return ResponseEntity.ok().build();
     }
-
-
-
 }

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Controller/UzyTavConfiguracionController.java

 package ec.edu.espe.movilidad.MovilidadWS.Controller;
 
-import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTavConfiguracion;
+import ec.edu.espe.movilidad.MovilidadWS.Dto.DtoUzyTavConfiguracion;
 import ec.edu.espe.movilidad.MovilidadWS.Service.UzyTavConfiguracion.IServiceUzyTavConfiguracion;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.HttpStatus;
@@ -13,76 +13,67 @@ import static ec.edu.espe.movilidad.MovilidadWS.Constant.GlobalConstants.V1_API_
 @RequestMapping(V1_API_VERSION+"/configuracion")
 public class UzyTavConfiguracionController {
 
+    private final IServiceUzyTavConfiguracion serviceUzyTavConfiguracion;
+
     @Autowired
-    private IServiceUzyTavConfiguracion serviceUzyTavConfiguracion;
+    public UzyTavConfiguracionController( IServiceUzyTavConfiguracion serviceUzyTavConfiguracion ){
+        this.serviceUzyTavConfiguracion = serviceUzyTavConfiguracion;
+    }
 
 
     @GetMapping("/exampleFindId/{id}")
-    public ResponseEntity<ModelUzyTavConfiguracion> ListarPorID(@PathVariable Long id) {
+    public ResponseEntity<DtoUzyTavConfiguracion> ListarPorID(@PathVariable Long id) {
         return new ResponseEntity<>(serviceUzyTavConfiguracion.ListarPorID(id), HttpStatus.OK);
     }
 
-
-
-
     @GetMapping("/CedVicerrector/{cedula}")
-    public ResponseEntity<?> buscarPorCedulaVicerrector(@PathVariable String cedula) {
-        ModelUzyTavConfiguracion uzyTavConfiguracion = serviceUzyTavConfiguracion.buscarPorCedulaVicerrector(cedula);
-        if (uzyTavConfiguracion != null) {
-            return ResponseEntity.ok(uzyTavConfiguracion);
-        } else {
-            return ResponseEntity.notFound().build();
-        }
+    public ResponseEntity<DtoUzyTavConfiguracion> buscarPorCedulaVicerrector(@PathVariable String cedula) {
+        return new ResponseEntity<>(serviceUzyTavConfiguracion.buscarPorCedulaVicerrector(cedula), HttpStatus.OK);
     }
 
     @GetMapping("/CedDirector/{cedula}")
-    public ResponseEntity<?> buscarPorCedulaDirector(@PathVariable String cedula) {
-        ModelUzyTavConfiguracion uzyTavConfiguracion = serviceUzyTavConfiguracion.buscarPorCedulaDirector(cedula);
-        if (uzyTavConfiguracion != null) {
-            return ResponseEntity.ok(uzyTavConfiguracion);
-        } else {
-            return ResponseEntity.notFound().build();
-        }
+    public ResponseEntity<DtoUzyTavConfiguracion> buscarPorCedulaDirector(@PathVariable String cedula) {
+        return new ResponseEntity<>(serviceUzyTavConfiguracion.buscarPorCedulaDirector(cedula), HttpStatus.OK);
     }
 
     @GetMapping("/getAll")
-    public ResponseEntity<List<ModelUzyTavConfiguracion>> ListarRegistros() {
+    public ResponseEntity<List<DtoUzyTavConfiguracion>> ListarRegistros() {
         return new ResponseEntity<>(serviceUzyTavConfiguracion.ListarRegistros(), HttpStatus.OK);
     }
 
     @PostMapping("/guardar")
-    public ResponseEntity<ModelUzyTavConfiguracion> guardar(@RequestBody ModelUzyTavConfiguracion modelUzyTavConfiguracion) {
-        return new  ResponseEntity<>(serviceUzyTavConfiguracion.guardar(modelUzyTavConfiguracion), HttpStatus.OK);
+    public ResponseEntity<DtoUzyTavConfiguracion> guardar(@RequestBody DtoUzyTavConfiguracion dtoUzyTavConfiguracion) {
+        return new  ResponseEntity<>(serviceUzyTavConfiguracion.guardar(dtoUzyTavConfiguracion), HttpStatus.OK);
     }
 
 
     @PutMapping("/editar/{id}")
-    public ResponseEntity<ModelUzyTavConfiguracion> editar(@PathVariable Long id, @RequestBody ModelUzyTavConfiguracion modelUzyTavConfiguracion) {
-        return new  ResponseEntity<>(serviceUzyTavConfiguracion.editar(id, modelUzyTavConfiguracion), HttpStatus.OK);
+    public ResponseEntity<DtoUzyTavConfiguracion> editar(@PathVariable Long id, @RequestBody DtoUzyTavConfiguracion dtoUzyTavConfiguracion) {
+        return new  ResponseEntity<>(serviceUzyTavConfiguracion.editar(id, dtoUzyTavConfiguracion), HttpStatus.OK);
     }
 
 
     @PutMapping("/editarHorasDocente/{id}")
-    public ResponseEntity<ModelUzyTavConfiguracion> editarHorasDocente(@PathVariable Long id, @RequestBody ModelUzyTavConfiguracion modelUzyTavConfiguracion) {
-        return new  ResponseEntity<>(serviceUzyTavConfiguracion.editarHorasDocente(id, modelUzyTavConfiguracion), HttpStatus.OK);
+    public ResponseEntity<DtoUzyTavConfiguracion> editarHorasDocente(@PathVariable Long id, @RequestBody DtoUzyTavConfiguracion dtoUzyTavConfiguracion) {
+        return new  ResponseEntity<>(serviceUzyTavConfiguracion.editarHorasDocente(id, dtoUzyTavConfiguracion), HttpStatus.OK);
     }
 
 
     @PutMapping("/editarHorasEstudiante/{id}")
-    public ResponseEntity<ModelUzyTavConfiguracion> editarHorasEstudiante(@PathVariable Long id, @RequestBody ModelUzyTavConfiguracion modelUzyTavConfiguracion) {
-        return new  ResponseEntity<>(serviceUzyTavConfiguracion.editarHorasEstudiante(id, modelUzyTavConfiguracion), HttpStatus.OK);
+    public ResponseEntity<DtoUzyTavConfiguracion> editarHorasEstudiante(@PathVariable Long id, @RequestBody DtoUzyTavConfiguracion dtoUzyTavConfiguracion) {
+        return new  ResponseEntity<>(serviceUzyTavConfiguracion.editarHorasEstudiante(id, dtoUzyTavConfiguracion), HttpStatus.OK);
     }
 
 
     @PutMapping("/editarDatosVicerrector/{id}")
-    public ResponseEntity<ModelUzyTavConfiguracion> editarDatosVicerrector(@PathVariable Long id, @RequestBody ModelUzyTavConfiguracion modelUzyTavConfiguracion) {
-        return new  ResponseEntity<>(serviceUzyTavConfiguracion.editarDatosVicerrector(id, modelUzyTavConfiguracion), HttpStatus.OK);
+    public ResponseEntity<DtoUzyTavConfiguracion> editarDatosVicerrector(@PathVariable Long id, @RequestBody DtoUzyTavConfiguracion dtoUzyTavConfiguracion) {
+        return new  ResponseEntity<>(serviceUzyTavConfiguracion.editarDatosVicerrector(id, dtoUzyTavConfiguracion), HttpStatus.OK);
     }
 
 
     @PutMapping("/editarDatosDirector/{id}")
-    public ResponseEntity<ModelUzyTavConfiguracion> editarDatosDirector(@PathVariable Long id, @RequestBody ModelUzyTavConfiguracion modelUzyTavConfiguracion) {
-        return new  ResponseEntity<>(serviceUzyTavConfiguracion.editarDatosDirector(id, modelUzyTavConfiguracion), HttpStatus.OK);
+    public ResponseEntity<DtoUzyTavConfiguracion> editarDatosDirector(@PathVariable Long id, @RequestBody DtoUzyTavConfiguracion dtoUzyTavConfiguracion) {
+        return new  ResponseEntity<>(serviceUzyTavConfiguracion.editarDatosDirector(id, dtoUzyTavConfiguracion), HttpStatus.OK);
     }
 
     @DeleteMapping("/eliminar/{id}")

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Controller/UzyTavZonaDetalleController.java

 package ec.edu.espe.movilidad.MovilidadWS.Controller;
 
-
-import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTavZonaDetalle;
+import ec.edu.espe.movilidad.MovilidadWS.Dto.DtoUzyTavZonaDetalle;
+import ec.edu.espe.movilidad.MovilidadWS.Service.UzyTCanton.IServiceUzyTCanton;
 import ec.edu.espe.movilidad.MovilidadWS.Service.UzyTavZonaDetalle.IServiceUzyTavZonaDetalle;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.HttpStatus;
@@ -14,37 +14,38 @@ import static ec.edu.espe.movilidad.MovilidadWS.Constant.GlobalConstants.V1_API_
 
 @RestController
 @CrossOrigin(origins = "*")
-@RequestMapping(V1_API_VERSION+"/zonadetalle")
+@RequestMapping(V1_API_VERSION + "/zonadetalle")
 
 public class UzyTavZonaDetalleController {
-    @Autowired
-    IServiceUzyTavZonaDetalle serviceUzyTavZonaDetalle;
 
+    private final IServiceUzyTavZonaDetalle serviceUzyTavZonaDetalle;
 
+    @Autowired
+    public UzyTavZonaDetalleController(IServiceUzyTavZonaDetalle serviceUzyTavZonaDetalle) {
+        this.serviceUzyTavZonaDetalle = serviceUzyTavZonaDetalle;
+    }
 
     @GetMapping("/exampleFindId/{id}")
-    public ResponseEntity<ModelUzyTavZonaDetalle> ListarPorID(@PathVariable Long id) {
+    public ResponseEntity<DtoUzyTavZonaDetalle> ListarPorID(@PathVariable Long id) {
         return new ResponseEntity<>(serviceUzyTavZonaDetalle.ListarPorID(id), HttpStatus.OK);
     }
 
     @GetMapping("/getAll")
-    public ResponseEntity<List<ModelUzyTavZonaDetalle>> ListarRegistros() {
+    public ResponseEntity<List<DtoUzyTavZonaDetalle>> ListarRegistros() {
         return new ResponseEntity<>(serviceUzyTavZonaDetalle.ListarRegistros(), HttpStatus.OK);
     }
 
-
     @PostMapping("/guardar")
-    public ResponseEntity<ModelUzyTavZonaDetalle> guardar(@RequestBody ModelUzyTavZonaDetalle modelUzyTavZonaDetalle) {
-        return new  ResponseEntity<>(serviceUzyTavZonaDetalle.guardar(modelUzyTavZonaDetalle), HttpStatus.OK);
+    public ResponseEntity<DtoUzyTavZonaDetalle> guardar(@RequestBody DtoUzyTavZonaDetalle dtoUzyTavZonaDetalle) {
+        return new ResponseEntity<>(serviceUzyTavZonaDetalle.guardar(dtoUzyTavZonaDetalle), HttpStatus.OK);
     }
 
-
     @PutMapping("/editar/{id}")
-    public ResponseEntity<ModelUzyTavZonaDetalle> editar(@PathVariable Long id, @RequestBody ModelUzyTavZonaDetalle modelUzyTavZonaDetalle) {
-        return new  ResponseEntity<>(serviceUzyTavZonaDetalle.editar(id, modelUzyTavZonaDetalle), HttpStatus.OK);
+    public ResponseEntity<DtoUzyTavZonaDetalle> editar(@PathVariable Long id,
+                                                       @RequestBody DtoUzyTavZonaDetalle dtoUzyTavZonaDetalle) {
+        return new ResponseEntity<>(serviceUzyTavZonaDetalle.editar(id, dtoUzyTavZonaDetalle), HttpStatus.OK);
     }
 
-
     @DeleteMapping("/eliminar/{id}")
     public ResponseEntity<Void> eliminar(@PathVariable Long id) {
         serviceUzyTavZonaDetalle.eliminar(id);

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Mapper/Components_Class/UzyTPerfilMapper.java

 package ec.edu.espe.movilidad.MovilidadWS.Mapper.Components_Class;
 
 import ec.edu.espe.movilidad.MovilidadWS.Dto.DtoUzyTPerfil;
+
 import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTPerfil;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
 import org.modelmapper.ModelMapper;
 import org.springframework.stereotype.Component;
 
@@ -20,4 +25,11 @@ public class UzyTPerfilMapper {
     public ModelUzyTPerfil dtoToEntity(DtoUzyTPerfil dto) {
         return modelMapper.map(dto, ModelUzyTPerfil.class);
     }
+
+    public List<DtoUzyTPerfil> entitiesToDtos(List<ModelUzyTPerfil> entities) {
+        return entities.stream()
+                .map(this::entityToDto)
+                .collect(Collectors.toList());
+    }
+
 }

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Mapper/Components_Class/UzyTPerfilMenuMapper.java

 package ec.edu.espe.movilidad.MovilidadWS.Mapper.Components_Class;
 
+
 import ec.edu.espe.movilidad.MovilidadWS.Dto.DtoUzyTPerfilMenu;
 import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTPerfilMenu;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
 import org.modelmapper.ModelMapper;
 import org.springframework.stereotype.Component;
 
@@ -20,4 +25,10 @@ public class UzyTPerfilMenuMapper {
     public ModelUzyTPerfilMenu dtoToEntity(DtoUzyTPerfilMenu dto) {
         return modelMapper.map(dto, ModelUzyTPerfilMenu.class);
     }
+
+    public List<DtoUzyTPerfilMenu> entitiesToDtos(List<ModelUzyTPerfilMenu> entities) {
+        return entities.stream()
+                .map(this::entityToDto)
+                .collect(Collectors.toList());
+    }
 }

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Mapper/Components_Class/UzyTPlanificacionMapper.java

@@ -2,6 +2,10 @@ package ec.edu.espe.movilidad.MovilidadWS.Mapper.Components_Class;
 
 import ec.edu.espe.movilidad.MovilidadWS.Dto.DtoUzyTPlanificacion;
 import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTPlanificacion;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
 import org.modelmapper.ModelMapper;
 import org.springframework.stereotype.Component;
 
@@ -20,4 +24,10 @@ public class UzyTPlanificacionMapper {
     public ModelUzyTPlanificacion dtoToEntity(DtoUzyTPlanificacion dto) {
         return modelMapper.map(dto, ModelUzyTPlanificacion.class);
     }
+
+    public List<DtoUzyTPlanificacion> entitiesToDtos(List<ModelUzyTPlanificacion> entities) {
+        return entities.stream()
+                .map(this::entityToDto)
+                .collect(Collectors.toList());
+    }
 }

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Mapper/Components_Class/UzyTavConfiguracionMapper.java

 package ec.edu.espe.movilidad.MovilidadWS.Mapper.Components_Class;
 
 import ec.edu.espe.movilidad.MovilidadWS.Dto.DtoUzyTavConfiguracion;
+
 import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTavConfiguracion;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
 import org.modelmapper.ModelMapper;
 import org.springframework.stereotype.Component;
 
@@ -20,4 +25,10 @@ public class UzyTavConfiguracionMapper {
     public ModelUzyTavConfiguracion dtoToEntity(DtoUzyTavConfiguracion dto) {
         return modelMapper.map(dto, ModelUzyTavConfiguracion.class);
     }
+
+    public List<DtoUzyTavConfiguracion> entitiesToDtos(List<ModelUzyTavConfiguracion> entities) {
+        return entities.stream()
+                .map(this::entityToDto)
+                .collect(Collectors.toList());
+    }
 }

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Mapper/Components_Class/UzyTavZonaDetalleMapper.java

@@ -2,6 +2,10 @@ package ec.edu.espe.movilidad.MovilidadWS.Mapper.Components_Class;
 
 import ec.edu.espe.movilidad.MovilidadWS.Dto.DtoUzyTavZonaDetalle;
 import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTavZonaDetalle;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
 import org.modelmapper.ModelMapper;
 import org.springframework.stereotype.Component;
 
@@ -20,4 +24,10 @@ public class UzyTavZonaDetalleMapper {
     public ModelUzyTavZonaDetalle dtoToEntity(DtoUzyTavZonaDetalle dto) {
         return modelMapper.map(dto, ModelUzyTavZonaDetalle.class);
     }
+
+    public List<DtoUzyTavZonaDetalle> entitiesToDtos(List<ModelUzyTavZonaDetalle> entities) {
+        return entities.stream()
+                .map(this::entityToDto)
+                .collect(Collectors.toList());
+    }
 }

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Security/JwtAuthenticationFilter.java

 package ec.edu.espe.movilidad.MovilidadWS.Security;
-
-import io.jsonwebtoken.Claims;
-import io.jsonwebtoken.Jwts;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
 import org.springframework.security.core.context.SecurityContextHolder;
 import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
 import org.springframework.web.filter.OncePerRequestFilter;
 
 import javax.servlet.FilterChain;
@@ -16,34 +15,38 @@ import java.io.IOException;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import static ec.edu.espe.movilidad.MovilidadWS.Constant.GlobalConstants.SECRET_KEY;
-
 
 public class JwtAuthenticationFilter extends OncePerRequestFilter {
-    private static final Logger loggerToken = LoggerFactory.getLogger(JwtAuthenticationFilter.class);
+    private static final Logger loggerAuth = LoggerFactory.getLogger(JwtAuthenticationFilter.class);
+
+    @Autowired
+    JwtUserDetailsService jwtUserDetailsService;
 
     @Override
     protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
-        try {
-            String authorizationHeader = request.getHeader("Authorization");
-            if (authorizationHeader != null && authorizationHeader.startsWith("Bearer ")) {
-                String token = authorizationHeader.substring(7); // Eliminar "Bearer" del encabezado
+        // Obtener el correo electrónico del encabezado
+        String email = request.getHeader("email");
+        String Token = request.getHeader("Authorization");
+        loggerAuth.info("Email válido obtenido en el backend:  {}", email);
+
+        loggerAuth.info("Token válido obtenido en el backend:  {}", Token);
+
+        if (email != null && SecurityContextHolder.getContext().getAuthentication() == null) {
+            // Autenticar al usuario por correo electrónico
+            UserDetails userDetails = jwtUserDetailsService.loadUserByUsername(email);
+            if (userDetails != null) {
+                UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(
+                        userDetails, null, userDetails.getAuthorities());
+                authenticationToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
+                SecurityContextHolder.getContext().setAuthentication(authenticationToken);
 
-                loggerToken.info("Token recibido en el backend: {}", token);
-
-
-                UsernamePasswordAuthenticationToken authentication = getAuthentication(token);
-                SecurityContextHolder.getContext().setAuthentication(authentication);
             }
-
-        } catch (Exception e) {
-            SecurityContextHolder.clearContext();
-            loggerToken.error("Error en el filtro de autenticación JWT: {}", e.getMessage());
         }
 
         filterChain.doFilter(request, response);
     }
 
+    /*
     private UsernamePasswordAuthenticationToken getAuthentication(String token) {
         try {
             if (tokenEsValido(token)) {
@@ -85,5 +88,6 @@ public class JwtAuthenticationFilter extends OncePerRequestFilter {
 
         return null;
     }
+     */
 }
 

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Security/JwtUserDetailsService.java

+package ec.edu.espe.movilidad.MovilidadWS.Security;
+
+import ec.edu.espe.movilidad.MovilidadWS.Dao.DaoUzyTUsuario;
+import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTUsuario;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.security.core.userdetails.User;
+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;
+
+@Service
+public class JwtUserDetailsService implements UserDetailsService {
+
+    private final DaoUzyTUsuario userRepository;
+
+    @Autowired
+    public JwtUserDetailsService(DaoUzyTUsuario userRepository) {
+        this.userRepository = userRepository;
+    }
+
+    @Override
+    public UserDetails loadUserByUsername(String email) throws UsernameNotFoundException {
+        ModelUzyTUsuario user = userRepository.findByEmail(email);
+        if (user == null) {
+            throw new UsernameNotFoundException("Usuario no encontrado");
+        }
+
+        return User
+                .withUsername(user.getUzytusuario_email_institucional())
+                .password("{noop}") // Cualquier contraseña, solo es para q no se vaya null
+                .roles("USER") // Roles
+                .build();
+    }
+
+}
+

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Security/SecurityConfig.java

@@ -25,15 +25,16 @@ public class SecurityConfig {
                 .csrf()
                 .disable()
                 .exceptionHandling()
-                .authenticationEntryPoint(jwtEntryPoint)
                 .and()
-                .cors()
+                .httpBasic().authenticationEntryPoint(jwtEntryPoint)
                 .and()
                 .authorizeRequests()
-                .anyRequest().permitAll()
+                .antMatchers("/api/v1.0/**").permitAll()
+                .antMatchers("/api/v2.0/convoca/**").authenticated()
                 .and()
                 .sessionManagement()
-                .sessionCreationPolicy(SessionCreationPolicy.STATELESS); // Deshabilitar el uso de sesiones
+                .sessionCreationPolicy(SessionCreationPolicy.STATELESS);
+
 
         http.addFilterBefore(jwtAuthenticationFilter(), UsernamePasswordAuthenticationFilter.class);
         return http.build();

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Service/UzyTPerfil/IServiceUzyTPerfil.java

 package ec.edu.espe.movilidad.MovilidadWS.Service.UzyTPerfil;
-
-import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTPerfil;
+import ec.edu.espe.movilidad.MovilidadWS.Dto.DtoUzyTPerfil;
 
 import java.util.List;
 
 public interface IServiceUzyTPerfil {
 
-    public ModelUzyTPerfil ListarPorID(Long id);
+    DtoUzyTPerfil ListarPorID(Long id);
 
-    public List<ModelUzyTPerfil> ListarRegistros();
+    List<DtoUzyTPerfil> ListarRegistros();
 
-    public ModelUzyTPerfil guardar(ModelUzyTPerfil modelUzyTPerfil);
+    DtoUzyTPerfil guardar(DtoUzyTPerfil dtoUzyTPerfil);
 
-    public ModelUzyTPerfil editar(Long id, ModelUzyTPerfil modelUzyTPerfil);
+    DtoUzyTPerfil editar(Long id, DtoUzyTPerfil dtoUzyTPerfil);
 
     void eliminar(Long id);
 }

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Service/UzyTPerfil/ServiceUzyTPerfil.java

 package ec.edu.espe.movilidad.MovilidadWS.Service.UzyTPerfil;
 
 import ec.edu.espe.movilidad.MovilidadWS.Dao.DaoUzyTPerfil;
+import ec.edu.espe.movilidad.MovilidadWS.Dto.DtoUzyTParroquia;
+import ec.edu.espe.movilidad.MovilidadWS.Dto.DtoUzyTPerfil;
+import ec.edu.espe.movilidad.MovilidadWS.Exceptions.ResourceNotFoundException;
+import ec.edu.espe.movilidad.MovilidadWS.Mapper.Components_Class.UzyTPerfilMapper;
 import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTMenu;
+import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTParroquia;
 import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTPerfil;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
+import org.springframework.web.bind.annotation.PathVariable;
 
 import java.util.List;
 
 @Service
-public class ServiceUzyTPerfil implements IServiceUzyTPerfil{
-    @Autowired
-    DaoUzyTPerfil daoUzyTPerfil;
-    @Override
-    public ModelUzyTPerfil ListarPorID(Long id) {
-        return daoUzyTPerfil.findById(id).get();
+public class ServiceUzyTPerfil implements IServiceUzyTPerfil {
+
+    private final DaoUzyTPerfil daoUzyTPerfil;
+    private final UzyTPerfilMapper mapper;
+
+    public ServiceUzyTPerfil(DaoUzyTPerfil daoUzyTPerfil, UzyTPerfilMapper mapper) {
+        this.daoUzyTPerfil = daoUzyTPerfil;
+        this.mapper = mapper;
     }
 
     @Override
-    public List<ModelUzyTPerfil> ListarRegistros() {
-        return daoUzyTPerfil.findAll();
+    public DtoUzyTPerfil ListarPorID(@PathVariable Long id) {
+        ModelUzyTPerfil entity = daoUzyTPerfil.findById(id)
+                .orElseThrow(() -> new ResourceNotFoundException("No se encontró el registro con ID: " + id));
+        return mapper.entityToDto(entity);
     }
 
     @Override
-    public ModelUzyTPerfil guardar(ModelUzyTPerfil modelUzyTPerfil) {
-        return daoUzyTPerfil.save(modelUzyTPerfil);
+    public List<DtoUzyTPerfil> ListarRegistros() {
+        List<ModelUzyTPerfil> entities = daoUzyTPerfil.findAll();
+        return mapper.entitiesToDtos(entities);
     }
 
     @Override
-    public ModelUzyTPerfil editar(Long id, ModelUzyTPerfil modelUzyTPerfil) {
-        ModelUzyTPerfil dato = daoUzyTPerfil.findById(id).get();
-        //.orElseThrow(()->new ControlExcepciones("No existe el registro con el ID : " + id));
-        //Seteamos los nuevos datos del registro
-        dato.setUzytperfilNombre(modelUzyTPerfil.getUzytperfilNombre());
+    public DtoUzyTPerfil guardar(DtoUzyTPerfil dtoUzyTPerfil) {
+        ModelUzyTPerfil entity = mapper.dtoToEntity(dtoUzyTPerfil);
+        ModelUzyTPerfil nuevoEntity = daoUzyTPerfil.save(entity);
+        return mapper.entityToDto(nuevoEntity);
+    }
 
-        ModelUzyTPerfil datoActualizado = daoUzyTPerfil.save(dato);
-        return datoActualizado;
+    @Override
+    public DtoUzyTPerfil editar(Long id, DtoUzyTPerfil dtoUzyTPerfil) {
+        try {
+            ModelUzyTPerfil entity = daoUzyTPerfil.findById(id)
+                    .orElseThrow(() -> new ResourceNotFoundException("No se encontró el registro con ID: " + id));
+            entity.setUzytperfilNombre(dtoUzyTPerfil.getUzytperfil_nombre());
+            ModelUzyTPerfil updatedEntity = daoUzyTPerfil.save(entity);
+            return mapper.entityToDto(updatedEntity);
+        } catch (Exception e) {
+            throw new ResourceNotFoundException("Error al editar el registro: " + e.getMessage());
+        }
     }
 
     @Override
     public void eliminar(Long id) {
         ModelUzyTPerfil dato = daoUzyTPerfil.findById(id).get();
-        //.orElseThrow(() -daoUzyTMenuntrolExcepciones("No existe el registro con el ID : " + id));
+
         daoUzyTPerfil.delete(dato);
     }
 }

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Service/UzyTPerfilMenu/IServiceUzyTPerfilMenu.java

 package ec.edu.espe.movilidad.MovilidadWS.Service.UzyTPerfilMenu;
 
-import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTLineaOperativa;
-import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTPerfilMenu;
+import ec.edu.espe.movilidad.MovilidadWS.Dto.DtoUzyTPerfilMenu;
+
 
 import java.util.List;
 
 public interface IServiceUzyTPerfilMenu {
 
-    public ModelUzyTPerfilMenu ListarPorID(Long id);
+    DtoUzyTPerfilMenu ListarPorID(Long id);
 
-    public List<ModelUzyTPerfilMenu> ListarRegistros();
+    List<DtoUzyTPerfilMenu> ListarRegistros();
 
-    public ModelUzyTPerfilMenu guardar(ModelUzyTPerfilMenu modelUzyTPerfilMenu);
+    DtoUzyTPerfilMenu guardar(DtoUzyTPerfilMenu dtoUzyTPerfilMenu);
 
-    public ModelUzyTPerfilMenu editar(Long id, ModelUzyTPerfilMenu modelUzyTPerfilMenu);
+    DtoUzyTPerfilMenu editar(Long id, DtoUzyTPerfilMenu dtoUzyTPerfilMenu);
 
     void eliminar(Long id);
 

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Service/UzyTPerfilMenu/ServiceUzyTPerfilMenu.java

 package ec.edu.espe.movilidad.MovilidadWS.Service.UzyTPerfilMenu;
 
 import ec.edu.espe.movilidad.MovilidadWS.Dao.DaoUzyTPerfilMenu;
+import ec.edu.espe.movilidad.MovilidadWS.Dto.DtoUzyTPerfilMenu;
+import ec.edu.espe.movilidad.MovilidadWS.Exceptions.ResourceNotFoundException;
+import ec.edu.espe.movilidad.MovilidadWS.Mapper.Components_Class.UzyTPerfilMenuMapper;
 import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTLineaOperativa;
 import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTPerfilMenu;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
+import org.springframework.web.bind.annotation.PathVariable;
 
 import java.util.List;
 
 @Service
 public class ServiceUzyTPerfilMenu implements IServiceUzyTPerfilMenu {
-    @Autowired
-    DaoUzyTPerfilMenu daoUzyTPerfilMenu;
+
+    private final DaoUzyTPerfilMenu daoUzyTPerfilMenu;
+    private final UzyTPerfilMenuMapper mapper;
+
+    public ServiceUzyTPerfilMenu(DaoUzyTPerfilMenu daoUzyTPerfilMenu, UzyTPerfilMenuMapper mapper) {
+        this.daoUzyTPerfilMenu = daoUzyTPerfilMenu;
+        this.mapper = mapper;
+    }
+
     @Override
-    public ModelUzyTPerfilMenu ListarPorID(Long id) {
-        return daoUzyTPerfilMenu.findById(id).get();
+    public DtoUzyTPerfilMenu ListarPorID(@PathVariable Long id) {
+        ModelUzyTPerfilMenu entity = daoUzyTPerfilMenu.findById(id)
+                .orElseThrow(() -> new ResourceNotFoundException("No se encontró el registro con ID: " + id));
+        return mapper.entityToDto(entity);
     }
 
     @Override
-    public List<ModelUzyTPerfilMenu> ListarRegistros() {
-        return daoUzyTPerfilMenu.findAll();
+    public List<DtoUzyTPerfilMenu> ListarRegistros() {
+        List<ModelUzyTPerfilMenu> entities = daoUzyTPerfilMenu.findAll();
+        return mapper.entitiesToDtos(entities);
     }
 
     @Override
-    public ModelUzyTPerfilMenu guardar(ModelUzyTPerfilMenu modelUzyTPerfilMenu) {
-        return daoUzyTPerfilMenu.save(modelUzyTPerfilMenu);
+    public DtoUzyTPerfilMenu guardar(DtoUzyTPerfilMenu dtoUzyTPerfilMenu) {
+        ModelUzyTPerfilMenu entity = mapper.dtoToEntity(dtoUzyTPerfilMenu);
+        ModelUzyTPerfilMenu nuevoEntity = daoUzyTPerfilMenu.save(entity);
+        return mapper.entityToDto(nuevoEntity);
     }
 
     @Override
-    public ModelUzyTPerfilMenu editar(Long id, ModelUzyTPerfilMenu modelUzyTPerfilMenu) {
-        ModelUzyTPerfilMenu dato = daoUzyTPerfilMenu.findById(id).get();
-        //.orElseThrow(()->new ControlExcepciones("No existe el registro con el ID : " + id));
-        //Seteamos los nuevos datos del registro
+    public DtoUzyTPerfilMenu editar(Long id, DtoUzyTPerfilMenu dtoUzyTPerfilMenu) {
+        try {
+            ModelUzyTPerfilMenu entity = daoUzyTPerfilMenu.findById(id)
+                    .orElseThrow(() -> new ResourceNotFoundException("No se encontró el registro con ID: " + id));
+
 
-        ModelUzyTPerfilMenu datoActualizado = daoUzyTPerfilMenu.save(dato);
-        return datoActualizado;
+
+            ModelUzyTPerfilMenu updatedEntity = daoUzyTPerfilMenu.save(entity);
+            return mapper.entityToDto(updatedEntity);
+        } catch (Exception e) {
+            throw new ResourceNotFoundException("Error al editar el registro: " + e.getMessage());
+        }
     }
 
     @Override
     public void eliminar(Long id) {
         ModelUzyTPerfilMenu dato = daoUzyTPerfilMenu.findById(id).get();
-        //.orElseThrow(() -> new ControlExcepciones("No existe el registro con el ID : " + id));
+
         daoUzyTPerfilMenu.delete(dato);
     }
 }

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Service/UzyTPlanificacion/IServiceUzyTPlanificacion.java

 package ec.edu.espe.movilidad.MovilidadWS.Service.UzyTPlanificacion;
 
-import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTPlanificacion;
+import ec.edu.espe.movilidad.MovilidadWS.Dto.DtoUzyTPlanificacion;
 
 import java.util.List;
 
 public interface IServiceUzyTPlanificacion {
-    public ModelUzyTPlanificacion ListarPorID(Long id);
 
-    public List<ModelUzyTPlanificacion> ListarRegistros();
+    public DtoUzyTPlanificacion ListarPorID(Long id);
 
-    public ModelUzyTPlanificacion guardar(ModelUzyTPlanificacion modelUzyTPlanificacion);
+    public List<DtoUzyTPlanificacion> ListarRegistros();
 
-    public ModelUzyTPlanificacion editar( Long id, ModelUzyTPlanificacion modelUzyTPlanificacion);
+    public DtoUzyTPlanificacion guardar(DtoUzyTPlanificacion dtoUzyTPlanificacion);
 
-    void eliminar(Long id);
+    public DtoUzyTPlanificacion editar(Long id, DtoUzyTPlanificacion dtoUzyTPlanificacion);
+
+    public void eliminar(Long id);
 }

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Service/UzyTPlanificacion/ServiceUzyTPlanificacion.java

 package ec.edu.espe.movilidad.MovilidadWS.Service.UzyTPlanificacion;
 
 import ec.edu.espe.movilidad.MovilidadWS.Dao.DaoUzyTPlanificacion;
+import ec.edu.espe.movilidad.MovilidadWS.Dto.DtoUzyTPlanificacion;
+import ec.edu.espe.movilidad.MovilidadWS.Exceptions.ResourceNotFoundException;
+import ec.edu.espe.movilidad.MovilidadWS.Mapper.Components_Class.UzyTPlanificacionMapper;
 import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTPlanificacion;
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
+import org.springframework.web.bind.annotation.PathVariable;
 
 import java.util.List;
 
 @Service
 public class ServiceUzyTPlanificacion implements IServiceUzyTPlanificacion {
-    @Autowired
-    DaoUzyTPlanificacion daoUzyTPlanificacion;
 
-    @Override
-    public ModelUzyTPlanificacion ListarPorID(Long id) {
-        return daoUzyTPlanificacion.findById(id).get();
+    private final DaoUzyTPlanificacion daoUzyTPlanificacion;
+    private final UzyTPlanificacionMapper mapper;
+
+    public ServiceUzyTPlanificacion(DaoUzyTPlanificacion daoUzyTPlanificacion, UzyTPlanificacionMapper mapper) {
+        this.daoUzyTPlanificacion = daoUzyTPlanificacion;
+        this.mapper = mapper;
     }
 
     @Override
-    public List<ModelUzyTPlanificacion> ListarRegistros() {
-        return daoUzyTPlanificacion.findAll();
+    public DtoUzyTPlanificacion ListarPorID(@PathVariable Long id) {
+        ModelUzyTPlanificacion entity = daoUzyTPlanificacion.findById(id)
+                .orElseThrow(() -> new ResourceNotFoundException("No se encontró el registro con ID: " + id));
+        return mapper.entityToDto(entity);
     }
 
     @Override
-    public ModelUzyTPlanificacion guardar(ModelUzyTPlanificacion modelUzyTPlanificacion) {
-        return daoUzyTPlanificacion.save(modelUzyTPlanificacion);
+    public List<DtoUzyTPlanificacion> ListarRegistros() {
+        List<ModelUzyTPlanificacion> entities = daoUzyTPlanificacion.findAll();
+        return mapper.entitiesToDtos(entities);
     }
 
     @Override
-    public ModelUzyTPlanificacion editar(Long id, ModelUzyTPlanificacion modelUzyTPlanificacion) {
-        ModelUzyTPlanificacion dato = daoUzyTPlanificacion.findById(id).get();
-        //.orElseThrow(()->new ControlExcepciones("No existe el registro con el ID : " + id));
-        //Seteamos los nuevos datos del registro
-        dato.setUzytplanificacionNombre(modelUzyTPlanificacion.getUzytplanificacionNombre());
-        dato.setUzytplanificacionNombreLargo(modelUzyTPlanificacion.getUzytplanificacionNombreLargo());
+    public DtoUzyTPlanificacion guardar(DtoUzyTPlanificacion dtoUzyTPlanificacion) {
+        ModelUzyTPlanificacion entity = mapper.dtoToEntity(dtoUzyTPlanificacion);
+        ModelUzyTPlanificacion nuevoEntity = daoUzyTPlanificacion.save(entity);
+        return mapper.entityToDto(nuevoEntity);
+    }
 
-        ModelUzyTPlanificacion datoActualizado = daoUzyTPlanificacion.save(dato);
-        return datoActualizado;
+    @Override
+    public DtoUzyTPlanificacion editar(Long id, DtoUzyTPlanificacion dtoUzyTPlanificacion) {
+        try {
+            ModelUzyTPlanificacion entity = daoUzyTPlanificacion.findById(id)
+                    .orElseThrow(() -> new ResourceNotFoundException("No se encontró el registro con ID: " + id));
+            entity.setUzytplanificacionNombre(dtoUzyTPlanificacion.getUzytplanificacionnombre());
+            entity.setUzytplanificacionNombreLargo(dtoUzyTPlanificacion.getUzytplanificacionnombre_largo());
+            ModelUzyTPlanificacion updatedEntity = daoUzyTPlanificacion.save(entity);
+            return mapper.entityToDto(updatedEntity);
+        } catch (Exception e) {
+            throw new ResourceNotFoundException("Error al editar el registro: " + e.getMessage());
+        }
     }
 
     @Override
     public void eliminar(Long id) {
         ModelUzyTPlanificacion dato = daoUzyTPlanificacion.findById(id).get();
-        //.orElseThrow(() -> new ControlExcepciones("No existe el registro con el ID : " + id));
+
         daoUzyTPlanificacion.delete(dato);
     }
 }

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Service/UzyTavConfiguracion/IServiceUzyTavConfiguracion.java

 package ec.edu.espe.movilidad.MovilidadWS.Service.UzyTavConfiguracion;
+import ec.edu.espe.movilidad.MovilidadWS.Dto.DtoUzyTavConfiguracion;
 
-import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTavConfiguracion;
 
 import java.util.List;
 
+
 public interface IServiceUzyTavConfiguracion {
 
-    public ModelUzyTavConfiguracion ListarPorID(Long id);
+    DtoUzyTavConfiguracion ListarPorID(Long id);
+
+    DtoUzyTavConfiguracion buscarPorCedulaVicerrector(String cedula);
 
-    public ModelUzyTavConfiguracion buscarPorCedulaVicerrector(String cedula);
+    DtoUzyTavConfiguracion buscarPorCedulaDirector(String cedula);
 
-    public ModelUzyTavConfiguracion buscarPorCedulaDirector(String cedula);
-    public List<ModelUzyTavConfiguracion> ListarRegistros();
+   List<DtoUzyTavConfiguracion> ListarRegistros();
 
-    public ModelUzyTavConfiguracion guardar(ModelUzyTavConfiguracion modeIServiceUzyTavConfiguracion);
+    DtoUzyTavConfiguracion guardar(DtoUzyTavConfiguracion dtoUzyTavConfiguracion);
 
-    public ModelUzyTavConfiguracion editar(Long id, ModelUzyTavConfiguracion modeIServiceUzyTavConfiguracion);
+    DtoUzyTavConfiguracion editar(Long id, DtoUzyTavConfiguracion dtoUzyTavConfiguracion);
 
 
-    public ModelUzyTavConfiguracion editarHorasDocente(Long id, ModelUzyTavConfiguracion modeIServiceUzyTavConfiguracion);
+    DtoUzyTavConfiguracion editarHorasDocente(Long id, DtoUzyTavConfiguracion dtoUzyTavConfiguracion);
 
 
-    public ModelUzyTavConfiguracion editarHorasEstudiante(Long id, ModelUzyTavConfiguracion modeIServiceUzyTavConfiguracion);
+    DtoUzyTavConfiguracion editarHorasEstudiante(Long id, DtoUzyTavConfiguracion dtoUzyTavConfiguracion);
 
 
-    public ModelUzyTavConfiguracion editarDatosVicerrector(Long id, ModelUzyTavConfiguracion modeIServiceUzyTavConfiguracion);
+    DtoUzyTavConfiguracion editarDatosVicerrector(Long id, DtoUzyTavConfiguracion dtoUzyTavConfiguracion);
 
 
-    public ModelUzyTavConfiguracion editarDatosDirector(Long id, ModelUzyTavConfiguracion modeIServiceUzyTavConfiguracion);
+    DtoUzyTavConfiguracion editarDatosDirector(Long id, DtoUzyTavConfiguracion dtoUzyTavConfiguracion);
 
     void eliminar(Long id);
 }

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Service/UzyTavConfiguracion/ServiceUzyTavConfiguracion.java

 package ec.edu.espe.movilidad.MovilidadWS.Service.UzyTavConfiguracion;
-
 import ec.edu.espe.movilidad.MovilidadWS.Dao.DaoUzyTavConfiguracion;
+import ec.edu.espe.movilidad.MovilidadWS.Dto.DtoUzyTavConfiguracion;
+import ec.edu.espe.movilidad.MovilidadWS.Exceptions.ResourceNotFoundException;
+import ec.edu.espe.movilidad.MovilidadWS.Mapper.Components_Class.UzyTavConfiguracionMapper;
 import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTavConfiguracion;
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.web.bind.annotation.PathVariable;
 
 import java.util.List;
+import java.util.stream.Collectors;
 
 @Service
 public class ServiceUzyTavConfiguracion implements IServiceUzyTavConfiguracion {
-    @Autowired
-    private DaoUzyTavConfiguracion daoUzyTavConfiguracion;
 
+    private final DaoUzyTavConfiguracion daoUzyTavConfiguracion;
+    private final UzyTavConfiguracionMapper mapper;
 
-    @Override
-    public ModelUzyTavConfiguracion ListarPorID(@PathVariable Long id) {
-        return daoUzyTavConfiguracion.findById(id).get();
+    public ServiceUzyTavConfiguracion(DaoUzyTavConfiguracion daoUzyTavConfiguracion, UzyTavConfiguracionMapper mapper) {
+        this.daoUzyTavConfiguracion = daoUzyTavConfiguracion;
+        this.mapper = mapper;
     }
 
     @Override
-    public ModelUzyTavConfiguracion buscarPorCedulaVicerrector(String cedula) {
-        return daoUzyTavConfiguracion.findByCedulaVicerrector(cedula);
+    public DtoUzyTavConfiguracion ListarPorID(@PathVariable Long id) {
+        ModelUzyTavConfiguracion entity = daoUzyTavConfiguracion.findById(id)
+                .orElseThrow(() -> new ResourceNotFoundException("No se encontró el registro con ID: " + id));
+        return mapper.entityToDto(entity);
     }
 
     @Override
-    public ModelUzyTavConfiguracion buscarPorCedulaDirector(String cedula) {
-        return daoUzyTavConfiguracion.findByCedulaDirector(cedula);
+    public DtoUzyTavConfiguracion buscarPorCedulaVicerrector(String cedula) {
+        ModelUzyTavConfiguracion entity = daoUzyTavConfiguracion.findByCedulaVicerrector(cedula);
+        if (entity == null) {
+            throw new ResourceNotFoundException("No se encontró el registro con cédula: " + cedula);
+        }
+        return mapper.entityToDto(entity);
     }
 
     @Override
-    public List<ModelUzyTavConfiguracion> ListarRegistros() {
-        return daoUzyTavConfiguracion.findAll();
+    public DtoUzyTavConfiguracion buscarPorCedulaDirector(String cedula) {
+        ModelUzyTavConfiguracion entity = daoUzyTavConfiguracion.findByCedulaDirector(cedula);
+        if (entity == null) {
+            throw new ResourceNotFoundException("No se encontró el registro con cédula: " + cedula);
+        }
+        return mapper.entityToDto(entity);
     }
 
     @Override
-    public ModelUzyTavConfiguracion guardar(ModelUzyTavConfiguracion modeIServiceUzyTavConfiguracion) {
-        return daoUzyTavConfiguracion.save(modeIServiceUzyTavConfiguracion);
+    public List<DtoUzyTavConfiguracion> ListarRegistros() {
+        List<ModelUzyTavConfiguracion> entities = daoUzyTavConfiguracion.findAll();
+        return entities.stream()
+                .map(mapper::entityToDto) // Utilizar mapper::entityToDto en lugar de mapper::dtoToEntity
+                .collect(Collectors.toList());
     }
 
     @Override
-    public ModelUzyTavConfiguracion editar(Long id, ModelUzyTavConfiguracion modeIServiceUzyTavConfiguracion) {
-        ModelUzyTavConfiguracion dato = daoUzyTavConfiguracion.findById(id).get();
-        //.orElseThrow(()->new ControlExcepciones("No existe el registro con el ID : " + id));
-        //Seteamos los nuevos datos del registry
-        dato.setUzytavconfiguracion_id(modeIServiceUzyTavConfiguracion.getUzytavconfiguracion_id());
-        dato.setUzytavconfiguracion_vicerrector_ced(modeIServiceUzyTavConfiguracion.getUzytavconfiguracion_vicerrector_ced());
-        dato.setUzytavconfiguracion_vicerrector_nom(modeIServiceUzyTavConfiguracion.getUzytavconfiguracion_vicerrector_nom());
-        dato.setUzytavconfiguracion_vicerrector_ape(modeIServiceUzyTavConfiguracion.getUzytavconfiguracion_vicerrector_ape());
-        dato.setUzytavconfiguracion_director_unid_vincu_ced(modeIServiceUzyTavConfiguracion.getUzytavconfiguracion_director_unid_vincu_ced());
-        dato.setUzytavconfiguracion_director_unid_vincu_nom(modeIServiceUzyTavConfiguracion.getUzytavconfiguracion_director_unid_vincu_nom());
-        dato.setUzytavconfiguracion_director_unid_vincu_ape(modeIServiceUzyTavConfiguracion.getUzytavconfiguracion_director_unid_vincu_ape());
-        dato.setUzytavconfiguracion_director_unid_vincu_abrev(modeIServiceUzyTavConfiguracion.getUzytavconfiguracion_director_unid_vincu_abrev());
-        dato.setUzytavconfiguracion_vicerrector_abrev(modeIServiceUzyTavConfiguracion.getUzytavconfiguracion_vicerrector_abrev());
-        dato.setUzytavconfiguracion_vicerrector_grado_mil(modeIServiceUzyTavConfiguracion.getUzytavconfiguracion_vicerrector_grado_mil());
-        dato.setUzytavconfiguracion_director_unid_vincu_grado_mil(modeIServiceUzyTavConfiguracion.getUzytavconfiguracion_director_unid_vincu_grado_mil());
-        dato.setUzytavconfiguracion_nro_horas_minimo_certificado_e(modeIServiceUzyTavConfiguracion.getUzytavconfiguracion_nro_horas_minimo_certificado_e());
-        dato.setUzytavconfiguracion_nro_horas_minimo_certificado_d(modeIServiceUzyTavConfiguracion.getUzytavconfiguracion_nro_horas_minimo_certificado_d());
-
-        ModelUzyTavConfiguracion datoActualizado = daoUzyTavConfiguracion.save(dato);
-        return datoActualizado;
+    public DtoUzyTavConfiguracion guardar(DtoUzyTavConfiguracion dtoUzyTavConfiguracion) {
+        ModelUzyTavConfiguracion entity = mapper.dtoToEntity(dtoUzyTavConfiguracion);
+        ModelUzyTavConfiguracion nuevoEntity = daoUzyTavConfiguracion.save(entity);
+        return mapper.entityToDto(nuevoEntity);
     }
 
     @Override
-    public ModelUzyTavConfiguracion editarHorasDocente(Long id, ModelUzyTavConfiguracion modeIServiceUzyTavConfiguracion) {
-        ModelUzyTavConfiguracion dato = daoUzyTavConfiguracion.findById(id).get();
-        //.orElseThrow(()->new ControlExcepciones("No existe el registro con el ID : " + id));
-        //Seteamos los nuevos datos del registry
-        dato.setUzytavconfiguracion_nro_horas_minimo_certificado_d(modeIServiceUzyTavConfiguracion.getUzytavconfiguracion_nro_horas_minimo_certificado_d());
-        ModelUzyTavConfiguracion datoActualizado = daoUzyTavConfiguracion.save(dato);
-        return datoActualizado;
+    public DtoUzyTavConfiguracion editar(Long id, DtoUzyTavConfiguracion dtoUzyTavConfiguracion) {
+        try {
+            ModelUzyTavConfiguracion entity = daoUzyTavConfiguracion.findById(id)
+                    .orElseThrow(() -> new ResourceNotFoundException("No se encontró el registro con ID: " + id));
+            entity.setUzytavconfiguracion_id(dtoUzyTavConfiguracion.getUzytavconfiguracion_id());
+            entity.setUzytavconfiguracion_vicerrector_ced(
+                    dtoUzyTavConfiguracion.getUzytavconfiguracion_vicerrector_ced());
+            entity.setUzytavconfiguracion_vicerrector_nom(
+                    dtoUzyTavConfiguracion.getUzytavconfiguracion_vicerrector_nom());
+            entity.setUzytavconfiguracion_vicerrector_ape(
+                    dtoUzyTavConfiguracion.getUzytavconfiguracion_vicerrector_ape());
+            entity.setUzytavconfiguracion_director_unid_vincu_ced(
+                    dtoUzyTavConfiguracion.getUzytavconfiguracion_director_unid_vincu_ced());
+            entity.setUzytavconfiguracion_director_unid_vincu_nom(
+                    dtoUzyTavConfiguracion.getUzytavconfiguracion_director_unid_vincu_nom());
+            entity.setUzytavconfiguracion_director_unid_vincu_ape(
+                    dtoUzyTavConfiguracion.getUzytavconfiguracion_director_unid_vincu_ape());
+            entity.setUzytavconfiguracion_director_unid_vincu_abrev(
+                    dtoUzyTavConfiguracion.getUzytavconfiguracion_director_unid_vincu_abrev());
+            entity.setUzytavconfiguracion_vicerrector_abrev(
+                    dtoUzyTavConfiguracion.getUzytavconfiguracion_vicerrector_abrev());
+            entity.setUzytavconfiguracion_vicerrector_grado_mil(
+                    dtoUzyTavConfiguracion.getUzytavconfiguracion_vicerrector_grado_mil());
+            entity.setUzytavconfiguracion_director_unid_vincu_grado_mil(
+                    dtoUzyTavConfiguracion.getUzytavconfiguracion_director_unid_vincu_grado_mil());
+            entity.setUzytavconfiguracion_nro_horas_minimo_certificado_e(
+                    dtoUzyTavConfiguracion.getUzytavconfiguracion_nro_horas_minimo_certificado_e());
+            entity.setUzytavconfiguracion_nro_horas_minimo_certificado_d(
+                    dtoUzyTavConfiguracion.getUzytavconfiguracion_nro_horas_minimo_certificado_d());
+            ModelUzyTavConfiguracion updatedEntity = daoUzyTavConfiguracion.save(entity);
+            return mapper.entityToDto(updatedEntity);
+        } catch (Exception e) {
+            throw new ResourceNotFoundException("Error al editar el registro: " + e.getMessage());
+        }
     }
 
     @Override
-    public ModelUzyTavConfiguracion editarHorasEstudiante(Long id, ModelUzyTavConfiguracion modeIServiceUzyTavConfiguracion) {
-        ModelUzyTavConfiguracion dato = daoUzyTavConfiguracion.findById(id).get();
-        //.orElseThrow(()->new ControlExcepciones("No existe el registro con el ID : " + id));
+    public DtoUzyTavConfiguracion editarHorasDocente(Long id, DtoUzyTavConfiguracion dtoUzyTavConfiguracion) {
+        ModelUzyTavConfiguracion entity = daoUzyTavConfiguracion.findById(id)
+                .orElseThrow(() -> new ResourceNotFoundException("No existe el registro con el ID: " + id));
+
+        // Actualizamos las propiedades de la entidad con los valores del DTO
+        entity.setUzytavconfiguracion_nro_horas_minimo_certificado_d(
+                dtoUzyTavConfiguracion.getUzytavconfiguracion_nro_horas_minimo_certificado_d());
 
-        dato.setUzytavconfiguracion_nro_horas_minimo_certificado_e(modeIServiceUzyTavConfiguracion.getUzytavconfiguracion_nro_horas_minimo_certificado_e());
+        ModelUzyTavConfiguracion entityActualizado = daoUzyTavConfiguracion.save(entity);
+        return mapper.entityToDto(entityActualizado);
+    }
+
+    @Override
+    public DtoUzyTavConfiguracion editarHorasEstudiante(Long id, DtoUzyTavConfiguracion dtoUzyTavConfiguracion) {
+        ModelUzyTavConfiguracion entity = daoUzyTavConfiguracion.findById(id)
+                .orElseThrow(() -> new ResourceNotFoundException("No existe el registro con el ID: " + id));
 
+        // Actualizamos las propiedades de la entidad con los valores del DTO
+        entity.setUzytavconfiguracion_nro_horas_minimo_certificado_e(
+                dtoUzyTavConfiguracion.getUzytavconfiguracion_nro_horas_minimo_certificado_e());
 
-        ModelUzyTavConfiguracion datoActualizado = daoUzyTavConfiguracion.save(dato);
-        return datoActualizado;
+        ModelUzyTavConfiguracion entityActualizado = daoUzyTavConfiguracion.save(entity);
+        return mapper.entityToDto(entityActualizado);
     }
 
     @Override
-    public ModelUzyTavConfiguracion editarDatosVicerrector(Long id, ModelUzyTavConfiguracion modeIServiceUzyTavConfiguracion) {
-        ModelUzyTavConfiguracion dato = daoUzyTavConfiguracion.findById(id).get();
-        //.orElseThrow(()->new ControlExcepciones("No existe el registro con el ID : " + id));
-        //Seteamos los nuevos datos del registry
-
-        dato.setUzytavconfiguracion_vicerrector_ced(modeIServiceUzyTavConfiguracion.getUzytavconfiguracion_vicerrector_ced());
-        dato.setUzytavconfiguracion_vicerrector_nom(modeIServiceUzyTavConfiguracion.getUzytavconfiguracion_vicerrector_nom());
-        dato.setUzytavconfiguracion_vicerrector_ape(modeIServiceUzyTavConfiguracion.getUzytavconfiguracion_vicerrector_ape());
-        dato.setUzytavconfiguracion_vicerrector_abrev(modeIServiceUzyTavConfiguracion.getUzytavconfiguracion_vicerrector_abrev());
-        dato.setUzytavconfiguracion_vicerrector_grado_mil(modeIServiceUzyTavConfiguracion.getUzytavconfiguracion_vicerrector_grado_mil());
-
-        ModelUzyTavConfiguracion datoActualizado = daoUzyTavConfiguracion.save(dato);
-        return datoActualizado;
+    public DtoUzyTavConfiguracion editarDatosVicerrector(Long id, DtoUzyTavConfiguracion dtoUzyTavConfiguracion) {
+        try {
+            ModelUzyTavConfiguracion entity = daoUzyTavConfiguracion.findById(id)
+                    .orElseThrow(() -> new ResourceNotFoundException("No se encontró el registro con ID: " + id));
+            entity.setUzytavconfiguracion_vicerrector_ced(
+                    dtoUzyTavConfiguracion.getUzytavconfiguracion_vicerrector_ced());
+            entity.setUzytavconfiguracion_vicerrector_nom(
+                    dtoUzyTavConfiguracion.getUzytavconfiguracion_vicerrector_nom());
+            entity.setUzytavconfiguracion_vicerrector_ape(
+                    dtoUzyTavConfiguracion.getUzytavconfiguracion_vicerrector_ape());
+            entity.setUzytavconfiguracion_vicerrector_abrev(
+                    dtoUzyTavConfiguracion.getUzytavconfiguracion_vicerrector_abrev());
+            entity.setUzytavconfiguracion_vicerrector_grado_mil(
+                    dtoUzyTavConfiguracion.getUzytavconfiguracion_vicerrector_grado_mil());
+            ModelUzyTavConfiguracion updatedEntity = daoUzyTavConfiguracion.save(entity);
+            return mapper.entityToDto(updatedEntity);
+        } catch (Exception e) {
+            throw new ResourceNotFoundException("Error al editar el registro: " + e.getMessage());
+        }
     }
 
     @Override
-    public ModelUzyTavConfiguracion editarDatosDirector(Long id, ModelUzyTavConfiguracion modeIServiceUzyTavConfiguracion) {
-        ModelUzyTavConfiguracion dato = daoUzyTavConfiguracion.findById(id).get();
-        //.orElseThrow(()->new ControlExcepciones("No existe el registro con el ID : " + id));
-        //Seteamos los nuevos datos del registry
-
-        dato.setUzytavconfiguracion_director_unid_vincu_ced(modeIServiceUzyTavConfiguracion.getUzytavconfiguracion_director_unid_vincu_ced());
-        dato.setUzytavconfiguracion_director_unid_vincu_nom(modeIServiceUzyTavConfiguracion.getUzytavconfiguracion_director_unid_vincu_nom());
-        dato.setUzytavconfiguracion_director_unid_vincu_ape(modeIServiceUzyTavConfiguracion.getUzytavconfiguracion_director_unid_vincu_ape());
-        dato.setUzytavconfiguracion_director_unid_vincu_abrev(modeIServiceUzyTavConfiguracion.getUzytavconfiguracion_director_unid_vincu_abrev());
-        dato.setUzytavconfiguracion_director_unid_vincu_grado_mil(modeIServiceUzyTavConfiguracion.getUzytavconfiguracion_director_unid_vincu_grado_mil());
-
-        ModelUzyTavConfiguracion datoActualizado = daoUzyTavConfiguracion.save(dato);
-        return datoActualizado;
+    public DtoUzyTavConfiguracion editarDatosDirector(Long id, DtoUzyTavConfiguracion dtoUzyTavConfiguracion) {
+
+        try {
+            ModelUzyTavConfiguracion entity = daoUzyTavConfiguracion.findById(id)
+                    .orElseThrow(() -> new ResourceNotFoundException("No se encontró el registro con ID: " + id));
+            entity.setUzytavconfiguracion_director_unid_vincu_ced(
+                    dtoUzyTavConfiguracion.getUzytavconfiguracion_director_unid_vincu_ced());
+            entity.setUzytavconfiguracion_director_unid_vincu_nom(
+                    dtoUzyTavConfiguracion.getUzytavconfiguracion_director_unid_vincu_nom());
+            entity.setUzytavconfiguracion_director_unid_vincu_ape(
+                    dtoUzyTavConfiguracion.getUzytavconfiguracion_director_unid_vincu_ape());
+            entity.setUzytavconfiguracion_director_unid_vincu_abrev(
+                    dtoUzyTavConfiguracion.getUzytavconfiguracion_director_unid_vincu_abrev());
+            entity.setUzytavconfiguracion_director_unid_vincu_grado_mil(
+                    dtoUzyTavConfiguracion.getUzytavconfiguracion_director_unid_vincu_grado_mil());
+            ModelUzyTavConfiguracion updatedEntity = daoUzyTavConfiguracion.save(entity);
+            return mapper.entityToDto(updatedEntity);
+        } catch (Exception e) {
+            throw new ResourceNotFoundException("Error al editar el registro: " + e.getMessage());
+        }
     }
 
     @Override
     public void eliminar(Long id) {
 
-        ModelUzyTavConfiguracion dato = daoUzyTavConfiguracion.findById(id).get();
-        //.orElseThrow(() -> new ControlExcepciones("No existe el registro con el ID : " + id));
-        daoUzyTavConfiguracion.delete(dato);
+        ModelUzyTavConfiguracion entity = daoUzyTavConfiguracion.findById(id).get();
+        daoUzyTavConfiguracion.delete(entity);
     }
 }

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Service/UzyTavPrograma_V/ServiceUzyTavPrograma_V.java

@@ -12,7 +12,7 @@ import java.util.List;
 
 @Service
 
-public class ServiceUzyTavPrograma_V implements IServiceUzyTavPrograma_V{
+public class ServiceUzyTavPrograma_V implements IServiceUzyTavPrograma_V {
 
     private final DaoUzyTavPrograma_V daoUzyTavProgramaV;
     private final Uzytavprograma_VMapper mapper;
@@ -41,16 +41,21 @@ public class ServiceUzyTavPrograma_V implements IServiceUzyTavPrograma_V{
     public DtoUzyTavPrograma_V guardar(DtoUzyTavPrograma_V dtoUzyTavProgramaV) {
         ModelUzyTavPrograma_V entity = mapper.dtoToEntity(dtoUzyTavProgramaV);
         ModelUzyTavPrograma_V nuevoEntity = daoUzyTavProgramaV.save(entity);
-        return mapper.entityToDto(nuevoEntity);
-    }
 
+        // Obtén el ID generado
+        Long idGuardado = nuevoEntity.getUzytavprograma_v_id();
+
+        // Establece el ID en el DTO
+        dtoUzyTavProgramaV.setUzytavprograma_v_id(idGuardado);
 
+        return dtoUzyTavProgramaV;
+    }
 
     @Override
     public DtoUzyTavPrograma_V editar(Long id, DtoUzyTavPrograma_V dtoUzyTavProgramaV) {
         try {
             ModelUzyTavPrograma_V entity = daoUzyTavProgramaV.findById(id).orElse(null);
-            //Seteamos los nuevos datos del registro
+            // Seteamos los nuevos datos del registro
             if (entity != null) {
                 entity.setUzytavprograma_vnombre(dtoUzyTavProgramaV.getUzytavprograma_vnombre());
                 entity.setUzytavprograma_vresumen(dtoUzyTavProgramaV.getUzytavprograma_vresumen());
@@ -63,9 +68,12 @@ public class ServiceUzyTavPrograma_V implements IServiceUzyTavPrograma_V{
                 entity.setUzytavprograma_vmetas(dtoUzyTavProgramaV.getUzytavprograma_vmetas());
                 entity.setUzytavprograma_vsituacion_actual(dtoUzyTavProgramaV.getUzytavprograma_vsituacion_actual());
                 entity.setUzytavprograma_vpoliticas(dtoUzyTavProgramaV.getUzytavprograma_vpoliticas());
-                entity.setUzytavprograma_vviavilidad_tecnica(dtoUzyTavProgramaV.getUzytavprograma_vviabilidad_tecnica());
-                entity.setUzytavprograma_vperderia_no_ejecuta(dtoUzyTavProgramaV.getUzytavprograma_vperderia_no_ejecuta());
-                entity.setUzytavprograma_vresultados_impacto(dtoUzyTavProgramaV.getUzytavprograma_vresultados_impacto());
+                entity.setUzytavprograma_vviavilidad_tecnica(
+                        dtoUzyTavProgramaV.getUzytavprograma_vviabilidad_tecnica());
+                entity.setUzytavprograma_vperderia_no_ejecuta(
+                        dtoUzyTavProgramaV.getUzytavprograma_vperderia_no_ejecuta());
+                entity.setUzytavprograma_vresultados_impacto(
+                        dtoUzyTavProgramaV.getUzytavprograma_vresultados_impacto());
                 entity.setUzytavprograma_vproyecto_nombre(dtoUzyTavProgramaV.getUzytavprograma_vproyecto_nombre());
                 entity.setUzytavprograma_vproyecto_digi(dtoUzyTavProgramaV.getUzytavprograma_vproyecto_digi());
                 entity.setUzytavprograma_vfactor_c_exito(dtoUzyTavProgramaV.getUzytavprograma_vfactor_c_exito());
@@ -91,7 +99,7 @@ public class ServiceUzyTavPrograma_V implements IServiceUzyTavPrograma_V{
                 entity.setUzytavprograma_vfactor_c_exito2(dtoUzyTavProgramaV.getUzytavprograma_vfactor_c_exito2());
                 ModelUzyTavPrograma_V updatedEntity = daoUzyTavProgramaV.save(entity);
                 return mapper.entityToDto(updatedEntity);
-            }else {
+            } else {
                 throw new ResourceNotFoundException("No se encontró el registro con ID: " + id);
             }
         } catch (Exception e) {

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Service/UzyTavZonaDetalle/IServiceUzyTavZonaDetalle.java

 package ec.edu.espe.movilidad.MovilidadWS.Service.UzyTavZonaDetalle;
 
-import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTavZonaDetalle;
 
 import java.util.List;
 
+import ec.edu.espe.movilidad.MovilidadWS.Dto.DtoUzyTavZonaDetalle;
+
 public interface IServiceUzyTavZonaDetalle {
 
-    public ModelUzyTavZonaDetalle ListarPorID(Long id);
+    public DtoUzyTavZonaDetalle ListarPorID(Long id);
 
-    public List<ModelUzyTavZonaDetalle> ListarRegistros();
+    public List<DtoUzyTavZonaDetalle> ListarRegistros();
 
-    public ModelUzyTavZonaDetalle guardar(ModelUzyTavZonaDetalle modelUzyTavZonaDetalle);
+    public DtoUzyTavZonaDetalle guardar(DtoUzyTavZonaDetalle dtoUzyTavZonaDetalle);
 
-    public ModelUzyTavZonaDetalle editar( Long id, ModelUzyTavZonaDetalle modelUzyTavZonaDetalle);
+    public DtoUzyTavZonaDetalle editar( Long id, DtoUzyTavZonaDetalle dtoUzyTavZonaDetalle);
 
     void eliminar(Long id);
 

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Service/UzyTavZonaDetalle/ServiceUzyTavZonaDetalle.java

 package ec.edu.espe.movilidad.MovilidadWS.Service.UzyTavZonaDetalle;
 
 import ec.edu.espe.movilidad.MovilidadWS.Dao.DaoUzyTavZonaDetalle;
+import ec.edu.espe.movilidad.MovilidadWS.Dto.DtoUzyTCanton;
+import ec.edu.espe.movilidad.MovilidadWS.Dto.DtoUzyTParroquia;
+import ec.edu.espe.movilidad.MovilidadWS.Dto.DtoUzyTavZonaDetalle;
+import ec.edu.espe.movilidad.MovilidadWS.Exceptions.ResourceNotFoundException;
+import ec.edu.espe.movilidad.MovilidadWS.Mapper.Components_Class.UzyTavZonaDetalleMapper;
+import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTCanton;
+import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTParroquia;
 import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTavZonaDetalle;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
+import org.springframework.web.bind.annotation.PathVariable;
 
 import java.util.List;
+import java.util.stream.Collectors;
 
 @Service
-public class ServiceUzyTavZonaDetalle implements IServiceUzyTavZonaDetalle{
-    @Autowired
-    DaoUzyTavZonaDetalle daoUzyTavZonaDetalle;
+public class ServiceUzyTavZonaDetalle implements IServiceUzyTavZonaDetalle {
+
+    private final DaoUzyTavZonaDetalle daoUzyTavZonaDetalle;
+    private final UzyTavZonaDetalleMapper mapper;
+
+    public ServiceUzyTavZonaDetalle(DaoUzyTavZonaDetalle daoUzyTavZonaDetalle, UzyTavZonaDetalleMapper mapper) {
+        this.daoUzyTavZonaDetalle = daoUzyTavZonaDetalle;
+        this.mapper = mapper;
+    }
+
     @Override
-    public ModelUzyTavZonaDetalle ListarPorID(Long id) {
-        return daoUzyTavZonaDetalle.findById(id).get();
+    public DtoUzyTavZonaDetalle ListarPorID(@PathVariable Long id) {
+        ModelUzyTavZonaDetalle entity = daoUzyTavZonaDetalle.findById(id)
+                .orElseThrow(() -> new ResourceNotFoundException("No se encontró el registro con ID: " + id));
+        return mapper.entityToDto(entity);
     }
 
     @Override
-    public List<ModelUzyTavZonaDetalle> ListarRegistros() {
-        return daoUzyTavZonaDetalle.findAll();
+    public List<DtoUzyTavZonaDetalle> ListarRegistros() {
+        List<ModelUzyTavZonaDetalle> entities = daoUzyTavZonaDetalle.findAll();
+        return mapper.entitiesToDtos(entities);
     }
 
+
+
     @Override
-    public ModelUzyTavZonaDetalle guardar(ModelUzyTavZonaDetalle modelUzyTavZonaDetalle) {
-        return daoUzyTavZonaDetalle.save(modelUzyTavZonaDetalle);
+    public DtoUzyTavZonaDetalle guardar(DtoUzyTavZonaDetalle dtoUzyTavZonaDetalle) {
+        ModelUzyTavZonaDetalle entity = mapper.dtoToEntity(dtoUzyTavZonaDetalle);
+        ModelUzyTavZonaDetalle nuevoEntity = daoUzyTavZonaDetalle.save(entity);
+        return mapper.entityToDto(nuevoEntity);
     }
 
     @Override
-    public ModelUzyTavZonaDetalle editar(Long id, ModelUzyTavZonaDetalle modelUzyTavZonaDetalle) {
-        ModelUzyTavZonaDetalle dato = daoUzyTavZonaDetalle.findById(id).get();
-        //.orElseThrow(()->new ControlExcepciones("No existe el registro con el ID : " + id));
-        //Seteamos los nuevos datos del registro
+    public DtoUzyTavZonaDetalle editar(Long id, DtoUzyTavZonaDetalle dtoUzyTavZonaDetalle) {
+        try {
+            ModelUzyTavZonaDetalle entity = daoUzyTavZonaDetalle.findById(id).get();
 
-        dato.setUzytavzona_detalle_id(modelUzyTavZonaDetalle.getUzytavzona_detalle_id());
-        dato.setUzytavzona_objetivos(modelUzyTavZonaDetalle.getUzytavzona_objetivos());
+            entity.setUzytavzona_detalle_id(dtoUzyTavZonaDetalle.getUzytavzona_detalle_id());
+            entity.setUzytavzona_objetivos(dtoUzyTavZonaDetalle.getUzytavzona_objetivos());
 
-        ModelUzyTavZonaDetalle datoActualizado = daoUzyTavZonaDetalle.save(dato);
-        return datoActualizado;
+            ModelUzyTavZonaDetalle updatedEntity = daoUzyTavZonaDetalle.save(entity);
+            return mapper.entityToDto(updatedEntity);
+        } catch (Exception e) {
+            throw new ResourceNotFoundException("Error al editar el registro: " + e.getMessage());
+        }
     }
 
     @Override
     public void eliminar(Long id) {
-        ModelUzyTavZonaDetalle example = daoUzyTavZonaDetalle.findById(id).get();
-        //.orElseThrow(() -> new ControlExcepciones("No existe el registro con el ID : " + id));
-        daoUzyTavZonaDetalle.delete(example);
-
+        ModelUzyTavZonaDetalle dato = daoUzyTavZonaDetalle.findById(id).get();
+        daoUzyTavZonaDetalle.delete(dato);
     }
 }