SE AGREGAN los DTO DE LAS TABLAS, CONVOCATORIA Y LINEAOPERATIVA, ADEMÁS SE…

SE AGREGAN los DTO DE LAS TABLAS, CONVOCATORIA Y LINEAOPERATIVA, ADEMÁS SE AGREGA EL SERVICIO PARA SUBIR, EDITAR, BUSCAR Y ELIMINAR UN PDF

build.gradle

@@ -19,16 +19,21 @@ repositories {
 }
 
 dependencies {
-	implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
-	implementation 'org.springframework.boot:spring-boot-starter-validation'
-	implementation 'org.springframework.boot:spring-boot-starter-web'
-	implementation 'commons-fileupload:commons-fileupload:1.4'
-	implementation 'com.fasterxml.jackson.dataformat:jackson-dataformat-xml:2.12.5'
+	implementation 'org.springframework.boot:spring-boot-starter-data-jpa' // Dependencia para la integración de JPA en Spring Boot
+	implementation 'org.springframework.boot:spring-boot-starter-validation' // Dependencia para la validación de datos en Spring Boot
+	implementation 'org.springframework.boot:spring-boot-starter-web' // Dependencia para crear aplicaciones web con Spring Boot
+	implementation 'commons-fileupload:commons-fileupload:1.4' // Dependencia para el manejo de archivos en Java
+	implementation 'com.fasterxml.jackson.dataformat:jackson-dataformat-xml:2.12.5' // Dependencia para el formato XML en Jackson
+	implementation 'commons-io:commons-io:2.11.0'
 
-	compileOnly 'org.projectlombok:lombok'
-	runtimeOnly 'com.oracle.database.jdbc:ojdbc8'
-	annotationProcessor 'org.projectlombok:lombok'
-	testImplementation 'org.springframework.boot:spring-boot-starter-test'
+	implementation 'org.javassist:javassist:3.27.0-GA' // Dependencia para la manipulación de bytecode en Java
+	implementation 'org.mapstruct:mapstruct:1.4.2.Final'
+	implementation 'org.modelmapper:modelmapper:2.4.4'// Dependencia para la generación de mappers en Java
+	annotationProcessor 'org.mapstruct:mapstruct-processor:1.4.2.Final' // Procesador de anotaciones para MapStruct
+	compileOnly 'org.projectlombok:lombok' // Dependencia para generar automáticamente código repetitivo en Java
+	runtimeOnly 'com.oracle.database.jdbc:ojdbc8' // Dependencia para el controlador JDBC de Oracle
+	annotationProcessor 'org.projectlombok:lombok' // Procesador de anotaciones para Lombok
+	testImplementation 'org.springframework.boot:spring-boot-starter-test' // Dependencia para pruebas unitarias en Spring Boot
 }
 
 tasks.named('test') {

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

 package ec.edu.espe.movilidad.MovilidadWS.Controller;
 
-import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTMenu;
-import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTPerfilMenu;
+import ec.edu.espe.movilidad.MovilidadWS.Dto.DtoUzyTMenu;
 import ec.edu.espe.movilidad.MovilidadWS.Service.UzyTMenu.IServiceUzyTMenu;
+import javassist.NotFoundException;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
@@ -16,37 +16,52 @@ import static ec.edu.espe.movilidad.MovilidadWS.Constant.GlobalConstants.V1_API_
 @CrossOrigin(origins = "*")
 @RequestMapping(V1_API_VERSION+"/menu")
 public class UzyTMenuController {
-    @Autowired
-    IServiceUzyTMenu serviceUzyTMenu;
+    private final IServiceUzyTMenu serviceUzyTMenu;
 
+    @Autowired
+    public UzyTMenuController(IServiceUzyTMenu serviceUzyTMenu) {
+        this.serviceUzyTMenu = serviceUzyTMenu;
+    }
 
     @GetMapping("/exampleFindId/{id}")
-    public ResponseEntity<ModelUzyTMenu> ListarPorID(@PathVariable Long id) {
-        return new ResponseEntity<>(serviceUzyTMenu.ListarPorID(id), HttpStatus.OK);
+    public ResponseEntity<DtoUzyTMenu> ListarPorID(@PathVariable Long id) {
+        try {
+            DtoUzyTMenu uzyTMenu = serviceUzyTMenu.ListarPorID(id);
+            return ResponseEntity.ok(uzyTMenu);
+        } catch (NotFoundException e) {
+            return ResponseEntity.notFound().build();
+        }
     }
-
 
     @GetMapping("/getAll")
-    public ResponseEntity<List<ModelUzyTMenu>> ListarRegistros() {
-        return new ResponseEntity<>(serviceUzyTMenu.ListarRegistros(), HttpStatus.OK);
+    public ResponseEntity<List<DtoUzyTMenu>> ListarRegistros() {
+        List<DtoUzyTMenu> uzyTMenuList = serviceUzyTMenu.ListarRegistros();
+        return ResponseEntity.ok(uzyTMenuList);
     }
 
-
     @PostMapping("/guardar")
-    public ResponseEntity<ModelUzyTMenu> guardar(@RequestBody ModelUzyTMenu modelUzyTMenu) {
-        return new  ResponseEntity<>(serviceUzyTMenu.guardar(modelUzyTMenu), HttpStatus.OK);
+    public ResponseEntity<DtoUzyTMenu> guardar(@RequestBody DtoUzyTMenu dtoUzyTMenu) {
+        DtoUzyTMenu createdUzyTMenu = serviceUzyTMenu.guardar(dtoUzyTMenu);
+        return ResponseEntity.status(HttpStatus.CREATED).body(createdUzyTMenu);
     }
 
-
     @PutMapping("/editar/{id}")
-    public ResponseEntity<ModelUzyTMenu> editar(@PathVariable Long id, @RequestBody ModelUzyTMenu modelUzyTMenu) {
-        return new  ResponseEntity<>(serviceUzyTMenu.editar(id, modelUzyTMenu), HttpStatus.OK);
+    public ResponseEntity<DtoUzyTMenu> editar(@PathVariable Long id, @RequestBody DtoUzyTMenu dtoUzyTMenu) {
+        try {
+            DtoUzyTMenu updatedUzyTMenu = serviceUzyTMenu.editar(id, dtoUzyTMenu);
+            return ResponseEntity.ok(updatedUzyTMenu);
+        } catch (NotFoundException e) {
+            return ResponseEntity.notFound().build();
+        }
     }
-
 
     @DeleteMapping("/eliminar/{id}")
     public ResponseEntity<Void> eliminar(@PathVariable Long id) {
+        try {
             serviceUzyTMenu.eliminar(id);
-        return ResponseEntity.ok().build();
+            return ResponseEntity.noContent().build();
+        } catch (NotFoundException e) {
+            return ResponseEntity.notFound().build();
+        }
     }
 }

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

 package ec.edu.espe.movilidad.MovilidadWS.Controller;
 
+import ec.edu.espe.movilidad.MovilidadWS.Dto.UzyTavConvocaDTO;
 import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTavConvoca;
 import ec.edu.espe.movilidad.MovilidadWS.Service.UzyTavConvoca.IServiceUzyTavConvoca;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.core.io.ByteArrayResource;
-import org.springframework.http.HttpHeaders;
-import org.springframework.http.HttpStatus;
-import org.springframework.http.MediaType;
-import org.springframework.http.ResponseEntity;
+import org.springframework.format.annotation.DateTimeFormat;
+import org.springframework.http.*;
+import org.springframework.util.StreamUtils;
 import org.springframework.web.bind.annotation.*;
 import org.springframework.web.multipart.MultipartFile;
 
 import java.io.IOException;
 import java.util.Date;
 import java.util.List;
+import java.util.NoSuchElementException;
 import java.util.Optional;
+import org.apache.commons.io.IOUtils;
+import org.apache.commons.io.IOUtils;
 
 import static ec.edu.espe.movilidad.MovilidadWS.Constant.GlobalConstants.V1_API_VERSION;
 
@@ -24,91 +27,95 @@ import static ec.edu.espe.movilidad.MovilidadWS.Constant.GlobalConstants.V1_API_
 public class UzyTavConvocaController {
 
 
-    @Autowired
-    IServiceUzyTavConvoca serviceUzyTavConvoca;
-
+    private final IServiceUzyTavConvoca serviceUzyTavConvoca;
 
-    @GetMapping("/exampleFindId/{id}")
-    public ResponseEntity<ModelUzyTavConvoca> ListarPorID(@PathVariable Long id) {
-        return new ResponseEntity<>(serviceUzyTavConvoca.ListarPorID(id), HttpStatus.OK);
+    @Autowired
+    public UzyTavConvocaController(IServiceUzyTavConvoca serviceUzyTavConvoca) {
+        this.serviceUzyTavConvoca = serviceUzyTavConvoca;
     }
 
-    @GetMapping("/getAll")
-    public ResponseEntity<List<ModelUzyTavConvoca>> ListarRegistros() {
-        return new ResponseEntity<>(serviceUzyTavConvoca.ListarRegistros(), HttpStatus.OK);
-    }
 
+    @PostMapping("/guardarnuevo")
+    public ResponseEntity<UzyTavConvocaDTO> saveUzyTavConvoca(
+            @RequestParam("file") MultipartFile file,
+            @ModelAttribute UzyTavConvocaDTO uzyTavConvocaDTO) throws IOException {
 
-    @PostMapping("/guardar")
-    public ResponseEntity<String> guardarConvocatoria(@RequestParam(value="uzytavconvoca_id", required = false) Long uzytavconvoca_id,
-                                                      @RequestParam(value="uzytavconvoca_nombre", required = false) String uzytavconvoca_nombre,
-                                                      @RequestParam("uzytavconvoca_digital") MultipartFile uzytavconvoca_digital,
-                                                      @RequestParam("uzytavconvoca_observacion") String uzytavconvoca_observacion,
-                                                      @RequestParam("uzytavconvoca_estado") String uzytavconvoca_estado,
-                                                      @RequestParam(value="uzytavconvoca_fecha_inicio", required = false)  Date uzytavconvoca_fecha_inicio,
-                                                      @RequestParam(value = "uzytavconvoca_fecha_fin", required = false)  Date uzytavconvoca_fecha_fin) throws IOException, IOException {
-        serviceUzyTavConvoca.guardarConvocatoria(uzytavconvoca_id, uzytavconvoca_nombre, uzytavconvoca_digital,
-                uzytavconvoca_observacion, uzytavconvoca_estado,
-                uzytavconvoca_fecha_inicio, uzytavconvoca_fecha_fin);
-        return new ResponseEntity<>("Convocatoria guardada correctamente", HttpStatus.OK);
-    }
+        uzyTavConvocaDTO.setUzytavconvoca_digital(file);
 
-    @PostMapping("/editar")
-    public ResponseEntity<?> editarConvocatoria(@RequestParam("uzytavconvoca_id") Long uzytavconvoca_id,
-                                                @RequestParam(value="uzytavconvoca_nombre", required = false) String uzytavconvoca_nombre,
-                                                @RequestParam(value = "uzytavconvoca_digital", required = false) MultipartFile uzytavconvoca_digital,
-                                                @RequestParam(value="uzytavconvoca_observacion", required = false) String uzytavconvoca_observacion,
-                                                @RequestParam(value="uzytavconvoca_estado", required = false) String uzytavconvoca_estado,
-                                                @RequestParam(value="uzytavconvoca_fecha_inicio", required = false)Date uzytavconvoca_fecha_inicio,
-                                                @RequestParam(value="uzytavconvoca_fecha_fin", required = false) Date uzytavconvoca_fecha_fin) throws IOException {
-        serviceUzyTavConvoca.editarConvocatoria(uzytavconvoca_id, uzytavconvoca_nombre, uzytavconvoca_digital, uzytavconvoca_observacion, uzytavconvoca_estado, uzytavconvoca_fecha_inicio, uzytavconvoca_fecha_fin);
-
-        return new ResponseEntity<>("Convocatoria editada", HttpStatus.OK);
+        UzyTavConvocaDTO savedUzyTavConvoca = serviceUzyTavConvoca.save(uzyTavConvocaDTO);
+        if (savedUzyTavConvoca != null) {
+            return ResponseEntity.ok(savedUzyTavConvoca);
+        } else {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
+        }
     }
 
+    @PutMapping("editar/{uzytavconvocaId}")
+    public ResponseEntity<UzyTavConvocaDTO> edit(
+            @PathVariable("uzytavconvocaId") Long uzytavconvocaId,
+            @ModelAttribute UzyTavConvocaDTO uzyTavConvocaDTO) {
+        try {
+            UzyTavConvocaDTO updatedUzyTavConvoca = serviceUzyTavConvoca.edit(uzytavconvocaId, uzyTavConvocaDTO);
+            return ResponseEntity.ok(updatedUzyTavConvoca);
+        } catch (NoSuchElementException e) {
+            // Manejar la excepción en caso de no encontrar el objeto a editar
+            return ResponseEntity.notFound().build();
+        } catch (IllegalArgumentException e) {
+            // Manejar la excepción en caso de parámetros incorrectos
+            return ResponseEntity.badRequest().build();
+        } catch (IOException e) {
+            // Manejar la excepción en caso de error al guardar el archivo
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
+        }
+    }
 
-    @GetMapping("/verPDF/{uzytavconvoca_id}")
-    public ResponseEntity<ByteArrayResource> verPDF(@PathVariable Long uzytavconvoca_id) {
-        // Obtengo el documento mediante el id de convoca
-        Optional<ModelUzyTavConvoca> documentOptional = Optional.ofNullable(serviceUzyTavConvoca.ListarPorID(uzytavconvoca_id));
-
-        if (documentOptional.isPresent()) {
-            ModelUzyTavConvoca document = documentOptional.get();
-            byte[] datosPDF = document.getUzytavconvoca_digital();
-
-           String nombrePDF= document.getUzytavconvoca_digital_nombre(); //obtengo el nombre del pdf de la bdd
-
-            // Creo un recurso de tipo ByteArrayResource a partir de los datos del PDF
-            ByteArrayResource resource = new ByteArrayResource(datosPDF);
-
-            // Devuelvo la respuesta con el recurso y los encabezados  para la visualización del PDF
-            return ResponseEntity.ok()
-                    .header(HttpHeaders.CONTENT_DISPOSITION, "inline; filename="+nombrePDF) //inline para visualizar en el navegador y filename el nombre q deve de mostrar el archivo
-                    .contentType(MediaType.APPLICATION_PDF)
-                    .body(resource);
+    @GetMapping("/exampleFindId/{id}")
+    public ResponseEntity<UzyTavConvocaDTO> listarPorID(@PathVariable("id") Long id) {
+        UzyTavConvocaDTO dto = serviceUzyTavConvoca.ListarPorID(id);
+        if (dto != null) {
+            return ResponseEntity.ok(dto);
         } else {
-
             return ResponseEntity.notFound().build();
         }
     }
 
-
-
-
-
-
-    @PutMapping("/editar/{id}")
-    public ResponseEntity<ModelUzyTavConvoca> editar(@PathVariable Long id, @RequestBody ModelUzyTavConvoca modelUzyTavConvoca) {
-        return new  ResponseEntity<>(serviceUzyTavConvoca.editar(id, modelUzyTavConvoca), HttpStatus.OK);
+    @GetMapping("/getAll")
+    public ResponseEntity<List<UzyTavConvocaDTO>> listarRegistros() {
+        List<UzyTavConvocaDTO> dtos = serviceUzyTavConvoca.ListarRegistros();
+        return ResponseEntity.ok(dtos);
     }
 
 
-
-
     @DeleteMapping("/eliminar/{id}")
     public ResponseEntity<Void> eliminar(@PathVariable Long id) {
         serviceUzyTavConvoca.eliminar(id);
         return ResponseEntity.ok().build();
     }
 
+    @DeleteMapping("/eliminarConPDF/{uzytavconvoca_id}")
+    public ResponseEntity<String> eliminarConPDF(@PathVariable("uzytavconvoca_id") Long uzytavconvocaId) {
+        try {
+            serviceUzyTavConvoca.eliminarConPDF(uzytavconvocaId);
+            return ResponseEntity.ok("Registro eliminado exitosamente.");
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
+                    .body("Error al eliminar el registro: " + e.getMessage());
+        }
+    }
+
+    @GetMapping("/verPDF/{id}")
+    public ResponseEntity<byte[]> obtenerContenidoPDF(@PathVariable("id") Long convocaId) {
+        String fileName = serviceUzyTavConvoca.obtenerNombrePDF(convocaId);
+        byte[] pdfContent = serviceUzyTavConvoca.obtenerContenidoPDF(convocaId);
+        if (pdfContent != null && fileName != null) {
+
+            HttpHeaders headers = new HttpHeaders();
+            headers.setContentType(MediaType.APPLICATION_PDF);
+            headers.setContentDisposition(ContentDisposition.builder("inline").filename(fileName).build());
+            return new ResponseEntity<>(pdfContent, headers, HttpStatus.OK);
+        } else {
+            return ResponseEntity.notFound().build();
+        }
+    }
+
 }

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Dao/DaoUzyTavConvoca.java

@@ -4,4 +4,6 @@ import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTavConvoca;
 import org.springframework.data.jpa.repository.JpaRepository;
 
 public interface DaoUzyTavConvoca extends JpaRepository<ModelUzyTavConvoca, Long> {
+
+
 }

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Dto/DtoModelUzyTLineaOperativa.java

+package ec.edu.espe.movilidad.MovilidadWS.Dto;
+
+import lombok.Data;
+import lombok.Value;
+
+import javax.validation.constraints.Size;
+import java.io.Serializable;
+
+@Data
+public class DtoModelUzyTLineaOperativa {
+    private Long uzytavlineaoperativa_ID;
+    @Size(max = 1000)
+    private String uzytavlineaoperativa_DESCRIP;
+    @Size(max = 1)
+    private String uzytavlineaoperativa_ESTADO;
+}
\ No newline at end of file

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Dto/DtoUzyTMenu.java

+package ec.edu.espe.movilidad.MovilidadWS.Dto;
+
+import lombok.Data;
+
+@Data
+public class DtoUzyTMenu {
+    private Long uzytmenuId;
+    private String uzytmenuNombre;
+}

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Dto/DtoUzytavprogramaV.java

+package ec.edu.espe.movilidad.MovilidadWS.Dto;
+
+import lombok.Data;
+
+import java.time.LocalDate;
+import java.util.Date;
+
+
+public class DtoUzytavprogramaV {
+
+
+        private Long uzytavprograma_v_id;
+
+        private String uzytavprograma_vnombre;
+
+        private String uzytavprograma_vresumen;
+
+        private Date uzytavprograma_vfecha_presenta;
+
+        private Date uzytavprograma_vfecha_inicio;
+
+        private Date uzytavprograma_vfecha_fin;
+
+        private String stvsubj_code;
+
+        private String uzytavprograma_vmonto_nombre;
+
+        private byte[] uzytavprograma_vmonto_digi;
+
+        private String uzytavprograma_vsituacion_actual;
+
+
+        private String uzytavprograma_vmetas;
+
+        private String uzytavprograma_vpoliticas;
+
+        private String uzytavprograma_vviavilidad_tecnica;
+
+        private String uzytavprograma_vperderia_no_ejecuta;
+
+        private String uzytavprograma_vresultados_impacto;
+
+        private String uzytavprograma_vproyecto_nombre;
+
+
+        private byte[] uzytavprograma_vproyecto_digi;
+
+        private String uzytavprograma_vfactor_c_exito;
+
+        private String uzytavprograma_vubicacion;
+
+        private String uzytavprograma_vdiagnostico;
+
+        private String uzytavprograma_vlinea_base;
+
+        private String uzytavprograma_vbeneficios;
+
+        private Integer uzytavprograma_vduracion_anios;
+
+        private Integer uzytavprograma_vdiuracion_meses;
+
+        private String stvcamp_code;
+
+        private Date uzytavprograma_vfecha_finr;
+
+        private String uzytavprograma_vestado;
+
+        private Integer uzytavprograma_vcobertura;
+
+        private String uzytavprograma_vubicacion2;
+
+        private String uzytavprograma_vdiagnostico2;
+
+        private String uzytavprograma_vestado_activo;
+
+        private String uzytavprograma_vevaluacion_cual;
+
+        private Date uzytavprograma_vfecha_cierre;
+
+        private Date uzytavprograma_vfecha_evaluacion;
+
+        private String uzytavprograma_vresumen2;
+
+        private String uzytavprograma_vlinea_base2;
+
+        private String uzytavprograma_vbeneficios2;
+        private String uzytavprograma_vfactor_c_exito2;
+
+    }
+

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Dto/UzyTavConvocaDTO.java

+package ec.edu.espe.movilidad.MovilidadWS.Dto;
+
+import lombok.Data;
+import org.springframework.web.multipart.MultipartFile;
+
+import java.util.Date;
+
+
+@Data
+public class UzyTavConvocaDTO {
+
+    private Long uzytavconvoca_id;
+    private String uzytavconvoca_nombre;
+    private MultipartFile uzytavconvoca_digital;
+    private String uzytavconvoca_observacion;
+    private String uzytavconvoca_estado;
+    private Date uzytavconvoca_fecha_inicio;
+    private Date uzytavconvoca_fecha_fin;
+    private String uzytavconvoca_digital_nombre;
+    private String uzytavconvoca_digital_url;
+
+
+}

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Dto/UzyTavProyecDTO.java

+package ec.edu.espe.movilidad.MovilidadWS.dto;
+
+import lombok.Data;
+
+@Data
+public class UzyTavProyecDTO {
+
+    private Long uzytavproyec_id;
+    // Agrega los atributos restantes necesarios aquí
+
+}

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Mapper/Configuration/ModelMapperConfig.java

+package ec.edu.espe.movilidad.MovilidadWS.Mapper.Configuration;
+
+import org.modelmapper.ModelMapper;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class ModelMapperConfig {
+
+    @Bean
+    public ModelMapper modelMapper() {
+        return new ModelMapper();
+    }
+
+}
\ No newline at end of file

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Mapper/UzyTMenuMapper.java

+package ec.edu.espe.movilidad.MovilidadWS.Mapper;
+
+import ec.edu.espe.movilidad.MovilidadWS.Dto.DtoUzyTMenu;
+import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTMenu;
+import org.modelmapper.PropertyMap;
+import org.springframework.stereotype.Component;
+import org.modelmapper.ModelMapper;
+@Component
+public class UzyTMenuMapper {
+
+    private final ModelMapper modelMapper;
+
+
+    public UzyTMenuMapper(ModelMapper modelMapper) {
+        this.modelMapper = modelMapper;
+        configureMappings();
+    }
+    public DtoUzyTMenu entityToDto(ModelUzyTMenu entity) {
+        return modelMapper.map(entity, DtoUzyTMenu.class);
+    }
+
+    public ModelUzyTMenu dtoToEntity(DtoUzyTMenu dto) {
+        return modelMapper.map(dto, ModelUzyTMenu.class);
+    }
+    private void configureMappings() {
+        modelMapper.addMappings(new PropertyMap<ModelUzyTMenu, DtoUzyTMenu>() {
+            @Override
+            protected void configure() {
+                map().setUzytmenuId(source.getId());
+            }
+        });
+    }
+}

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Mapper/UzyTavConvocaMapper.java

+package ec.edu.espe.movilidad.MovilidadWS.Mapper;
+
+import ec.edu.espe.movilidad.MovilidadWS.Dto.UzyTavConvocaDTO;
+import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTavConvoca;
+import org.modelmapper.ModelMapper;
+import org.modelmapper.PropertyMap;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+
+@Component
+public class UzyTavConvocaMapper {
+    private final ModelMapper modelMapper;
+
+    public UzyTavConvocaMapper(ModelMapper modelMapper) {
+        this.modelMapper = modelMapper;
+        configureMappings();
+    }
+
+    public UzyTavConvocaDTO entityToDto(ModelUzyTavConvoca entity) {
+        return modelMapper.map(entity, UzyTavConvocaDTO.class);
+    }
+
+    public ModelUzyTavConvoca dtoToEntity(UzyTavConvocaDTO dto) {
+        return modelMapper.map(dto, ModelUzyTavConvoca.class);
+    }
+
+
+    private void configureMappings() {
+        modelMapper.addMappings(new PropertyMap<ModelUzyTavConvoca, UzyTavConvocaDTO>() {
+            @Override
+            protected void configure() {
+                map().setUzytavconvoca_id(source.getUzytavconvoca_id());
+            }
+        });
+    }
+
+
+
+}

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Model/ModelUzyTMenu.java

 package ec.edu.espe.movilidad.MovilidadWS.Model;
 
+import lombok.Data;
 import lombok.Getter;
 import lombok.Setter;
 
 import javax.persistence.*;
 import javax.validation.constraints.Size;
 
+@Data
 @Getter
 @Setter
 @Entity
@@ -14,11 +16,10 @@ public class ModelUzyTMenu {
     @Id
     @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "uzytmenu_seq")
     @SequenceGenerator(name = "uzytmenu_seq", sequenceName = "SEQ_UZYTMENU", allocationSize = 1)
-    @Column(name = "UZYTMENU_ID", nullable = false)
+    @Column(name = "UZYTMENU_ID")
     private Long id;
 
     @Size(max = 50)
     @Column(name = "UZYTMENU_NOMBRE", length = 50)
     private String uzytmenuNombre;
-
 }
\ No newline at end of file

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Model/ModelUzyTavConvoca.java

@@ -2,6 +2,7 @@ package ec.edu.espe.movilidad.MovilidadWS.Model;
 
 import com.fasterxml.jackson.annotation.JsonIgnore;
 import lombok.Data;
+import org.springframework.web.multipart.MultipartFile;
 
 import javax.persistence.Entity;
 import javax.persistence.Table;
@@ -25,10 +26,10 @@ public class ModelUzyTavConvoca {
     @Column(name = "uzytavconvoca_nombre")
     private String uzytavconvoca_nombre;
 
-    @Lob
-    @Column(name = "uzytavconvoca_digital")
+    @Column(name = "uzytavconvoca_digital", columnDefinition = "BLOB")
     private byte[] uzytavconvoca_digital;
 
+
     @Column(name = "uzytavconvoca_observacion")
     private String uzytavconvoca_observacion;
 

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Service/FileStorage/FileStorageService.java

+package ec.edu.espe.movilidad.MovilidadWS.Service.FileStorage;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.web.multipart.MultipartFile;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.*;
+
+@Service
+public class FileStorageService implements IFileStorageService {
+
+    private final Path rootFolder = Paths.get("uploads");
+
+    @Override
+    public String saveFile(MultipartFile file, String fileName, boolean overwrite) {
+        try {
+            Path filePath = rootFolder.resolve(fileName);
+            // Verificar si el archivo ya existe y si se permite la sobrescritura
+            if (Files.exists(filePath) && !overwrite) {
+                throw new FileAlreadyExistsException("File already exists: " + fileName);
+            }
+
+            // Eliminar el archivo anterior si existe
+            if (Files.exists(filePath)) {
+                Files.delete(filePath);
+            }
+
+            // Guardar el archivo, reemplazando si es necesario
+            try (InputStream inputStream = file.getInputStream()) {
+                Files.copy(inputStream, filePath, StandardCopyOption.REPLACE_EXISTING);
+            }
+
+            return filePath.toString();
+        } catch (FileAlreadyExistsException e) {
+            // Manejar la excepción de archivo existente
+            // ... Realizar acciones adecuadas (por ejemplo, generar un nombre único)
+            throw new RuntimeException("File already exists: " + fileName, e);
+        } catch (IOException e) {
+            // Manejar la excepción de E/S
+            // ... Realizar acciones adecuadas (por ejemplo, registrar el error)
+            throw new RuntimeException("Failed to save file: " + fileName, e);
+        }
+    }
+
+
+    public String moveFile(String sourceFilePath, String targetFileName, boolean overwrite) throws IOException {
+        Path sourcePath = Paths.get(sourceFilePath);
+        Path targetPath = rootFolder.resolve(targetFileName);
+
+        if (Files.exists(targetPath) && !overwrite) {
+            throw new FileAlreadyExistsException("File already exists: " + targetFileName);
+        }
+
+        // Eliminar el archivo objetivo si existe y se permite la sobrescritura
+        if (Files.exists(targetPath)) {
+            Files.delete(targetPath);
+        }
+
+        // Mover el archivo de la ubicación de origen a la ubicación de destino
+        Files.move(sourcePath, targetPath, StandardCopyOption.REPLACE_EXISTING);
+
+        return targetPath.toString();
+    }
+
+
+}
\ No newline at end of file

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Service/FileStorage/IFileStorageService.java

+package ec.edu.espe.movilidad.MovilidadWS.Service.FileStorage;
+
+import org.springframework.web.multipart.MultipartFile;
+
+import java.io.IOException;
+
+public interface IFileStorageService {
+
+    String saveFile(MultipartFile file, String fileName, boolean overwrite);
+
+    String moveFile(String sourceFilePath, String targetFileName, boolean overwrite) throws IOException;
+}

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Service/UzyTMenu/IServiceUzyTMenu.java

 package ec.edu.espe.movilidad.MovilidadWS.Service.UzyTMenu;
 
+import ec.edu.espe.movilidad.MovilidadWS.Dto.DtoUzyTMenu;
 import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTMenu;
 import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTPerfilMenu;
+import javassist.NotFoundException;
 
 import java.util.List;
 
 public interface IServiceUzyTMenu {
 
-    public ModelUzyTMenu ListarPorID(Long id);
+    public DtoUzyTMenu ListarPorID(Long id) throws NotFoundException;
 
-    public List<ModelUzyTMenu> ListarRegistros();
+    public List<DtoUzyTMenu> ListarRegistros();
 
-    public ModelUzyTMenu guardar(ModelUzyTMenu modelUzyTMenu);
+    public DtoUzyTMenu guardar(DtoUzyTMenu dtoUzyTMenu);
 
-    public ModelUzyTMenu editar(Long id, ModelUzyTMenu modelUzyTMenu);
+    public DtoUzyTMenu editar(Long id, DtoUzyTMenu dtoUzyTMenu) throws NotFoundException;
 
-    void eliminar(Long id);
+    void eliminar(Long id) throws NotFoundException;
 }

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Service/UzyTMenu/ServiceUzyTMenu.java

 package ec.edu.espe.movilidad.MovilidadWS.Service.UzyTMenu;
 
 import ec.edu.espe.movilidad.MovilidadWS.Dao.DaoUzyTMenu;
+import ec.edu.espe.movilidad.MovilidadWS.Dto.DtoUzyTMenu;
+import ec.edu.espe.movilidad.MovilidadWS.Mapper.UzyTMenuMapper;
 import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTMenu;
-import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTPerfilMenu;
-import org.springframework.beans.factory.annotation.Autowired;
+import javassist.NotFoundException;
 import org.springframework.stereotype.Service;
 
 import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
 
 @Service
-public class ServiceUzyTMenu implements IServiceUzyTMenu{
+public class ServiceUzyTMenu implements IServiceUzyTMenu {
+    private final DaoUzyTMenu daoUzyTMenu;
+    private final UzyTMenuMapper uzyTMenuMapper;
 
-
-    @Autowired
-    DaoUzyTMenu daoUzyTMenu;
+    public ServiceUzyTMenu(DaoUzyTMenu daoUzyTMenu, UzyTMenuMapper uzyTMenuMapper) {
+        this.daoUzyTMenu = daoUzyTMenu;
+        this.uzyTMenuMapper = uzyTMenuMapper;
+    }
 
     @Override
-    public ModelUzyTMenu ListarPorID(Long id) {
-        return daoUzyTMenu.findById(id).get();
+    public DtoUzyTMenu ListarPorID(Long id) throws NotFoundException {
+        Optional<ModelUzyTMenu> optionalEntity = daoUzyTMenu.findById(id);
+        if (optionalEntity.isPresent()) {
+            ModelUzyTMenu entity = optionalEntity.get();
+            return uzyTMenuMapper.entityToDto(entity);
+        } else {
+            throw new NotFoundException("Uzytmenu not found");
+        }
     }
 
     @Override
-    public List<ModelUzyTMenu> ListarRegistros() {
-        return daoUzyTMenu.findAll();
+    public List<DtoUzyTMenu> ListarRegistros() {
+        List<ModelUzyTMenu> entities = daoUzyTMenu.findAll();
+        return entities.stream()
+                .map(uzyTMenuMapper::entityToDto)
+                .collect(Collectors.toList());
     }
 
     @Override
-    public ModelUzyTMenu guardar(ModelUzyTMenu modelUzyTMenu) {
-        return daoUzyTMenu.save(modelUzyTMenu);
+    public DtoUzyTMenu guardar(DtoUzyTMenu dtoUzyTMenu) {
+        ModelUzyTMenu entity = uzyTMenuMapper.dtoToEntity(dtoUzyTMenu);
+        ModelUzyTMenu savedEntity = daoUzyTMenu.save(entity);
+        return uzyTMenuMapper.entityToDto(savedEntity);
     }
 
     @Override
-    public ModelUzyTMenu editar(Long id, ModelUzyTMenu modelUzyTMenu) {
-        ModelUzyTMenu dato = daoUzyTMenu.findById(id).get();
-        //.orElseThrow(()->new ControlExcepciones("No existe el registro con el ID : " + id));
-        //Seteamos los nuevos datos del registro
-        dato.setUzytmenuNombre(modelUzyTMenu.getUzytmenuNombre());
+    public DtoUzyTMenu editar(Long id, DtoUzyTMenu dtoUzyTMenu) throws NotFoundException {
+        Optional<ModelUzyTMenu> optionalEntity = daoUzyTMenu.findById(id);
+        if (optionalEntity.isPresent()) {
+            ModelUzyTMenu entity = optionalEntity.get();
+            // Actualizar los campos de la entidad con los valores del DTO
+            entity.setUzytmenuNombre(dtoUzyTMenu.getUzytmenuNombre());
 
-        ModelUzyTMenu datoActualizado = daoUzyTMenu.save(dato);
-        return datoActualizado;
+            ModelUzyTMenu updatedEntity = daoUzyTMenu.save(entity);
+            return uzyTMenuMapper.entityToDto(updatedEntity);
+        } else {
+            throw new NotFoundException("Uzytmenu not found");
+        }
     }
 
     @Override
-    public void eliminar(Long id) {
-        ModelUzyTMenu dato = daoUzyTMenu.findById(id).get();
-        //.orElseThrow(() -daoUzyTMenuntrolExcepciones("No existe el registro con el ID : " + id));
-        daoUzyTMenu.delete(dato);
+    public void eliminar(Long id) throws NotFoundException {
+        Optional<ModelUzyTMenu> optionalEntity = daoUzyTMenu.findById(id);
+        if (optionalEntity.isPresent()) {
+            ModelUzyTMenu entity = optionalEntity.get();
+            daoUzyTMenu.delete(entity);
+        } else {
+            throw new NotFoundException("Uzytmenu not found");
+        }
     }
 }

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Service/UzyTavConvoca/IServiceUzyTavConvoca.java

 package ec.edu.espe.movilidad.MovilidadWS.Service.UzyTavConvoca;
 
+import ec.edu.espe.movilidad.MovilidadWS.Dto.UzyTavConvocaDTO;
 import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTavConvoca;
 import org.springframework.web.multipart.MultipartFile;
 
@@ -9,18 +10,17 @@ import java.util.List;
 
 public interface IServiceUzyTavConvoca {
 
-    public ModelUzyTavConvoca ListarPorID(Long id);
+    public UzyTavConvocaDTO ListarPorID(Long id);
 
-    public List<ModelUzyTavConvoca> ListarRegistros();
+    public List<UzyTavConvocaDTO> ListarRegistros();
 
-     void guardarConvocatoria(Long uzytavconvoca_id, String uzytavconvoca_nombre, MultipartFile uzytavconvoca_digital,
-                                      String uzytavconvoca_observacion, String uzytavconvoca_estado,
-                                      Date uzytavconvoca_fecha_inicio, Date uzytavconvoca_fecha_fin) throws IOException;
-
-    public ModelUzyTavConvoca editar(Long id, ModelUzyTavConvoca modelUzyTavConvoca);
-
-    void editarConvocatoria(Long uzytavconvoca_id, String uzytavconvoca_nombre, MultipartFile uzytavconvoca_digital, String uzytavconvoca_observacion, String uzytavconvoca_estado, Date uzytavconvoca_fecha_inicio, Date uzytavconvoca_fecha_fin) throws IOException;
+    public UzyTavConvocaDTO   save(UzyTavConvocaDTO convocatoriaDTO)throws IOException;
 
+    public UzyTavConvocaDTO   edit(Long uzytavconvocaId, UzyTavConvocaDTO convocatoriaDTO)throws IOException;
 
     void eliminar(Long id);
+    public byte[] obtenerContenidoPDF(Long convocaId);
+    public String obtenerUrlPDF(Long uzytavconvocaId);
+    public String obtenerNombrePDF(Long convocaId);
+    void eliminarConPDF(Long  uzytavconvoca_id);
 }

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Service/UzyTavConvoca/ServiceUzyTavConvoca.java

 package ec.edu.espe.movilidad.MovilidadWS.Service.UzyTavConvoca;
 
 import ec.edu.espe.movilidad.MovilidadWS.Dao.DaoUzyTavConvoca;
+import ec.edu.espe.movilidad.MovilidadWS.Dto.DtoUzyTMenu;
+import ec.edu.espe.movilidad.MovilidadWS.Dto.UzyTavConvocaDTO;
+import ec.edu.espe.movilidad.MovilidadWS.Mapper.UzyTavConvocaMapper;
+import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTMenu;
 import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTavConvoca;
+import ec.edu.espe.movilidad.MovilidadWS.Service.FileStorage.IFileStorageService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.web.multipart.MultipartFile;
 
+import java.io.File;
 import java.io.IOException;
-import java.util.Date;
-import java.util.List;
+import java.io.InputStream;
+import java.nio.file.*;
+import java.util.*;
+import java.util.stream.Collectors;
 
 @Service
 public class ServiceUzyTavConvoca implements IServiceUzyTavConvoca{
+
+    private final Path rootFolder= Paths.get("uploads");
+    private final DaoUzyTavConvoca daoUzyTavConvoca;
+    private final UzyTavConvocaMapper modelMapper;
+    private final IFileStorageService fileStorageService;
+
+
     @Autowired
-    DaoUzyTavConvoca daoUzyTavConvoca;
+    public ServiceUzyTavConvoca(DaoUzyTavConvoca daoUzyTavConvoca, UzyTavConvocaMapper modelMapper, IFileStorageService fileStorageService) {
+        this.daoUzyTavConvoca = daoUzyTavConvoca;
+        this.modelMapper = modelMapper;
+        this.fileStorageService= fileStorageService;
+    }
+
     @Override
-    public ModelUzyTavConvoca ListarPorID(Long id) {
-        return  daoUzyTavConvoca.findById(id).get();
+    public UzyTavConvocaDTO  ListarPorID(Long id) {
+        Optional<ModelUzyTavConvoca> optionalUzyTavConvoca = daoUzyTavConvoca.findById(id);
+        if (optionalUzyTavConvoca.isPresent()) {
+            ModelUzyTavConvoca model = optionalUzyTavConvoca.get();
+            return modelMapper.entityToDto(model);
         }
+        return null;
+    }
+
 
     @Override
-    public List<ModelUzyTavConvoca> ListarRegistros() {
-        return daoUzyTavConvoca.findAll();
+    public List<UzyTavConvocaDTO> ListarRegistros() {
+        List<ModelUzyTavConvoca> entities = daoUzyTavConvoca.findAll();
+        return entities.stream()
+                .map(modelMapper::entityToDto)
+                .collect(Collectors.toList());
     }
 
+    @Override
+    public UzyTavConvocaDTO save(UzyTavConvocaDTO uzyTavConvocaDTO) throws IOException {
+        MultipartFile file = uzyTavConvocaDTO.getUzytavconvoca_digital();
+        if (file != null && !file.isEmpty()) {
+            // Guardar el archivo en una ubicación temporal
+            String tempFileName = "temp_" + file.getOriginalFilename();
+            String tempFilePath = fileStorageService.saveFile(file, tempFileName, true);
+
+            // Guardar el registro en la base de datos para generar el ID
+            ModelUzyTavConvoca uzyTavConvoca = modelMapper.dtoToEntity(uzyTavConvocaDTO);
+            uzyTavConvoca = daoUzyTavConvoca.save(uzyTavConvoca);
+
+            // Generar el nombre del archivo con el ID generado por la base de datos
+            Long uzytavconvocaId = uzyTavConvoca.getUzytavconvoca_id();
+            String fileName = uzytavconvocaId + "_" + file.getOriginalFilename();
+
+            // Mueve el archivo de la ubicación temporal a la ubicación final
+            String fileUrl = fileStorageService.moveFile(tempFilePath, fileName, true);
+            uzyTavConvoca.setUzytavconvoca_digital_nombre(fileName);
+            uzyTavConvoca.setUzytavconvoca_digital_url(fileUrl);
+
+            // Actualiza el registro en la base de datos con el nombre y la URL del archivo
+            uzyTavConvoca = daoUzyTavConvoca.save(uzyTavConvoca);
+
+            return modelMapper.entityToDto(uzyTavConvoca);
+        } else {
+            // No se proporcionó ningún archivo, guardar solo el registro en la base de datos
+            ModelUzyTavConvoca uzyTavConvoca = modelMapper.dtoToEntity(uzyTavConvocaDTO);
+            uzyTavConvoca = daoUzyTavConvoca.save(uzyTavConvoca);
+            return modelMapper.entityToDto(uzyTavConvoca);
+        }
+    }
 
     @Override
-    public void guardarConvocatoria(Long uzytavconvoca_id, String uzytavconvoca_nombre, MultipartFile uzytavconvoca_digital, String uzytavconvoca_observacion, String uzytavconvoca_estado, Date uzytavconvoca_fecha_inicio, Date uzytavconvoca_fecha_fin) throws IOException {
-        ModelUzyTavConvoca convocatoria = new ModelUzyTavConvoca();
-        convocatoria.setUzytavconvoca_id(uzytavconvoca_id);
-        convocatoria.setUzytavconvoca_nombre(uzytavconvoca_nombre);
-        convocatoria.setUzytavconvoca_digital(uzytavconvoca_digital.getBytes());
-        convocatoria.setUzytavconvoca_observacion(uzytavconvoca_observacion);
-        convocatoria.setUzytavconvoca_estado(uzytavconvoca_estado);
-        convocatoria.setUzytavconvoca_fecha_inicio(uzytavconvoca_fecha_inicio);
-        convocatoria.setUzytavconvoca_fecha_fin(uzytavconvoca_fecha_fin);
-        convocatoria.setUzytavconvoca_digital_nombre(uzytavconvoca_digital.getOriginalFilename());
-        String UrlPdf= "localhost/" + uzytavconvoca_id;
-        convocatoria.setUzytavconvoca_digital_url(UrlPdf);
-        daoUzyTavConvoca.save(convocatoria);
+    public UzyTavConvocaDTO edit(Long uzytavconvocaId, UzyTavConvocaDTO uzyTavConvocaDTO) {
+        if (uzytavconvocaId == null || uzyTavConvocaDTO == null) {
+            throw new IllegalArgumentException("Invalid parameters for editing UzyTavConvoca");
         }
 
+        Optional<ModelUzyTavConvoca> optionalUzyTavConvoca = daoUzyTavConvoca.findById(uzytavconvocaId);
+        if (optionalUzyTavConvoca.isPresent()) {
+            ModelUzyTavConvoca uzyTavConvoca = optionalUzyTavConvoca.get();
+            MultipartFile file = uzyTavConvocaDTO.getUzytavconvoca_digital();
+
+            if (file != null && !file.isEmpty()) {
+                // Eliminar el archivo PDF anterior, si existe
+                String previousFileName = uzyTavConvoca.getUzytavconvoca_digital_nombre();
+                if (previousFileName != null && !previousFileName.isEmpty()) {
+                    try {
+                        Path previousFilePath = rootFolder.resolve(previousFileName);
+                        Files.deleteIfExists(previousFilePath);
+                    } catch (IOException e) {
+                        throw new RuntimeException("Failed to delete previous file: " + previousFileName, e);
+                    }
+                }
 
+                // Guardar el nuevo archivo PDF
+                String fileName = uzytavconvocaId + "_" + file.getOriginalFilename();
+                String fileUrl = fileStorageService.saveFile(file, fileName, true);
+                uzyTavConvoca.setUzytavconvoca_digital_url(fileUrl);
+                uzyTavConvoca.setUzytavconvoca_digital_nombre(fileName);
+            }
 
-    @Override
-    public ModelUzyTavConvoca editar(Long id, ModelUzyTavConvoca modelUzyTavConvoca) {
-        ModelUzyTavConvoca dato = daoUzyTavConvoca.findById(id).get();
-        //.orElseThrow(()->new ControlExcepciones("No existe el registro con el ID : " + id));
-        //Seteamos los nuevos datos del registro
-        dato.setUzytavconvoca_id(modelUzyTavConvoca.getUzytavconvoca_id());
-        dato.setUzytavconvoca_nombre(modelUzyTavConvoca.getUzytavconvoca_nombre());
-        dato.setUzytavconvoca_digital(modelUzyTavConvoca.getUzytavconvoca_digital());
-        dato.setUzytavconvoca_observacion(modelUzyTavConvoca.getUzytavconvoca_observacion());
-        dato.setUzytavconvoca_estado(modelUzyTavConvoca.getUzytavconvoca_estado());
-        dato.setUzytavconvoca_fecha_inicio(modelUzyTavConvoca.getUzytavconvoca_fecha_inicio());
-        dato.setUzytavconvoca_fecha_fin(modelUzyTavConvoca.getUzytavconvoca_fecha_fin());
-        dato.setUzytavconvoca_digital_nombre(modelUzyTavConvoca.getUzytavconvoca_digital_nombre());
-        dato.setUzytavconvoca_digital_url(modelUzyTavConvoca.getUzytavconvoca_digital_url());
-
-        ModelUzyTavConvoca datoActualizado = daoUzyTavConvoca.save(dato);
-        return datoActualizado;
+            // Actualizar los campos necesarios del objeto uzyTavConvoca con los valores del DTO
+            uzyTavConvoca.setUzytavconvoca_nombre(uzyTavConvocaDTO.getUzytavconvoca_nombre());
+            uzyTavConvoca.setUzytavconvoca_observacion(uzyTavConvocaDTO.getUzytavconvoca_observacion());
+            uzyTavConvoca.setUzytavconvoca_estado(uzyTavConvocaDTO.getUzytavconvoca_estado());
+            uzyTavConvoca.setUzytavconvoca_fecha_inicio(uzyTavConvocaDTO.getUzytavconvoca_fecha_inicio());
+            uzyTavConvoca.setUzytavconvoca_fecha_fin(uzyTavConvocaDTO.getUzytavconvoca_fecha_fin());
+            // Actualizar otros campos según sea necesario
+
+            uzyTavConvoca = daoUzyTavConvoca.save(uzyTavConvoca);
+            return modelMapper.entityToDto(uzyTavConvoca);
+        } else {
+            throw new NoSuchElementException("UzyTavConvoca not found for editing");
+        }
     }
 
-    @Override
-    public void editarConvocatoria(Long uzytavconvoca_id, String uzytavconvoca_nombre, MultipartFile uzytavconvoca_digital, String uzytavconvoca_observacion, String uzytavconvoca_estado, Date uzytavconvoca_fecha_inicio, Date uzytavconvoca_fecha_fin) throws IOException {
-        ModelUzyTavConvoca convocatoria = daoUzyTavConvoca.findById(uzytavconvoca_id).orElse(null);
 
-        if (convocatoria != null) {// SI ENCUENTRA LA CONVOCATORIA LA EDITA
-            convocatoria.setUzytavconvoca_nombre(uzytavconvoca_nombre);
-            convocatoria.setUzytavconvoca_observacion(uzytavconvoca_observacion);
-            convocatoria.setUzytavconvoca_estado(uzytavconvoca_estado);
-            convocatoria.setUzytavconvoca_fecha_inicio(uzytavconvoca_fecha_inicio);
-            convocatoria.setUzytavconvoca_fecha_fin(uzytavconvoca_fecha_fin);
 
-            if (!uzytavconvoca_digital.isEmpty()) { //VERIFICA SI EL ARCHIVO NO ESTÁ VACIO PARA PODER EDITARLO, SI ESTÁ VACIO DEJA POR DEFECTO EL ARCHIVO QUE CONTENÍA EL REGISTRO
-                convocatoria.setUzytavconvoca_digital(uzytavconvoca_digital.getBytes());
-                convocatoria.setUzytavconvoca_digital_nombre(uzytavconvoca_digital.getOriginalFilename());
+    @Override
+    public void eliminar(Long uzytavconvoca_id) {
+        daoUzyTavConvoca.deleteById(uzytavconvoca_id);
     }
 
-            String urlPdf = "localhost/" + uzytavconvoca_id;
-            convocatoria.setUzytavconvoca_digital_url(urlPdf);
 
-            daoUzyTavConvoca.save(convocatoria);
+    @Override
+    public void eliminarConPDF(Long uzytavconvoca_id) {
+        Optional<ModelUzyTavConvoca> optionalUzyTavConvoca = daoUzyTavConvoca.findById(uzytavconvoca_id);
+        if (optionalUzyTavConvoca.isPresent()) {
+            ModelUzyTavConvoca uzyTavConvoca = optionalUzyTavConvoca.get();
+            String fileName = uzyTavConvoca.getUzytavconvoca_digital_nombre();
+            if (fileName != null && !fileName.isEmpty()) {
+                // Eliminar el archivo PDF
+                Path filePath = rootFolder.resolve(fileName);
+                try {
+                    Files.deleteIfExists(filePath);
+                } catch (IOException e) {
+                    throw new RuntimeException("Failed to delete file: " + fileName, e);
+                }
+            }
+            // Eliminar el registro de la base de datos
+            daoUzyTavConvoca.deleteById(uzytavconvoca_id);
         }
     }
 
     @Override
-    public void eliminar(Long id) {
-        ModelUzyTavConvoca dato = daoUzyTavConvoca.findById(id).get();
-        //.orElseThrow(() -> new ControlExcepciones("No existe el registro con el ID : " + id));
-        daoUzyTavConvoca.delete(dato);
+    public String obtenerUrlPDF(Long uzytavconvocaId) {
+        Optional<ModelUzyTavConvoca> optionalUzyTavConvoca = daoUzyTavConvoca.findById(uzytavconvocaId);
+        if (optionalUzyTavConvoca.isPresent()) {
+            ModelUzyTavConvoca uzyTavConvoca = optionalUzyTavConvoca.get();
+            String fileName = uzyTavConvoca.getUzytavconvoca_digital_nombre();
+            if (fileName != null && !fileName.isEmpty()) {
+                String fileUrl = rootFolder.resolve(fileName).toString();
+                return fileUrl;
+            }
+        }
+        return null;
+    }
+
+    @Override
+    public byte[] obtenerContenidoPDF(Long convocaId) {
+        Optional<ModelUzyTavConvoca> optionalConvoca = daoUzyTavConvoca.findById(convocaId);
+        if (optionalConvoca.isPresent()) {
+            ModelUzyTavConvoca convoca = optionalConvoca.get();
+            String fileName = convoca.getUzytavconvoca_digital_nombre();
+            if (fileName != null && !fileName.isEmpty()) {
+                Path filePath = rootFolder.resolve(fileName);
+                try {
+                    return Files.readAllBytes(filePath);
+                } catch (IOException e) {
+                    throw new RuntimeException("Failed to read PDF file: " + fileName, e);
+                }
             }
+        }
+        return null;
+    }
+
+
+
+    public String obtenerNombrePDF(Long convocaId) {
+        Optional<ModelUzyTavConvoca> optionalUzyTavConvoca = daoUzyTavConvoca.findById(convocaId);
+        if (optionalUzyTavConvoca.isPresent()) {
+            ModelUzyTavConvoca uzyTavConvoca = optionalUzyTavConvoca.get();
+            return uzyTavConvoca.getUzytavconvoca_digital_nombre();
+        }
+        return null;
+    }
+
 }

src/main/resources/application-local.properties

@@ -17,7 +17,10 @@ spring.jpa.hibernate.ddl-auto=none
 spring.datasource.username=UTIC1
 spring.datasource.password=D3s4ut1.*123
 spring.jpa.properties.hibernate.id.new_generator_mappings=true
+#spring.main.scan-packages=ec.edu.espe.movilidad.MovilidadWS.Mapper
 
 
 #spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
 spring.datasource.driver-class-name=oracle.jdbc.driver.OracleDriver
+spring.servlet.multipart.enabled=true
+spring.servlet.multipart.max-file-size=10MB