Skip to content

P
prueba_italika_itzi
Commit 1a9d19a6 authored by itzi Enriquez's avatar itzi Enriquez
Browse files
Options

Examen técnico

parent ef2c05a4
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 1157 additions and 0 deletions
prod-italika/.gitattributes 0 → 100644
View file @ 1a9d19a6
/mvnw text eol=lf
*.cmd text eol=crlf
prod-italika/.gitignore 0 → 100644
View file @ 1a9d19a6
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/
prod-italika/.mvn/wrapper/maven-wrapper.properties 0 → 100644
View file @ 1a9d19a6
# 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
#
# http://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.
wrapperVersion=3.3.2
distributionType=only-script
distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.9.9/apache-maven-3.9.9-bin.zip
prod-italika/mvnw 0 → 100644
View file @ 1a9d19a6
This diff is collapsed.
prod-italika/mvnw.cmd 0 → 100644
View file @ 1a9d19a6
<# : batch portion
@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 http://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 Apache Maven Wrapper startup batch script, version 3.3.2
@REM
@REM Optional ENV vars
@REM MVNW_REPOURL - repo url base for downloading maven distribution
@REM MVNW_USERNAME/MVNW_PASSWORD - user and password for downloading maven
@REM MVNW_VERBOSE - true: enable verbose log; others: silence the output
@REM ----------------------------------------------------------------------------
@IF "%__MVNW_ARG0_NAME__%"=="" (SET __MVNW_ARG0_NAME__=%~nx0)
@SET __MVNW_CMD__=
@SET __MVNW_ERROR__=
@SET __MVNW_PSMODULEP_SAVE=%PSModulePath%
@SET PSModulePath=
@FOR /F "usebackq tokens=1* delims==" %%A IN (`powershell -noprofile "& {$scriptDir='%~dp0'; $script='%__MVNW_ARG0_NAME__%'; icm -ScriptBlock ([Scriptblock]::Create((Get-Content -Raw '%~f0'))) -NoNewScope}"`) DO @(
IF "%%A"=="MVN_CMD" (set __MVNW_CMD__=%%B) ELSE IF "%%B"=="" (echo %%A) ELSE (echo %%A=%%B)
)
@SET PSModulePath=%__MVNW_PSMODULEP_SAVE%
@SET __MVNW_PSMODULEP_SAVE=
@SET __MVNW_ARG0_NAME__=
@SET MVNW_USERNAME=
@SET MVNW_PASSWORD=
@IF NOT "%__MVNW_CMD__%"=="" (%__MVNW_CMD__% %*)
@echo Cannot start maven from wrapper >&2 && exit /b 1
@GOTO :EOF
: end batch / begin powershell #>
$ErrorActionPreference = "Stop"
if ($env:MVNW_VERBOSE -eq "true") {
$VerbosePreference = "Continue"
}
# calculate distributionUrl, requires .mvn/wrapper/maven-wrapper.properties
$distributionUrl = (Get-Content -Raw "$scriptDir/.mvn/wrapper/maven-wrapper.properties" | ConvertFrom-StringData).distributionUrl
if (!$distributionUrl) {
Write-Error "cannot read distributionUrl property in $scriptDir/.mvn/wrapper/maven-wrapper.properties"
}
switch -wildcard -casesensitive ( $($distributionUrl -replace '^.*/','') ) {
"maven-mvnd-*" {
$USE_MVND = $true
$distributionUrl = $distributionUrl -replace '-bin\.[^.]*$',"-windows-amd64.zip"
$MVN_CMD = "mvnd.cmd"
break
}
default {
$USE_MVND = $false
$MVN_CMD = $script -replace '^mvnw','mvn'
break
}
}
# apply MVNW_REPOURL and calculate MAVEN_HOME
# maven home pattern: ~/.m2/wrapper/dists/{apache-maven-<version>,maven-mvnd-<version>-<platform>}/<hash>
if ($env:MVNW_REPOURL) {
$MVNW_REPO_PATTERN = if ($USE_MVND) { "/org/apache/maven/" } else { "/maven/mvnd/" }
$distributionUrl = "$env:MVNW_REPOURL$MVNW_REPO_PATTERN$($distributionUrl -replace '^.*'+$MVNW_REPO_PATTERN,'')"
}
$distributionUrlName = $distributionUrl -replace '^.*/',''
$distributionUrlNameMain = $distributionUrlName -replace '\.[^.]*$','' -replace '-bin$',''
$MAVEN_HOME_PARENT = "$HOME/.m2/wrapper/dists/$distributionUrlNameMain"
if ($env:MAVEN_USER_HOME) {
$MAVEN_HOME_PARENT = "$env:MAVEN_USER_HOME/wrapper/dists/$distributionUrlNameMain"
}
$MAVEN_HOME_NAME = ([System.Security.Cryptography.MD5]::Create().ComputeHash([byte[]][char[]]$distributionUrl) | ForEach-Object {$_.ToString("x2")}) -join ''
$MAVEN_HOME = "$MAVEN_HOME_PARENT/$MAVEN_HOME_NAME"
if (Test-Path -Path "$MAVEN_HOME" -PathType Container) {
Write-Verbose "found existing MAVEN_HOME at $MAVEN_HOME"
Write-Output "MVN_CMD=$MAVEN_HOME/bin/$MVN_CMD"
exit $?
}
if (! $distributionUrlNameMain -or ($distributionUrlName -eq $distributionUrlNameMain)) {
Write-Error "distributionUrl is not valid, must end with *-bin.zip, but found $distributionUrl"
}
# prepare tmp dir
$TMP_DOWNLOAD_DIR_HOLDER = New-TemporaryFile
$TMP_DOWNLOAD_DIR = New-Item -Itemtype Directory -Path "$TMP_DOWNLOAD_DIR_HOLDER.dir"
$TMP_DOWNLOAD_DIR_HOLDER.Delete() | Out-Null
trap {
if ($TMP_DOWNLOAD_DIR.Exists) {
try { Remove-Item $TMP_DOWNLOAD_DIR -Recurse -Force | Out-Null }
catch { Write-Warning "Cannot remove $TMP_DOWNLOAD_DIR" }
}
}
New-Item -Itemtype Directory -Path "$MAVEN_HOME_PARENT" -Force | Out-Null
# Download and Install Apache Maven
Write-Verbose "Couldn't find MAVEN_HOME, downloading and installing it ..."
Write-Verbose "Downloading from: $distributionUrl"
Write-Verbose "Downloading to: $TMP_DOWNLOAD_DIR/$distributionUrlName"
$webclient = New-Object System.Net.WebClient
if ($env:MVNW_USERNAME -and $env:MVNW_PASSWORD) {
$webclient.Credentials = New-Object System.Net.NetworkCredential($env:MVNW_USERNAME, $env:MVNW_PASSWORD)
}
[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
$webclient.DownloadFile($distributionUrl, "$TMP_DOWNLOAD_DIR/$distributionUrlName") | Out-Null
# If specified, validate the SHA-256 sum of the Maven distribution zip file
$distributionSha256Sum = (Get-Content -Raw "$scriptDir/.mvn/wrapper/maven-wrapper.properties" | ConvertFrom-StringData).distributionSha256Sum
if ($distributionSha256Sum) {
if ($USE_MVND) {
Write-Error "Checksum validation is not supported for maven-mvnd. `nPlease disable validation by removing 'distributionSha256Sum' from your maven-wrapper.properties."
}
Import-Module $PSHOME\Modules\Microsoft.PowerShell.Utility -Function Get-FileHash
if ((Get-FileHash "$TMP_DOWNLOAD_DIR/$distributionUrlName" -Algorithm SHA256).Hash.ToLower() -ne $distributionSha256Sum) {
Write-Error "Error: Failed to validate Maven distribution SHA-256, your Maven distribution might be compromised. If you updated your Maven version, you need to update the specified distributionSha256Sum property."
}
}
# unzip and move
Expand-Archive "$TMP_DOWNLOAD_DIR/$distributionUrlName" -DestinationPath "$TMP_DOWNLOAD_DIR" | Out-Null
Rename-Item -Path "$TMP_DOWNLOAD_DIR/$distributionUrlNameMain" -NewName $MAVEN_HOME_NAME | Out-Null
try {
Move-Item -Path "$TMP_DOWNLOAD_DIR/$MAVEN_HOME_NAME" -Destination $MAVEN_HOME_PARENT | Out-Null
} catch {
if (! (Test-Path -Path "$MAVEN_HOME" -PathType Container)) {
Write-Error "fail to move MAVEN_HOME"
}
} finally {
try { Remove-Item $TMP_DOWNLOAD_DIR -Recurse -Force | Out-Null }
catch { Write-Warning "Cannot remove $TMP_DOWNLOAD_DIR" }
}
Write-Output "MVN_CMD=$MAVEN_HOME/bin/$MVN_CMD"
prod-italika/pom.xml 0 → 100644
View file @ 1a9d19a6
<?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.4.4</version>
<relativePath /> <!-- lookup parent from repository -->
</parent>
<groupId>mx.italika</groupId>
<artifactId>demo-test</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>prod-italika</name>
<description>Demo project for Spring Boot</description>
<url />
<licenses>
<license />
</licenses>
<developers>
<developer />
</developers>
<scm>
<connection />
<developerConnection />
<tag />
<url />
</scm>
<properties>
<java.version>21</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-security</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</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.springframework.security</groupId>
<artifactId>spring-security-test</artifactId>
<scope>test</scope>
</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>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt-jackson</artifactId>
<version>0.11.5</version>
<scope>runtime</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<annotationProcessorPaths>
<path>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</path>
</annotationProcessorPaths>
</configuration>
</plugin>
<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>
prod-italika/src/main/java/mx/italika/prod/italika/ProdItalikaApplication.java 0 → 100644
View file @ 1a9d19a6
package mx.italika.prod.italika;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class ProdItalikaApplication {
public static void main(String[] args) {
SpringApplication.run(ProdItalikaApplication.class, args);
}
}
prod-italika/src/main/java/mx/italika/prod/italika/config/JwtAuthFilter.java 0 → 100644
View file @ 1a9d19a6
package mx.italika.prod.italika.config;
import java.io.IOException;
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 jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
@Component
public class JwtAuthFilter extends OncePerRequestFilter {
private final UserDetailsService userDetailsService;
private final JwtService jwtService;
public JwtAuthFilter(UserDetailsService userDetailsService, JwtService jwtService) {
this.userDetailsService = userDetailsService;
this.jwtService = jwtService;
}
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
String authHeader = request.getHeader("Authorization");
String token = null;
String username = null;
if (authHeader != null && authHeader.startsWith("Bearer ")) {
token = authHeader.substring(7);
username = jwtService.extractUsername(token);
}
if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
UserDetails userDetails = userDetailsService.loadUserByUsername(username);
if (jwtService.validateToken(token, userDetails)) {
UsernamePasswordAuthenticationToken authToken = new UsernamePasswordAuthenticationToken(
userDetails,
userDetails.getPassword(),
userDetails.getAuthorities());
authToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
SecurityContextHolder.getContext().setAuthentication(authToken);
}
}
filterChain.doFilter(request, response);
}
}
prod-italika/src/main/java/mx/italika/prod/italika/config/JwtService.java 0 → 100644
View file @ 1a9d19a6
package mx.italika.prod.italika.config;
import java.security.Key;
import java.util.Date;
import java.util.function.Function;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.stereotype.Component;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import io.jsonwebtoken.io.Decoders;
import io.jsonwebtoken.security.Keys;
import mx.italika.prod.italika.model.bean.UsuarioBean;
@Component
public class JwtService {
private static final String SECRET = "5367566859703373367639792F423F452848284D6251655468576D5A71347437";
private static final int TOKEN_VALIDITY = 1800; // 30 minutos
public String generateToken(UsuarioBean bean) {
return Jwts.builder()
.setSubject(bean.getUsername())
.claim("roles", bean.getRoles())
.setIssuedAt(new Date(System.currentTimeMillis()))
.setExpiration(new Date(System.currentTimeMillis() + TOKEN_VALIDITY * 1000))
.signWith(getSignKey(), SignatureAlgorithm.HS256)
.compact();
}
private Claims extractAllClaims(String token) {
return Jwts.parserBuilder().setSigningKey(getSignKey()).build().parseClaimsJws(token).getBody();
}
private Key getSignKey() {
byte[] keyBytes = Decoders.BASE64.decode(SECRET);
return Keys.hmacShaKeyFor(keyBytes);
}
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 boolean validateToken(String token, UserDetails userDetails) {
final String username = extractUsername(token);
return username.equals(userDetails.getUsername()) && !isTokenExpired(token);
}
public boolean validateToken2(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);
}
}
\ No newline at end of file
prod-italika/src/main/java/mx/italika/prod/italika/config/SecurityConfig.java 0 → 100644
View file @ 1a9d19a6
package mx.italika.prod.italika.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.authentication.configuration.AuthenticationConfiguration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
@Configuration
@EnableWebSecurity
public class SecurityConfig {
JwtAuthFilter jwtAuthFilter;
public SecurityConfig(JwtAuthFilter jwtAuthFilter) {
this.jwtAuthFilter = jwtAuthFilter;
}
@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
http.csrf(csrf -> csrf.disable())
.authorizeHttpRequests(
auth -> auth.requestMatchers("/api/public/**","/auth/login").permitAll().anyRequest().authenticated())
.addFilterBefore(jwtAuthFilter, UsernamePasswordAuthenticationFilter.class);
return http.build();
}
@Bean
public AuthenticationManager authenticationManager(AuthenticationConfiguration authenticationConfiguration)
throws Exception {
return authenticationConfiguration.getAuthenticationManager();
}
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
}
prod-italika/src/main/java/mx/italika/prod/italika/controller/LoginController.java 0 → 100644
View file @ 1a9d19a6
package mx.italika.prod.italika.controller;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import mx.italika.prod.italika.model.bean.UsuarioBean;
import mx.italika.prod.italika.service.UsuarioServiceimpl;
/**
* Itzi Enriquez
*/
@RestController
@RequestMapping("/auth")
public class LoginController {
UsuarioServiceimpl usuarioServiceimpl;
public LoginController(UsuarioServiceimpl usuarioServiceimpl) {
this.usuarioServiceimpl = usuarioServiceimpl;
}
@PostMapping(value = "/login", produces = "application/json")
@ResponseBody
public ResponseEntity<?> login(@RequestBody UsuarioBean bean) {
return usuarioServiceimpl.login(bean);
}
}
prod-italika/src/main/java/mx/italika/prod/italika/controller/ProductoController.java 0 → 100644
View file @ 1a9d19a6
package mx.italika.prod.italika.controller;
import java.util.List;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import mx.italika.prod.italika.model.entity.ProductoEntity;
import mx.italika.prod.italika.service.ProductoServiceImpl;
/**
* Itzi Enriquez
*/
@RestController
@RequestMapping("/api/v1/productos")
public class ProductoController {
private ProductoServiceImpl productoService;
public ProductoController(ProductoServiceImpl productoService) {
this.productoService = productoService;
}
@GetMapping
public List<ProductoEntity> listarProductos() {
return productoService.obtenerTodos();
}
@PostMapping("/crear")
public ResponseEntity<String> crearProducto(@RequestBody ProductoEntity producto) {
productoService.crearProducto(producto);
return ResponseEntity.ok("Producto creado exitosamente");
}
@PutMapping("/{id}")
public ResponseEntity<?> actualizarProducto(@PathVariable Long id, @RequestBody ProductoEntity producto) {
return productoService.actualizarProducto(id, producto);
}
@DeleteMapping("/{id}")
public ResponseEntity<?> eliminarProducto(@PathVariable Long id) {
return productoService.eliminarProducto(id);
}
}
\ No newline at end of file
prod-italika/src/main/java/mx/italika/prod/italika/controller/TestController.java 0 → 100644
View file @ 1a9d19a6
package mx.italika.prod.italika.controller;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/api")
public class TestController {
@GetMapping("/public")
public ResponseEntity<String> getPublicData() {
return ResponseEntity.ok("Este endpoint es públic.");
}
}
prod-italika/src/main/java/mx/italika/prod/italika/model/LoginRecord.java 0 → 100644
View file @ 1a9d19a6
package mx.italika.prod.italika.model;
public record LoginRecord(
String token,
String refrestToken) {
}
prod-italika/src/main/java/mx/italika/prod/italika/model/bean/ResponseBean.java 0 → 100644
View file @ 1a9d19a6
package mx.italika.prod.italika.model.bean;
import java.io.Serializable;
public class ResponseBean<T> implements Serializable {
private static final long serialVersionUID = 915183857131405669L;
private String status;
private int code;
private String message;
private T data;
public int getCode() {
return code;
}
public void setCode(int code) {
this.code = code;
}
public String getStatus() {
return status;
}
public ResponseBean() {
super();
}
public ResponseBean(String status, int code, String message) {
super();
this.status = status;
this.code = code;
this.message = message;
}
public ResponseBean(String status, int code, String message, T data) {
super();
this.status = status;
this.code = code;
this.message = message;
this.data = data;
}
public String isStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
}
prod-italika/src/main/java/mx/italika/prod/italika/model/bean/UsuarioBean.java 0 → 100644
View file @ 1a9d19a6
package mx.italika.prod.italika.model.bean;
import java.io.Serializable;
import java.util.Collection;
import java.util.List;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import lombok.Data;
import mx.italika.prod.italika.model.entity.UsuarioEntity;
@Data
public class UsuarioBean implements UserDetails, Serializable {
/**
*
*/
private static final long serialVersionUID = 1L;
private String username;
private String password;
private String rol;
private String nombre;
private String aPaterno;
private String aMaterno;
List<String> roles;
public UsuarioBean(){
super();
}
public UsuarioBean(UsuarioEntity usuarioEntity) {
this.username = usuarioEntity.getUsername();
this.password = usuarioEntity.getPassword();
this.roles = (usuarioEntity.getTblUsuarioRols() != null)
? usuarioEntity.getTblUsuarioRols()
.stream()
.map(role -> role.getIdRol().getNombre())
.toList()
: List.of();
}
@Override
public Collection<? extends GrantedAuthority> getAuthorities() {
if (roles != null) {
return roles.stream()
.map(SimpleGrantedAuthority::new)
.toList();
}
return List.of();
}
@Override
public String getPassword() {
return password;
}
@Override
public String getUsername() {
return username;
}
}
prod-italika/src/main/java/mx/italika/prod/italika/model/entity/PersonaEntity.java 0 → 100644
View file @ 1a9d19a6
package mx.italika.prod.italika.model.entity;
import jakarta.persistence.*;
import lombok.Getter;
import lombok.Setter;
import java.util.LinkedHashSet;
import java.util.Set;
@Getter
@Setter
@Entity
@Table(name = "tbl_persona", schema = "test_db_1")
public class PersonaEntity {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id_persona", nullable = false)
private Integer id;
@Column(name = "nombres")
private String nombres;
@Column(name = "a_paterno")
private String aPaterno;
@Column(name = "a_materno")
private String aMaterno;
@Column(name = "curp")
private String curp;
@Column(name = "direccion")
private String direccion;
@OneToMany
private Set<UsuarioEntity> tblUsuarios = new LinkedHashSet<>();
}
\ No newline at end of file
prod-italika/src/main/java/mx/italika/prod/italika/model/entity/ProductoEntity.java 0 → 100644
View file @ 1a9d19a6
package mx.italika.prod.italika.model.entity;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.NamedStoredProcedureQuery;
import lombok.Data;
@Data
@Entity
@NamedStoredProcedureQuery(
name = "ProductoEntity.obtenerProductos",
procedureName = "sp_obtener_productos",
resultClasses = ProductoEntity.class
)
public class ProductoEntity {
@Id
private Long idProducto;
private String nombre;
private String descripcion;
private Double precio;
private Integer cantidad;
private boolean estatus;
}
prod-italika/src/main/java/mx/italika/prod/italika/model/entity/RolEntity.java 0 → 100644
View file @ 1a9d19a6
package mx.italika.prod.italika.model.entity;
import java.time.Instant;
import java.util.LinkedHashSet;
import java.util.Set;
import org.hibernate.annotations.ColumnDefault;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.OneToMany;
import jakarta.persistence.Table;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@Entity
@Table(name = "c_rol")
public class RolEntity {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id_rol", nullable = false)
private Integer id;
@Column(name = "clave", nullable = false, length = 50)
private String clave;
@Column(name = "nombre", nullable = false, length = 150)
private String nombre;
@ColumnDefault("CURRENT_TIMESTAMP")
@Column(name = "fecha_alta")
private Instant fechaAlta;
@Column(name = "fecha_baja")
private Instant fechaBaja;
@Column(name = "fecha_modifica")
private Instant fechaModifica;
@Column(name = "es_global")
private Boolean esGlobal;
@OneToMany(mappedBy = "idRol")
private Set<UsuarioRolEntity> tblUsuarioRols = new LinkedHashSet<>();
}
\ No newline at end of file
prod-italika/src/main/java/mx/italika/prod/italika/model/entity/UsuarioEntity.java 0 → 100644
View file @ 1a9d19a6
package mx.italika.prod.italika.model.entity;
import jakarta.persistence.*;
import lombok.Getter;
import lombok.Setter;
import java.util.LinkedHashSet;
import java.util.Set;
@Getter
@Setter
@Entity
@Table(name = "tbl_usuario", schema = "test_db_1")
public class UsuarioEntity {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id_usuario", nullable = false)
private Integer id;
@Column(name = "username")
private String username;
@Column(name = "password")
private String password;
@Column(name = "correo")
private String correo;
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "id_persona")
private PersonaEntity idPersona;
@OneToMany(mappedBy = "idUsuario",fetch = FetchType.EAGER )
private Set<UsuarioRolEntity> tblUsuarioRols = new LinkedHashSet<>();
}
\ No newline at end of file
prod-italika/src/main/java/mx/italika/prod/italika/model/entity/UsuarioRolEntity.java 0 → 100644
View file @ 1a9d19a6
package mx.italika.prod.italika.model.entity;
import jakarta.persistence.*;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@Entity
@Table(name = "tbl_usuario_rol")
public class UsuarioRolEntity {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id_ususario_rol", nullable = false)
private Integer id;
@ManyToOne(fetch = FetchType.EAGER)
@JoinColumn(name = "id_rol")
private RolEntity idRol;
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "id_usuario")
private UsuarioEntity idUsuario;
}
\ No newline at end of file
prod-italika/src/main/java/mx/italika/prod/italika/repository/ProductoRepository.java 0 → 100644
View file @ 1a9d19a6
package mx.italika.prod.italika.repository;
import java.util.List;
import java.util.Optional;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.query.Procedure;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;
import mx.italika.prod.italika.model.entity.ProductoEntity;
/**
* Itzi Enriquez
*/
@Transactional
@Repository
public interface ProductoRepository extends JpaRepository<ProductoEntity, Long> {
@Transactional
@Procedure(procedureName = "sp_obtener_productos")
List<ProductoEntity> obtenerTodosLosProductos();
@Procedure(procedureName = "sp_obtener_producto_por_id")
Optional<ProductoEntity> obtenerProductoPorId(Long p_id_producto);
@Procedure(procedureName = "sp_crear_producto")
void crearProducto(String p_nombre, String p_descripcion, Double p_precio, Integer p_cantidad);
@Procedure(procedureName = "sp_actualizar_producto")
void actualizarProducto(Long p_id_producto, String p_nombre, String p_descripcion, Double p_precio, Integer p_cantidad);
@Procedure(procedureName = "sp_eliminar_producto")
void eliminarProducto(Long p_id_producto);
}
\ No newline at end of file
prod-italika/src/main/java/mx/italika/prod/italika/repository/UsuarioRepository.java 0 → 100644
View file @ 1a9d19a6
package mx.italika.prod.italika.repository;
import java.util.Optional;
import org.springframework.data.jpa.repository.JpaRepository;
import mx.italika.prod.italika.model.entity.UsuarioEntity;
public interface UsuarioRepository extends JpaRepository<UsuarioEntity, Integer> {
Optional<UsuarioEntity> findByUsername(String username);
}
prod-italika/src/main/java/mx/italika/prod/italika/service/ProductoServiceImpl.java 0 → 100644
View file @ 1a9d19a6
package mx.italika.prod.italika.service;
import java.util.List;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import mx.italika.prod.italika.model.bean.ResponseBean;
import mx.italika.prod.italika.model.entity.ProductoEntity;
import mx.italika.prod.italika.repository.ProductoRepository;
/**
* Itzi Enriquez
*/
@Service
public class ProductoServiceImpl {
private ProductoRepository productoRepository;
public ProductoServiceImpl(ProductoRepository productoRepository) {
this.productoRepository = productoRepository;
}
@Transactional
public List<ProductoEntity> obtenerTodos() {
return productoRepository.obtenerTodosLosProductos();
}
@Transactional
public void crearProducto(ProductoEntity producto) {
productoRepository.crearProducto(
producto.getNombre(),
producto.getDescripcion(),
producto.getPrecio(),
producto.getCantidad()
);
}
@Transactional
public ResponseEntity<ResponseBean<Object>> actualizarProducto(Long id, ProductoEntity producto) {
try {
return productoRepository.obtenerProductoPorId(id)
.filter(ProductoEntity::isEstatus)
.map(productoEntity -> {
productoRepository.actualizarProducto(
id,
producto.getNombre(),
producto.getDescripcion(),
producto.getPrecio(),
producto.getCantidad()
);
return ResponseEntity.ok(
new ResponseBean<>("success", 200, "Actualización de registro exitosa")
);
})
.orElseGet(() -> ResponseEntity.badRequest().body(new ResponseBean<>("error", 901, "Error: El estatus es falso o producto no encontrado")
));
} catch (Exception e) {
return ResponseEntity.internalServerError().body(
new ResponseBean<>("error", 500, "Error interno del servidor: " + e.getMessage())
);
}
}
@Transactional
public ResponseEntity<ResponseBean<Object>> eliminarProducto(Long id) {
try {
return productoRepository.obtenerProductoPorId(id)
.filter(ProductoEntity::isEstatus)
.map(productoEntity -> {
productoRepository.eliminarProducto(id);
return ResponseEntity.ok(
new ResponseBean<>("success", 200, "El producto fue eliminado exitosamente")
);
})
.orElseGet(() -> ResponseEntity.badRequest().body(
new ResponseBean<>("error", 901, "Error: El estatus es falso o el producto no fue encontrado")
));
} catch (Exception e) {
return ResponseEntity.internalServerError().body(
new ResponseBean<>("error", 500, "Error interno del servidor: " + e.getMessage())
);
}
}
}
\ No newline at end of file
prod-italika/src/main/java/mx/italika/prod/italika/service/UsuarioServiceimpl.java 0 → 100644
View file @ 1a9d19a6
package mx.italika.prod.italika.service;
import org.springframework.http.ResponseEntity;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;
import mx.italika.prod.italika.config.JwtService;
import mx.italika.prod.italika.model.LoginRecord;
import mx.italika.prod.italika.model.bean.ResponseBean;
import mx.italika.prod.italika.model.bean.UsuarioBean;
import mx.italika.prod.italika.model.entity.UsuarioEntity;
import mx.italika.prod.italika.repository.UsuarioRepository;
@Service
public class UsuarioServiceimpl implements UserDetailsService {
private UsuarioRepository usuarioRepository;
JwtService jwtService;
public UsuarioServiceimpl(UsuarioRepository usuarioRepository, JwtService jwtService ) {
this.usuarioRepository = usuarioRepository;
this.jwtService = jwtService;
}
@Override
public UsuarioBean loadUserByUsername(String username) throws UsernameNotFoundException {
UsuarioEntity usuarioEntity = usuarioRepository.findByUsername(username)
.orElseThrow(() -> new UsernameNotFoundException("Usuario no encontrado: " + username));
return new UsuarioBean(usuarioEntity);
}
public ResponseEntity<?> login(UsuarioBean usuarioBean) {
try {
UsuarioBean responseBean = loadUserByUsername(usuarioBean.getUsername());
String token = jwtService.generateToken(responseBean);
LoginRecord loginRecord = new LoginRecord(token, null);
return ResponseEntity.ok(new ResponseBean<>("success", 200, "Inicio de sesión exitoso", loginRecord));
} catch (UsernameNotFoundException e) {
return ResponseEntity.badRequest().body( new ResponseBean<>("error", 901, "Error al iniciar sesión", null));
}
}
}
prod-italika/src/main/resources/application.properties 0 → 100644
View file @ 1a9d19a6
spring.application.name=prod-italika
server.port=7854
#jpa
spring.datasource.url=jdbc:mysql://localhost:3309/italika_db
spring.datasource.username=root
spring.datasource.password=rootpassword
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.jpa.hibernate.use-new-id-generator-mappings=false
spring.jpa.show-sql=true
#log
logging.level.org.springframework.security= ERROR
logging.level.org.springframework.data=ERROR
logging.level.org.hibernate=ERROR
\ No newline at end of file
prod-italika/src/test/java/mx/italika/prod/italika/ProdItalikaApplicationTests.java 0 → 100644
View file @ 1a9d19a6
package mx.italika.prod.italika;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class ProdItalikaApplicationTests {
@Test
void contextLoads() {
}
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment