Se agrega el control de la Autenticación obteniendo el token desde el front

build.gradle

@@ -28,13 +28,17 @@ dependencies {
 	implementation 'commons-io:commons-io:2.11.0'
 	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
+	implementation 'org.modelmapper:modelmapper:3.0.0'// Dependencia para la generación de mappers en Java
 
-	//implementation 'org.springframework.boot:spring-boot-starter-security' // seguridad de Apis
+	implementation 'org.springframework.boot:spring-boot-starter-security' // seguridad de Apis
 	implementation 'io.jsonwebtoken:jjwt-api:0.11.2'
 	implementation 'io.jsonwebtoken:jjwt-impl:0.11.2'
 	implementation 'io.jsonwebtoken:jjwt-jackson:0.11.2'
 
+	implementation 'org.springframework.security.oauth.boot:spring-security-oauth2-autoconfigure:2.5.1'
+	implementation 'org.json:json:20210307'
+
+	implementation 'org.springframework.boot:spring-boot-starter-oauth2-resource-server'
 	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

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Constant/GlobalConstants.java

@@ -3,6 +3,9 @@ package ec.edu.espe.movilidad.MovilidadWS.Constant;
 public class GlobalConstants {
 
     public static final String V1_API_VERSION = "/api/v1.0";
+
+    public static final String SECRET_KEY = "A506EBCBA3E9E641750B0ED9F0D2B81EB43264E1DB61FE5B8DA4A709F4C623AE";
+
     private GlobalConstants() {
     }
 }

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

+package ec.edu.espe.movilidad.MovilidadWS.Controller;
+
+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.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+@RestController
+@CrossOrigin(origins = "*")
+@RequestMapping("/api/v1.0/users")
+public class UserController {
+
+    private final DaoUzyTUsuario userRepository;
+
+    @Autowired
+    public UserController(DaoUzyTUsuario userRepository) {
+        this.userRepository = userRepository;
+    }
+
+    @GetMapping("/by-email/{email}")
+    public ResponseEntity<ModelUzyTUsuario> getUserByEmail(@PathVariable String email) {
+        ModelUzyTUsuario user = userRepository.findByEmail(email);
+        if (user != null) {
+            return ResponseEntity.ok(user);
+        } else {
+            return ResponseEntity.notFound().build();
+        }
+    }
+}

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

@@ -7,6 +7,7 @@ import org.springframework.data.repository.query.Param;
 import org.springframework.stereotype.Repository;
 
 import java.util.List;
+import java.util.Optional;
 
 @Repository
 public interface DaoUzyTUsuario extends JpaRepository<ModelUzyTUsuario, Long> {
@@ -22,4 +23,12 @@ public interface DaoUzyTUsuario extends JpaRepository<ModelUzyTUsuario, Long> {
     @Query("SELECT u FROM ModelUzyTUsuario u WHERE LOWER(u.uzytusuario_nombres) LIKE CONCAT('%', LOWER(:usuario), '%') OR LOWER(u.uzytusuario_apellidos) LIKE CONCAT('%', LOWER(:usuario), '%')")
     List<ModelUzyTUsuario> findByUsuario(@Param("usuario") String usuario);
 
+    @Query("SELECT u FROM ModelUzyTUsuario u WHERE u.spriden_id = :spriden_id")
+    Optional<ModelUzyTUsuario> findBySpridenID(@Param("spriden_id") String spriden_id);
+
+    @Query("SELECT u FROM ModelUzyTUsuario u WHERE u.uzytusuario_email_institucional = :email")
+    ModelUzyTUsuario findByEmail(@Param("email") String email);
+
+
+
 }

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

@@ -7,6 +7,7 @@ import lombok.Data;
 public class DtoUzyTClasificadorPresup {
     private Long uzytclasificador_presup_id;
     private DtoUzyTClasificadorPresup clasificadorPresupPadre;
+    private Long uzytclasificador_presup_padre;
     private String uzytclasificador_presup_nombre;
     private Integer uzytclasificador_presup_ejercicio;
     private String uzytclasificador_presup_estado;

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

@@ -28,7 +28,7 @@ public class UzyTavConfObjMapper {
 
     public ModelUzyTavConfObj dtoToEntity(DtoUzyTavConfObj dto) {
         ModelUzyTavConfObj entity = modelMapper.map(dto, ModelUzyTavConfObj.class);
-        Long conftipoID = dto.getUzytavconfobj_id();
+        Long conftipoID = dto.getUzytavconftipo_id();
         ModelUzyTavConfTipo confTipo = entityManager.find(ModelUzyTavConfTipo.class, conftipoID);
         entity.setUzytavconftipo(confTipo);
         return entity;

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

@@ -14,8 +14,6 @@ import java.util.Set;
 @Table(name = "uzytclasificador_presup", schema = "UTIC1")
 public class ModelUzyTClasificadorPresup {
     @Id
-    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "uzytclasificador_presup_seq")
-    @SequenceGenerator(name = "uzytclasificador_presup_seq", sequenceName = "SEQ_UZYTCLASIFICADOR_PRESUP", allocationSize = 1)
     @Column(name = "uzytclasificador_presup_id")
     private Long uzytclasificador_presup_id;
 

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

@@ -94,6 +94,13 @@ public class ModelUzyTUsuario {
     @Column(name = "spbpers_sex")
     private String spbpers_sex;
 
+    public String getUzytusuario_tipo_user() {
+        return uzytusuario_tipo_user;
+    }
+
+    public void setUzytusuario_tipo_user(String uzytusuario_tipo_user) {
+        this.uzytusuario_tipo_user = uzytusuario_tipo_user;
+    }
     //RELACIÓN CON LA TABLA ANEXOSPR-TABLA HIJA
 
     @JsonIgnore

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

@@ -6,7 +6,7 @@ import lombok.Setter;
 
 import javax.persistence.*;
 import javax.validation.constraints.Size;
-import java.time.LocalDate;
+import java.util.Date;
 import java.util.LinkedHashSet;
 import java.util.Set;
 
@@ -27,7 +27,7 @@ public class ModelUzyTavConfObj {
     private String uzytavconfobj_descripcion;
 
     @Column(name = "uzytavconfobj_fecha")
-    private LocalDate uzytavconfobj_fecha;
+    private Date uzytavconfobj_fecha;
 
     @Size(max = 1)
     @Column(name = "uzytavconfobj_estado", length = 1)

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

+package ec.edu.espe.movilidad.MovilidadWS.Security;
+
+import lombok.AllArgsConstructor;
+import org.springframework.security.core.GrantedAuthority;
+import org.springframework.security.core.userdetails.UserDetails;
+
+import java.util.List;
+@AllArgsConstructor
+public class CustomUserDetails implements UserDetails {
+    private String username;
+    private String password;
+    private List<GrantedAuthority> authorities;
+
+    @Override
+    public String getUsername() {
+
+        return username;
+    }
+
+
+    @Override
+    public boolean isAccountNonExpired() {
+        return true;
+    }
+
+    @Override
+    public boolean isAccountNonLocked() {
+        return true;
+    }
+
+    @Override
+    public boolean isCredentialsNonExpired() {
+        return true;
+    }
+
+    @Override
+    public boolean isEnabled() {
+        return true;
+    }
+
+    @Override
+    public String getPassword() {
+        return password;
+    }
+
+    @Override
+    public List<GrantedAuthority> getAuthorities() {
+        return authorities;
+    }
+
+    // Implementa los demás métodos de UserDetails según sea necesario
+}

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.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.web.filter.OncePerRequestFilter;
+
+import javax.servlet.FilterChain;
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+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 logger = LoggerFactory.getLogger(JwtAuthenticationFilter.class);
+
+    @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
+
+                logger.info("Token recibido en el backend: {}", token);
+
+
+                UsernamePasswordAuthenticationToken authentication = getAuthentication(token);
+                SecurityContextHolder.getContext().setAuthentication(authentication);
+            }
+
+        } catch (Exception e) {
+            SecurityContextHolder.clearContext();
+            logger.error("Error en el filtro de autenticación JWT: {}", e.getMessage());
+        }
+
+        filterChain.doFilter(request, response);
+    }
+
+    private UsernamePasswordAuthenticationToken getAuthentication(String token) {
+        try {
+            if (tokenEsValido(token)) {
+                UserDetails userDetails = getUserDetailsFromToken(token);
+                UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
+                logger.info("Token válido obtenido en el backend:  {}", token);
+                return authenticationToken;
+            }
+        } catch (Exception e) {
+            logger.error("Error al obtener la autenticación desde el token: {}", e.getMessage());
+        }
+
+        return null;
+    }
+
+    private boolean tokenEsValido(String token) {
+        logger.info("token de validación:  {}", token);
+        UserDetails userDetails = getUserDetailsFromToken(token);
+        boolean isValid = JwtUtils.validateToken(token, userDetails);
+
+        logger.info("Resultado de la validación del token:  {}", isValid);
+
+        return isValid;
+    }
+
+    private UserDetails getUserDetailsFromToken(String token) {
+        try {
+            logger.info("Extrayendo detalles del usuario del token:   {}", token);
+            Claims claims = Jwts.parserBuilder()
+                    .setSigningKey(SECRET_KEY)
+                    .build()
+                    .parseClaimsJws(token)
+                    .getBody();
+
+            String username = claims.getSubject();
+            return new CustomUserDetails(username, "", null);
+        } catch (Exception e) {
+            logger.error("Error al obtener los detalles del usuario desde el token: {}", e.getMessage());
+        }
+
+        return null;
+    }
+}
+

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

+package ec.edu.espe.movilidad.MovilidadWS.Security;
+
+import org.springframework.security.authentication.AbstractAuthenticationToken;
+
+public class JwtAuthenticationToken extends AbstractAuthenticationToken {
+
+    private final String token;
+
+    public JwtAuthenticationToken(String token) {
+        super(null);
+        this.token = token;
+    }
+
+    @Override
+    public Object getCredentials() {
+        return null;
+    }
+
+    @Override
+    public Object getPrincipal() {
+        return null;
+    }
+
+    public String getToken() {
+        return token;
+    }
+}
+

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

+package ec.edu.espe.movilidad.MovilidadWS.Security;
+
+import io.jsonwebtoken.Jwts;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.stereotype.Component;
+import static ec.edu.espe.movilidad.MovilidadWS.Constant.GlobalConstants.SECRET_KEY;
+
+import java.util.Date;
+
+@Component
+public class JwtUtils {
+
+    public static boolean validateToken(String token, UserDetails userDetails) {
+        if (token == null) {
+            System.out.println("Token nullo: " + token);
+            return false;
+        }
+        String username = extractUsername(token);
+        System.out.println("Token: " + token);
+        return username.equals(userDetails.getUsername()) && !isTokenExpired(token);
+    }
+
+    public static String extractUsername(String token) {
+        return Jwts.parserBuilder()
+                .setSigningKey(SECRET_KEY)
+                .build()
+                .parseClaimsJws(token)
+                .getBody()
+                .getSubject();
+    }
+
+    public static boolean isTokenExpired(String token) {
+        return Jwts.parserBuilder()
+                .setSigningKey(SECRET_KEY)
+                .build()
+                .parseClaimsJws(token)
+                .getBody()
+                .getExpiration()
+                .before(new Date());
+    }
+}

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

+package ec.edu.espe.movilidad.MovilidadWS.Security;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.config.http.SessionCreationPolicy;
+
+import org.springframework.security.web.SecurityFilterChain;
+import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
+
+
+@Configuration
+public class SecurityConfig {
+
+    @Bean
+    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
+        http
+                .csrf().disable()
+                .cors()
+                .and()
+                .authorizeRequests()
+                .anyRequest().permitAll()
+                .and()
+                .sessionManagement()
+                .sessionCreationPolicy(SessionCreationPolicy.STATELESS); // Deshabilitar el uso de sesiones
+
+        http.addFilterBefore(jwtAuthenticationFilter(), UsernamePasswordAuthenticationFilter.class);
+        return http.build();
+    }
+
+
+    @Bean
+    public JwtAuthenticationFilter jwtAuthenticationFilter() {
+        return new JwtAuthenticationFilter();
+    }
+
+}
+

src/main/java/ec/edu/espe/movilidad/MovilidadWS/Service/UzyTavConfObj/ServiceUzyTavConfObj.java

@@ -47,7 +47,12 @@ public class ServiceUzyTavConfObj implements IServiceUzyTavConfObj{
             // Seteamos los nuevos datos del registro
             if (entity != null) {
                 // Aquí realizas la asignación de los nuevos datos a la entidad
+                entity.setUzytavconfobj_descripcion(dtoUzyTavConfObj.getUzytavconfobj_descripcion());
+                entity.setUzytavconfobj_fecha(dtoUzyTavConfObj.getUzytavconfobj_fecha());
+                entity.setUzytavconfobj_estado(dtoUzyTavConfObj.getUzytavconfobj_estado());
+
                 ModelUzyTavConfObj updatedEntity = daoUzyTavConfObj.save(entity);
+
                 return mapper.entityToDto(updatedEntity);
             } else {
                 throw new ResourceNotFoundException("No se encontró el registro con ID: " + id);

src/main/resources/application-local.properties

@@ -24,3 +24,5 @@ spring.jpa.properties.hibernate.id.new_generator_mappings=true
 spring.datasource.driver-class-name=oracle.jdbc.driver.OracleDriver
 spring.servlet.multipart.enabled=true
 spring.servlet.multipart.max-file-size=10MB
+logging.level.org.springframework.security= DEBUG
+