backend y frontend añadido

backend/.gitignore

+HELP.md
+target/
+!.mvn/wrapper/maven-wrapper.jar
+!**/src/main/**/target/
+!**/src/test/**/target/
+
+### STS ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+
+### IntelliJ IDEA ###
+.idea
+*.iws
+*.iml
+*.ipr
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+build/
+!**/src/main/**/build/
+!**/src/test/**/build/
+
+### VS Code ###
+.vscode/

backend/.mvn/wrapper/maven-wrapper.properties

+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.8.7/apache-maven-3.8.7-bin.zip
+wrapperUrl=https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.1.1/maven-wrapper-3.1.1.jar

backend/Dockerfile

+FROM eclipse-temurin:17
+
+LABEL mentainer="w7moises@gmail.com"
+
+WORKDIR /app
+
+COPY target/backend-0.0.1-SNAPSHOT.jar /app/byte.jar
+
+ENTRYPOINT ["java", "-jar", "byte.jar"]
\ No newline at end of file

backend/README.md

+# Practica
+
+Este proyecto fue creado en Spring boot 3.0.0
+
+## Iniciar en local
+Para correr el proyecto en local se debe primero insertar manualmente el query de data.sql en la base de datos para tener datos de prueba.
+
+## Iniciar en docker
+
+Para correr el proyecto se debe generar el contenedor docker.
+Seguir estos pasos:
+Nota: la base de datos se rellena automaticamente con los datos de data.sql
+
+1. Modificar el docker-compose.yml de acuerdo a sus requisitos
+2. Generar jar con el comando `mvn clean package` o `mvn clean install`
+3. Ejecutar el comando `docker-compose up -d`
+4. Insertar los querys de data.sql en la base de datos para tener datos de prueba
\ No newline at end of file

backend/docker-compose.yml

+version:  "3.8"
+
+services:
+  mysqldb:
+    container_name: mysqldb
+    image: mysql:latest
+    environment:
+        MYSQL_ROOT_PASSWORD: admin
+        MYSQL_DATABASE: bytedb
+        MYSQL_USER: admin
+        MYSQL_PASSWORD: admin
+    ports:
+        - 3333:3306
+    volumes:
+      - ./src/main/resources/:/docker-entrypoint-initdb.d
+    networks:
+        - springboot-mysql-net
+
+  app:
+    container_name: app
+    image: app
+    build:
+      context: .
+      dockerfile: Dockerfile
+    ports:
+        - 8080:8080
+    depends_on:
+        - mysqldb
+    environment:
+        MYSQL_HOST: mysqldb
+        MYSQL_PORT: 3306
+        MYSQL_USER: admin
+        MYSQL_PASSWORD: admin
+    networks:
+        - springboot-mysql-net
+    restart: on-failure
+
+networks:
+  springboot-mysql-net:

backend/mvnw.cmd

+@REM ----------------------------------------------------------------------------
+@REM Licensed to the Apache Software Foundation (ASF) under one
+@REM or more contributor license agreements.  See the NOTICE file
+@REM distributed with this work for additional information
+@REM regarding copyright ownership.  The ASF licenses this file
+@REM to you under the Apache License, Version 2.0 (the
+@REM "License"); you may not use this file except in compliance
+@REM with the License.  You may obtain a copy of the License at
+@REM
+@REM    https://www.apache.org/licenses/LICENSE-2.0
+@REM
+@REM Unless required by applicable law or agreed to in writing,
+@REM software distributed under the License is distributed on an
+@REM "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+@REM KIND, either express or implied.  See the License for the
+@REM specific language governing permissions and limitations
+@REM under the License.
+@REM ----------------------------------------------------------------------------
+
+@REM ----------------------------------------------------------------------------
+@REM Maven Start Up Batch script
+@REM
+@REM Required ENV vars:
+@REM JAVA_HOME - location of a JDK home dir
+@REM
+@REM Optional ENV vars
+@REM M2_HOME - location of maven2's installed home dir
+@REM MAVEN_BATCH_ECHO - set to 'on' to enable the echoing of the batch commands
+@REM MAVEN_BATCH_PAUSE - set to 'on' to wait for a keystroke before ending
+@REM MAVEN_OPTS - parameters passed to the Java VM when running Maven
+@REM     e.g. to debug Maven itself, use
+@REM set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000
+@REM MAVEN_SKIP_RC - flag to disable loading of mavenrc files
+@REM ----------------------------------------------------------------------------
+
+@REM Begin all REM lines with '@' in case MAVEN_BATCH_ECHO is 'on'
+@echo off
+@REM set title of command window
+title %0
+@REM enable echoing by setting MAVEN_BATCH_ECHO to 'on'
+@if "%MAVEN_BATCH_ECHO%" == "on"  echo %MAVEN_BATCH_ECHO%
+
+@REM set %HOME% to equivalent of $HOME
+if "%HOME%" == "" (set "HOME=%HOMEDRIVE%%HOMEPATH%")
+
+@REM Execute a user defined script before this one
+if not "%MAVEN_SKIP_RC%" == "" goto skipRcPre
+@REM check for pre script, once with legacy .bat ending and once with .cmd ending
+if exist "%USERPROFILE%\mavenrc_pre.bat" call "%USERPROFILE%\mavenrc_pre.bat" %*
+if exist "%USERPROFILE%\mavenrc_pre.cmd" call "%USERPROFILE%\mavenrc_pre.cmd" %*
+:skipRcPre
+
+@setlocal
+
+set ERROR_CODE=0
+
+@REM To isolate internal variables from possible post scripts, we use another setlocal
+@setlocal
+
+@REM ==== START VALIDATION ====
+if not "%JAVA_HOME%" == "" goto OkJHome
+
+echo.
+echo Error: JAVA_HOME not found in your environment. >&2
+echo Please set the JAVA_HOME variable in your environment to match the >&2
+echo location of your Java installation. >&2
+echo.
+goto error
+
+:OkJHome
+if exist "%JAVA_HOME%\bin\java.exe" goto init
+
+echo.
+echo Error: JAVA_HOME is set to an invalid directory. >&2
+echo JAVA_HOME = "%JAVA_HOME%" >&2
+echo Please set the JAVA_HOME variable in your environment to match the >&2
+echo location of your Java installation. >&2
+echo.
+goto error
+
+@REM ==== END VALIDATION ====
+
+:init
+
+@REM Find the project base dir, i.e. the directory that contains the folder ".mvn".
+@REM Fallback to current working directory if not found.
+
+set MAVEN_PROJECTBASEDIR=%MAVEN_BASEDIR%
+IF NOT "%MAVEN_PROJECTBASEDIR%"=="" goto endDetectBaseDir
+
+set EXEC_DIR=%CD%
+set WDIR=%EXEC_DIR%
+:findBaseDir
+IF EXIST "%WDIR%"\.mvn goto baseDirFound
+cd ..
+IF "%WDIR%"=="%CD%" goto baseDirNotFound
+set WDIR=%CD%
+goto findBaseDir
+
+:baseDirFound
+set MAVEN_PROJECTBASEDIR=%WDIR%
+cd "%EXEC_DIR%"
+goto endDetectBaseDir
+
+:baseDirNotFound
+set MAVEN_PROJECTBASEDIR=%EXEC_DIR%
+cd "%EXEC_DIR%"
+
+:endDetectBaseDir
+
+IF NOT EXIST "%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config" goto endReadAdditionalConfig
+
+@setlocal EnableExtensions EnableDelayedExpansion
+for /F "usebackq delims=" %%a in ("%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config") do set JVM_CONFIG_MAVEN_PROPS=!JVM_CONFIG_MAVEN_PROPS! %%a
+@endlocal & set JVM_CONFIG_MAVEN_PROPS=%JVM_CONFIG_MAVEN_PROPS%
+
+:endReadAdditionalConfig
+
+SET MAVEN_JAVA_EXE="%JAVA_HOME%\bin\java.exe"
+set WRAPPER_JAR="%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.jar"
+set WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain
+
+set DOWNLOAD_URL="https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.1.0/maven-wrapper-3.1.0.jar"
+
+FOR /F "usebackq tokens=1,2 delims==" %%A IN ("%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.properties") DO (
+    IF "%%A"=="wrapperUrl" SET DOWNLOAD_URL=%%B
+)
+
+@REM Extension to allow automatically downloading the maven-wrapper.jar from Maven-central
+@REM This allows using the maven wrapper in projects that prohibit checking in binary data.
+if exist %WRAPPER_JAR% (
+    if "%MVNW_VERBOSE%" == "true" (
+        echo Found %WRAPPER_JAR%
+    )
+) else (
+    if not "%MVNW_REPOURL%" == "" (
+        SET DOWNLOAD_URL="%MVNW_REPOURL%/org/apache/maven/wrapper/maven-wrapper/3.1.0/maven-wrapper-3.1.0.jar"
+    )
+    if "%MVNW_VERBOSE%" == "true" (
+        echo Couldn't find %WRAPPER_JAR%, downloading it ...
+        echo Downloading from: %DOWNLOAD_URL%
+    )
+
+    powershell -Command "&{"^
+		"$webclient = new-object System.Net.WebClient;"^
+		"if (-not ([string]::IsNullOrEmpty('%MVNW_USERNAME%') -and [string]::IsNullOrEmpty('%MVNW_PASSWORD%'))) {"^
+		"$webclient.Credentials = new-object System.Net.NetworkCredential('%MVNW_USERNAME%', '%MVNW_PASSWORD%');"^
+		"}"^
+		"[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12; $webclient.DownloadFile('%DOWNLOAD_URL%', '%WRAPPER_JAR%')"^
+		"}"
+    if "%MVNW_VERBOSE%" == "true" (
+        echo Finished downloading %WRAPPER_JAR%
+    )
+)
+@REM End of extension
+
+@REM Provide a "standardized" way to retrieve the CLI args that will
+@REM work with both Windows and non-Windows executions.
+set MAVEN_CMD_LINE_ARGS=%*
+
+%MAVEN_JAVA_EXE% ^
+  %JVM_CONFIG_MAVEN_PROPS% ^
+  %MAVEN_OPTS% ^
+  %MAVEN_DEBUG_OPTS% ^
+  -classpath %WRAPPER_JAR% ^
+  "-Dmaven.multiModuleProjectDirectory=%MAVEN_PROJECTBASEDIR%" ^
+  %WRAPPER_LAUNCHER% %MAVEN_CONFIG% %*
+if ERRORLEVEL 1 goto error
+goto end
+
+:error
+set ERROR_CODE=1
+
+:end
+@endlocal & set ERROR_CODE=%ERROR_CODE%
+
+if not "%MAVEN_SKIP_RC%"=="" goto skipRcPost
+@REM check for post script, once with legacy .bat ending and once with .cmd ending
+if exist "%USERPROFILE%\mavenrc_post.bat" call "%USERPROFILE%\mavenrc_post.bat"
+if exist "%USERPROFILE%\mavenrc_post.cmd" call "%USERPROFILE%\mavenrc_post.cmd"
+:skipRcPost
+
+@REM pause the script if MAVEN_BATCH_PAUSE is set to 'on'
+if "%MAVEN_BATCH_PAUSE%"=="on" pause
+
+if "%MAVEN_TERMINATE_CMD%"=="on" exit %ERROR_CODE%
+
+cmd /C exit /B %ERROR_CODE%

backend/pom.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-starter-parent</artifactId>
+        <version>3.0.6</version>
+        <relativePath/> <!-- lookup parent from repository -->
+    </parent>
+    <groupId>com.app.backend</groupId>
+    <artifactId>backend</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <name>backend</name>
+    <description>backend</description>
+    <properties>
+        <java.version>17</java.version>
+    </properties>
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-jpa</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-mail</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.mysql</groupId>
+            <artifactId>mysql-connector-j</artifactId>
+            <scope>runtime</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <optional>true</optional>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.modelmapper</groupId>
+            <artifactId>modelmapper</artifactId>
+            <version>3.0.0</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-validation</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-actuator</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-security</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.jsonwebtoken</groupId>
+            <artifactId>jjwt-api</artifactId>
+            <version>0.11.5</version>
+        </dependency>
+        <dependency>
+            <groupId>io.jsonwebtoken</groupId>
+            <artifactId>jjwt-impl</artifactId>
+            <version>0.11.5</version>
+        </dependency>
+        <dependency>
+            <groupId>io.jsonwebtoken</groupId>
+            <artifactId>jjwt-jackson</artifactId>
+            <version>0.11.5</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.security</groupId>
+            <artifactId>spring-security-test</artifactId>
+            <version>6.0.0</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+                <configuration>
+                    <excludes>
+                        <exclude>
+                            <groupId>org.projectlombok</groupId>
+                            <artifactId>lombok</artifactId>
+                        </exclude>
+                    </excludes>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+</project>

backend/src/main/java/com/app/backend/BackendApplication.java

+package com.app.backend;
+
+import org.modelmapper.ModelMapper;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.context.annotation.Bean;
+
+@SpringBootApplication
+public class BackendApplication {
+
+    @Bean
+    public ModelMapper modelMapper() {
+        return new ModelMapper();
+    }
+
+    public static void main(String[] args) {
+        SpringApplication.run(BackendApplication.class, args);
+    }
+}

backend/src/main/java/com/app/backend/config/ApplicationConfig.java

+package com.app.backend.config;
+
+import com.app.backend.repository.UserRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.security.authentication.AuthenticationManager;
+import org.springframework.security.authentication.AuthenticationProvider;
+import org.springframework.security.authentication.dao.DaoAuthenticationProvider;
+import org.springframework.security.config.annotation.authentication.configuration.AuthenticationConfiguration;
+import org.springframework.security.core.userdetails.UserDetailsService;
+import org.springframework.security.core.userdetails.UsernameNotFoundException;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+import org.springframework.security.crypto.password.PasswordEncoder;
+
+@Configuration
+@RequiredArgsConstructor
+public class ApplicationConfig {
+
+  private final UserRepository repository;
+
+  @Bean
+  public UserDetailsService userDetailsService() {
+    return username -> repository.findByEmail(username)
+        .orElseThrow(() -> new UsernameNotFoundException("User not found"));
+  }
+
+  @Bean
+  public AuthenticationProvider authenticationProvider() {
+    DaoAuthenticationProvider authProvider = new DaoAuthenticationProvider();
+    authProvider.setUserDetailsService(userDetailsService());
+    authProvider.setPasswordEncoder(passwordEncoder());
+    return authProvider;
+  }
+
+  @Bean
+  public AuthenticationManager authenticationManager(AuthenticationConfiguration config) throws Exception {
+    return config.getAuthenticationManager();
+  }
+
+  @Bean
+  public PasswordEncoder passwordEncoder() {
+    return new BCryptPasswordEncoder();
+  }
+
+}

backend/src/main/java/com/app/backend/config/JwtAuthenticationFilter.java

+package com.app.backend.config;
+
+import com.app.backend.repository.TokenRepository;
+import jakarta.servlet.FilterChain;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import lombok.RequiredArgsConstructor;
+import org.springframework.lang.NonNull;
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.security.core.userdetails.UserDetailsService;
+import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
+import org.springframework.stereotype.Component;
+import org.springframework.web.filter.OncePerRequestFilter;
+
+import java.io.IOException;
+
+@Component
+@RequiredArgsConstructor
+public class JwtAuthenticationFilter extends OncePerRequestFilter {
+
+  private final JwtService jwtService;
+  private final UserDetailsService userDetailsService;
+  private final TokenRepository tokenRepository;
+
+  @Override
+  protected void doFilterInternal(
+      @NonNull HttpServletRequest request,
+      @NonNull HttpServletResponse response,
+      @NonNull FilterChain filterChain
+  ) throws ServletException, IOException {
+    final String authHeader = request.getHeader("Authorization");
+    final String jwt;
+    final String userEmail;
+    if (authHeader == null ||!authHeader.startsWith("Bearer ")) {
+      filterChain.doFilter(request, response);
+      return;
+    }
+    jwt = authHeader.substring(7);
+    userEmail = jwtService.extractUsername(jwt);
+    if (userEmail != null && SecurityContextHolder.getContext().getAuthentication() == null) {
+      UserDetails userDetails = this.userDetailsService.loadUserByUsername(userEmail);
+      var isTokenValid = tokenRepository.findByToken(jwt)
+          .map(t -> !t.isExpired() && !t.isRevoked())
+          .orElse(false);
+      if (jwtService.isTokenValid(jwt, userDetails) && isTokenValid) {
+        UsernamePasswordAuthenticationToken authToken = new UsernamePasswordAuthenticationToken(
+            userDetails,
+            null,
+            userDetails.getAuthorities()
+        );
+        authToken.setDetails(
+            new WebAuthenticationDetailsSource().buildDetails(request)
+        );
+        SecurityContextHolder.getContext().setAuthentication(authToken);
+      }
+    }
+    filterChain.doFilter(request, response);
+  }
+}

backend/src/main/java/com/app/backend/config/JwtService.java

+package com.app.backend.config;
+
+import io.jsonwebtoken.Claims;
+import io.jsonwebtoken.Jwts;
+import io.jsonwebtoken.SignatureAlgorithm;
+import io.jsonwebtoken.io.Decoders;
+import io.jsonwebtoken.security.Keys;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.stereotype.Service;
+
+import java.security.Key;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Function;
+
+@Service
+public class JwtService {
+
+  private static final String SECRET_KEY = "b65e96650acf0508cae56b79a796140b6ac1b80874f7c2d635b131e2ad82a55d";
+
+  public String extractUsername(String token) {
+    return extractClaim(token, Claims::getSubject);
+  }
+
+  public <T> T extractClaim(String token, Function<Claims, T> claimsResolver) {
+    final Claims claims = extractAllClaims(token);
+    return claimsResolver.apply(claims);
+  }
+
+  public String generateToken(UserDetails userDetails) {
+    return generateToken(new HashMap<>(), userDetails);
+  }
+
+  public String generateToken(
+      Map<String, Object> extraClaims,
+      UserDetails userDetails
+  ) {
+    return Jwts
+        .builder()
+        .setClaims(extraClaims)
+        .setSubject(userDetails.getUsername())
+        .setIssuedAt(new Date(System.currentTimeMillis()))
+        .setExpiration(new Date(System.currentTimeMillis() + 10000 * 60 * 24))
+        .signWith(getSignInKey(), SignatureAlgorithm.HS256)
+        .compact();
+  }
+
+  public boolean isTokenValid(String token, UserDetails userDetails) {
+    final String username = extractUsername(token);
+    return (username.equals(userDetails.getUsername())) && !isTokenExpired(token);
+  }
+
+  private boolean isTokenExpired(String token) {
+    return extractExpiration(token).before(new Date());
+  }
+
+  private Date extractExpiration(String token) {
+    return extractClaim(token, Claims::getExpiration);
+  }
+
+  private Claims extractAllClaims(String token) {
+    return Jwts
+        .parserBuilder()
+        .setSigningKey(getSignInKey())
+        .build()
+        .parseClaimsJws(token)
+        .getBody();
+  }
+
+  private Key getSignInKey() {
+    byte[] keyBytes = Decoders.BASE64.decode(SECRET_KEY);
+    return Keys.hmacShaKeyFor(keyBytes);
+  }
+}

backend/src/main/java/com/app/backend/config/LogoutService.java

+package com.app.backend.config;
+
+import com.app.backend.repository.TokenRepository;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import lombok.RequiredArgsConstructor;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.web.authentication.logout.LogoutHandler;
+import org.springframework.stereotype.Service;
+
+@Service
+@RequiredArgsConstructor
+public class LogoutService implements LogoutHandler {
+
+  private final TokenRepository tokenRepository;
+
+  @Override
+  public void logout(
+      HttpServletRequest request,
+      HttpServletResponse response,
+      Authentication authentication
+  ) {
+    final String authHeader = request.getHeader("Authorization");
+    final String jwt;
+    if (authHeader == null ||!authHeader.startsWith("Bearer ")) {
+      return;
+    }
+    jwt = authHeader.substring(7);
+    var storedToken = tokenRepository.findByToken(jwt)
+        .orElse(null);
+    if (storedToken != null) {
+      storedToken.setExpired(true);
+      storedToken.setRevoked(true);
+      tokenRepository.save(storedToken);
+      SecurityContextHolder.clearContext();
+    }
+  }
+}

backend/src/main/java/com/app/backend/config/SecurityConfig.java

+package com.app.backend.config;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.security.authentication.AuthenticationProvider;
+import org.springframework.security.config.annotation.method.configuration.EnableMethodSecurity;
+import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
+import org.springframework.security.config.http.SessionCreationPolicy;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.web.SecurityFilterChain;
+import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
+import org.springframework.security.web.authentication.logout.LogoutHandler;
+
+@Configuration
+@EnableWebSecurity
+@EnableMethodSecurity
+@RequiredArgsConstructor
+public class SecurityConfig {
+
+    private final JwtAuthenticationFilter jwtAuthFilter;
+    private final AuthenticationProvider authenticationProvider;
+    private final LogoutHandler logoutHandler;
+
+    @Bean
+    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
+        http
+                .csrf()
+                .disable()
+                .authorizeHttpRequests()
+                .requestMatchers("/api/v1/auth/**")
+                .permitAll()
+                .requestMatchers("/actuator/**")
+                .permitAll()
+                .requestMatchers("/api/v1/**")
+                .permitAll()
+                .anyRequest()
+                .authenticated()
+                .and()
+                .sessionManagement()
+                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
+                .and()
+                .authenticationProvider(authenticationProvider)
+                .addFilterBefore(jwtAuthFilter, UsernamePasswordAuthenticationFilter.class)
+                .logout()
+                .logoutUrl("/auth/logout")
+                .addLogoutHandler(logoutHandler)
+                .logoutSuccessHandler((request, response, authentication) -> SecurityContextHolder.clearContext())
+        ;
+
+        return http.build();
+    }
+}

backend/src/main/java/com/app/backend/controller/AereopuertoController.java

+package com.app.backend.controller;
+
+import com.app.backend.dto.AereopuertoDto;
+import com.app.backend.service.AereopuertoService;
+import jakarta.validation.Valid;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@CrossOrigin(origins = "*", allowedHeaders = "*")
+@RequestMapping("api/v1/aereopuertos")
+public class AereopuertoController {
+
+    private final AereopuertoService aereopuertoService;
+
+    public AereopuertoController(AereopuertoService aereopuertoService) {
+        this.aereopuertoService = aereopuertoService;
+    }
+
+    @GetMapping("/page")
+    public ResponseEntity<Page<AereopuertoDto>> getAllAereopuertos(Pageable pageable) {
+        Page<AereopuertoDto> aereopuertoList = aereopuertoService.getAereopuertos(pageable);
+        return new ResponseEntity<>(aereopuertoList, HttpStatus.OK);
+    }
+
+    @GetMapping("/{id}")
+    public ResponseEntity<AereopuertoDto> getAereopuertoById(@PathVariable Long id) {
+        AereopuertoDto aereopuerto = aereopuertoService.getAereopuertoById(id);
+        return new ResponseEntity<>(aereopuerto, HttpStatus.OK);
+    }
+
+    @GetMapping
+    public ResponseEntity<List<AereopuertoDto>> getAereopuertos() {
+        List<AereopuertoDto> aereopuertos = aereopuertoService.getAereopuertos();
+        return new ResponseEntity<>(aereopuertos, HttpStatus.OK);
+    }
+
+    @PostMapping
+    public ResponseEntity<AereopuertoDto> createAereopuerto(@RequestBody @Valid AereopuertoDto aereopuertoDto) {
+        AereopuertoDto aereopuerto = aereopuertoService.createAereopuerto(aereopuertoDto);
+        return new ResponseEntity<>(aereopuerto, HttpStatus.CREATED);
+    }
+
+    @PutMapping("/{id}")
+    public ResponseEntity<AereopuertoDto> updateAereopuerto(@PathVariable Long id, @RequestBody @Valid AereopuertoDto aereopuertoDto) {
+        AereopuertoDto aereopuerto = aereopuertoService.updateAereopuerto(id, aereopuertoDto);
+        return new ResponseEntity<>(aereopuerto, HttpStatus.OK);
+    }
+
+    @DeleteMapping("/{id}")
+    public ResponseEntity<AereopuertoDto> deleteAereopuerto(@PathVariable Long id) {
+        AereopuertoDto aereopuerto = aereopuertoService.deleteAereopuerto(id);
+        return new ResponseEntity<>(aereopuerto, HttpStatus.OK);
+    }
+}

backend/src/main/java/com/app/backend/controller/AgenteController.java

+package com.app.backend.controller;
+
+import com.app.backend.dto.AgenteDto;
+import com.app.backend.service.AgenteService;
+import jakarta.validation.Valid;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+@RestController
+@CrossOrigin(origins = "*", allowedHeaders = "*")
+@RequestMapping("api/v1/agentes")
+public class AgenteController {
+
+    private final AgenteService agenteService;
+
+    public AgenteController(AgenteService agenteService) {
+        this.agenteService = agenteService;
+    }
+
+    @GetMapping("/page")
+    public ResponseEntity<Page<AgenteDto>> getAllAgentes(Pageable pageable) {
+        Page<AgenteDto> agenteList = agenteService.getAllAgentes(pageable);
+        return new ResponseEntity<>(agenteList, HttpStatus.OK);
+    }
+
+    @GetMapping("/{id}")
+    public ResponseEntity<AgenteDto> getAgenteById(@PathVariable Long id) {
+        AgenteDto agente = agenteService.getAgenteById(id);
+        return new ResponseEntity<>(agente, HttpStatus.OK);
+    }
+
+    @PostMapping
+    public ResponseEntity<AgenteDto> createAgente(@RequestBody @Valid AgenteDto agenteDto) {
+        AgenteDto agente = agenteService.createAgente(agenteDto);
+        return new ResponseEntity<>(agente, HttpStatus.CREATED);
+    }
+
+    @PutMapping("/{id}")
+    public ResponseEntity<AgenteDto> updateAgente(@PathVariable Long id, @RequestBody @Valid AgenteDto agenteDto) {
+        AgenteDto agente = agenteService.updateAgente(id, agenteDto);
+        return new ResponseEntity<>(agente, HttpStatus.OK);
+    }
+
+    @DeleteMapping("/{id}")
+    public ResponseEntity<AgenteDto> deleteAgente(@PathVariable Long id) {
+        AgenteDto agente = agenteService.deleteAgente(id);
+        return new ResponseEntity<>(agente, HttpStatus.OK);
+    }
+}

backend/src/main/java/com/app/backend/controller/AuthenticationController.java

+package com.app.backend.controller;
+
+import com.app.backend.dto.UserDto;
+import com.app.backend.model.Role;
+import com.app.backend.model.auth.AuthenticationRequest;
+import com.app.backend.model.auth.AuthenticationResponse;
+import com.app.backend.service.impl.AuthenticationServiceImpl;
+import jakarta.validation.Valid;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+@RestController
+@CrossOrigin(origins = "*", allowedHeaders = "*")
+@RequestMapping("api/v1/auth")
+public class AuthenticationController {
+
+  private final AuthenticationServiceImpl service;
+
+  public AuthenticationController(AuthenticationServiceImpl service) {
+    this.service = service;
+  }
+
+  @PostMapping("/register")
+  public ResponseEntity<AuthenticationResponse> register(@RequestBody @Valid UserDto request) {
+    return ResponseEntity.ok(service.register(request, Role.ROLE_SUPERVISOR));
+  }
+
+  @PostMapping("/authenticate")
+  public ResponseEntity<AuthenticationResponse> authenticate(@RequestBody @Valid AuthenticationRequest request) {
+    return ResponseEntity.ok(service.authenticate(request));
+  }
+
+}

backend/src/main/java/com/app/backend/controller/CostoController.java

+package com.app.backend.controller;
+
+import com.app.backend.dto.CostoDto;
+import com.app.backend.dto.create.CreateCostoDto;
+import com.app.backend.service.CostoService;
+import jakarta.validation.Valid;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@CrossOrigin(origins = "*", allowedHeaders = "*")
+@RequestMapping("api/v1/costos")
+public class CostoController {
+
+    private final CostoService costoService;
+
+    public CostoController(CostoService costoService) {
+        this.costoService = costoService;
+    }
+
+    @GetMapping("/page")
+    public ResponseEntity<List<CostoDto>> getAllCostos() {
+        List<CostoDto> costoList = costoService.getAllCostos();
+        return new ResponseEntity<>(costoList, HttpStatus.OK);
+    }
+
+    @GetMapping("/vuelo/{id}")
+    public ResponseEntity<List<CostoDto>> getAllCostos(@PathVariable Long id) {
+        List<CostoDto> costoList = costoService.getAllCostosByVueloId(id);
+        return new ResponseEntity<>(costoList, HttpStatus.OK);
+    }
+
+    @GetMapping("/{id}")
+    public ResponseEntity<CostoDto> getCostoById(@PathVariable Long id) {
+        CostoDto costo = costoService.getCostoById(id);
+        return new ResponseEntity<>(costo, HttpStatus.OK);
+    }
+
+    @PostMapping
+    public ResponseEntity<CostoDto> createCosto(@RequestBody @Valid CreateCostoDto costoDto) {
+        CostoDto costo = costoService.createCosto(costoDto);
+        return new ResponseEntity<>(costo, HttpStatus.CREATED);
+    }
+
+    @PutMapping("/{id}")
+    public ResponseEntity<CostoDto> updateCosto(@PathVariable Long id, @RequestBody @Valid CreateCostoDto costoDto) {
+        CostoDto costo = costoService.updateCosto(id, costoDto);
+        return new ResponseEntity<>(costo, HttpStatus.OK);
+    }
+
+    @DeleteMapping("/{id}")
+    public ResponseEntity<CostoDto> deleteCosto(@PathVariable Long id) {
+        CostoDto costo = costoService.deleteCosto(id);
+        return new ResponseEntity<>(costo, HttpStatus.OK);
+    }
+}

backend/src/main/java/com/app/backend/controller/EscalaController.java

+package com.app.backend.controller;
+
+import com.app.backend.dto.EscalaDto;
+import com.app.backend.dto.create.CreateEscalaDto;
+import com.app.backend.service.EscalaService;
+import jakarta.validation.Valid;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@CrossOrigin(origins = "*", allowedHeaders = "*")
+@RequestMapping("api/v1/escalas")
+public class EscalaController {
+
+    private final EscalaService escalaService;
+
+    public EscalaController(EscalaService service) {
+        this.escalaService = service;
+    }
+
+    @GetMapping
+    public ResponseEntity<List<EscalaDto>> getAllEscalas() {
+        List<EscalaDto> escalaList = escalaService.getAllEscalas();
+        return new ResponseEntity<>(escalaList, HttpStatus.OK);
+    }
+
+    @GetMapping("vuelo/{id}")
+    public ResponseEntity<List<EscalaDto>> getAllEscalasByVueloId(@PathVariable Long id) {
+        List<EscalaDto> escalaList =escalaService.getEscalasByVueloId(id);
+        return new ResponseEntity<>(escalaList, HttpStatus.OK);
+    }
+
+    @GetMapping("/{id}")
+    public ResponseEntity<EscalaDto> getEscalaById(@PathVariable Long id) {
+        EscalaDto escala = escalaService.getEscalaById(id);
+        return new ResponseEntity<>(escala, HttpStatus.OK);
+    }
+
+    @PostMapping
+    public ResponseEntity<EscalaDto> createEscala(@RequestBody @Valid CreateEscalaDto escalaDto) {
+        EscalaDto escala = escalaService.createEscala(escalaDto);
+        return new ResponseEntity<>(escala, HttpStatus.CREATED);
+    }
+
+    @PutMapping("/{id}")
+    public ResponseEntity<EscalaDto> updateEscala(@PathVariable Long id, @RequestBody @Valid CreateEscalaDto escalaDto) {
+        EscalaDto escala = escalaService.updateEscala(id, escalaDto);
+        return new ResponseEntity<>(escala, HttpStatus.OK);
+    }
+
+    @DeleteMapping("/{id}")
+    public ResponseEntity<EscalaDto> deleteEscala(@PathVariable Long id) {
+        EscalaDto escala = escalaService.deleteEscala(id);
+        return new ResponseEntity<>(escala, HttpStatus.OK);
+    }
+}

backend/src/main/java/com/app/backend/controller/PagoController.java

+package com.app.backend.controller;
+
+import com.app.backend.dto.PagoDto;
+import com.app.backend.dto.create.CreatePagoDto;
+import com.app.backend.service.PagoService;
+import jakarta.validation.Valid;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@CrossOrigin(origins = "*", allowedHeaders = "*")
+@RequestMapping("api/v1/pagos")
+public class PagoController {
+
+    private final PagoService pagoService;
+
+    public PagoController(PagoService pagoService) {
+        this.pagoService = pagoService;
+    }
+
+    @GetMapping
+    public ResponseEntity<List<PagoDto>> getAllPagos() {
+        List<PagoDto> pagoList = pagoService.getAllPagos();
+        return new ResponseEntity<>(pagoList, HttpStatus.OK);
+    }
+
+    @PostMapping
+    public ResponseEntity<PagoDto> createPago(@RequestBody @Valid CreatePagoDto pagoDto) {
+        PagoDto pago = pagoService.createPago(pagoDto);
+        return new ResponseEntity<>(pago, HttpStatus.CREATED);
+    }
+}

backend/src/main/java/com/app/backend/controller/PasajeroController.java

+package com.app.backend.controller;
+
+import com.app.backend.dto.PasajeroDto;
+import com.app.backend.service.PasajeroService;
+import jakarta.validation.Valid;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@CrossOrigin(origins = "*", allowedHeaders = "*")
+@RequestMapping("api/v1/pasajeros")
+public class PasajeroController {
+
+    private final PasajeroService pasajeroService;
+
+    public PasajeroController(PasajeroService pasajeroService) {
+        this.pasajeroService = pasajeroService;
+    }
+
+    @GetMapping("/page")
+    public ResponseEntity<Page<PasajeroDto>> getAllPasajeros(Pageable pageable) {
+        Page<PasajeroDto> pasajeroList = pasajeroService.getAllPasajeros(pageable);
+        return new ResponseEntity<>(pasajeroList, HttpStatus.OK);
+    }
+
+    @GetMapping
+    public ResponseEntity<List<PasajeroDto>> getAllPasajeros() {
+        List<PasajeroDto> pasajeroList = pasajeroService.getAllPasajeros();
+        return new ResponseEntity<>(pasajeroList, HttpStatus.OK);
+    }
+
+    @GetMapping("/{id}")
+    public ResponseEntity<PasajeroDto> getPasajeroById(@PathVariable Long id) {
+        PasajeroDto pasajero = pasajeroService.getPasajeroById(id);
+        return new ResponseEntity<>(pasajero, HttpStatus.OK);
+    }
+
+    @PostMapping
+    public ResponseEntity<PasajeroDto> createPasajero(@RequestBody @Valid PasajeroDto pasajeroDto) {
+        PasajeroDto pasajero = pasajeroService.createPasajero(pasajeroDto);
+        return new ResponseEntity<>(pasajero, HttpStatus.CREATED);
+    }
+
+    @PutMapping("/{id}")
+    public ResponseEntity<PasajeroDto> updatePasajero(@PathVariable Long id, @RequestBody @Valid PasajeroDto pasajeroDto) {
+        PasajeroDto pasajero = pasajeroService.updatePasajero(id, pasajeroDto);
+        return new ResponseEntity<>(pasajero, HttpStatus.OK);
+    }
+
+    @DeleteMapping("/{id}")
+    public ResponseEntity<PasajeroDto> deletePasajero(@PathVariable Long id) {
+        PasajeroDto pasajero = pasajeroService.deletePasajero(id);
+        return new ResponseEntity<>(pasajero, HttpStatus.OK);
+    }
+}

backend/src/main/java/com/app/backend/controller/ReservaController.java

+package com.app.backend.controller;
+
+import com.app.backend.dto.ReservaDto;
+import com.app.backend.dto.create.CreateReservaDto;
+import com.app.backend.service.ReservaService;
+import jakarta.validation.Valid;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@CrossOrigin(origins = "*", allowedHeaders = "*")
+@RequestMapping("api/v1/reservas")
+public class ReservaController {
+
+    private final ReservaService reservaService;
+
+    public ReservaController(ReservaService reservaService) {
+        this.reservaService = reservaService;
+    }
+
+    @GetMapping("/page")
+    public ResponseEntity<Page<ReservaDto>> getAllReservas(Pageable pageable) {
+        Page<ReservaDto> reservaList = reservaService.getAllReservas(pageable);
+        return new ResponseEntity<>(reservaList, HttpStatus.OK);
+    }
+
+    @GetMapping("/email/{email}")
+    public ResponseEntity<List<ReservaDto>> getAllReservas(@PathVariable String email) {
+        List<ReservaDto> reservaList = reservaService.getAllReservasByEmail(email);
+        return new ResponseEntity<>(reservaList, HttpStatus.OK);
+    }
+
+    @GetMapping("/{id}")
+    public ResponseEntity<ReservaDto> getReservaById(@PathVariable Long id) {
+        ReservaDto reserva = reservaService.getReservaById(id);
+        return new ResponseEntity<>(reserva, HttpStatus.OK);
+    }
+
+    @PostMapping
+    public ResponseEntity<ReservaDto> createReserva(@RequestBody @Valid CreateReservaDto reservaDto) {
+        ReservaDto reserva = reservaService.createReserva(reservaDto);
+        return new ResponseEntity<>(reserva, HttpStatus.CREATED);
+    }
+
+    @PutMapping("/{id}")
+    public ResponseEntity<ReservaDto> updateReserva(@PathVariable Long id, @RequestBody @Valid CreateReservaDto reservaDto) {
+        ReservaDto reserva = reservaService.updateReserva(id, reservaDto);
+        return new ResponseEntity<>(reserva, HttpStatus.OK);
+    }
+
+    @DeleteMapping("/{id}")
+    public ResponseEntity<ReservaDto> deleteReserva(@PathVariable Long id) {
+        ReservaDto reserva = reservaService.deleteReserva(id);
+        return new ResponseEntity<>(reserva, HttpStatus.OK);
+    }
+}

backend/src/main/java/com/app/backend/controller/VueloController.java

+package com.app.backend.controller;
+
+import com.app.backend.dto.VueloDto;
+import com.app.backend.dto.create.CreateVueloDto;
+import com.app.backend.model.Aereolinea;
+import com.app.backend.model.Avion;
+import com.app.backend.service.VueloService;
+import jakarta.validation.Valid;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@CrossOrigin(origins = "*", allowedHeaders = "*")
+@RequestMapping("api/v1")
+public class VueloController {
+
+    private final VueloService vueloService;
+
+    public VueloController(VueloService vueloService) {
+        this.vueloService = vueloService;
+    }
+
+    @GetMapping("/vuelos/page")
+    public ResponseEntity<Page<VueloDto>> getAllVuelos(Pageable pageable) {
+        Page<VueloDto> vueloList = vueloService.getVuelos(pageable);
+        return new ResponseEntity<>(vueloList, HttpStatus.OK);
+    }
+
+    @GetMapping("/vuelos/{id}")
+    public ResponseEntity<VueloDto> getVueloById(@PathVariable Long id) {
+        VueloDto vuelo = vueloService.getVueloById(id);
+        return new ResponseEntity<>(vuelo, HttpStatus.OK);
+    }
+
+    @PostMapping("/vuelos")
+    public ResponseEntity<VueloDto> createVuelo(@RequestBody @Valid CreateVueloDto createVueloDto) {
+        VueloDto vuelo = vueloService.createVuelo(createVueloDto);
+        return new ResponseEntity<>(vuelo, HttpStatus.CREATED);
+    }
+
+    @PutMapping("/vuelos/{id}")
+    public ResponseEntity<VueloDto> updateVuelo(@PathVariable Long id, @RequestBody @Valid CreateVueloDto createVueloDto) {
+        VueloDto vuelo = vueloService.updateVuelo(id, createVueloDto);
+        return new ResponseEntity<>(vuelo, HttpStatus.OK);
+    }
+
+    @DeleteMapping("/vuelos/{id}")
+    public ResponseEntity<VueloDto> deleteVuelo(@PathVariable Long id) {
+        VueloDto vuelo = vueloService.deleteVuelo(id);
+        return new ResponseEntity<>(vuelo, HttpStatus.OK);
+    }
+
+    @GetMapping("/aviones")
+    public ResponseEntity<List<Avion>> getAllAviones() {
+        List<Avion> avionList = vueloService.getAviones();
+        return new ResponseEntity<>(avionList, HttpStatus.OK);
+    }
+
+    @GetMapping("/aereolineas")
+    public ResponseEntity<List<Aereolinea>> getAllAereolineas() {
+        List<Aereolinea> aereolineaList = vueloService.getAereolineas();
+        return new ResponseEntity<>(aereolineaList, HttpStatus.OK);
+    }
+}

backend/src/main/java/com/app/backend/dto/AereopuertoDto.java

+package com.app.backend.dto;
+
+import jakarta.validation.constraints.NotBlank;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class AereopuertoDto {
+
+    private Long airportId;
+
+    @NotBlank(message = "El nombre del aeropuerto es requerido")
+    private String airportName;
+
+    @NotBlank(message = "La ubicación del aeropuerto es requerida")
+    private String airportLocation;
+
+    @NotBlank(message = "Los detalles del aeropuerto son requeridos")
+    private String otherDetails;
+}

backend/src/main/java/com/app/backend/dto/AgenteDto.java

+package com.app.backend.dto;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Pattern;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class AgenteDto {
+
+    private Long agentId;
+
+    @NotBlank(message = "Agent name is required")
+    @Pattern(regexp = "^[a-zA-Z ]*$", message = "Agent name must be alphabetic")
+    private String agentName;
+
+    @NotBlank(message = "Agent details are required")
+    private String agentDetails;
+}

backend/src/main/java/com/app/backend/dto/CostoDto.java

+package com.app.backend.dto;
+
+import com.app.backend.model.Aereolinea;
+import com.app.backend.model.Vuelo;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.math.BigDecimal;
+import java.util.Date;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class CostoDto {
+
+    private Long costId;
+
+    private Vuelo flight;
+
+    private Aereolinea airline;
+
+    @JsonFormat(pattern = "dd-MM-yyyy")
+    private Date validFromDate;
+
+    @JsonFormat(pattern = "dd-MM-yyyy")
+    private Date validToDate;
+
+    private BigDecimal flightCost;
+}

backend/src/main/java/com/app/backend/dto/EscalaDto.java

+package com.app.backend.dto;
+
+import com.app.backend.model.Aereopuerto;
+import com.app.backend.model.Vuelo;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import jakarta.validation.constraints.NotBlank;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.util.Date;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class EscalaDto {
+
+    private Long legId;
+
+    private Vuelo flight;
+
+    private Aereopuerto origin_airport;
+
+    private Aereopuerto destination_airport;
+
+    @JsonFormat(pattern = "dd-MM-yyyy")
+    private Date actualDepartureDate;
+
+    @JsonFormat(pattern = "dd-MM-yyyy")
+    private Date actualArrivalDate;
+
+    @NotBlank(message = "departure_time is required")
+    private String actualDepartureTime;
+
+    @NotBlank(message = "arrival_time is required")
+    private String actualArrivalTime;
+}

backend/src/main/java/com/app/backend/dto/PagoDto.java

+package com.app.backend.dto;
+
+import com.app.backend.model.Reserva;
+import com.app.backend.model.Status;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.math.BigDecimal;
+import java.util.Date;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class PagoDto {
+
+    private Long paymentId;
+
+    private Reserva reservation;
+
+    private Status status;
+
+    @JsonFormat(pattern = "dd-MM-yyyy")
+    private Date paymentDate;
+
+    private BigDecimal paymentAmount;
+}

backend/src/main/java/com/app/backend/dto/PasajeroDto.java

+package com.app.backend.dto;
+
+import jakarta.validation.constraints.Email;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Pattern;
+import jakarta.validation.constraints.Size;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class PasajeroDto {
+
+    private Long passengerId;
+
+    @NotBlank(message = "First name is required")
+    @Pattern(regexp = "^[a-zA-Z ]*$", message = "First name must be alphabetic")
+    private String firstName;
+
+    @NotBlank(message = "Second name is required")
+    @Pattern(regexp = "^[a-zA-Z ]*$", message = "Second name must be alphabetic")
+    private String secondName;
+
+    @NotBlank(message = "Last name is required")
+    @Pattern(regexp = "^[a-zA-Z ]*$", message = "Last name must be alphabetic")
+    private String lastName;
+
+    @NotBlank(message = "Phone number is required")
+    @Size(min = 9, max = 9, message = "Phone number must be 9 digits")
+    @Pattern(regexp = "^\\d*$", message = "Phone number must be numeric")
+    private String phoneNumber;
+
+    @NotBlank(message = "Email address is required")
+    @Email
+    private String emailAddress;
+
+    @NotBlank(message = "Address is required")
+    @Pattern(regexp = "^[a-zA-Z ]*$", message = "Address must be alphabetic")
+    private String city;
+
+    @NotBlank(message = "Country is required")
+    @Pattern(regexp = "^[a-zA-Z ]*$", message = "Country must be alphabetic")
+    private String country;
+
+    @NotBlank(message = "Other details are required")
+    private String otherDetails;
+}

backend/src/main/java/com/app/backend/dto/ReservaDto.java

+package com.app.backend.dto;
+
+import com.app.backend.model.*;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.util.Date;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class ReservaDto {
+
+    private Long reservationId;
+
+    private Agente agent;
+
+    private Pasajero passenger;
+
+    private Status reservationStatusCode;
+
+    private String ticketCode;
+
+    private Type travelTypeClass;
+
+    private Long numberInParty;
+
+    private Escala leg;
+
+    @JsonFormat(pattern = "dd-MM-yyyy")
+    private Date reservationDate;
+}

backend/src/main/java/com/app/backend/dto/UserDto.java

+package com.app.backend.dto;
+
+import jakarta.validation.constraints.Email;
+import jakarta.validation.constraints.NotEmpty;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class UserDto {
+    private Long id;
+    @NotEmpty(message = "firstname is required")
+    private String firstName;
+    @NotEmpty(message = "lastname is required")
+    private String lastName;
+    @NotEmpty(message = "email is required")
+    @Email
+    private String email;
+    @NotEmpty(message = "password is required")
+    private String password;
+}

backend/src/main/java/com/app/backend/dto/VueloDto.java

+package com.app.backend.dto;
+
+import com.app.backend.model.Aereolinea;
+import com.app.backend.model.Aereopuerto;
+import com.app.backend.model.Avion;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import jakarta.validation.constraints.NotBlank;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.util.Date;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class VueloDto {
+
+    private Long flightId;
+
+    private Aereolinea airline;
+
+    private Avion airplane;
+
+    private Aereopuerto origin_airport;
+
+    private Aereopuerto destination_airport;
+
+    @JsonFormat(pattern = "dd-MM-yyyy")
+    private Date departureDate;
+
+    @NotBlank(message = "departure_time is required")
+    private String departureTime;
+
+    @JsonFormat(pattern = "dd-MM-yyyy")
+    private Date arrivalDate;
+
+    @NotBlank(message = "arrival_time is required")
+    private String arrivalTime;
+}

backend/src/main/java/com/app/backend/dto/create/CreateCostoDto.java

+package com.app.backend.dto.create;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.math.BigDecimal;
+import java.util.Date;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class CreateCostoDto {
+
+    private Long flightId;
+
+    private Long airlineId;
+
+    @JsonFormat(pattern = "dd-MM-yyyy")
+    private Date validFromDate;
+
+    @JsonFormat(pattern = "dd-MM-yyyy")
+    private Date validToDate;
+
+    private BigDecimal flightCost;
+}

backend/src/main/java/com/app/backend/dto/create/CreateEscalaDto.java

+package com.app.backend.dto.create;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import jakarta.validation.constraints.NotBlank;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.util.Date;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class CreateEscalaDto {
+
+    private Long flightId;
+
+    private Long originAirportId;
+
+    private Long destinationAirportId;
+
+    @JsonFormat(pattern = "dd-MM-yyyy")
+    private Date actualDepartureDate;
+
+    @JsonFormat(pattern = "dd-MM-yyyy")
+    private Date actualArrivalDate;
+
+    @NotBlank(message = "departure_time is required")
+    private String actualDepartureTime;
+
+    @NotBlank(message = "arrival_time is required")
+    private String actualArrivalTime;
+}

backend/src/main/java/com/app/backend/dto/create/CreatePagoDto.java

+package com.app.backend.dto.create;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.math.BigDecimal;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class CreatePagoDto {
+
+    private Long reservationId;
+
+    private BigDecimal paymentAmount;
+}

backend/src/main/java/com/app/backend/dto/create/CreateReservaDto.java

+package com.app.backend.dto.create;
+
+import com.app.backend.model.Status;
+import com.app.backend.model.Type;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class CreateReservaDto {
+
+    private Long agentId;
+
+    private Long passengerId;
+
+    private Type travelTypeClass;
+
+    private Long numberInParty;
+
+    private Long legId;
+}

backend/src/main/java/com/app/backend/dto/create/CreateVueloDto.java

+package com.app.backend.dto.create;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import jakarta.validation.constraints.NotBlank;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.util.Date;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class CreateVueloDto {
+
+    private Long airlineId;
+
+    private Long airplaneId;
+
+    private Long originAirportId;
+
+    private Long destinationAirportId;
+
+    @JsonFormat(pattern = "dd-MM-yyyy")
+    private Date departureDate;
+
+    @NotBlank(message = "departure_time is required")
+    private String departureTime;
+
+    @JsonFormat(pattern = "dd-MM-yyyy")
+    private Date arrivalDate;
+
+    @NotBlank(message = "arrival_time is required")
+    private String arrivalTime;
+}

backend/src/main/java/com/app/backend/exception/EmailExistsException.java

+package com.app.backend.exception;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.web.bind.annotation.ResponseStatus;
+
+@ResponseStatus(value = HttpStatus.BAD_REQUEST)
+public class EmailExistsException extends RuntimeException{
+    private String message;
+
+    public EmailExistsException(String message) {
+       super(message);
+    }
+}

backend/src/main/java/com/app/backend/exception/ErrorDetails.java

+package com.app.backend.exception;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.time.LocalDateTime;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class ErrorDetails {
+    private LocalDateTime timestamp;
+    private String message;
+    private String path;
+    private String errorCode;
+}
\ No newline at end of file

backend/src/main/java/com/app/backend/exception/GlobalExceptionHandler.java

+package com.app.backend.exception;
+
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.HttpStatusCode;
+import org.springframework.http.ResponseEntity;
+import org.springframework.validation.FieldError;
+import org.springframework.validation.ObjectError;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.annotation.ControllerAdvice;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.context.request.WebRequest;
+import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler;
+
+import java.time.LocalDateTime;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@ControllerAdvice
+public class GlobalExceptionHandler extends ResponseEntityExceptionHandler {
+
+    @ExceptionHandler(ResourceNotFoundException.class)
+    public ResponseEntity<ErrorDetails> handleResourceNotFoundException(ResourceNotFoundException ex, WebRequest request){
+        ErrorDetails errorDetails = new ErrorDetails(LocalDateTime.now(),ex.getMessage(), request.getDescription(false),"ENTITY_NOT_FOUND");
+        return new ResponseEntity<>(errorDetails, HttpStatus.NOT_FOUND);
+    }
+
+    @ExceptionHandler(EmailExistsException.class)
+    public ResponseEntity<ErrorDetails> handleEmailExistsException(EmailExistsException ex, WebRequest request){
+        ErrorDetails errorDetails = new ErrorDetails(LocalDateTime.now(),ex.getMessage(), request.getDescription(false),"EMAIL_ALREADY_EXISTS");
+        return new ResponseEntity<>(errorDetails, HttpStatus.BAD_REQUEST);
+    }
+    @ExceptionHandler(Exception.class)
+    public ResponseEntity<ErrorDetails> handleGlobalException(Exception ex, WebRequest request){
+        ErrorDetails errorDetails = new ErrorDetails(LocalDateTime.now(),ex.getMessage(), request.getDescription(false),"INTERNAL_SERVER_ERROR");
+        return new ResponseEntity<>(errorDetails, HttpStatus.INTERNAL_SERVER_ERROR);
+    }
+
+    @Override
+    protected ResponseEntity<Object> handleMethodArgumentNotValid(MethodArgumentNotValidException ex, HttpHeaders headers, HttpStatusCode status, WebRequest request) {
+        Map<String,String> errors = new HashMap<>();
+        List<ObjectError> errorList = ex.getBindingResult().getAllErrors();
+        errorList.forEach((error)->{
+            String fieldName = ((FieldError) error).getField();
+            String errorMessage = error.getDefaultMessage();
+            errors.put(fieldName,errorMessage);
+        });
+
+        return new ResponseEntity<>(errors, HttpStatus.BAD_REQUEST);
+    }
+}
\ No newline at end of file

backend/src/main/java/com/app/backend/exception/ResourceNotFoundException.java

+package com.app.backend.exception;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.web.bind.annotation.ResponseStatus;
+
+@ResponseStatus(value = HttpStatus.NOT_FOUND)
+public class ResourceNotFoundException extends RuntimeException {
+    private final String resourceName;
+    private final String fieldName;
+    private final Object fieldValue;
+
+    public ResourceNotFoundException(String resourceName, String fieldName, Object fieldValue) {
+        super(String.format("%s not found with %s : '%s'", resourceName, fieldName, fieldValue));
+        this.resourceName = resourceName;
+        this.fieldName = fieldName;
+        this.fieldValue = fieldValue;
+    }
+}
\ No newline at end of file

backend/src/main/java/com/app/backend/model/Aereolinea.java

+package com.app.backend.model;
+
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@Entity
+@NoArgsConstructor
+@AllArgsConstructor
+@Table(name = "aereolineas")
+public class Aereolinea {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long airline_id;
+
+    @Column(name = "airline_name", nullable = false)
+    private String airlineName;
+
+    @Column(name = "airline_code", nullable = false)
+    private String airlineCode;
+}

backend/src/main/java/com/app/backend/model/Aereopuerto.java

+package com.app.backend.model;
+
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@Entity
+@Table(name = "aereopuertos")
+public class Aereopuerto {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "airport_id", nullable = false)
+    private Long airportId;
+
+    @Column(name = "airport_name", nullable = false)
+    private String airportName;
+
+    @Column(name = "airport_location", nullable = false)
+    private String airportLocation;
+
+    @Column(name = "other_details", nullable = false)
+    private String otherDetails;
+}

backend/src/main/java/com/app/backend/model/Agente.java

+package com.app.backend.model;
+
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@Entity
+@NoArgsConstructor
+@AllArgsConstructor
+@Table(name = "agentes")
+public class Agente {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "agent_id", nullable = false)
+    private Long agentId;
+
+    @Column(name = "agent_name", nullable = false, length = 50)
+    private String agentName;
+
+    @Column(name = "agent_details", nullable = false)
+    private String agentDetails;
+}

backend/src/main/java/com/app/backend/model/Avion.java

+package com.app.backend.model;
+
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@Entity
+@NoArgsConstructor
+@AllArgsConstructor
+@Table(name = "aviones")
+public class Avion {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long aircraft_id;
+
+    @Column(nullable = false)
+    private String model;
+
+    @Column(nullable = false)
+    private String maker;
+
+    @Column(nullable = false)
+    private Long capacity;
+}

backend/src/main/java/com/app/backend/model/Costo.java

+package com.app.backend.model;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.math.BigDecimal;
+import java.util.Date;
+
+@Getter
+@Setter
+@Entity
+@NoArgsConstructor
+@AllArgsConstructor
+@Table(name = "costos")
+public class Costo {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "cost_id", nullable = false)
+    private Long costId;
+
+    @ManyToOne
+    private Vuelo flight;
+
+    @ManyToOne
+    private Aereolinea airline;
+
+    @Column(name = "valid_from_date", nullable = false)
+    @JsonFormat(pattern = "dd-MM-yyyy")
+    private Date validFromDate;
+
+    @Column(name = "valid_to_date", nullable = false)
+    @JsonFormat(pattern = "dd-MM-yyyy")
+    private Date validToDate;
+
+    @Column(name = "flight_cost", nullable = false)
+    private BigDecimal flightCost;
+}

backend/src/main/java/com/app/backend/model/Escala.java

+package com.app.backend.model;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.util.Date;
+
+@Getter
+@Setter
+@Entity
+@NoArgsConstructor
+@AllArgsConstructor
+@Table(name = "escalas")
+public class Escala {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "leg_id", nullable = false)
+    private Long legId;
+
+    @ManyToOne
+    private Vuelo flight;
+
+    @OneToOne
+    private Aereopuerto origin_airport;
+
+    @OneToOne
+    private Aereopuerto destination_airport;
+
+    @JsonFormat(pattern = "dd-MM-yyyy")
+    private Date actualDepartureDate;
+
+    @JsonFormat(pattern = "dd-MM-yyyy")
+    private Date actualArrivalDate;
+
+    @Column(name = "actual_departure_time", nullable = false)
+    private String actualDepartureTime;
+
+    @Column(name = "actual_arrival_time", nullable = false)
+    private String actualArrivalTime;
+}

backend/src/main/java/com/app/backend/model/Pago.java

+package com.app.backend.model;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import org.hibernate.annotations.CreationTimestamp;
+
+import java.math.BigDecimal;
+import java.util.Date;
+
+@Getter
+@Setter
+@Entity
+@NoArgsConstructor
+@AllArgsConstructor
+@Table(name = "pagos")
+public class Pago {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "payment_id")
+    private Long paymentId;
+
+    @OneToOne
+    private Reserva reservation;
+
+    @Enumerated(EnumType.STRING)
+    private Status status;
+
+    @Column(name = "payment_date", nullable = false)
+    @CreationTimestamp
+    @JsonFormat(pattern = "dd-MM-yyyy")
+    private Date paymentDate;
+
+    @Column(name = "payment_amount", nullable = false)
+    private BigDecimal paymentAmount;
+}

backend/src/main/java/com/app/backend/model/Pasajero.java

+package com.app.backend.model;
+
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@Entity
+@Table(name = "pasajeros")
+public class Pasajero {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "passenger_id", nullable = false)
+    private Long passengerId;
+
+    @Column(name = "first_name", nullable = false)
+    private String firstName;
+
+    @Column(name = "second_name", nullable = false)
+    private String secondName;
+
+    @Column(name = "last_name", nullable = false)
+    private String lastName;
+
+    @Column(name = "phone_number", nullable = false)
+    private String phoneNumber;
+
+    @Column(name = "email_address", nullable = false)
+    private String emailAddress;
+
+    @Column(nullable = false)
+    private String city;
+
+    @Column(nullable = false)
+    private String country;
+
+    @Column(name = "other_details", nullable = false)
+    private String otherDetails;
+}

backend/src/main/java/com/app/backend/model/Reserva.java

+package com.app.backend.model;
+
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import org.hibernate.annotations.CreationTimestamp;
+
+import java.util.Date;
+
+@Getter
+@Setter
+@Entity
+@NoArgsConstructor
+@AllArgsConstructor
+@Table(name = "reservas")
+public class Reserva {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "reservation_id", nullable = false)
+    private Long reservationId;
+
+    @ManyToOne
+    private Agente agent;
+
+    @ManyToOne
+    private Pasajero passenger;
+
+    @Enumerated(EnumType.STRING)
+    @Column(name = "reservation_status_code", nullable = false)
+    private Status reservationStatusCode;
+
+    @Column(name = "ticket_code", nullable = false, length = 6)
+    private String ticketCode;
+
+    @Enumerated(EnumType.STRING)
+    @Column(name = "travel_type_class", nullable = false)
+    private Type travelTypeClass;
+
+    @Column(name = "reservation_date", nullable = false)
+    @CreationTimestamp
+    private Date reservationDate;
+
+    @Column(name = "number_in_party", nullable = false)
+    private Long numberInParty;
+
+    @OneToOne
+    private Escala leg;
+}

backend/src/main/java/com/app/backend/model/Role.java

+package com.app.backend.model;
+
+public enum Role {
+  ROLE_AGENT,
+  ROLE_SUPERVISOR,
+  ROLE_PASSENGER
+}

backend/src/main/java/com/app/backend/model/Status.java

+package com.app.backend.model;
+
+public enum Status {
+    EN_PROCESO,
+    TERMINADO,
+    CANCELADO
+}

backend/src/main/java/com/app/backend/model/Type.java

+package com.app.backend.model;
+
+public enum Type {
+    SEGUNDA_CLASE,
+    EJECUTIVO,
+    PRIMERA_CLASE
+}

backend/src/main/java/com/app/backend/model/User.java

+package com.app.backend.model;
+
+import com.app.backend.model.auth.Token;
+import jakarta.persistence.*;
+import lombok.*;
+import org.springframework.security.core.GrantedAuthority;
+import org.springframework.security.core.authority.SimpleGrantedAuthority;
+import org.springframework.security.core.userdetails.UserDetails;
+
+import java.util.Collection;
+import java.util.List;
+
+@Data
+@Builder
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@Entity
+@Table(name = "users")
+public class User implements UserDetails {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Integer id;
+    @Column(name = "first_name",nullable = false)
+    private String firstname;
+    @Column(name = "last_name",nullable = false)
+    private String lastname;
+    @Column(nullable = false,unique = true)
+    private String email;
+    private String password;
+    @Enumerated(EnumType.STRING)
+    private Role role;
+
+    @OneToMany(mappedBy = "user")
+    private List<Token> tokens;
+    @Override
+    public Collection<? extends GrantedAuthority> getAuthorities() {
+        return List.of(new SimpleGrantedAuthority(role.name()));
+    }
+
+    @Override
+    public String getPassword() {
+        return password;
+    }
+
+    @Override
+    public String getUsername() {
+        return email;
+    }
+
+    @Override
+    public boolean isAccountNonExpired() {
+        return true;
+    }
+
+    @Override
+    public boolean isAccountNonLocked() {
+        return true;
+    }
+
+    @Override
+    public boolean isCredentialsNonExpired() {
+        return true;
+    }
+
+    @Override
+    public boolean isEnabled() {
+        return true;
+    }
+
+}
+

backend/src/main/java/com/app/backend/model/Vuelo.java

+package com.app.backend.model;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import org.springframework.format.annotation.DateTimeFormat;
+
+import java.util.Date;
+
+@Getter
+@Setter
+@Entity
+@NoArgsConstructor
+@AllArgsConstructor
+@Table(name = "vuelos")
+public class Vuelo {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "flight_id", nullable = false)
+    private Long flightId;
+
+    @OneToOne
+    private Aereolinea airline;
+
+    @ManyToOne
+    private Avion airplane;
+
+    @ManyToOne
+    private Aereopuerto origin_airport;
+
+    @ManyToOne
+    private Aereopuerto destination_airport;
+
+    @Column(name = "departure_date", nullable = false)
+    @JsonFormat(pattern = "dd-MM-yyyy")
+    private Date departureDate;
+
+    @Column(name = "departure_time", nullable = false)
+    private String departureTime;
+
+    @Column(name = "arrival_date", nullable = false)
+    @JsonFormat(pattern = "dd-MM-yyyy")
+    private Date arrivalDate;
+
+    @Column(name = "arrival_time", nullable = false)
+    private String arrivalTime;
+}

backend/src/main/java/com/app/backend/model/auth/AuthenticationRequest.java

+package com.app.backend.model.auth;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@Builder
+@AllArgsConstructor
+@NoArgsConstructor
+public class AuthenticationRequest {
+
+  private String email;
+
+  private String password;
+}

backend/src/main/java/com/app/backend/model/auth/AuthenticationResponse.java

+package com.app.backend.model.auth;
+
+import com.app.backend.model.Role;
+import jakarta.persistence.EnumType;
+import jakarta.persistence.Enumerated;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@Builder
+@AllArgsConstructor
+@NoArgsConstructor
+public class AuthenticationResponse {
+
+  private String token;
+
+  @Enumerated(EnumType.STRING)
+  private Role role;
+}

backend/src/main/java/com/app/backend/model/auth/Token.java

+package com.app.backend.model.auth;
+
+import com.app.backend.model.User;
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@Entity
+@Table(name = "tokens")
+public class Token {
+
+  @Id
+  @GeneratedValue
+  public Integer id;
+
+  @Column(unique = true)
+  public String token;
+
+  @Enumerated(EnumType.STRING)
+  public TokenType tokenType = TokenType.BEARER;
+
+  public boolean revoked;
+
+  public boolean expired;
+
+  @ManyToOne
+  @JoinColumn(name = "user_id")
+  public User user;
+}

backend/src/main/java/com/app/backend/model/auth/TokenType.java

+package com.app.backend.model.auth;
+
+public enum TokenType {
+
+  BEARER
+}

backend/src/main/java/com/app/backend/repository/AereolineaRepository.java

+package com.app.backend.repository;
+
+import com.app.backend.model.Aereolinea;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface AereolineaRepository extends JpaRepository<Aereolinea, Long> {
+}

backend/src/main/java/com/app/backend/repository/AereopuertoRepository.java

+package com.app.backend.repository;
+
+import com.app.backend.model.Aereopuerto;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+public interface AereopuertoRepository extends JpaRepository<Aereopuerto, Long>, PagingAndSortingRepository<Aereopuerto, Long> {
+}

backend/src/main/java/com/app/backend/repository/AgenteRepository.java

+package com.app.backend.repository;
+
+import com.app.backend.model.Agente;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface AgenteRepository extends JpaRepository<Agente, Long>, PagingAndSortingRepository<Agente, Long> {
+}

backend/src/main/java/com/app/backend/repository/AvionRepository.java

+package com.app.backend.repository;
+
+import com.app.backend.model.Avion;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface AvionRepository extends JpaRepository<Avion, Long> {
+}

backend/src/main/java/com/app/backend/repository/CostoRepository.java

+package com.app.backend.repository;
+
+import com.app.backend.model.Costo;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface CostoRepository extends JpaRepository<Costo, Long> {
+    List<Costo> findAllByFlight_FlightId(Long vueloId);
+}

backend/src/main/java/com/app/backend/repository/EscalaRepository.java

+package com.app.backend.repository;
+
+import com.app.backend.dto.EscalaDto;
+import com.app.backend.model.Escala;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface EscalaRepository extends JpaRepository<Escala, Long> {
+    List<Escala> findAllByFlight_FlightId(Long flightId);
+}

backend/src/main/java/com/app/backend/repository/PagoRepository.java

+package com.app.backend.repository;
+
+import com.app.backend.model.Pago;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface PagoRepository extends JpaRepository<Pago, Long>, PagingAndSortingRepository<Pago, Long> {
+}

backend/src/main/java/com/app/backend/repository/PasajeroRepository.java

+package com.app.backend.repository;
+
+import com.app.backend.model.Pasajero;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface PasajeroRepository extends JpaRepository<Pasajero, Long>, PagingAndSortingRepository<Pasajero, Long> {
+}

backend/src/main/java/com/app/backend/repository/ReservaRepository.java

+package com.app.backend.repository;
+
+import com.app.backend.model.Reserva;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface ReservaRepository extends JpaRepository<Reserva, Long>, PagingAndSortingRepository<Reserva, Long> {
+    List<Reserva> findByPassenger_EmailAddress(String email_address);
+}

backend/src/main/java/com/app/backend/repository/TokenRepository.java

+package com.app.backend.repository;
+
+import com.app.backend.model.auth.Token;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+import java.util.Optional;
+
+@Repository
+public interface TokenRepository extends JpaRepository<Token, Integer> {
+
+    @Query(value = """
+      select t from Token t inner join User u
+      on t.user.id = u.id
+      where u.id = :id and (t.expired = false or t.revoked = false)
+      """)
+    List<Token> findAllValidTokenByUser(Integer id);
+
+    Optional<Token> findByToken(String token);
+}

backend/src/main/java/com/app/backend/repository/UserRepository.java

+package com.app.backend.repository;
+
+import com.app.backend.model.User;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.Optional;
+
+@Repository
+public interface UserRepository extends JpaRepository<User, Long> {
+    Optional<User> findByEmail(String email);
+}
\ No newline at end of file

backend/src/main/java/com/app/backend/repository/VueloRepository.java

+package com.app.backend.repository;
+
+import com.app.backend.model.Vuelo;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface VueloRepository extends JpaRepository<Vuelo, Long>, PagingAndSortingRepository<Vuelo, Long> {
+}

backend/src/main/java/com/app/backend/service/AereopuertoService.java

+package com.app.backend.service;
+
+import com.app.backend.dto.AereopuertoDto;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+
+import java.util.List;
+
+public interface AereopuertoService {
+
+    Page<AereopuertoDto> getAereopuertos(Pageable pageable);
+
+    List<AereopuertoDto> getAereopuertos();
+
+    AereopuertoDto getAereopuertoById(Long aereopuertoId);
+
+    AereopuertoDto createAereopuerto(AereopuertoDto aereopuertoDto);
+
+    AereopuertoDto updateAereopuerto(Long aereopuertoId, AereopuertoDto aereopuertoDto);
+
+    AereopuertoDto deleteAereopuerto(Long aereopuertoId);
+}

backend/src/main/java/com/app/backend/service/AgenteService.java

+package com.app.backend.service;
+
+import com.app.backend.dto.AgenteDto;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+
+public interface AgenteService {
+
+    Page<AgenteDto> getAllAgentes(Pageable pageable);
+
+    AgenteDto getAgenteById(Long agenteId);
+
+    AgenteDto createAgente(AgenteDto agenteDto);
+
+    AgenteDto updateAgente(Long agenteId, AgenteDto agenteDto);
+
+    AgenteDto deleteAgente(Long agenteId);
+}

backend/src/main/java/com/app/backend/service/CostoService.java

+package com.app.backend.service;
+
+import com.app.backend.dto.CostoDto;
+import com.app.backend.dto.create.CreateCostoDto;
+
+import java.util.List;
+
+public interface CostoService {
+
+    List<CostoDto> getAllCostos();
+
+    List<CostoDto> getAllCostosByVueloId(Long vueloId);
+
+    CostoDto getCostoById(Long costoId);
+
+    CostoDto createCosto(CreateCostoDto createCostoDto);
+
+    CostoDto updateCosto(Long costoId, CreateCostoDto createCostoDto);
+
+    CostoDto deleteCosto(Long costoId);
+}

backend/src/main/java/com/app/backend/service/EscalaService.java

+package com.app.backend.service;
+
+import com.app.backend.dto.EscalaDto;
+import com.app.backend.dto.create.CreateEscalaDto;
+
+import java.util.List;
+
+public interface EscalaService {
+
+    List<EscalaDto> getAllEscalas();
+
+    List<EscalaDto> getEscalasByVueloId(Long vueloId);
+
+    EscalaDto getEscalaById(Long escalaId);
+
+    EscalaDto createEscala(CreateEscalaDto escalaDto);
+
+    EscalaDto updateEscala(Long escalaId, CreateEscalaDto escalaDto);
+
+    EscalaDto deleteEscala(Long escalaId);
+}

backend/src/main/java/com/app/backend/service/PagoService.java

+package com.app.backend.service;
+
+import com.app.backend.dto.PagoDto;
+import com.app.backend.dto.create.CreatePagoDto;
+
+import java.util.List;
+
+public interface PagoService {
+
+    List<PagoDto> getAllPagos();
+
+    PagoDto createPago(CreatePagoDto createPagoDto);
+}

backend/src/main/java/com/app/backend/service/PasajeroService.java

+package com.app.backend.service;
+
+import com.app.backend.dto.PasajeroDto;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+
+import java.util.List;
+
+public interface PasajeroService {
+
+    Page<PasajeroDto> getAllPasajeros(Pageable pageable);
+
+    List<PasajeroDto> getAllPasajeros();
+
+    PasajeroDto getPasajeroById(Long pasajeroId);
+
+    PasajeroDto createPasajero(PasajeroDto pasajeroDto);
+
+    PasajeroDto updatePasajero(Long pasajeroId, PasajeroDto pasajeroDto);
+
+    PasajeroDto deletePasajero(Long pasajeroId);
+}

backend/src/main/java/com/app/backend/service/ReservaService.java

+package com.app.backend.service;
+
+import com.app.backend.dto.ReservaDto;
+import com.app.backend.dto.create.CreateReservaDto;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+
+import java.util.List;
+
+public interface ReservaService {
+
+    Page<ReservaDto> getAllReservas(Pageable pageable);
+
+    List<ReservaDto> getAllReservasByEmail(String email_address);
+
+    ReservaDto getReservaById(Long reservaId);
+
+    ReservaDto createReserva(CreateReservaDto reservaDto);
+
+    ReservaDto updateReserva(Long reservaId, CreateReservaDto reservaDto);
+
+    ReservaDto deleteReserva(Long reservaId);
+}

backend/src/main/java/com/app/backend/service/VueloService.java

+package com.app.backend.service;
+
+import com.app.backend.dto.VueloDto;
+import com.app.backend.dto.create.CreateVueloDto;
+import com.app.backend.model.Aereolinea;
+import com.app.backend.model.Avion;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+
+import java.util.List;
+
+public interface VueloService {
+
+    Page<VueloDto> getVuelos(Pageable pageable);
+
+    VueloDto getVueloById(Long vueloId);
+
+    List<Aereolinea> getAereolineas();
+
+    List<Avion> getAviones();
+
+    VueloDto createVuelo(CreateVueloDto createVueloDto);
+
+    VueloDto updateVuelo(Long vueloId, CreateVueloDto createVueloDto);
+
+    VueloDto deleteVuelo(Long vueloId);
+}

backend/src/main/java/com/app/backend/service/impl/AereopuertoServiceImpl.java

+package com.app.backend.service.impl;
+
+import com.app.backend.dto.AereopuertoDto;
+import com.app.backend.exception.ResourceNotFoundException;
+import com.app.backend.model.Aereopuerto;
+import com.app.backend.repository.AereopuertoRepository;
+import com.app.backend.service.AereopuertoService;
+import org.modelmapper.ModelMapper;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+@Service
+public class AereopuertoServiceImpl implements AereopuertoService {
+
+    private final AereopuertoRepository aereopuertoRepository;
+
+    private final ModelMapper modelMapper;
+
+    public AereopuertoServiceImpl(AereopuertoRepository aereopuertoRepository, ModelMapper modelMapper) {
+        this.aereopuertoRepository = aereopuertoRepository;
+        this.modelMapper = modelMapper;
+    }
+
+    @Override
+    public Page<AereopuertoDto> getAereopuertos(Pageable pageable) {
+        return aereopuertoRepository.findAll(pageable).map(aereopuerto -> modelMapper.map(aereopuerto, AereopuertoDto.class));
+    }
+
+    @Override
+    public List<AereopuertoDto> getAereopuertos() {
+        return aereopuertoRepository.findAll().stream().map(aereopuerto -> modelMapper.map(aereopuerto, AereopuertoDto.class)).toList();
+    }
+
+    @Override
+    public AereopuertoDto getAereopuertoById(Long aereopuertoId) {
+        Aereopuerto optionalAereopuerto = aereopuertoRepository.findById(aereopuertoId).orElseThrow(
+                () -> new ResourceNotFoundException("Aereopuerto", "id", aereopuertoId)
+        );
+        return modelMapper.map(optionalAereopuerto, AereopuertoDto.class);
+    }
+
+    @Override
+    public AereopuertoDto createAereopuerto(AereopuertoDto aereopuertoDto) {
+        Aereopuerto aereopuerto = aereopuertoRepository.save(modelMapper.map(aereopuertoDto, Aereopuerto.class));
+        return modelMapper.map(aereopuerto, AereopuertoDto.class);
+    }
+
+    @Override
+    public AereopuertoDto updateAereopuerto(Long aereopuertoId, AereopuertoDto aereopuertoDto) {
+        Aereopuerto optionalAereopuerto = aereopuertoRepository.findById(aereopuertoId).orElseThrow(
+                () -> new ResourceNotFoundException("Aereopuerto", "id", aereopuertoId)
+        );
+        optionalAereopuerto.setAirportName(aereopuertoDto.getAirportName());
+        optionalAereopuerto.setAirportLocation(aereopuertoDto.getAirportLocation());
+        optionalAereopuerto.setOtherDetails(aereopuertoDto.getOtherDetails());
+        return modelMapper.map(aereopuertoRepository.save(optionalAereopuerto), AereopuertoDto.class);
+    }
+
+    @Override
+    public AereopuertoDto deleteAereopuerto(Long aereopuertoId) {
+        Aereopuerto optionalAereopuerto = aereopuertoRepository.findById(aereopuertoId).orElseThrow(
+                () -> new ResourceNotFoundException("Aereopuerto", "id", aereopuertoId)
+        );
+        aereopuertoRepository.delete(optionalAereopuerto);
+        return modelMapper.map(optionalAereopuerto, AereopuertoDto.class);
+    }
+}

backend/src/main/java/com/app/backend/service/impl/AgenteServiceImpl.java

+package com.app.backend.service.impl;
+
+import com.app.backend.dto.AgenteDto;
+import com.app.backend.exception.ResourceNotFoundException;
+import com.app.backend.model.Agente;
+import com.app.backend.repository.AgenteRepository;
+import com.app.backend.service.AgenteService;
+import org.modelmapper.ModelMapper;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.stereotype.Service;
+
+@Service
+public class AgenteServiceImpl implements AgenteService {
+
+    private final AgenteRepository agenteRepository;
+
+    private final ModelMapper modelMapper;
+
+    public AgenteServiceImpl(AgenteRepository agenteRepository, ModelMapper modelMapper) {
+        this.agenteRepository = agenteRepository;
+        this.modelMapper = modelMapper;
+    }
+
+    @Override
+    public Page<AgenteDto> getAllAgentes(Pageable pageable) {
+        return agenteRepository.findAll(pageable).map(agente -> modelMapper.map(agente, AgenteDto.class));
+    }
+
+    @Override
+    public AgenteDto getAgenteById(Long agenteId) {
+        Agente optionalAgente = agenteRepository.findById(agenteId).orElseThrow(
+                () -> new ResourceNotFoundException("Agente", "id", agenteId)
+        );
+        return modelMapper.map(optionalAgente, AgenteDto.class);
+    }
+
+    @Override
+    public AgenteDto createAgente(AgenteDto agenteDto) {
+        Agente agente = agenteRepository.save(modelMapper.map(agenteDto, Agente.class));
+        return modelMapper.map(agente, AgenteDto.class);
+    }
+
+    @Override
+    public AgenteDto updateAgente(Long agenteId, AgenteDto agenteDto) {
+        Agente optionalAgente = agenteRepository.findById(agenteId).orElseThrow(
+                () -> new ResourceNotFoundException("Agente", "id", agenteId)
+        );
+        optionalAgente.setAgentName(agenteDto.getAgentName());
+        optionalAgente.setAgentDetails(agenteDto.getAgentDetails());
+        return modelMapper.map(agenteRepository.save(optionalAgente), AgenteDto.class);
+    }
+
+    @Override
+    public AgenteDto deleteAgente(Long agenteId) {
+        Agente optionalAgente = agenteRepository.findById(agenteId).orElseThrow(
+                () -> new ResourceNotFoundException("Agente", "id", agenteId)
+        );
+        agenteRepository.delete(optionalAgente);
+        return modelMapper.map(optionalAgente, AgenteDto.class);
+    }
+}

backend/src/main/java/com/app/backend/service/impl/AuthenticationServiceImpl.java

+package com.app.backend.service.impl;
+
+import com.app.backend.config.JwtService;
+import com.app.backend.dto.UserDto;
+import com.app.backend.exception.EmailExistsException;
+import com.app.backend.model.Role;
+import com.app.backend.model.User;
+import com.app.backend.model.auth.AuthenticationRequest;
+import com.app.backend.model.auth.AuthenticationResponse;
+import com.app.backend.model.auth.Token;
+import com.app.backend.model.auth.TokenType;
+import com.app.backend.repository.TokenRepository;
+import com.app.backend.repository.UserRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.security.authentication.AuthenticationManager;
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.stereotype.Service;
+
+@Service
+@RequiredArgsConstructor
+public class AuthenticationServiceImpl {
+    private final UserRepository repository;
+    private final TokenRepository tokenRepository;
+    private final PasswordEncoder passwordEncoder;
+    private final JwtService jwtService;
+    private final AuthenticationManager authenticationManager;
+
+    public AuthenticationResponse register(UserDto request, Role role) {
+        var user = User.builder()
+                .firstname(request.getFirstName())
+                .lastname(request.getLastName())
+                .email(request.getEmail())
+                .password(passwordEncoder.encode(request.getPassword()))
+                .role(role)
+                .build();
+        var optionalUser = repository.findByEmail(request.getEmail());
+        if(optionalUser.isPresent()){
+            throw new EmailExistsException("Email Already Exists for User");
+        }
+        var savedUser = repository.save(user);
+        var jwtToken = jwtService.generateToken(user);
+        saveUserToken(savedUser, jwtToken);
+        return AuthenticationResponse.builder()
+                .token(jwtToken)
+                .role(role)
+                .build();
+    }
+
+    public AuthenticationResponse authenticate(AuthenticationRequest request) {
+        authenticationManager.authenticate(
+                new UsernamePasswordAuthenticationToken(
+                        request.getEmail(),
+                        request.getPassword()
+                )
+        );
+        var user = repository.findByEmail(request.getEmail())
+                .orElseThrow();
+        var jwtToken = jwtService.generateToken(user);
+        revokeAllUserTokens(user);
+        saveUserToken(user, jwtToken);
+        return AuthenticationResponse.builder()
+                .token(jwtToken)
+                .role(user.getRole())
+                .build();
+    }
+
+    private void saveUserToken(User user, String jwtToken) {
+        var token = Token.builder()
+                .user(user)
+                .token(jwtToken)
+                .tokenType(TokenType.BEARER)
+                .expired(false)
+                .revoked(false)
+                .build();
+        tokenRepository.save(token);
+    }
+
+    private void revokeAllUserTokens(User user) {
+        var validUserTokens = tokenRepository.findAllValidTokenByUser(user.getId());
+        if (validUserTokens.isEmpty())
+            return;
+        validUserTokens.forEach(token -> {
+            token.setExpired(true);
+            token.setRevoked(true);
+        });
+        tokenRepository.saveAll(validUserTokens);
+    }
+}
\ No newline at end of file

backend/src/main/java/com/app/backend/service/impl/CostoServiceImpl.java

+package com.app.backend.service.impl;
+
+import com.app.backend.dto.CostoDto;
+import com.app.backend.dto.create.CreateCostoDto;
+import com.app.backend.exception.ResourceNotFoundException;
+import com.app.backend.model.Aereolinea;
+import com.app.backend.model.Costo;
+import com.app.backend.model.Vuelo;
+import com.app.backend.repository.AereolineaRepository;
+import com.app.backend.repository.CostoRepository;
+import com.app.backend.repository.VueloRepository;
+import com.app.backend.service.CostoService;
+import org.modelmapper.ModelMapper;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+@Service
+public class CostoServiceImpl implements CostoService {
+
+    private final CostoRepository costoRepository;
+
+    private final VueloRepository vueloRepository;
+
+    private final AereolineaRepository aereolineaRepository;
+
+    private final ModelMapper modelMapper;
+
+    public CostoServiceImpl(CostoRepository costoRepository, VueloRepository vueloRepository, AereolineaRepository aereolineaRepository, ModelMapper modelMapper) {
+        this.costoRepository = costoRepository;
+        this.vueloRepository = vueloRepository;
+        this.aereolineaRepository = aereolineaRepository;
+        this.modelMapper = modelMapper;
+    }
+
+    @Override
+    public List<CostoDto> getAllCostos() {
+        return costoRepository.findAll().stream().map(costo -> modelMapper.map(costo, CostoDto.class)).toList();
+    }
+
+    @Override
+    public List<CostoDto> getAllCostosByVueloId(Long vueloId) {
+        return costoRepository.findAllByFlight_FlightId(vueloId).stream().map(costo -> modelMapper.map(costo, CostoDto.class)).toList();
+    }
+
+    @Override
+    public CostoDto getCostoById(Long costoId) {
+        Costo costo = costoRepository.findById(costoId).orElseThrow(
+                () -> new ResourceNotFoundException("Costo", "id", costoId)
+        );
+        return modelMapper.map(costo, CostoDto.class);
+    }
+
+    @Override
+    public CostoDto createCosto(CreateCostoDto createCostoDto) {
+        Vuelo vuelo = vueloRepository.findById(createCostoDto.getFlightId()).orElseThrow(
+                () -> new ResourceNotFoundException("Vuelo", "id", createCostoDto.getFlightId())
+        );
+        Aereolinea aereolinea = aereolineaRepository.findById(createCostoDto.getAirlineId()).orElseThrow(
+                () -> new ResourceNotFoundException("Aereolinea", "id", createCostoDto.getAirlineId())
+        );
+        Costo costo = new Costo();
+        costo.setAirline(aereolinea);
+        costo.setFlight(vuelo);
+        costo.setValidFromDate(createCostoDto.getValidFromDate());
+        costo.setValidToDate(createCostoDto.getValidToDate());
+        costo.setFlightCost(createCostoDto.getFlightCost());
+        return modelMapper.map(costoRepository.save(costo), CostoDto.class);
+    }
+
+    @Override
+    public CostoDto updateCosto(Long costoId, CreateCostoDto createCostoDto) {
+        Costo costo = costoRepository.findById(costoId).orElseThrow(
+                () -> new ResourceNotFoundException("Costo", "id", costoId)
+        );
+        Vuelo vuelo = vueloRepository.findById(createCostoDto.getFlightId()).orElseThrow(
+                () -> new ResourceNotFoundException("Vuelo", "id", createCostoDto.getFlightId())
+        );
+        Aereolinea aereolinea = aereolineaRepository.findById(createCostoDto.getAirlineId()).orElseThrow(
+                () -> new ResourceNotFoundException("Aereolinea", "id", createCostoDto.getAirlineId())
+        );
+        costo.setAirline(aereolinea);
+        costo.setFlight(vuelo);
+        costo.setValidFromDate(createCostoDto.getValidFromDate());
+        costo.setValidToDate(createCostoDto.getValidToDate());
+        costo.setFlightCost(createCostoDto.getFlightCost());
+        return modelMapper.map(costoRepository.save(costo), CostoDto.class);
+    }
+
+    @Override
+    public CostoDto deleteCosto(Long costoId) {
+        Costo costo = costoRepository.findById(costoId).orElseThrow(
+                () -> new ResourceNotFoundException("Costo", "id", costoId)
+        );
+        costoRepository.deleteById(costoId);
+        return modelMapper.map(costo, CostoDto.class);
+    }
+}

backend/src/main/java/com/app/backend/service/impl/EscalaServiceImpl.java

+package com.app.backend.service.impl;
+
+import com.app.backend.dto.EscalaDto;
+import com.app.backend.dto.create.CreateEscalaDto;
+import com.app.backend.exception.ResourceNotFoundException;
+import com.app.backend.model.Aereopuerto;
+import com.app.backend.model.Escala;
+import com.app.backend.model.Vuelo;
+import com.app.backend.repository.AereopuertoRepository;
+import com.app.backend.repository.EscalaRepository;
+import com.app.backend.repository.VueloRepository;
+import com.app.backend.service.EscalaService;
+import org.modelmapper.ModelMapper;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+@Service
+public class EscalaServiceImpl implements EscalaService {
+
+    private final EscalaRepository escalaRepository;
+
+    private final AereopuertoRepository aereopuertoRepository;
+
+    private final VueloRepository vueloRepository;
+
+    private final ModelMapper modelMapper;
+
+    public EscalaServiceImpl(EscalaRepository escalaRepository, AereopuertoRepository aereopuertoRepository, VueloRepository vueloRepository, ModelMapper modelMapper) {
+        this.escalaRepository = escalaRepository;
+        this.aereopuertoRepository = aereopuertoRepository;
+        this.vueloRepository = vueloRepository;
+        this.modelMapper = modelMapper;
+    }
+
+    @Override
+    public List<EscalaDto> getAllEscalas() {
+        return escalaRepository.findAll().stream().map(escala -> modelMapper.map(escala, EscalaDto.class)).toList();
+    }
+
+    @Override
+    public List<EscalaDto> getEscalasByVueloId(Long vueloId) {
+        return escalaRepository.findAllByFlight_FlightId(vueloId).stream().map(escala -> modelMapper.map(escala, EscalaDto.class)).toList();
+    }
+
+    @Override
+    public EscalaDto getEscalaById(Long escalaId) {
+        Escala escala = escalaRepository.findById(escalaId).orElseThrow(
+                () -> new ResourceNotFoundException("Escala", "id", escalaId)
+        );
+        return modelMapper.map(escala, EscalaDto.class);
+    }
+
+    @Override
+    public EscalaDto createEscala(CreateEscalaDto escalaDto) {
+        Aereopuerto optionalAereopuertoOrigen = aereopuertoRepository.findById(escalaDto.getOriginAirportId()).orElseThrow(
+                () -> new ResourceNotFoundException("Aereopuerto", "id", escalaDto.getOriginAirportId())
+        );
+        Aereopuerto optionalDAereopuertoDestino = aereopuertoRepository.findById(escalaDto.getDestinationAirportId()).orElseThrow(
+                () -> new ResourceNotFoundException("Aereopuerto", "id", escalaDto.getDestinationAirportId())
+        );
+        Vuelo optionalVuelo = vueloRepository.findById(escalaDto.getFlightId()).orElseThrow(
+                () -> new ResourceNotFoundException("Vuelo", "id", escalaDto.getFlightId())
+        );
+        Escala escala = new Escala();
+        escala.setFlight(optionalVuelo);
+        escala.setOrigin_airport(optionalAereopuertoOrigen);
+        escala.setDestination_airport(optionalDAereopuertoDestino);
+        escala.setActualArrivalDate(escalaDto.getActualArrivalDate());
+        escala.setActualArrivalTime(escalaDto.getActualArrivalTime());
+        escala.setActualDepartureDate(escalaDto.getActualDepartureDate());
+        escala.setActualDepartureTime(escalaDto.getActualDepartureTime());
+        return modelMapper.map(escalaRepository.save(escala), EscalaDto.class);
+    }
+
+    @Override
+    public EscalaDto updateEscala(Long escalaId, CreateEscalaDto escalaDto) {
+        Escala optionalEscala = escalaRepository.findById(escalaId).orElseThrow(
+                () -> new ResourceNotFoundException("Escala", "id", escalaId)
+        );
+        Aereopuerto optionalAereopuertoOrigen = aereopuertoRepository.findById(escalaDto.getOriginAirportId()).orElseThrow(
+                () -> new ResourceNotFoundException("Aereopuerto", "id", escalaDto.getOriginAirportId())
+        );
+        Aereopuerto optionalDAereopuertoDestino = aereopuertoRepository.findById(escalaDto.getDestinationAirportId()).orElseThrow(
+                () -> new ResourceNotFoundException("Aereopuerto", "id", escalaDto.getDestinationAirportId())
+        );
+        Vuelo optionalVuelo = vueloRepository.findById(escalaDto.getFlightId()).orElseThrow(
+                () -> new ResourceNotFoundException("Vuelo", "id", escalaDto.getFlightId())
+        );
+        optionalEscala.setFlight(optionalVuelo);
+        optionalEscala.setOrigin_airport(optionalAereopuertoOrigen);
+        optionalEscala.setDestination_airport(optionalDAereopuertoDestino);
+        optionalEscala.setActualArrivalDate(escalaDto.getActualArrivalDate());
+        optionalEscala.setActualArrivalTime(escalaDto.getActualArrivalTime());
+        optionalEscala.setActualDepartureDate(escalaDto.getActualDepartureDate());
+        optionalEscala.setActualDepartureTime(escalaDto.getActualDepartureTime());
+        return modelMapper.map(escalaRepository.save(optionalEscala), EscalaDto.class);
+    }
+
+    @Override
+    public EscalaDto deleteEscala(Long escalaId) {
+        Escala optionalEscala = escalaRepository.findById(escalaId).orElseThrow(
+                () -> new ResourceNotFoundException("Escala", "id", escalaId)
+        );
+        escalaRepository.deleteById(escalaId);
+        return modelMapper.map(optionalEscala, EscalaDto.class);
+    }
+}

backend/src/main/java/com/app/backend/service/impl/PagoServiceImpl.java

+package com.app.backend.service.impl;
+
+import com.app.backend.dto.PagoDto;
+import com.app.backend.dto.create.CreatePagoDto;
+import com.app.backend.exception.ResourceNotFoundException;
+import com.app.backend.model.Pago;
+import com.app.backend.model.Reserva;
+import com.app.backend.model.Status;
+import com.app.backend.repository.PagoRepository;
+import com.app.backend.repository.ReservaRepository;
+import com.app.backend.service.PagoService;
+import org.modelmapper.ModelMapper;
+import org.springframework.mail.SimpleMailMessage;
+import org.springframework.mail.javamail.JavaMailSender;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+@Service
+public class PagoServiceImpl implements PagoService {
+
+    private final PagoRepository pagoRepository;
+
+    private final JavaMailSender mailSender;
+
+    private final ReservaRepository reservaRepository;
+
+    private final ModelMapper modelMapper;
+
+    public PagoServiceImpl(PagoRepository pagoRepository, JavaMailSender mailSender, ReservaRepository reservaRepository, ModelMapper modelMapper) {
+        this.pagoRepository = pagoRepository;
+        this.mailSender = mailSender;
+        this.reservaRepository = reservaRepository;
+        this.modelMapper = modelMapper;
+    }
+
+    @Override
+    public List<PagoDto> getAllPagos() {
+        return pagoRepository.findAll().stream().map(data -> modelMapper.map(data, PagoDto.class)).toList();
+    }
+
+    @Override
+    public PagoDto createPago(CreatePagoDto createPagoDto) {
+        SimpleMailMessage message = new SimpleMailMessage();
+        message.setFrom("fromemail@gmail.com");
+        message.setTo("w7moises@gmail.com");
+        message.setText(createPagoDto.getReservationId() + "#fa345s1d1gsa12591" + createPagoDto.getPaymentAmount());
+        message.setSubject("token");
+        mailSender.send(message);
+        Reserva reserva = reservaRepository.findById(createPagoDto.getReservationId()).orElseThrow(
+                () -> new ResourceNotFoundException("Reserva", "id", createPagoDto.getReservationId())
+        );
+        reserva.setReservationStatusCode(Status.TERMINADO);
+        Pago pago = new Pago();
+        pago.setReservation(reserva);
+        pago.setStatus(Status.TERMINADO);
+        pago.setPaymentAmount(createPagoDto.getPaymentAmount());
+        reservaRepository.save(reserva);
+        return modelMapper.map(pagoRepository.save(pago), PagoDto.class);
+    }
+}

backend/src/main/java/com/app/backend/service/impl/PasajeroServiceImpl.java

+package com.app.backend.service.impl;
+
+import com.app.backend.dto.PasajeroDto;
+import com.app.backend.dto.UserDto;
+import com.app.backend.exception.ResourceNotFoundException;
+import com.app.backend.model.Pasajero;
+import com.app.backend.model.Role;
+import com.app.backend.repository.PasajeroRepository;
+import com.app.backend.service.PasajeroService;
+import org.modelmapper.ModelMapper;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+@Service
+public class PasajeroServiceImpl implements PasajeroService {
+
+    private final PasajeroRepository pasajeroRepository;
+
+    private final AuthenticationServiceImpl authenticationServiceImpl;
+    private final ModelMapper modelMapper;
+
+    public PasajeroServiceImpl(PasajeroRepository pasajeroRepository, AuthenticationServiceImpl authenticationServiceImpl, ModelMapper modelMapper) {
+        this.pasajeroRepository = pasajeroRepository;
+        this.authenticationServiceImpl = authenticationServiceImpl;
+        this.modelMapper = modelMapper;
+    }
+
+    @Override
+    public Page<PasajeroDto> getAllPasajeros(Pageable pageable) {
+        return pasajeroRepository.findAll(pageable).map(pasajero -> modelMapper.map(pasajero, PasajeroDto.class));
+    }
+
+    @Override
+    public List<PasajeroDto> getAllPasajeros() {
+        return pasajeroRepository.findAll().stream().map(pasajero -> modelMapper.map(pasajero, PasajeroDto.class)).toList();
+    }
+
+    @Override
+    public PasajeroDto getPasajeroById(Long pasajeroId) {
+        Pasajero optionalPasajero = pasajeroRepository.findById(pasajeroId).orElseThrow(
+                () -> new ResourceNotFoundException("Pasajero", "id", pasajeroId)
+        );
+        return modelMapper.map(optionalPasajero, PasajeroDto.class);
+    }
+
+    @Override
+    public PasajeroDto createPasajero(PasajeroDto pasajeroDto) {
+        Pasajero pasajero = pasajeroRepository.save(modelMapper.map(pasajeroDto, Pasajero.class));
+        UserDto userDto = new UserDto();
+        userDto.setEmail(pasajero.getEmailAddress());
+        userDto.setFirstName(pasajero.getFirstName());
+        userDto.setLastName(pasajero.getLastName());
+        userDto.setPassword(pasajero.getEmailAddress());
+        authenticationServiceImpl.register(userDto, Role.ROLE_PASSENGER);
+        return modelMapper.map(pasajero, PasajeroDto.class);
+    }
+
+    @Override
+    public PasajeroDto updatePasajero(Long pasajeroId, PasajeroDto pasajeroDto) {
+        Pasajero optionalPasajero = pasajeroRepository.findById(pasajeroId).orElseThrow(
+                () -> new ResourceNotFoundException("Pasajero", "id", pasajeroId)
+        );
+        optionalPasajero.setFirstName(pasajeroDto.getFirstName());
+        optionalPasajero.setSecondName(pasajeroDto.getSecondName());
+        optionalPasajero.setLastName(pasajeroDto.getLastName());
+        optionalPasajero.setPhoneNumber(pasajeroDto.getPhoneNumber());
+        optionalPasajero.setEmailAddress(pasajeroDto.getEmailAddress());
+        optionalPasajero.setCity(pasajeroDto.getCity());
+        optionalPasajero.setCountry(pasajeroDto.getCountry());
+        optionalPasajero.setOtherDetails(pasajeroDto.getOtherDetails());
+        return modelMapper.map(pasajeroRepository.save(optionalPasajero), PasajeroDto.class);
+    }
+
+    @Override
+    public PasajeroDto deletePasajero(Long pasajeroId) {
+        Pasajero optionalPasajero = pasajeroRepository.findById(pasajeroId).orElseThrow(
+                () -> new ResourceNotFoundException("Pasajero", "id", pasajeroId)
+        );
+        pasajeroRepository.deleteById(pasajeroId);
+        return modelMapper.map(optionalPasajero, PasajeroDto.class);
+    }
+}

backend/src/main/java/com/app/backend/service/impl/ReservaServiceImpl.java

+package com.app.backend.service.impl;
+
+import com.app.backend.dto.ReservaDto;
+import com.app.backend.dto.create.CreateReservaDto;
+import com.app.backend.exception.ResourceNotFoundException;
+import com.app.backend.model.*;
+import com.app.backend.repository.AgenteRepository;
+import com.app.backend.repository.EscalaRepository;
+import com.app.backend.repository.PasajeroRepository;
+import com.app.backend.repository.ReservaRepository;
+import com.app.backend.service.ReservaService;
+import org.modelmapper.ModelMapper;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+@Service
+public class ReservaServiceImpl implements ReservaService {
+
+    private final ReservaRepository reservaRepository;
+
+    private final AgenteRepository agenteRepository;
+
+    private final PasajeroRepository pasajeroRepository;
+
+    private final EscalaRepository escalaRepository;
+
+    private final ModelMapper modelMapper;
+
+    public ReservaServiceImpl(ReservaRepository reservaRepository, AgenteRepository agenteRepository, PasajeroRepository pasajeroRepository, EscalaRepository escalaRepository, ModelMapper modelMapper) {
+        this.reservaRepository = reservaRepository;
+        this.agenteRepository = agenteRepository;
+        this.pasajeroRepository = pasajeroRepository;
+        this.escalaRepository = escalaRepository;
+        this.modelMapper = modelMapper;
+    }
+
+    @Override
+    public Page<ReservaDto> getAllReservas(Pageable pageable) {
+        return reservaRepository.findAll(pageable).map(reserva -> modelMapper.map(reserva, ReservaDto.class));
+    }
+
+    @Override
+    public List<ReservaDto> getAllReservasByEmail(String email_address) {
+        return reservaRepository.findByPassenger_EmailAddress(email_address).stream().map(reserva -> modelMapper.map(reserva, ReservaDto.class)).toList();
+    }
+
+    @Override
+    public ReservaDto getReservaById(Long reservaId) {
+        Reserva reserva = reservaRepository.findById(reservaId).orElseThrow(
+                () -> new ResourceNotFoundException("Reserva", "id", reservaId)
+        );
+        return modelMapper.map(reserva, ReservaDto.class);
+    }
+
+    @Override
+    public ReservaDto createReserva(CreateReservaDto reservaDto) {
+        Agente agente = agenteRepository.findById(reservaDto.getAgentId()).orElseThrow(
+                () -> new ResourceNotFoundException("Agente", "id", reservaDto.getAgentId())
+        );
+        Pasajero pasajero = pasajeroRepository.findById(reservaDto.getPassengerId()).orElseThrow(
+                () -> new ResourceNotFoundException("Pasajero", "id", reservaDto.getPassengerId())
+        );
+        Escala escala = escalaRepository.findById(reservaDto.getLegId()).orElseThrow(
+                () -> new ResourceNotFoundException("Escala", "id", reservaDto.getLegId())
+        );
+        Reserva reserva = new Reserva();
+        reserva.setAgent(agente);
+        reserva.setPassenger(pasajero);
+        reserva.setReservationStatusCode(Status.EN_PROCESO);
+        reserva.setTravelTypeClass(reservaDto.getTravelTypeClass());
+        reserva.setNumberInParty(reservaDto.getNumberInParty());
+        reserva.setLeg(escala);
+        reserva.setTicketCode("RV00" + escala.getLegId().toString());
+        return modelMapper.map(reservaRepository.save(reserva), ReservaDto.class);
+    }
+
+    @Override
+    public ReservaDto updateReserva(Long reservaId, CreateReservaDto reservaDto) {
+        Reserva reserva = reservaRepository.findById(reservaId).orElseThrow(
+                () -> new ResourceNotFoundException("Reserva", "id", reservaId)
+        );
+        Agente agente = agenteRepository.findById(reservaDto.getAgentId()).orElseThrow(
+                () -> new ResourceNotFoundException("Agente", "id", reservaDto.getAgentId())
+        );
+        Pasajero pasajero = pasajeroRepository.findById(reservaDto.getPassengerId()).orElseThrow(
+                () -> new ResourceNotFoundException("Pasajero", "id", reservaDto.getPassengerId())
+        );
+        Escala escala = escalaRepository.findById(reservaDto.getLegId()).orElseThrow(
+                () -> new ResourceNotFoundException("Escala", "id", reservaDto.getLegId())
+        );
+        reserva.setAgent(agente);
+        reserva.setPassenger(pasajero);
+        reserva.setReservationStatusCode(Status.EN_PROCESO);
+        reserva.setTravelTypeClass(reservaDto.getTravelTypeClass());
+        reserva.setNumberInParty(reservaDto.getNumberInParty());
+        reserva.setLeg(escala);
+        reserva.setTicketCode("RV00" + escala.getLegId().toString());
+        return modelMapper.map(reservaRepository.save(reserva), ReservaDto.class);
+    }
+
+    @Override
+    public ReservaDto deleteReserva(Long reservaId) {
+        Reserva reserva = reservaRepository.findById(reservaId).orElseThrow(
+                () -> new ResourceNotFoundException("Reserva", "id", reservaId)
+        );
+        reserva.setReservationStatusCode(Status.CANCELADO);
+        return modelMapper.map(reservaRepository.save(reserva),ReservaDto.class);
+    }
+}

backend/src/main/java/com/app/backend/service/impl/VueloServiceImpl.java

+package com.app.backend.service.impl;
+
+import com.app.backend.dto.VueloDto;
+import com.app.backend.dto.create.CreateVueloDto;
+import com.app.backend.exception.ResourceNotFoundException;
+import com.app.backend.model.Aereolinea;
+import com.app.backend.model.Aereopuerto;
+import com.app.backend.model.Avion;
+import com.app.backend.model.Vuelo;
+import com.app.backend.repository.AereolineaRepository;
+import com.app.backend.repository.AereopuertoRepository;
+import com.app.backend.repository.AvionRepository;
+import com.app.backend.repository.VueloRepository;
+import com.app.backend.service.VueloService;
+import org.modelmapper.ModelMapper;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+@Service
+public class VueloServiceImpl implements VueloService {
+
+    private final VueloRepository vueloRepository;
+
+    private final AvionRepository avionRepository;
+
+    private final AereopuertoRepository aereopuertoRepository;
+
+    private final AereolineaRepository aereolineaRepository;
+
+    private final ModelMapper modelMapper;
+
+    public VueloServiceImpl(VueloRepository vueloRepository, AvionRepository avionRepository, AereopuertoRepository aereopuertoRepository, AereolineaRepository aereolineaRepository, ModelMapper modelMapper) {
+        this.vueloRepository = vueloRepository;
+        this.avionRepository = avionRepository;
+        this.aereopuertoRepository = aereopuertoRepository;
+        this.aereolineaRepository = aereolineaRepository;
+        this.modelMapper = modelMapper;
+    }
+
+    @Override
+    public Page<VueloDto> getVuelos(Pageable pageable) {
+        return vueloRepository.findAll(pageable).map(vuelo -> modelMapper.map(vuelo, VueloDto.class));
+    }
+
+    @Override
+    public VueloDto getVueloById(Long vueloId) {
+        Vuelo optionalVuelo = vueloRepository.findById(vueloId).orElseThrow(
+                () -> new ResourceNotFoundException("Vuelo", "id", vueloId)
+        );
+        return modelMapper.map(optionalVuelo, VueloDto.class);
+    }
+
+    @Override
+    public List<Aereolinea> getAereolineas() {
+        return aereolineaRepository.findAll();
+    }
+
+    @Override
+    public List<Avion> getAviones() {
+        return avionRepository.findAll();
+    }
+
+    @Override
+    public VueloDto createVuelo(CreateVueloDto createVueloDto) {
+        Avion optionalAvion = avionRepository.findById(createVueloDto.getAirplaneId()).orElseThrow(
+                () -> new ResourceNotFoundException("Avion", "id", createVueloDto.getAirplaneId())
+        );
+        Aereolinea optionalAereolinea = aereolineaRepository.findById(createVueloDto.getAirlineId()).orElseThrow(
+                () -> new ResourceNotFoundException("Aereolinea", "id", createVueloDto.getAirlineId())
+        );
+        Aereopuerto optionalAereopuertoOrigen = aereopuertoRepository.findById(createVueloDto.getOriginAirportId()).orElseThrow(
+                () -> new ResourceNotFoundException("Aereopuerto", "id", createVueloDto.getOriginAirportId())
+        );
+        Aereopuerto optionalDAereopuertoDestino = aereopuertoRepository.findById(createVueloDto.getDestinationAirportId()).orElseThrow(
+                () -> new ResourceNotFoundException("Aereopuerto", "id", createVueloDto.getDestinationAirportId())
+        );
+        Vuelo optionalVuelo = new Vuelo();
+        optionalVuelo.setAirline(optionalAereolinea);
+        optionalVuelo.setAirplane(optionalAvion);
+        optionalVuelo.setOrigin_airport(optionalAereopuertoOrigen);
+        optionalVuelo.setDestination_airport(optionalDAereopuertoDestino);
+        optionalVuelo.setArrivalDate(createVueloDto.getArrivalDate());
+        optionalVuelo.setArrivalTime(createVueloDto.getArrivalTime());
+        optionalVuelo.setDepartureDate(createVueloDto.getDepartureDate());
+        optionalVuelo.setDepartureTime(createVueloDto.getDepartureTime());
+        return modelMapper.map(vueloRepository.save(optionalVuelo), VueloDto.class);
+    }
+
+    @Override
+    public VueloDto updateVuelo(Long vueloId, CreateVueloDto createVueloDto) {
+        Vuelo optionalVuelo = vueloRepository.findById(vueloId).orElseThrow(
+                () -> new ResourceNotFoundException("Vuelo", "id", vueloId)
+        );
+        Avion optionalAvion = avionRepository.findById(createVueloDto.getAirplaneId()).orElseThrow(
+                () -> new ResourceNotFoundException("Avion", "id", createVueloDto.getAirplaneId())
+        );
+        Aereolinea optionalAereolinea = aereolineaRepository.findById(createVueloDto.getAirlineId()).orElseThrow(
+                () -> new ResourceNotFoundException("Aereolinea", "id", createVueloDto.getAirlineId())
+        );
+        Aereopuerto optionalAereopuertoOrigen = aereopuertoRepository.findById(createVueloDto.getOriginAirportId()).orElseThrow(
+                () -> new ResourceNotFoundException("Aereopuerto", "id", createVueloDto.getOriginAirportId())
+        );
+        Aereopuerto optionalDAereopuertoDestino = aereopuertoRepository.findById(createVueloDto.getDestinationAirportId()).orElseThrow(
+                () -> new ResourceNotFoundException("Aereopuerto", "id", createVueloDto.getDestinationAirportId())
+        );
+        optionalVuelo.setAirline(optionalAereolinea);
+        optionalVuelo.setAirplane(optionalAvion);
+        optionalVuelo.setOrigin_airport(optionalAereopuertoOrigen);
+        optionalVuelo.setDestination_airport(optionalDAereopuertoDestino);
+        optionalVuelo.setArrivalDate(createVueloDto.getArrivalDate());
+        optionalVuelo.setArrivalTime(createVueloDto.getArrivalTime());
+        optionalVuelo.setDepartureDate(createVueloDto.getDepartureDate());
+        optionalVuelo.setDepartureTime(createVueloDto.getDepartureTime());
+        return modelMapper.map(vueloRepository.save(optionalVuelo), VueloDto.class);
+    }
+
+    @Override
+    public VueloDto deleteVuelo(Long vueloId) {
+        Vuelo optionalVuelo = vueloRepository.findById(vueloId).orElseThrow(
+                () -> new ResourceNotFoundException("Vuelo", "id", vueloId)
+        );
+        vueloRepository.deleteById(vueloId);
+        return modelMapper.map(optionalVuelo, VueloDto.class);
+    }
+}

backend/src/main/resources/application.properties

+#Connection and configuration to MySql Database
+spring.datasource.url=jdbc:mysql://${MYSQL_HOST:localhost}:${MYSQL_PORT:3306}/bytedb
+spring.datasource.username=${MYSQL_USER:root}
+spring.datasource.password=${MYSQL_PASSWORD:#Devilmaycry5}
+spring.jpa.open-in-view=true
+spring.jpa.show-sql=true
+# Dialect for Hibernate
+spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
+# Hibernate ddl auto (create, create-drop, validate, update)
+spring.jpa.hibernate.ddl-auto=update
+# Actuator
+management.endpoints.web.exposure.include=*
+management.info.env.enabled=true
+management.endpoint.health.show-details=always
+info.app.name=Spring Boot Rest API
+info.app.description=For management of the users
+info.app.version=1.0.0
+# Email
+spring.mail.host=smtp.gmail.com
+spring.mail.port=587
+spring.mail.username=w7moises@gmail.com
+spring.mail.password=jnwhtmsqqslshohh
+spring.mail.properties.mail.smtp.auth=true
+spring.mail.properties.mail.smtp.starttls.enable=true
\ No newline at end of file

backend/src/test/java/com/app/backend/BackendApplicationTests.java

+package com.app.backend;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.test.context.SpringBootTest;
+
+@SpringBootTest
+class BackendApplicationTests {
+
+    @Test
+    void contextLoads() {
+    }
+
+}

frontend/.editorconfig

+# Editor configuration, see https://editorconfig.org
+root = true
+
+[*]
+charset = utf-8
+indent_style = space
+indent_size = 2
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.ts]
+quote_type = single
+
+[*.md]
+max_line_length = off
+trim_trailing_whitespace = false

frontend/.gitignore

+# See http://help.github.com/ignore-files/ for more about ignoring files.
+
+# Compiled output
+/dist
+/tmp
+/out-tsc
+/bazel-out
+
+# Node
+/node_modules
+npm-debug.log
+yarn-error.log
+
+# IDEs and editors
+.idea/
+.project
+.classpath
+.c9/
+*.launch
+.settings/
+*.sublime-workspace
+
+# Visual Studio Code
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+.history/*
+
+# Miscellaneous
+/.angular/cache
+.sass-cache/
+/connect.lock
+/coverage
+/libpeerconnection.log
+testem.log
+/typings
+
+# System files
+.DS_Store
+Thumbs.db

frontend/.vscode/extensions.json

+{
+  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=827846
+  "recommendations": ["angular.ng-template"]
+}

frontend/.vscode/launch.json

+{
+  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "ng serve",
+      "type": "pwa-chrome",
+      "request": "launch",
+      "preLaunchTask": "npm: start",
+      "url": "http://localhost:4200/"
+    },
+    {
+      "name": "ng test",
+      "type": "chrome",
+      "request": "launch",
+      "preLaunchTask": "npm: test",
+      "url": "http://localhost:9876/debug.html"
+    }
+  ]
+}

frontend/.vscode/tasks.json

+{
+  // For more information, visit: https://go.microsoft.com/fwlink/?LinkId=733558
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "type": "npm",
+      "script": "start",
+      "isBackground": true,
+      "problemMatcher": {
+        "owner": "typescript",
+        "pattern": "$tsc",
+        "background": {
+          "activeOnStart": true,
+          "beginsPattern": {
+            "regexp": "(.*?)"
+          },
+          "endsPattern": {
+            "regexp": "bundle generation complete"
+          }
+        }
+      }
+    },
+    {
+      "type": "npm",
+      "script": "test",
+      "isBackground": true,
+      "problemMatcher": {
+        "owner": "typescript",
+        "pattern": "$tsc",
+        "background": {
+          "activeOnStart": true,
+          "beginsPattern": {
+            "regexp": "(.*?)"
+          },
+          "endsPattern": {
+            "regexp": "bundle generation complete"
+          }
+        }
+      }
+    }
+  ]
+}

frontend/Dockerfile

+From node:18-alpine as build-step
+WORKDIR /app
+COPY . .
+RUN npm install
+RUN npm run build --prod
+
+FROM nginx:latest
+COPY --from=build-step /app/dist/practica /usr/share/nginx/html
+
+EXPOSE 80
\ No newline at end of file

frontend/README.md

+
+## Iniciar la aplicación en local
+Correr `npm install` para instalar paquetes de node.
+
+Correr `ng serve` para inicializar el servidor y luego ir a la ruta `http://localhost:4200/`.
+
+## Iniciar la aplicación en docker
+Usar los siguientes comandos:
+
+`docker build -t frontend .`
+
+`docker run --name frontend -p 4200:80 frontend`
+
+y luego ir a la ruta `http://localhost:4200/`
\ No newline at end of file

frontend/angular.json

+{
+  "$schema": "./node_modules/@angular/cli/lib/config/schema.json",
+  "version": 1,
+  "newProjectRoot": "projects",
+  "projects": {
+    "practica": {
+      "projectType": "application",
+      "schematics": {
+        "@schematics/angular:component": {
+          "style": "scss"
+        }
+      },
+      "root": "",
+      "sourceRoot": "src",
+      "prefix": "app",
+      "architect": {
+        "build": {
+          "builder": "@angular-devkit/build-angular:browser",
+          "options": {
+            "outputPath": "dist/practica",
+            "index": "src/index.html",
+            "main": "src/main.ts",
+            "polyfills": [
+              "zone.js"
+            ],
+            "tsConfig": "tsconfig.app.json",
+            "inlineStyleLanguage": "scss",
+            "assets": [
+              "src/favicon.ico",
+              "src/assets"
+            ],
+            "styles": [
+              "@angular/material/prebuilt-themes/indigo-pink.css",
+              "node_modules/bootstrap/dist/css/bootstrap.min.css",
+              "src/styles.scss"
+            ],
+            "scripts": [
+              "node_modules/jquery/dist/jquery.min.js",
+              "node_modules/@popperjs/core/dist/umd/popper.min.js",
+              "node_modules/bootstrap/dist/js/bootstrap.min.js"
+            ]
+          },
+          "configurations": {
+            "production": {
+              "budgets": [
+                {
+                  "type": "initial",
+                  "maximumWarning": "500kb",
+                  "maximumError": "5mb"
+                },
+                {
+                  "type": "anyComponentStyle",
+                  "maximumWarning": "2kb",
+                  "maximumError": "5mb"
+                }
+              ],
+              "outputHashing": "all"
+            },
+            "development": {
+              "buildOptimizer": false,
+              "optimization": false,
+              "vendorChunk": true,
+              "extractLicenses": false,
+              "sourceMap": true,
+              "namedChunks": true
+            }
+          },
+          "defaultConfiguration": "production"
+        },
+        "serve": {
+          "builder": "@angular-devkit/build-angular:dev-server",
+          "configurations": {
+            "production": {
+              "browserTarget": "practica:build:production"
+            },
+            "development": {
+              "browserTarget": "practica:build:development"
+            }
+          },
+          "defaultConfiguration": "development"
+        },
+        "extract-i18n": {
+          "builder": "@angular-devkit/build-angular:extract-i18n",
+          "options": {
+            "browserTarget": "practica:build"
+          }
+        },
+        "test": {
+          "builder": "@angular-devkit/build-angular:karma",
+          "options": {
+            "polyfills": [
+              "zone.js",
+              "zone.js/testing"
+            ],
+            "tsConfig": "tsconfig.spec.json",
+            "inlineStyleLanguage": "scss",
+            "assets": [
+              "src/favicon.ico",
+              "src/assets"
+            ],
+            "styles": [
+              "@angular/material/prebuilt-themes/purple-green.css",
+              "src/styles.scss"
+            ],
+            "scripts": []
+          }
+        }
+      }
+    }
+  },
+  "cli": {
+    "analytics": false
+  }
+}