Josué Leiva - freeCodeCamp.org

%.2f en Python – ¿Que significa?

Josué Leiva — Mon, 31 Jul 2023 00:19:49 +0000

Artículo original: %.2f in Python – What does it Mean?

En Python existen varios métodos para dar formato a los tipos de datos.

El operador de formato %f es usado específicamente para dar formato a valores flotantes (números con decimales)

Podemos utilizar %f para especificar el número de dígitos decimales a ser retornados cuando un número con punto flotante (decimal) es redondeado.

Cómo usar el formateador `%f` en Python

En esta sección, verás algunos ejemplos en cómo usar el formateador %f y los varios parámetros con los que puede ser usado para retornar diversos resultados.

Este es el primer ejemplo:

numero_flotante = 1.9876

print("%f" % numero_flotante)
# 1.987600

El usar %f en el ejemplo de arriba añadió dos ceros al número. Pero no hay nada muy especial sobre ello. Pronto veremos que más podemos hacer para modificar el valor resultante.

Nota que el operador %f debe estar anidado dentro de comillas, y debe estar separado del número flotante al cual está formateando mediante el operador módulo (%): "%f" % numero_flotante.

Veamos otro ejemplo:

numero_flotante = 1.9876
print("%.1f" % numero_flotante)

#2.0

En el código de arriba, hemos añadido .1 entre % y f en el operador %f. Esto significa que queremos redondear el número hasta un dígito decimal.

Nota que obtendrás un resultado similar al primer ejemplo si omites el punto (.) que viene antes del dígito que le entregamos en medio % y f.

El valor resultante en nuestro ejemplo es 2.0 el cual fue retornado cuando 1.9876 fue redondeado a un dígito decimal.

Usemos %.2f y veamos que sucede.

numero_flotante = 1.9876
print("%.2f" % numero_flotante)
# 1.99

Como era de esperarse, el número de punto flotante (1.9876) fue redondeado hasta dos lugares decimales - 1.99. Por lo que %.2f significa redondear a dos espacios decimales.

Puedes jugar con el código para ver que sucede mientras cambias el número en el operador de formato.

Cómo usar el formateador `%d` en Python

Otro método de formateo que podemos usar con números de punto flotante en Python es el formateador %d. Este retorna el número entero en un número de punto flotante.

Aquí hay un ejemplo:

numero_flotante = 1.9876
print("%d" % numero_flotante)
# 1

En el ejemplo de arriba, hemos creado un número de punto flotante: numero_flotante = 1.9876

Cuando la variable numero_flotante es formateada usando %d, solo 1 fue retornado.

El formateador %d ignora los números decimales y solo retorna la parte entera.

Resumen

En este artículo, hablamos sobre el operador de formato %f en Python. Lo utilizas para darle formato a los números flotantes.

Dependiendo en los parámetros entregados, el formateador %f redondea un valor flotante al decimal más cercano provisto.

También hablamos del operador de formato, %d el cual solo retorna el valor entero de un número flotante.

¡Feliz codificación!

Cómo crear APIs seguras con Flask y Auth0

Josué Leiva — Mon, 17 Apr 2023 02:48:05 +0000

Artículo original: How to Build Secure APIs with Flask and Auth0

Las APIs son el corazón del desarrollo moderno. Soportan todo tipo de sistemas, desde móviles, web, y aplicaciones de escritorio, hasta dispositivos IoT y autos autónomos. Son un puente entre tus clientes y la lógica y almacenamiento de tu aplicación.

Este punto central de acceso a la información de tu aplicación plantea la pregunta: ¿Cómo puedes proveer acceso a la información a quienes lo necesitan mientras deniegas el acceso a peticiones no autorizadas?

La industria ha provisto de diversos protocolos y buenas prácticas para asegurar APIs. Hoy nos enfocaremos en OAuth2 (artículo en inglés), una de las opciones más populares para autorizar clientes en nuestras APIs.

Pero ¿cómo implementamos OAuth2? hay dos formas de hacerlo:

La forma DIY (hacerlo tu mismo)
Trabajar con un tercero seguro como Auth0

En este artículo, te guiaré a través de una implementación de OAuth2 para Python y Flask (documentación en inglés) usando Autho como nuestro proveedor de identidad. Pero primero, debemos discutir la forma DIY.

¿Por qué no construir tu propia autenticación y autorización?

Por algunos años ahora, he querido devolver a la comunidad que tanto me ha ayudado al enseñarme programación y ayudarme a progresar en mi búsqueda de conocimiento. Siempre he pensado que una gran forma de contribuir era al tener mi propio blog, algo que he intentado más de algunas veces y fallado.

Pero ¿dónde fallé? En vez de enfocarme en escribir, intenté construir mi propio motor de blog, ya que está en mi naturaleza. Es lo que los desarrolladores hacen. Les encanta construir.

Pero ¿por qué menciono esto aquí? Ya que muchos caen en la misma trampa al momento de construir APIs. Permíteme explicarlo con un ejemplo.

Bob es un gran desarrollador, y él tiene esta gran idea de hacer una app de ToDo (lista de tareas pendientes) que podría ser la siguiente gran app. Bob está en conocimiento de que para una implementación exitosa, los usuarios pueden acceder sólo su propia información.

Esta es la línea de tiempo de la app de Bob:

Sprint 0: Investigar ideas y crear prototipos.
Sprint 1: Construir la tabla de usuarios y vista de inicio de sesión con una API.
Sprint 2: Añadir vistas de reset de contraseñas y construir las plantillas de email
Sprint 3: Construir, crear y listar las vistas de ToDos
Sprint 4: MVP se publica
Retroalimentación de usuarios:
Algunos usuarios no pueden ingresar debido a un bug.
Algunos usuarios se sienten inseguros sin autenticación de 2 factores.
Algunos usuarios no quieren otra contraseña más. Prefieren ingresar usando Google o Facebook.

Hablemos sobre lo que ha pasado. Bob pasó los primeros sprints no construyendo su app pero construyendo los bloques básicos, como las funcionalidades de login, notificaciones de email y así. Este valioso tiempo lo podría haber usado de forma distinta, pero lo que sucede a continuación es más preocupante.

El backlog de Bob se comienza a llenar. Ahora él necesita improvisar un método de autenticación de 2do factor, añadir un ingreso rápido (google) y algunas funciones no relacionadas con el producto que podrían potencialmente retrasar su producto.

Y aún hay una gran pregunta para ser respondida: ¿Implementó Bob todos los mecanismos de seguridad correctamente? Un error crítico podría exponer toda la información de los usuarios a terceros.

Lo que Bob hizo es lo que yo hice en mi blog muchas ocasiones. Algunas veces, es de gran ayuda descansar en terceros si queremos hacer las cosas bien.

Hoy en día, los hackers y ataques se han hecho tan sofisticados que la seguridad ya no es un factor trivial. Es un sistema complicado en sí, y es usualmente mejor dejar esa implementación a expertos - no solo para que se haga bien, sino para que también nos podamos enfocar en lo que importa: construir nuestra aplicación y sus APIs.

Cómo Configurar una Cuenta Gratuita de Administración de Identidades en Auth0

Auth0 es un proveedor líder en autorización y autenticación, pero veamos cómo puede ayudar a Bob (o a tí) a construir una app mejor.

Ahorra tiempo
Es segura
Tiene un plan gratis

Es tiempo de ponerse prácticos. Primero, asegúrate de tener una cuenta Auth0. Sino, puedes crear una aquí gratuitamente.

Crear una nueva API Auth0

Aún hay una cosa que debemos hacer antes de comenzar a programar. Ve a la sección de APIs de tu dashboard en Auth0 y haz click en el botón "Crear API" (Create API). Después de ello, llena el formulario con tus detalles. Sin embargo, asegúrate que selecciones RS256 como Signing Algorithm.

Tu formulario debiera verse así:

Creating the API – image showing fields to fill out

Después de crear un API exitosamente, se abre la página de detalles. Mantén esa pestaña abierta, ya que contiene información que necesitaremos para configurar nuestra aplicación. Si la cierras, no te preocupes, siempre puedes acceder a ella nuevamente.

Cómo impulsar nuestra aplicación

Ya que nos enfocaremos sólo en aspectos de seguridad, tomaremos algunos atajos al construir nuestra demo de API. Sin embargo, cuando desarrolles APIs reales (artículo en inglés), por favor sigue las mejores prácticas para APIs Flask (artículo en inglés).

Instalar las dependencias

Primero, instala las siguientes dependencias para establecer Flask y autenticar usuarios.

pipenv install flask python-dotenv python-jose flask-cors six

Construir los endpoints

Nuestra API será directa. Consistirá sólo de tres endpoints, las cuales todas serán, por ahora, accesibles públicamente. Sin embargo, arreglaremos eso pronto. Acá están nuestros endpoints:

/ (endpoint público)
/user (requiere un usuario autenticado)
/admin (sólo los usuarios de rol admin)

Vamos a ello:

from flask import Flask

app = Flask(__name__)

@app.route("/")
def index_view():
    """
    Endpoint por defecto, es publico y puede ser accedido por cualquiera
    """
    return jsonify(msg="Hello world!")

@app.route("/user")
def user_view():
    """
    Endpoint Usuario, solo puede ser accedido por un usuario autorizado
    """
    return jsonify(msg="Hello user!")

@app.route("/admin")
def admin_view():
    """
    Endpoint Admin, solo puede ser accedido por un admin
    """
    return jsonify(msg="Hello admin!")

Bastante simple, no? Vamos a ejecutarlo:

~ pipenv run flask run
* Environment: production
   WARNING: This is a development server. Do not use it in a production deployment.
   Use a production WSGI server instead.
 * Debug mode: off
 * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

Y si accedemos nuestro endpoint:

~ curl -i http://localhost:5000
HTTP/1.0 200 OK
Content-Type: application/json
Content-Length: 23
Server: Werkzeug/2.0.1 Python/3.9.1
Date: Tue, 24 Jan 2023 21:24:57 GMT

{"msg":"Hello world!"}

~ curl -i http://localhost:5000/user
HTTP/1.0 200 OK
Content-Type: application/json
Content-Length: 22
Server: Werkzeug/2.0.1 Python/3.9.1
Date: Tue, 24 Jan 2023 21:25:42 GMT

{"msg":"Hello user!"}

~ curl -i http://localhost:5000/admin
HTTP/1.0 200 OK
Content-Type: application/json
Content-Length: 23
Server: Werkzeug/2.0.1 Python/3.9.1
Date: Tue, 24 Jan 2023 21:26:18 GMT

{"msg":"Hello admin!"}

Cómo asegurar los endpoints

Ya que estamos usando OAuth, vamos a autenticar las peticiones al validar un token de acceso en formato JWT. Lo enviaremos a la API en cada petición como parte de las cabeceras HTTP.

Variables de Configuración Auth0

Como mencionado en la sección previa, nuestra API necesita ser consciente y requerirá información de nuestro dashboard Auth0. Así que ve devuelta a tu página detallada de API y agarra dos valores distintos.

Primero, el identificador de API:

Este es el valor requerido cuando la API es creada. También puedes obtenerla desde tu página detallada de API:

How to find the API identifier on the API details page

Siguiente, dominio Auth0:

A menos que estés utilizando un dominio customizado, este valor será [NOMBRE_TENANT].auth0.com, y puedes agarrarlo desde la pestaña Test (asegúrate no incluir https:// y la última barra diagonal /).

Getting the Auth0 domain

Siguiente, traspasa esos valores a variables para que así puedan ser utilizadas en las funciones de validación.

AUTH0_DOMAIN = 'TU-DOMINIO-AUTH0'
API_IDENTIFIER = 'IDENTIFICADOR-API'
ALGORITHMS = ["RS256"]

Métodos de error

Durante esta implementación, necesitaremos una manera de lanzar errores cuando la autenticación falla. Así que usaremos los siguientes ayudantes para esos menesteres:

class AuthError(Exception):
    def __init__(self, error, status_code):
        self.error = error
        self.status_code = status_code

@app.errorhandler(AuthError)
def handle_auth_error(ex):
    response = jsonify(ex.error)
    response.status_code = ex.status_code
    return response

Cómo capturar el token JWT

El primer paso para validar un usuario es obtener el token JWT desde las cabeceras HTTP. Esto es bastante simple, pero hay algunas cosas a tener en mente. Aquí hay un ejemplo de ello:

def get_token_auth_header():
    """
    Obtiene el Token de Acceso desde la cabecera Authorization
    """
    auth = request.headers.get("Authorization", None)
    if not auth:
        raise AuthError({"code": "authorization_header_missing",
                        "description":
                            "Se esperaba cabecera de autenticacion"}, 401)

    parts = auth.split()

    if parts[0].lower() != "bearer":
        raise AuthError({"code": "invalid_header",
                        "description":
                            "La cabecera de autenticacion debe comenzar con"
                            " Bearer"}, 401)
    elif len(parts) == 1:
        raise AuthError({"code": "invalid_header",
                        "description": "Token no encontrado"}, 401)
    elif len(parts) > 2:
        raise AuthError({"code": "invalid_header",
                        "description":
                            "La cabecera debe ser"
                            " Bearer token"}, 401)

    token = parts[1]
    return token

Cómo validar el token

Tener un token traspasado a nuestra API es una buena señal, pero no significa que es un cliente válido. Necesitamos revisar la firma del token.

Ya que la lógica para requerir autenticación puede ser utilizada para más de un endpoint, sería importante abstraerla y hacerla fácilmente accesible para los desarrolladores su implementación. La mejor forma de hacer esto es usando decoradores (artículos en inglés).

def requires_auth(f):
    """
	Determina si el Token de Acceso es valido
    """
    @wraps(f)
    def decorated(*args, **kwargs):
        token = get_token_auth_header()
        jsonurl = urlopen("https://"+AUTH0_DOMAIN+"/.well-known/jwks.json")
        jwks = json.loads(jsonurl.read())
        unverified_header = jwt.get_unverified_header(token)
        rsa_key = {}
        for key in jwks["keys"]:
            if key["kid"] == unverified_header["kid"]:
                rsa_key = {
                    "kty": key["kty"],
                    "kid": key["kid"],
                    "use": key["use"],
                    "n": key["n"],
                    "e": key["e"]
                }
        if rsa_key:
            try:
                payload = jwt.decode(
                    token,
                    rsa_key,
                    algorithms=ALGORITHMS,
                    audience=API_IDENTIFIER,
                    issuer="https://"+AUTH0_DOMAIN+"/"
                )
            except jwt.ExpiredSignatureError:
                raise AuthError({"code": "token_expired",
                                "description": "token is expired"}, 401)
            except jwt.JWTClaimsError:
                raise AuthError({"code": "invalid_claims",
                                "description":
                                    "incorrect claims,"
                                    "please check the audience and issuer"}, 401)
            except Exception:
                raise AuthError({"code": "invalid_header",
                                "description":
                                    "Unable to parse authentication"
                                    " token."}, 401)

            _request_ctx_stack.top.current_user = payload
            return f(*args, **kwargs)
        raise AuthError({"code": "invalid_header",
                        "description": "Unable to find appropriate key"}, 401)
    return decorated

El nuevo decorador creado requires_auth, cuando aplicado a un endpoint, automáticamente rechazará la petición si no hay un usuario válido que pueda ser autenticado.

Cómo requerir una petición autenticada para un endpoint

Ya estamos listos para asegurar nuestros endpoints, actualicemos los user y admin para utilizar nuestro decorador.

@app.route("/user")
@requires_auth
def user_view():
    """
    Endpoint Usuario, solo puede ser accedido por un usuario autorizado
    """
    return jsonify(msg="Hello user!")

@app.route("/admin")
@requires_auth
def admin_view():
    """
    Endpoint Admin, solo puede ser accedido por un admin
    """
    return jsonify(msg="Hello admin!")

Nuestro único cambio fue añadir @required_auth al comienzo de la declaración de cada función de endpoint, y con ello podemos probar una vez más:

~ curl -i http://localhost:5000/user
HTTP/1.0 401 UNAUTHORIZED
Content-Type: application/json
Content-Length: 89
Server: Werkzeug/2.0.1 Python/3.9.1
Date: Tue, 24 Jan 2023 21:42:26 GMT

{"code":"authorization_header_missing","description":"Se esperaba cabecera de autenticacion"}

~ curl -i http://localhost:5000/admin
HTTP/1.0 401 UNAUTHORIZED
Content-Type: application/json
Content-Length: 89
Server: Werkzeug/2.0.1 Python/3.9.1
Date: Tue, 24 Jan 2023 21:42:42 GMT

{"code":"authorization_header_missing","description":"Se esperaba cabecera de autenticacion"}

Como se esperaba, no podemos acceder a nuestros endpoints ya que la cabecera de autorización no se encuentra. Pero antes de añadir una, veamos si nuestro endpoint público aún funciona:

Como esperado

~ curl -i http://localhost:5000
HTTP/1.0 200 OK
Content-Type: application/json
Content-Length: 23
Server: Werkzeug/2.0.1 Python/3.9.1
Date: Tue, 24 Jan 2023 21:43:55 GMT

{"msg":"Hello world!"}

Increíble, funciona como se esperaba.

Cómo probarlo

Para probar nuestros nuevos endpoints asegurados, necesitamos obtener un token de acceso válido que podamos pasar a la petición. Podemos hacer eso directamente en la pestaña Test de la página detallada de la API, y es tan simple como copiar un valor desde la pantalla:

Copying the token for testing

Once we have the token we can change our curl request accordingly:

Una vez que tengamos el token podemos cambiar nuestra petición de curl acorde a:

~ curl -i -H "Authorization: bearer [TOKEN_DE_ACCESO]"  http://localhost:5000/user
HTTP/1.0 200 OK
Content-Type: application/json
Content-Length: 22
Server: Werkzeug/2.0.1 Python/3.9.1
Date: Tue, 24 Jan 2023 22:17:06 GMT

{"msg":"Hello user!"}

Por favor recuerda reemplazar TOKEN_DE_ACCESO con el valor que copiaste desde tu dashboard.

¡Funciona! Pero aún tenemos algo de trabajo que hacer. Incluso cuando nuestro endpoint /admin está asegurado, puede ser accedido por cualquier usuario:

~ curl -i -H "Authorization: bearer [TOKEN_DE_ACCESO]"  http://localhost:5000/admin
HTTP/1.0 200 OK
Content-Type: application/json
Content-Length: 23
Server: Werkzeug/2.0.1 Python/3.9.1
Date: Tue, 24 Jan 2023 22:21:09 GMT

{"msg":"Hello admin!"}

Control de acceso basado en roles

Para el control de acceso basado en roles hay algunas cosas que debemos hacer:

Crear permisos para la API
Activar el añadir permisos a el token JWT para la API
Actualizar el código
Probar con usuarios

Los primeros 2 puntos están bastante bien explicados en los documentos Auth0 (artículo en inglés), así que sólo asegúrate de añadir los permisos correspondientes en tu API.

Siguiente, necesitamos actualizar el código. Necesitamos una función para revisar si dado permiso existe en el token de acceso y retornar True si lo hace y Falsesi no:

def requires_scope(required_scope):
    """
	Determina si el objetivo requerido esta presente en el Token de Acceso
    Args:
    	required_scope (str): El objetivo requerido para acceder al recurso
    """
    token = get_token_auth_header()
    unverified_claims = jwt.get_unverified_claims(token)
    if unverified_claims.get("scope"):
            token_scopes = unverified_claims["scope"].split()
            for token_scope in token_scopes:
                if token_scope == required_scope:
                    return True
    return False

Y últimamente, puede ser como a continuación:

@app.route("/admin")
@requires_auth
def admin_view():
    """
	Endpoint Admin, solo puede ser accedido por un admin
    """
    if requires_scope("read:admin"):
        return jsonify(msg="Hello admin!")

    raise AuthError({
        "code": "Unauthorized",
        "description": "No tienes acceso a este recurso"
    }, 403)

Ahora, sólo usuarios con el permiso read:admin pueden acceder a nuestro endpoint admin.

Con el fin de probar tu implementación final, puedes seguir los pasos detallados en obtener un token de acceso (artículo en inglés) para un usuario determinado.

También puedes usar el Dashboard de Auth0 para probar los permisos, pero eso va fuera del enfoque de este artículo. Si te gustaría aprender más de ello, lee aquí.

Conclusión

Hoy hemos aprendido cómo asegurar una API Flask. Hemos explorado la forma hágalo-usted-mismo, y hemos construido una API segura con tres niveles de acceso - acceso público, acceso privado y acceso privado-focalizado.

Hay muchas cosas más que Auth0 puede hacer por tus APIs y también para las aplicaciones de tus clientes. Hoy sólo hemos raspado la superficie, y depende de tí y tu equipo cuando se trabajan en escenarios de la vida real el explorar el potencial de sus servicios.

El código completo está disponible en Github.

¡Gracias por leer! Si te gusta mi estilo de enseñanza, puedes Suscribirte a mi newsletter semanal para desarrolladores y constructores y obtener un email semanal lleno de contenido relevante.

Tutorial de Spring Boot: Cómo crear Apps Java modernas y rápidas

Josué Leiva — Tue, 14 Mar 2023 20:36:09 +0000

Artículo original: Spring Boot Tutorial – How to Build Fast and Modern Java Apps

En este artículo te voy a guiar en la construcción de un prototipo con Spring Boot. Piénsalo como crear un proyecto para una hackaton o un proyecto para tu startup en poco tiempo.

En otras palabras, no estamos intentando crear algo perfecto sino algo que funcione.

Si te atascas en cualquier parte de este tutorial o si olvidé mencionar algo, puedes revisar el repositorio GitHub que he incluido en la Conclusión.

Requisitos previos

Fundamentos de JAVA y POO
Conocimiento básico de bases de datos relacionales (uno a uno, varios a varios, y así)
Los fundamentos de Spring serían de gran ayuda.
Nivel básico de HTML.

También asegúrate de tener lo siguiente:

JDK (Java Development Kit) actualizado.
IntelliJ IDEA o algún otro IDE de JAVA.

¿Qué estamos construyendo?

Vamos a construir un sistema de reservación de servicios donde los usuarios ingresarán y harán una reservación para utilizar algún servicio como un gimnasio, piscina, o sauna.

Cada servicio tendrá cierta capacidad (número de personas que pueden utilizar el servicio al mismo tiempo) así las personas podrán hacer uso de las comodidades de forma segura durante la pandemia del Covid-19.

Lista de características para la App

Podemos pensar de nuestra app como el sistema de reservaciones para un departamento complejo.

Los usuarios debieran poder ingresar.
Asumiremos que las cuentas de los residentes son pre-creadas y no habrá registro de usuarios.
Los usuarios deben poder ver sus reservaciones.
Los usuarios debieran poder crear nuevas reservas al seleccionar el tipo de servicio, fecha y hora.
Sólo los usuarios ingresados debieran poder ver la página de reservas y crear reservas.
Debemos revisar la capacidad y sólo crear nuevas reservaciones si el número actual de reservas no excede la capacidad.

Tecnologías que usaremos

Vamos a aprender sobre muchas tecnologías útiles que te harán más eficiente como desarrollador Spring Boot. Mencionaré brevemente qué son y para qué son buenas y después las veremos en acción.

Bootify
Hibernate
Spring Boot
Maven
JPA
Swagger
H2 (Base de datos en memoria)
Thymeleaf
Bootstrap
Spring Security

¿Por qué Spring Boot?

El framework Spring es generalmente utilizado para trabajos a gran escala de nivel empresarial. Usualmente, no es la primera opción para proyectos pequeños, pero debo argumentar que puede ser un tanto rápido para hacer prototipos.

Tiene las siguientes ventajas:

La programación basada en anotaciones genera mucho código para ti detrás de escenas. Y especialmente con la disponibilidad de librerías como Lombok, se ha vuelto mucho más fácil enfocarse en la lógica del trabajo.
Tiene un buen soporte para bases de datos en memoria, por lo que no tenemos que crear una base de datos real y conectarnos a ella. (H2)
Tiene un ecosistema maduro, así que puedes encontrar fácilmente respuestas a la mayoría de las preguntas.
Casi "no requiere" configuración. Con la ayuda de Spring Boot, nos deshacemos de las feas configuraciones XML en el lado Spring de las cosas y configurar tu aplicación es realmente fácil.
Hay muchas cosas pasando detrás de las escenas. Spring provee tanta magia y hace tantas cosas para hacer que las cosas funcionen. Así que usualmente no tienes que preocuparte de eso y simplemente debes dejar que el framework maneje las cosas.
Tenemos Spring Security (repositorio en inglés). Teniendo uno de los frameworks de seguridad más completos y probados para la batalla a tu lado te otorga mayor confianza en la seguridad de tu aplicación. También se preocupa de gran parte del trabajo duro por ti.

Cómo crear el proyecto con Bootify

Para crear el proyecto, vas a utilizar Bootify. Es un servicio freemium (De gratis y pago dependiendo del plan) que hace el desarrollo en Spring Boot más rápido al generar muchos modelos de código por ti, lo cual te permite enfocarte en el trabajo lógico.

Bootify nos permite especificar nuestras preferencias y automáticamente importar las dependencias, similar a Spring Initializr.

Pero hay más que eso. También puedes especificar tus entidades y generará el modelo correspondiente y sus clases DTO. Puede incluso generar el servicio y el código a nivel de control para operaciones comunes de CRUD.

Creo que es una herramienta más conveniente para el desarrollo de APIs que para aplicaciones MVC debido a que genera el código de REST API por defecto. Pero aun así hará nuestras vidas más fáciles, incluso con una aplicación Spring Boot MVC que contiene vistas. Sólo tenemos que hacerle algunos ajustes al código generado.

Abramos el sitio web de Bootify y hagamos clic en el botón "Start Project" en la esquina superior derecha.

Debes seleccionar:

Maven como el tipo de compilación
Versión de Java: 14
Habilita "Enable Lombok" para activar Lombok
Base de datos: H2
Habilita "add dateCreated/lastUpdated to entities"
Packages: "Technical"
Habilita "OpenAPI/Swagger UI"
Añade org.springframework.boot:spring-boot-devtools en "further dependencies"

Después de terminar, deberías ver esto:

Ahora vamos a especificar nuestras entidades. Comienza por clicar la pestaña Entities en el menú de la izquierda.

Vamos a tener las siguientes entidades y relaciones:

"Reservation" que contiene la información relacionada con cada reservación, tales como la fecha de reserva, la hora de inicio de reserva, la hora de término de la reserva, y el usuario que tiene esta reserva.
La entidad "User" que contiene nuestro modelo de usuario y que tendrá relaciones con "Reservation".
La entidad "Amenity" (Servicio) que contiene el tipo de servicio y su capacidad (el número máximo de reservaciones por cierto tiempo, por ejemplo: 2 personas pueden utilizar y reservar la Sauna al mismo tiempo).

Vamos a definir nuestra entidad Reservation como se muestra a continuación y habilitaremos "Add REST endpoints" (Añadir endpoints REST) (aunque modificaremos la salida). Después haz clic en el botón "Save" (guardar).

Vamos a especificar las relaciones más tarde, así que el único campo que nuestra entidad "User" (usuario) tiene es id.

Podríamos crear una entidad para "Amenities" (servicios) para guardar la información sobre el nombre del servicio y su capacidad y después podríamos referenciarlo desde Reservation. Pero la relación entre Amenity y Reservation sería uno-a-uno.

Así que en vez de ello, por la simplicidad, vamos a crear una enum llamado AmenityType (tipo de servicio) y guardaremos AmenityType dentro de Reservation.

Ahora crearemos una relación entre las entidades User (usuario) y Reservation (Reserva) al hacer click en el botón + al lado del menú Relations (relaciones).

Menú para crear relaciones

Será una relación Varios-a-Uno, ya que un usuario puede tener diversas reservaciones, pero una reserva debe tener uno y sólo un usuario. Nos aseguraremos que así sea el caso al activar la casilla requerida.

User-Reservation Relation

Hacemos clic en "Save Changes" y terminamos. Tu modelo final debería verse así:

Ahora haz clic en el enlace de descarga en el menú de la izquierda para descargar el código del proyecto generado para así poder empezar a trabajar en el. Puedes ver el primer commit del repositorio github del proyecto para comparar y ver si tienes algún problema.

Después de descargar el proyecto, ábrelo en un IDE - Yo usaré IntelliJ IDEA. Tu estructura de archivos debiese verse así:

├── amenity-reservation-system.iml
├── mvnw
├── mvnw.cmd
├── pom.xml
├── src
│   └── main
│       ├── java
│       │   └── com
│       │       └── amenity_reservation_system
│       │           ├── AmenityReservationSystemApplication.java
│       │           ├── HomeController.java
│       │           ├── config
│       │           │   ├── DomainConfig.java
│       │           │   ├── JacksonConfig.java
│       │           │   └── RestExceptionHandler.java
│       │           ├── domain
│       │           │   ├── Reservation.java
│       │           │   └── User.java
│       │           ├── model
│       │           │   ├── ErrorResponse.java
│       │           │   ├── FieldError.java
│       │           │   ├── ReservationDTO.java
│       │           │   └── UserDTO.java
│       │           ├── repos
│       │           │   ├── ReservationRepository.java
│       │           │   └── UserRepository.java
│       │           ├── rest
│       │           │   ├── ReservationController.java
│       │           │   └── UserController.java
│       │           └── service
│       │               ├── ReservationService.java
│       │               └── UserService.java
│       └── resources
│           └── application.yml
└── target
    ├── classes
    │   ├── application.yml
    │   └── com
    │       └── amenity_reservation_system
    │           ├── AmenityReservationSystemApplication.class
    │           ├── HomeController.class
    │           ├── config
    │           │   ├── DomainConfig.class
    │           │   ├── JacksonConfig.class
    │           │   └── RestExceptionHandler.class
    │           ├── domain
    │           │   ├── Reservation.class
    │           │   └── User.class
    │           ├── model
    │           │   ├── ErrorResponse.class
    │           │   ├── FieldError.class
    │           │   ├── ReservationDTO.class
    │           │   └── UserDTO.class
    │           ├── repos
    │           │   ├── ReservationRepository.class
    │           │   └── UserRepository.class
    │           ├── rest
    │           │   ├── ReservationController.class
    │           │   └── UserController.class
    │           └── service
    │               ├── ReservationService.class
    │               └── UserService.class
    └── generated-sources
        └── annotations

Cómo probar y explorar el código generado

Tomaremos nuestro tiempo para experimentar el código generado y entenderlo capa por capa.

La carpeta Repos contiene el código de la capa de acceso de datos, es decir nuestros repositorios. Vamos a usar métodos JPA para obtener nuestros datos, los cuales son métodos prefabricados que puedes utilizar al definirlos dentro de la interfaz del repositorio.

Nota que las clases de nuestro repositorio heredan la interfaz JpaRepository. Esta es la interfaz que nos permitirá utilizar los métodos mencionados.

Las peticiones JPA siguen cierta convención, y cuando creamos el método que obedece las convenciones, este sabrá automáticamente qué datos quieres recuperar, detrás de las escenas. Si aún no comprendes, no te preocupes, veremos ejemplos.

Ejemplos de palabras clave, oraciones y sus peticiones (snippets) JPQL correspondientes.

Las clases Model presentan nuestro modelo de datos, y qué clases tendrán qué campos.

Cada clase model(modelo) corresponde a una tabla de base de datos con el mismo nombre y los campos en la clase modelo serán las columnas en la tabla correspondiente.

Vea la anotación @Entity al comienzo de nuestras clases modelo. Esta anotación es manejada por Hibernate (artículo en inglés) y cuando Hibernate ve @Entity, creará una tabla usando el nombre de nuestra clase como el nombre de la tabla.

Si te preguntas, "¿Qué es Hibernate de todos modos?", es una herramienta de mapeo de objetos relacionales (ORM por sus siglas en inglés) en Java que nos permite crear mapas de POJOs (Objeto Java Plano antiguo) hacia las tablas de la base de datos. También provee cualidades tales como restricción de validación de datos, pero no profundizaremos en Hibernate en este post debido a que es un tema vasto de por sí.

Una cualidad increíble de Hibernate es que maneja toda la creación de tablas y las operaciones de borrado para que así no debas usar scripts SQL adicionales.

También representamos las relaciones entre objetos en las clases modelo. Para ver un ejemplo, demos un vistazo en nuestra clase User:

    @OneToMany(mappedBy = "user")
    private Set userReservations;

Esta tiene un objeto userReservations que contiene un set de referencias que se asemeja a las reservaciones de este usuario en particular. En la clase Reservation tenemos la relación inversa:

@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "user_id", nullable = false)
private User user;

Teniendo referencias en los dos lados hace posible acceder el otro lado de la relación (objeto usuario hacia reservación y viceversa).

Controllers va a manejar las peticiones que son pasadas a este controlador por el handler de peticiones y retornará las vistas correspondientes en este caso.

Los controladores que fueron generados por Bootify están configurados para devolver respuestas JSON, y las vamos a modificar en la siguiente sección para retornar nuestras vistas.

Services tendrá la lógica de nuestra aplicación. La mejor práctica es mantener los controladores simples, esto al mantener la lógica del programa en un lugar separado, las clases de servicio.

Los controladores no debieran interactuar con los repositorios directamente, sino llamar el servicio que interactúa con el repositorio, realizar cualquier operación adicional y devolver el resultado al controlador.

¡Probemos la API!

Ahora vamos a la parte divertida, intentar ver la API en acción. Ejecuta la aplicación Spring en tu IDE favorito. Abre tu navegador y ve a esta dirección:

http://localhost:8080/swagger-ui/index.html?configUrl=/v3/api-docs/swagger-config#/

Swagger automáticamente documenta nuestro código y nos permite enviar peticiones fácilmente. Deberías estar viendo esto:

Vamos a primero crear un usuario al mandar una petición POST a UserController. Vamos a hacer eso al hacer click en la última caja (la verde) bajo la lista user-controller (controlador de usuario).

Swagger nos muestra los parámetros que este endpoint espera - por ahora solo el id - y también las respuestas que la API retorna.

Haz clic en el botón "Try it out" (pruébalo) en la esquina superior derecha. Te pide que ingreses un id. Sé que no tiene sentido y que el código siquiera va a utilizar el id que ingreses, pero vamos a arreglar eso en la sección siguiente (solo es un problema con el código generado)

Por el bien de la experimentación, ingresa cualquier número, como 1 para el id, y haz clic en el botón execute (ejecutar).

El cuerpo de la respuesta contiene el id del objeto creado. Podemos confirmar que es creado en la base de datos al crear la consola H2.

Pero antes de hacer eso, tenemos que hacer un pequeño ajuste al archivo application.yml que contiene la configuración y ajustes de la app.

Abre tu archivo application.yml y pega el siguiente código:

spring:
  datasource:
    url: ${JDBC_DATABASE_URL:jdbc:h2:mem:amenity-reservation-system}
    username: ${JDBC_DATABASE_USERNAME:sa}
    password: ${JDBC_DATABASE_PASSWORD:}
  dbcp2:
    max-wait-millis: 30000
    validation-query: "SELECT 1"
    validation-query-timeout: 30
  jpa:
    hibernate:
      ddl-auto: update
    open-in-view: false
    properties:
      hibernate:
        jdbc:
          lob:
            non_contextual_creation: true
        id:
          new_generator_mappings: true
springdoc:
  pathsToMatch: /api/**

Luego deberíamos poder acceder la consola H2 al ir a esta dirección:

http://localhost:8080/h2-console/

Aquí tienes que revisar que el username (nombre de usuario) es "sa" y hacer clic en el botón Connect (conectar)

Haz clic en la tabla USER en el menú de la izquierda y la consola escribirá la petición select all por ti.

Panel de administración de la base de datos H2

Vamos a hacer click en el botón Run(ejecutar) que está arriba de la consulta.

Y podemos ver que el objeto User es en efecto creado - excelente!

Ya tenemos una API funcional en este punto y no hemos escrito ni una línea de código.

Cómo Ajustar el Código para Nuestro Caso Particular

Como mencioné antes, el código generado no se adapta totalmente al uso que necesitamos y tenemos que hacerle algunos ajustes.

Vamos a remover la carpeta "model" que contiene los DTOs y cosas que no vamos a usar. En cambio vamos a mostrar la información dentro de las vistas.

cd src/main/java/com/amenity_reservation_system/ 
rm -rf model

Eliminamos la carpeta model dentro del proyecto

Por ahora tendremos muchos errores ya que el código utiliza clases DTO, pero nos desharemos de la mayoría de ellos después de remover las clases controladoras actuales.

Eliminaremos las clases controladoras (controllers) porque ya no queremos exponer la funcionalidad de modificar nuestra información. Nuestros usuarios debieran ser capaces de hacer eso al interactuar con nuestra UI, y para ello vamos a crear nuevos controladores para retornar los componentes de las vistas en la siguiente sección.

rm -rf rest

Eliminamos las clases controladoras

Finalmente, necesitamos refactorizar un poco nuestras clases service ya que las clases DTO ya no están presentes:

package com.amenity_reservation_system.service;

import com.amenity_reservation_system.domain.User;
import com.amenity_reservation_system.repos.UserRepository;
import java.util.List;
import java.util.stream.Collectors;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Service;
import org.springframework.web.server.ResponseStatusException;


@Service
public class UserService {

    private final UserRepository userRepository;

    public UserService(final UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public List findAll() {
        return userRepository.findAll();
    }

    public User get(final Long id) {
        return userRepository.findById(id)
                .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND));
    }

    public Long create(final User user) {
        return userRepository.save(user).getId();
    }

    public void update(final Long id, final User user) {
        final User existingUser = userRepository.findById(id)
                .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND));
        
        userRepository.save(user);
    }

    public void delete(final Long id) {
        userRepository.deleteById(id);
    }
}

Clases service refactorizadas

Básicamente eliminamos el código relacionado con las clases DTO de la clase UserService y reemplazamos los typos de retorno con User. Hagamos lo mismo para ReservationService.

package com.amenity_reservation_system.service;

import com.amenity_reservation_system.domain.Reservation;
import com.amenity_reservation_system.domain.User;
import com.amenity_reservation_system.repos.ReservationRepository;
import com.amenity_reservation_system.repos.UserRepository;
import java.util.List;
import java.util.stream.Collectors;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Service;
import org.springframework.web.server.ResponseStatusException;


@Service
public class ReservationService {

    private final ReservationRepository reservationRepository;
    private final UserRepository userRepository;

    public ReservationService(final ReservationRepository reservationRepository,
            final UserRepository userRepository) {
        this.reservationRepository = reservationRepository;
        this.userRepository = userRepository;
    }

    public List findAll() {
        return reservationRepository.findAll();
    }

    public Reservation get(final Long id) {
        return reservationRepository.findById(id)
                .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND));
    }

    public Long create(final Reservation reservation) {
        return reservationRepository.save(reservation).getId();
    }

    public void update(final Long id, final Reservation reservation) {
        final Reservation existingReservation = reservationRepository.findById(id)
                .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND));
        reservationRepository.save(reservation);
    }

    public void delete(final Long id) {
        reservationRepository.deleteById(id);
    }

}

Vamos también a eliminar las clases config:

rm -rf config

Y renombramos la carpeta "domain" a "model". Si estás usando un IDE, te recomiendo fuertemente que utilices la función de renombre de tu IDE para cambiar el nombre de esta carpeta, ya que renombrará automáticamente los imports para que sean iguales al nuevo nombre del paquete.

mv domain model

También, revisa que tus clases modelo (User y Reservation) tienen los nombres de paquete correctos después de esta operación. La primera línea de estos dos archivos debiera ser:

package com.amenity_reservation_system.model;

Si se mantiene como paquete domain, puedes tener errores.

En este punto, deberías ser capaz de compilar y correr el proyecto sin ningún problema.

Como crear los Archivos de Controladores y Vistas para Mostrar Información

Thymeleaf es un motor de plantillas para Spring que nos permite crear UIs y mostrar nuestros modelos de información a los usuarios.

Podemos acceder a los objetos Java dentro de la plantilla Thymeleaf, y también podemos usar HTML, CSS y JavaScript. Si sabes sobre JSPs, esto es JSP con esteroides.

Vamos a crear algunas plantillas Thymeleaf que no harán nada sino que sólo mostrarán la información por ahora. Les daremos estilo en la siguiente sección. También crearemos los controladores que nos retornarán esas vistas.

Antes de comenzar con las plantillas Thymeleaf, necesitamos añadir una dependencia Maven para Spring Boot Thymeleaf, Tus dependencias deberían verse así en tu archivo pom.xml:



    4.0.0
    
        org.springframework.boot
        spring-boot-starter-parent
        2.4.4
        
    
    com
    amenity-reservation-system
    0.0.1-SNAPSHOT
    amenity-reservation-system

    
        14
    

    
        
            org.springframework.boot
            spring-boot-starter-web
        
        
            org.springframework.boot
            spring-boot-starter-validation
        
        
            org.springframework.boot
            spring-boot-starter-data-jpa
        
        
            com.h2database
            h2
            runtime
        
        
            org.springdoc
            springdoc-openapi-ui
            1.5.2
        
        
            org.springframework.boot
            spring-boot-devtools
        
        
            org.projectlombok
            lombok
            1.18.20
            provided
        
        
            org.springframework.boot
            spring-boot-starter-test
            test
        
        
            org.springframework.boot
            spring-boot-starter-thymeleaf
        

    

    
        
            
                org.springframework.boot
                spring-boot-maven-plugin

Si quieres puedes simplemente copiar y pegar el contenido de la etiqueta "dependencies". Ahora le diremos a Maven que instale las dependencias.

mvn clean install

Realizamos la instalación limpia de todas las dependencias

Ahora estamos listos para crear nuestras vistas. Vamos a crear una carpeta bajo resources para mantener nuestras plantillas, así:

cd ../../../resources
mkdir templates

Y crearemos un archivo de vista:

cd templates
touch index.html

Copia y pega el siguiente fragmento de código en el. Este archivo será nuestra página de inicio en el futuro.




    
    Amenities Reservation App

    




hello world!

También vamos a necesitar crear un controlador que nos devuelva esta vista para así poder verla en el navegador.

cd ../java/com/amenity_reservation_system
mkdir controller && cd controller
touch HomeController

Pega este código en HomeController:

package com.amenity_reservation_system.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;


@Controller
public class HomeController {

    @GetMapping("/")
    public String index(Model model) {

        return "index";
    }
}

Nota cómo anotamos nuestro método con @Controller en vez de @RestController esta vez. La anotación @RestController implica que el controlador retornará una respuesta REST mientras que @Controller puede retornar vistas HTML pre-renderizadas (Renderizado del lado del Servidor o SSR en inglés)

Cuando una petición es recibida en nuestra aplicación, Spring automáticamente ejecutará este método controlador. Después encontrará el archivo index.html que creamos previamente bajo la carpeta "resources" y enviará ese archivo al cliente.

Confirmemos que está funcionando al enviar una petición a nuestra aplicación. No te olvides de reiniciarla, después envía esta petición:

GET localhost:8080

Deberías poder ver el mensaje "Hello World" en el navegador.

Cómo Definir Distintos Tipos de Servicios

Tenemos la clase Reservation pero no hemos creado alguna forma de especificar qué tipo de servicio está siendo reservado (piscina, sauna, gimnasio, etc)

Hay múltiples formas de hacer esto. Una de ellas sería crear una entidad llamada Amenity (Servicio) para guardar la información compartida entre entidades. Después crearemos las clases PoolAmenity, SaunaAmenity, y GymAmenity las cuales se extenderían de la clase Amenity.

Esta es una solución extensible pero se siente un tanto exagerada para nuestra simple aplicación, ya que no tenemos mucha información por cada tipo de servicio y solo vamos a especificar la capacidad de cada servicio.

Para mantener las cosas simples y no molestarnos con tablas de herencia y otras cosas complicadas, solo crearemos una clase enum para indicar el tipo de servicio como un String y dejar que cada reservación tenga una de ellas.

Iremos a la carpeta de modelos desde el controlador de archivos y crearemos la clase enum para AmenityType (Tipo de servicio):

cd ../model
touch AmenityType.java

public enum AmenityType {
    POOL("POOL"), SAUNA("SAUNA"), GYM("GYM");

    private final String name;

    private AmenityType(String value) {
        name = value;
    }

    @Override
    public String toString() {
        return name;
    }
}

En esta enum, definiremos una variable name (nombre) para mantener el nombre de la enum y crear un constructor privado para solo permitir conjuntos limitados de tipos. Nota que las declaraciones del tipo de servicio llaman al constructor desde dentro de la clase con sus valores de nombre.

Ahora necesitamos modificar la clase "Reservation" para que contenga una referencia a AmenityType:

@Enumerated(EnumType.STRING)
@Column(nullable = false)
private AmenityType amenityType;

Usaremos la anotación @Enumerated para describir cómo queremos guardar la enum en nuestra base de datos. También vamos a hacerla no nula, ya que cada Reservation (reservación) debe tener un AmenityType (tipo de servicio).

Como Mostrar las Reservaciones de un Usuario

¿Cuál es la característica más crucial de nuestra app? Crear y mostrar las reservaciones de un usuario.

Aún no tenemos una forma de autenticar a los usuarios, por lo que no podemos realmente pedirle al usuario que inicie sesión y mostrarle sus reservaciones. Pero aun así queremos implementarlo y probar la funcionalidad de hacer y mostrar las reservas.

Con ese propósito, podemos pedirle a Spring que ponga alguna información inicial en nuestra base de datos cada vez que nuestra aplicación se ejecute. Después podemos pedir esa información para ver si nuestras peticiones realmente funcionan. Y en ese momento, podemos proceder a llamar estos servicios desde Views y añadir autenticación en nuestra aplicación para las siguientes secciones.

Vamos a utilizar un bean CommandLineRunner para ejecutar el código inicial. Cada vez que el Container de Spring encuentre un bean de tipo CommandLineRunner ejecutará el código dentro de sí. Antes de ese paso, añadiremos unos cuantos métodos a nuestras clases modelo para hacer la creación de objetos más fácil y menos verbosa.

Dale un vistazo a las anotaciones de las clases modelo y deberías ver anotaciones como @Getter y @Setter. Esas son anotaciones Lombok.

Lombok es un procesador de anotaciones que podemos utilizar para hacer nuestra experiencia de código mejor al permitir que genere el código por nosotros. Cuando anotamos una clase con @Getter y @Setter, Lombok genera los setters y getters para cada campo de esta clase.

Spring usa métodos setter y getter para muchas de las operaciones triviales detrás de las escenas, así que son casi siempre requeridos. Además de que crearlos para cada entidad, se vuelve un problema sin la ayuda de Lombok.

Sin embargo Lombok puede hacer más que ello. También añadiremos las siguientes anotaciones a nuestras clases Reservation y User:

@Builder
@NoArgsConstructor
@AllArgsConstructor

Con estas anotaciones, Lombok implementa el patrón creacional de construcción para esta clase y también crea 2 constructores: Uno sin argumentos (constructor por defecto) y otro con todos los argumentos. Creo que es increíble que podamos hacer tanto con solo unas pocas anotaciones.

Ahora estamos listos para añadir información inicial. Ve a tu clase principal (AmenityReservationSystemApplication.java) y añade este método:

package com.amenity_reservation_system;

import com.amenity_reservation_system.model.AmenityType;
import com.amenity_reservation_system.model.Reservation;
import com.amenity_reservation_system.model.User;
import com.amenity_reservation_system.repos.ReservationRepository;
import com.amenity_reservation_system.repos.UserRepository;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalTime;
import java.time.ZoneId;
import java.util.Date;


@SpringBootApplication
public class AmenityReservationSystemApplication {

    public static void main(String[] args) {
        SpringApplication.run(AmenityReservationSystemApplication.class, args);
    }

    @Bean
    public CommandLineRunner loadData(UserRepository userRepository,
                                      ReservationRepository reservationRepository) {
        return (args) -> {
            User user = userRepository.save(new User());
            DateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
            Date date = new Date();
            LocalDate localDate = date.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
            Reservation reservation = Reservation.builder()
                    .reservationDate(localDate)
                    .startTime(LocalTime.of(12, 00))
                    .endTime(LocalTime.of(13, 00))
                    .user(user)
                    .amenityType(AmenityType.POOL)
                    .build();

            reservationRepository.save(reservation);
        };
    }
}

Si tienes un error sobre las operaciones de guardado, algo como "Inferred type 'S' for parameter ... does not match" (El tipo inferido 'S' para el parámetro ... no coincide), es porque renombramos el dominio del directorio a model. Ve a las clases del repositorio y arregla las rutas de importación a model.User y model.Reservation.

Nota cómo hemos usado el builder pattern (patrón de constructor) para crear los objetos de reservación más fácilmente. Cuando la creación de objetos se torna compleja y el constructor requiere muchos parámetros, es fácil olvidar el orden de los parámetros o revolver el orden.

Sin el patrón de constructor, necesitamos o llamar a un constructor con muchos parámetros o llamar al constructor por defecto y escribir código #properties para llamar a los setters.

Después de que estés listo, corre tu aplicación nuevamente para insertar la información inicial y conéctate a la consola H2 como aprendimos antes para así confirmar que nuestra información está efectivamente insertada. Si no tienes ningún error, deberías ser capaz de ver que el usuario y la reservación son insertadas exitosamente.

Hemos insertado una reservación para ser capaces de probar la funcionalidad de listado de las reservaciones, pero nuestras vistas actualmente no tienen una forma de mostrar las reservaciones y añadir las reservaciones. Necesitamos crear una UI para ello.

No tenemos un mecanismo de autenticación o registro aún, así que actuaremos como si el usuario con ID 10001 estuviese con la sesión iniciada. Más tarde mejoraremos ello al revisar dinámicamente quién está conectado y mostraremos una página distinta si el usuario no está conectado (si no ha hecho inicio de sesión).

Como Crear Vistas con Thymeleaf

Comenzaremos por crear una página home simple y una barra de navegación para nosotros mismos. Utilizaremos fragmentos de Thymeleaf para el código de la "navbar".

Los fragmentos de Thymeleaf nos permiten crear componentes reusables de estructura similar a los componentes de React/Vue si es que estás familiarizado. Vamos a crear una carpeta para nuestros fragmentos bajo "templates" y la llamaremos "fragments".

mkdir fragments
touch nav.html

Pondremos nuestra navbar dentro del archivo nav.html. Copia y pega el siguiente código:





    
        Amenities Reservation System

Fragmento Thymeleaf de la barra de navegación

En su estado actual no hace mucho, pero en el futuro podríamos añadir un botón de inicio de sesión o algunos enlaces.

Ahora crearemos una página de inicio simple que servirá a los usuarios que no están conectados. Tendremos nuestro fragmento de navbar arriba y tendremos un botón de login que le pedirá al usuario que inicie sesión antes de utilizar la aplicación.




    
    Amenities Reservation App

    




    
    
    

    
        Reservation management made easy.
        Lorem, ipsum dolor sit amet consectetur adipisicing elit.
            Numquam in quia natus magnam ducimus quas molestias velit vero maiores.
            Eaque sunt laudantium voluptas. Fugiat molestiae ipsa delectus iusto vel quod.
        Reserve an Amenity

nav.html

Debería verse así:

Crearemos otra página para mostrar si el usuario ya inició sesión. Para mantenerlo simple también la trataremos como página principal, y si el usuario ya está conectado, serán capaces de ver sus reservas en la página.

También es bueno en términos de practicidad para el usuario debido a que disminuye los pasos que deben tomar para ver sus reservaciones.

Ahora crearemos esta página como otro endpoint. Pero antes de añadir el login a nuestra aplicación mostraremos esta página previa si el usuario no está conectado y la página siguiente si están conectados, dinámicamente.

Antes de comenzar a trabajar en nuestra nueva página, añadiremos otro mapeo a HomeController que nos retornará nuestra nueva página. Más tarde fusionaremos estos dos controladores:

package com.amenity_reservation_system;

import com.amenity_reservation_system.domain.User;
import com.amenity_reservation_system.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;


@Controller
public class HomeController {

    final UserService userService;

    public HomeController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/")
    public String index(Model model) {
        return "index";
    }

    @GetMapping("/reservations")
    public String reservations(Model model) {
        User user = userService.get(10000L);
        model.addAttribute("user", user);

        return "reservations";
    }
}

HomeController.java

Si una petición es recibida en "/reservations", este código llamará a nuestro "userService" y preguntará por el usuario con id 10000L. Después añadirá este usuario a Model.

View accederá a este modelo y presentará la información sobre las reservaciones de este usuario. También hemos "auto-conectado" el servicio de usuario para que lo utilice.

Navega a la carpeta "templates" si es que ya no estás allí y crea otro archivo llamado "reservations.html":

touch reservations.html

Copia y pega el siguiente código:




    
    Reservations

    




    
    
        Welcome 
        

        
            
                
                    Amenity
                    Date
                    Start Time
                    End Time

En esta plantilla Thymeleaf, importamos Bootstrap y Thymeleaf tal y como antes y accedemos a la variable usuario que fue añadida al modelo en nuestro controlador mediante el uso de la sintaxis ${}.

Para acceder a la información, Thymeleaf utiliza los métodos getter de los objetos y podemos imprimir esa información al usar el atributo th:text. Thymeleaf también soporta bucles. En el tbody tenemos un bucle th:each, el cual lo podemos pensar como un bucle foreach sobre las reservaciones del usuario.

Puede que tengas un error que diga algo como "Could not initialize proxy, ... lazy loading". Esto sucede ya que la view está intentando acceder al objeto "reservations" mientras que aún no existe. Para sacarnos de encima este problema podemos modificar las siguientes líneas en User.java:

    @OneToMany(mappedBy = "user", fetch = FetchType.EAGER)
    private Set reservations = new HashSet<>();

Añadimos una declaración que le indica a Java que traiga este objeto prematuramente:

Ahora deberías poder ver la página de reservaciones:

Cómo Crear una Reservación

También necesitaremos alguna forma de crear nuevas reservas, así que construiremos ese mecanismo para nuestro usuario pre-creado que mostramos en las reservaciones. Después podeemos alterarlo para mostrar las reservas del usuario conectado.

Antes de proseguir, necesitaremos actualizar los formatos de fecha en nuestro archivo Reservation.java para evitar cualquier problema de formatos no coincidentes. Asegúrate que tus formatos para estas variables son iguales:

    @DateTimeFormat(pattern = "yyyy-MM-dd")
    @Column(nullable = false)
    private LocalDate reservationDate;

    @DateTimeFormat(pattern = "HH:mm")
    @Column
    private LocalTime startTime;

    @DateTimeFormat(pattern = "HH:mm")
    @Column
    private LocalTime endTime;

En la sección previa, creamos nuestro controlador reservations. Ahora necesitamos modificarlo un poco para añadirle otro atributo al modelo.

Aprendimos que podemos acceder a los objetos que son añadidos al modelo al utilizar la sintaxis ${}. Ahora haremos algo similar:

@GetMapping("/reservations")
    public String reservations(Model model, HttpSession session) {
        User user = userService.get(10000L);
        session.setAttribute("user", user);
        Reservation reservation = new Reservation();
        model.addAttribute("reservation", reservation);

        return "reservations";
    }

Estamos actualizando nuestro controlador de reservaciones para mover el objeto usuario a la sesión ya que queremos que sea accesible desde otro método de controlador y no solo desde una plantilla.

Piénsalo así: una vez que el usuario inicia sesión, la cuenta de este usuario será responsable por cada acción que sea hecha después de ese punto. Puedes pensar de "Session" como una variable global que es accesible desde cualquier parte.

También creamos un objeto Reservation y lo añadimos al modelo. Thymeleaf tendrá acceso a este objeto recién creado en nuestra plantilla de vista usando este modelo y llamará a los setters para establecer sus campos.

Ahora vamos a crear la vista para crear la reservación. Utilizaremos Bootstrap Modal (Bootstrap v4.0) para mostrar un formulario modal después de hacer click en el botón.

Primero podemos manejar el código para llamar el modal que crearemos en el siguiente paso, ve al archivo "reservations.html", y añade este fragmento después de la tabla que añadimos anteriormente:

Este botón gatillará nuestro modal. En el div, insertamos este modal que crearemos usando la etiqueta th:with para pasar el objeto reservation que fue puesto en el modelo, en el controlador. Si no hacemos esto, el fragmento no sabrá sobre el objeto reservation.

También debemos cambiar la manera en como accedemos el usuario para imprimir su nombre ya que no lo almacenaremos en el modal, sino que en la sesión:

Welcome

Así que finalmente tu archivo reservations.html debiera verse así:



  
    
    Reservations

    
  
  
    
      
      
        Welcome 
        

        
          
            
              Amenity
              Date
              Start Time
              End Time

Ahora estamos listos para crear el fragmento modal. Podemos crear un fragmento para el modal igual a como lo hicimos con el nav.

pwd
/src/main/resources
cd templates/fragments
touch modal.html

Creando el archivo modal.html

Y añade la siguiente plantilla de código:


  
    
      
        
          
            
              Create Reservation
            
            
          

          
            
              
                Amenity
                
                  
                
              
              
                Date
                
                  
                
              
              
                From
                
                  
                
              
              
                To
                
                  
                  Amenities are available from 8 am to 8 pm

Hay algunos puntos importantes aquí de los cuales debes tomar nota.

Nota como hemos accedido al objeto reservation en la etiqueta form:

La etiqueta th:object asocia este formulario con el objeto reservation que creamos antes. th:action determina donde este objeto será enviado cuando el formulario es enviado, y nuestro método de envío será POST. Crearemos este controlador con la ruta /reservations-submit después de este paso.

Usamos la etiqueta th:field para enlazar las entradas de los campos de nuestro objeto reservation. Thymeleaf llama los setters del objeto reservation cuando los valores de los campos de entrada cambian.

Ahora vamos a crear el controlador que recibirá este formulario. Ve a HomeController y añade el siguiente método:

@PostMapping("/reservations-submit")
    public String reservationsSubmit(@ModelAttribute Reservation reservation,
                                     @SessionAttribute("user") User user) {

        // Save to DB after updating
        assert user != null;
        reservation.setUser(user);
        reservationService.create(reservation);
        Set userReservations = user.getReservations();
        userReservations.add(reservation);
        user.setReservations(userReservations);
        userService.update(user.getId(), user);
        return "redirect:/reservations";
    }

Y también añade ReservationService a nuestras dependencias:

    final UserService userService;
    final ReservationService reservationService;

    public HomeController(UserService userService, ReservationService reservationService) {
        this.userService = userService;
        this.reservationService = reservationService;
    }

Después que nuestro fragmento modal envía el objeto reservation a este controlador, ese objeto será enlazado con la anotación @ModelAttribute. También necesitamos el usuario así que usamos @SessionAttribute para tener una referencia a él.

Los campos del objeto reservation debieran ser todos establecidos por el formulario. Ahora solo necesitamos guardarlo en la base de datos.

Esto lo hacemos al llamar al método create. Después añadimos la nueva reserva a la lista de reservas del usuario y actualizamos el usuario para reflejar esos cambios. Después entonces redirigimos el usuario a la página de reservaciones para mostrar la lista de reservas actualizada.

Tu nueva página de reservaciones debiera verse así:

Y cuando haces click en el botón, el modal para crear la reserva debería aparecer.

Cómo Añadir Autenticación y Autorización a la App

Utilizaremos Spring Security para añadir autenticación y autorización en nuestra aplicación. Queremos asegurarnos que nadie pueda ver las reservas de nadie más y que los usuarios deban iniciar sesión para crear reservas.

Si deseas aprender más de ello, escribí un artículo que provee una vista general de Spring Security (Artículo en inglés).

Lo mantendremos simple y mayormente usaremos los elementos por defecto ya que es un elemento complejo ya de por sí. Si quieres aprender cómo establecer Spring Security Auth debidamente, puedes revisar mi artículo (artículo en inglés) en ello.

Necesitamos añadir "Spring Security" y "Thymeleaf Spring Security" a nuestras dependencias, así que abre tu pom.xml y añade lo siguiente a tu lista de dependencias:


    org.springframework.boot
    spring-boot-starter-security



    org.thymeleaf.extras
    thymeleaf-extras-springsecurity5
    3.0.4.RELEASE

Ahora, por defecto, Spring Security protege todos los endpoints, así que necesitaremos configurarlo para que permita ver la página de inicio.

Vamos a crear una carpeta de configuración para guardar nuestro archivo WebSecurityConfig. Asumiendo que estás en la carpeta raíz:

cd /src/main/java/com/amenity_reservation_system
mkdir config && cd config
touch WebSecurityConfig.java

Este debiera ser el contenido de tu archivo config:

package com.amenity_reservation_system.config;

import com.amenity_reservation_system.service.UserDetailsServiceImpl;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    private final UserDetailsServiceImpl userDetailsService;

    private final BCryptPasswordEncoder bCryptPasswordEncoder;

    public WebSecurityConfig(UserDetailsServiceImpl userDetailsService, BCryptPasswordEncoder bCryptPasswordEncoder) {
        this.userDetailsService = userDetailsService;
        this.bCryptPasswordEncoder = bCryptPasswordEncoder;
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                .authorizeRequests()
                .antMatchers("/", "/webjars/**").permitAll()
                .anyRequest().authenticated()
                .and()
                .formLogin()
                .permitAll()
                .and()
                .logout()
                .permitAll()
                .logoutSuccessUrl("/");
    }

    public void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService).passwordEncoder(bCryptPasswordEncoder);
    }

}

WebSecurityConfig.java

No iré en los detalles, pero aquí hay un resumen de lo que ha pasado:

Configuramos Spring Security para permitir todas las peticiones hechas a la página de inicio ("/")
Configuramos nuestros estilos ("/webjars/**")
Le solicitamos que nos provea con formularios de inicio y cierre de sesión.
Le solicitamos que permita las peticiones a ellos así como redirigir a la página principal después que el cierre de sesión sea exitoso.

¿No es increíble lo que puedes lograr usando solo unas pocas declaraciones?

Tambien configuramos nuestro AuthenticationManagerBuilder para usar bCryptPasswordEncoder y userDetailsService. Pero espera, aún no tenemos ninguno de ellos, y tu IDE puede que se esté quejando de eso. Así que los crearemos.

Antes de seguir adelante, puede ser una buena idea añadir campos username y passwordHash a nuestra clase User. Los utilizaremos para autenticar el usuario en vez de usar su nombre completo. Después lo añadiremos al constructor.

package com.amenity_reservation_system.model;

import java.time.OffsetDateTime;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.*;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;


@Entity
@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
public class User {

    @Id
    @Column(nullable = false, updatable = false)
    @SequenceGenerator(
            name = "primary_sequence",
            sequenceName = "primary_sequence",
            allocationSize = 1,
            initialValue = 10000
    )
    @GeneratedValue(
            strategy = GenerationType.SEQUENCE,
            generator = "primary_sequence"
    )
    private Long id;

    @Column(nullable = false, unique = true)
    private String fullName;

    @Column(nullable = false, unique = true)
    private String username;

    @Column
    private String passwordHash;

    @OneToMany(mappedBy = "user", fetch = FetchType.EAGER)
    private Set reservations = new HashSet<>();

    @Column(nullable = false, updatable = false)
    private OffsetDateTime dateCreated;

    @Column(nullable = false)
    private OffsetDateTime lastUpdated;

    @PrePersist
    public void prePersist() {
        dateCreated = OffsetDateTime.now();
        lastUpdated = dateCreated;
    }

    @PreUpdate
    public void preUpdate() {
        lastUpdated = OffsetDateTime.now();
    }

    public User(String fullName, String username, String passwordHash) {
        this.fullName = fullName;
        this.username = username;
        this.passwordHash = passwordHash;
    }
}

User.java

Crea un archivo llamado UserDetailsServiceImpl bajo la carpeta services:

cd service
touch UserDetailsServiceImpl.java

package com.amenity_reservation_system.service;

import com.amenity_reservation_system.model.User;
import com.amenity_reservation_system.repos.UserRepository;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;

@Service
public class UserDetailsServiceImpl implements UserDetailsService {

    private UserRepository userRepository;

    public UserDetailsServiceImpl(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        final User user = userRepository.findUserByUsername(username);

        if (user == null) {
            throw new UsernameNotFoundException(username);
        }

        UserDetails userDetails = org.springframework.security.core.userdetails.User.withUsername(
                user.getUsername()).password(user.getPwHash()).roles("USER").build();

        return userDetails;
    }
}

UserDetailsServiceImpl.java

Esto básicamente le dice a Spring Security que queremos usar la entidad User que creamos antes al obtener el objeto User de nuestra base de datos y que use el método JPA de nuestro repositorio. Pero nuevamente, no tenemos el método findUserByUsername (encontrarUsuarioPorNombredeusuario) en nuestro UserRepository (RepositorioUsuario). Puedes intentar arreglar esto por tu cuenta a modo de reto, es bastante simple.

Recuerda, no necesitamos escribir consultas. Es suficiente proveer la firma y dejar que JPA haga el trabajo.

package com.amenity_reservation_system.repos;

import com.amenity_reservation_system.model.User;
import org.springframework.data.jpa.repository.JpaRepository;


public interface UserRepository extends JpaRepository {

    User findUserByUsername(String username);
}

UserRepository.java

We also need a BCryptPasswordEncoder bean to satisfy that dependency in WebSecurityConfig and to make it work. Let's modify our main class to add a bean and change the constructor parameters to give our predefined User a username.

También necesitamos el bean BCryptPasswordEncoder para satisfacer esa dependencia en WebSecurityConfig y para hacer que funcione. Modificaremos nuestra clase principal para añadir un bean y cambiar los parámetros del constructor para darle a nuestro User predefinido un username (nombre de usuario).

package com.amenity_reservation_system;

import com.amenity_reservation_system.model.AmenityType;
import com.amenity_reservation_system.model.Reservation;
import com.amenity_reservation_system.model.User;
import com.amenity_reservation_system.repos.ReservationRepository;
import com.amenity_reservation_system.repos.UserRepository;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalTime;
import java.time.ZoneId;
import java.util.Date;


@SpringBootApplication
public class AmenityReservationSystemApplication {

    public static void main(String[] args) {
        SpringApplication.run(AmenityReservationSystemApplication.class, args);
    }


    @Bean
    public CommandLineRunner loadData(UserRepository userRepository,
                                      ReservationRepository reservationRepository) {
    return (args) -> {
      User user =
          userRepository.save(
              new User("Yigit Kemal Erinc",
                      "yigiterinc",
                      bCryptPasswordEncoder().encode("12345")));
      DateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
      Date date = new Date();
      LocalDate localDate = date.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
      Reservation reservation =
          Reservation.builder()
              .reservationDate(localDate)
              .startTime(LocalTime.of(12, 00))
              .endTime(LocalTime.of(13, 00))
              .user(user)
              .amenityType(AmenityType.POOL)
              .build();

      reservationRepository.save(reservation);
    };
    }

    @Bean
    public BCryptPasswordEncoder bCryptPasswordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

Tu aplicación ahora debería estar lista para compilar y ya tendría que redirigirte a la página de login si envías una petición a "/reservations".

Sería agradable tener botones para iniciar y cerrar sesión en la barra de navegación, y queremos mostrar el inicio de sesión si no está autenticado y viceversa. Podemos hacerlo de esta manera en nav.htm:





    
        Amenities Reservation System
    
        Log in
        Log out

nav.html

El enlace para iniciar sesión ahora debiera ser visible en la navbar.

Página principal sin la sesión iniciada.

Cómo Mostrar las Reservaciones de los Usuarios Conectados

Nuestra página de reservaciones actualmente está mostrando las reservaciones de un usuario fijo y no las reservas del usuario conectado.

    @GetMapping("/reservations")
    public String reservations(Model model, HttpSession session) {
        User user = userService.get(10000L);
        session.setAttribute("user", user);
        Reservation reservation = new Reservation();
        model.addAttribute("reservation", reservation);

        return "reservations";
    }

Controlador de reservas actual

Necesitamos mostrar las reservas del usuario actual (con la sesión iniciada). Para lograr eso, debemos usar algo de Spring Security.

Ve a la clase HomeController (Lo sé, ese nombre es un tanto problemático ahora) y cámbiala con el código a continuación:

@GetMapping("/reservations")
    public String reservations(Model model, HttpSession session) {
        UserDetails principal = (UserDetails) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
        String name = principal.getUsername();
        User user = userService.getUserByUsername(name);

        // This should always be the case 
        if (user != null) {
            session.setAttribute("user", user);

            // Empty reservation object in case the user creates a new reservation
            Reservation reservation = new Reservation();
            model.addAttribute("reservation", reservation);

            return "reservations";
        }

        return "index";    
        }

Controlador de reservas

Debido a que añadimos Spring Security al proyecto, este automáticamente crea el objeto Authentication detrás de las escenas - obtenemos eso desde SecurityContextHolder.

Obtenemos el objeto UserDetails que guarda la información relacionada al usuario. Después evaluamos si el objeto usuario es nulo. Esto debería ser siempre el caso ya que reservations es un endpoint protegido y el usuario siempre debe iniciar sesión para ver esa página - pero siempre es bueno asegurarse que todo es según lo esperado.

Después llamámos a la clase UserService para obtener el objeto User que tiene su nombre de usuario - pero aún no hemos añadido el método getUserByUsername. Así que iremos a UserService y añadiremos este simple método.

    public User getUserByUsername(String username) {
        return userRepository.findUserByUsername(username);
    }

Ahora deberías poder ver las reservas del usuario conectado. Puedes intentarlo al añadir otro usuario y crear reservas para ese usuario también.

Cómo Evaluar la Capacidad

Actualmente no tenemos un mecanismo para almacenar la capacidad de cada tipo de servicio. Necesitamos almacenarlos de alguna forma y también evaluar si hay suficiente capacidad antes de aprobar alguna reservación.

Con ese propósito, vamos a crear una clase llamada Capacity bajo la carpeta model.

package com.amenity_reservation_system.model;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

import javax.persistence.*;

@Entity
@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
public class Capacity {

    @Id
    @Column(nullable = false, updatable = false)
    @SequenceGenerator(
            name = "primary_sequence",
            sequenceName = "primary_sequence",
            allocationSize = 1,
            initialValue = 10000
    )
    @GeneratedValue(
            strategy = GenerationType.SEQUENCE,
            generator = "primary_sequence"
    )
    private Long id;

    @Column(nullable = false, unique = true)
    @Enumerated(EnumType.STRING)
    private AmenityType amenityType;

    @Column(nullable = false)
    private int capacity;

    public Capacity(AmenityType amenityType, int capacity) {
        this.amenityType = amenityType;
        this.capacity = capacity;
    }
}

Capacity.java

Esta es la entidad que representará nuestro construct lógico a ser guardado en nuestra base de datos. Es básicamente una entrada de ruta con un AmenityType (tipo de servicio) y su capacidad correspondiente.

También necesitamos un repositorio para guardar las entradas de Capacity, así que vamos a crear CapacityRepository bajo la carpeta repos.

package com.amenity_reservation_system.repos;

import com.amenity_reservation_system.model.Capacity;
import org.springframework.data.jpa.repository.JpaRepository;

public interface CapacityRepository extends JpaRepository {
}

Necesitamos llenar esta nueva tabla con las capacidades iniciales. Podríamos leerlas desde un archivo de configuración o algo, pero lo mantendremos simple y lo estableceremos directamente usando loadData en nuestro método principal.

package com.amenity_reservation_system;

import com.amenity_reservation_system.model.AmenityType;
import com.amenity_reservation_system.model.Capacity;
import com.amenity_reservation_system.model.Reservation;
import com.amenity_reservation_system.model.User;
import com.amenity_reservation_system.repos.CapacityRepository;
import com.amenity_reservation_system.repos.ReservationRepository;
import com.amenity_reservation_system.repos.UserRepository;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalTime;
import java.time.ZoneId;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

@SpringBootApplication
public class AmenityReservationSystemApplication {

  private Map initialCapacities =
      new HashMap<>() {
        {
          put(AmenityType.GYM, 20);
          put(AmenityType.POOL, 4);
          put(AmenityType.SAUNA, 1);
        }
      };

  public static void main(String[] args) {
    SpringApplication.run(AmenityReservationSystemApplication.class, args);
  }

  @Bean
  public CommandLineRunner loadData(
      UserRepository userRepository,
      CapacityRepository capacityRepository) {
    return (args) -> {
      userRepository.save(
          new User("Yigit Kemal Erinc", "yigiterinc", bCryptPasswordEncoder().encode("12345")));

      for (AmenityType amenityType : initialCapacities.keySet()) {
        capacityRepository.save(new Capacity(amenityType, initialCapacities.get(amenityType)));
      }
    };
  }

  @Bean
  public BCryptPasswordEncoder bCryptPasswordEncoder() {
    return new BCryptPasswordEncoder();
  }
}

Acabo de añadir las capacidades dentro del mapa initialCapacities (capacidades iniciales) y luego las guarde en CapacityRepository (repositorio de capacidades) dentro del método loadData.

Ahora podemos revisar si el número de reservaciones en la hora solicitada excede la capacidad y rechazar la petición de reserva si lo hace.

Esta es la lógica: Necesitamos obtener el número de reservas que están en un mismo día y superponerlas con la petición actual. Después necesitamos obtener el aforo para este tipo de servicio y si la capacidad es excedida podemos lanzar una excepción.

Por lo tanto, necesitamos una consulta para obtener el número de posibles reservas superpuestas. No es la consulta más fácil de escribir, pero JPA es bastante conveniente y tenemos acceso a esa consulta dentro de nuestro ReservationRepository sin la necesidad de escribir SQL o HQL.

Te animo a que lo intentes por tu cuenta antes de seguir, ya que esta es la única razón de por qué he añadido este concepto de capacidad en este tutorial (para mostrar un ejemplo más avanzado de consultas JPA)

Así que así es como el método ReservationService se ve. Necesitas reemplazar el 0 (cero) con una llamada a reservationRepository para obtener el número de reservas superpuestas.

Si el número actual de reservas superpuestas es igual a la capacidad, significa que la siguiente la excederá, así que lanzamos una excepción.

public Long create(final Reservation reservation) {
        int capacity = capacityRepository.findByAmenityType(reservation.getAmenityType()).getCapacity();
        int overlappingReservations = 0; // TODO

        if (overlappingReservations >= capacity) {
            // Throw a custom exception
        }

        return reservationRepository.save(reservation).getId();
    }

Para encontrar las reservaciones superpuestas hay algunas condiciones que debemos evaluar:

Primero que todo, la fecha de la reservación debe ser la misma que de la petición:

La hora de inicio puede ser antes que el startTime (hora de inicio) de una nueva petición. En ese caso, la hora de término debe ser más tarde que en nuestra petición, en orden de que solapen (startTimeBeforeAndEndTimeAfter) (Hora de inicio antes y hora de término después).
O que la hora de término puede ser posteriormente, pero la hora de inicio puede estar entre la hora de inicio o la hora de término de la petición (endTimeAfterOrStartTimeBetween) (Hora de término después u hora de inicio entre medio).

Así que nuestra consulta final debiera retornar todas las reservas que coincidan con cualquiera de esas 2 posibilidades.

Podemos expresarlo así:

List findReservationsByReservationDateAndStartTimeBeforeAndEndTimeAfterOrStartTimeBetween
            (LocalDate reservationDate, LocalTime startTime, LocalTime endTime, LocalTime betweenStart, LocalTime betweenEnd);

Y el método create final se ve así:

 public Long create(final Reservation reservation) {
        int capacity = capacityRepository.findByAmenityType(reservation.getAmenityType()).getCapacity();
        int overlappingReservations = reservationRepository
                .findReservationsByReservationDateAndStartTimeBeforeAndEndTimeAfterOrStartTimeBetween(
                        reservation.getReservationDate(),
                        reservation.getStartTime(), reservation.getEndTime(),
                        reservation.getStartTime(), reservation.getEndTime()).size();

        if (overlappingReservations >= capacity) {
            throw new CapacityFullException("This amenity's capacity is full at desired time");
        }

        return reservationRepository.save(reservation).getId();
    }

No necesitas preocuparte sobre la excepción customizada, pero si estás interesado, aquí está el código:

package com.amenity_reservation_system.exception;

public class CapacityFullException extends RuntimeException {
    public CapacityFullException(String message) {
        super(message);
    }
}

Normalmente deberíamos mostrar un error modal si la capacidad es excedida pero lo saltaré para evitar cosas de UI repetitivas. Puedes intentarlo como un reto si deseas.

Conclusión

En este tutorial, hemos aprendido sobre tantas tecnologías que hacen el desarrollo de Spring Boot más fácil y más rápido.

Creo que muchas personas subestiman el framework en términos de velocidad de desarrollo y la calidad del trabajo resultante.

Asumiendo que eres fluido con la tecnología, argumentaría que Spring Boot no es más lento (en desarrollo) que cualquier otro framework backend si haces todo en la moda moderna.

Puedes encontrar todo el código en este repositorio (en inglés):

https://github.com/yigiterinc/amenity-reservation-system.git

Si estás interesado en leer más contenido como este, siéntete libre de suscribirte a mi blog en https://erinc.io (blog en inglés) para ser notificado de mis nuevas publicaciones.

Cómo cambiar el brillo de la pantalla en Windows 10: Ajustes de brillo y cómo reducirlo

Josué Leiva — Fri, 03 Mar 2023 02:10:51 +0000

Artículo original: How to Change Screen Brightness on Windows 10 – Brightness Settings and How to Turn Brightness Down

Si tu pantalla es muy brillante, te puede dar problemas oculares - especialmente si te sientas en frente de un computador programando todo el día.

Esto es porque una pantalla muy brillante puede forzar el ojo y fatigarlo, lo que puede derivar en dolores de cabeza y otros padecimientos.

Si eres un usuario regular de la computadora, la salud ocular es crítica para un desempeño óptimo. Así que en este artículo, te mostraré 5 formas diferentes de cambiar el brillo de tu pantalla en Windows 10.

Cómo cambiar el ajuste del brillo en el centro de acciones de Windows 10

La forma más rápida de bajar el brillo o ajustar el brillo de tu pantalla es en Centro de Acción.

Para cambiar el brillo, haz clic en el ícono de notificación al extremo derecho de la barra de tareas. Tendrás acceso a un deslizador con el cual puedes incrementar o decrementar el brillo.

Si no ves el deslizador aparecer inmediatamente, haz clic en "expandir" para revelarlo.

Cómo cambiar los ajustes del brillo en el centro de movilidad de Windows

Otra forma rápida de cambiar el brillo de tu pantalla es hacerlo en el Centro de Movilidad de Windows.

Hay varias formas de llegar hasta ahí. Una es hacer clic derecho en tu medidor de batería y seguidamente seleccionar "Centro de Movilidad de Windows". Otra es al hacer clic derecho en el menú de Inicio (logo de Windows) y de ahí seleccionar "Centro de Movilidad"

La primera pestaña que verás es un deslizador para ajustar el brillo a cualquier nivel que desees.

Cómo cambiar el brillo en los ajustes de Windows 10

También puedes ajustar el brillo en el menú de ajustes.

Paso 1: Hacer clic en el menú de Inicio (Logo de Windows).

Paso 2: Hacer clic en Configuración.

Paso 3: Abrir Sistema y luego haz clic en Pantalla.

Paso 4: Justo bajo Brillo y Color, utiliza el deslizador para ajustar el Brillo de la pantalla a uno que te acomode. Deslizar hacia la izquierda disminuye el brillo, y hacia la derecha lo aumenta.

Si te gusta utilizar un atajo teclado, presiona y mantiene las teclas Windows e I (Windows + I) para abrir la configuración, luego haz clic en Pantalla para obtener tener acceso al deslizador para aumentar y disminuir el nivel de brillo.

Cómo cambiar el ajuste de brillo automáticamente según la vida útil de tu batería

Esta es una buena idea tanto para tus ojos como para tu computadora. Windows 10 tiene una opción que te permite disminuir el brillo de la pantalla cuando la vida útil de tu batería se encuentra en o bajo cierto porcentaje.

Para hacerlo, sigue los pasos abajo:

Paso 1: Haz clic en Inicio, Configuración y luego en Sistema. O simplemente presiona y mantiene Win + I.

Paso 2: Haz clic en "Sistema" y luego en "Batería".

Paso 3: Bajo "Ahorro de Batería", habilita "Activar automáticamente el ahorro de batería a las"

Paso 4: Usa el selector para seleccionar el porcentaje al cual deseas que ahorrar batería se encienda.

Paso 5: Habilita "Reducir el brillo de la pantalla con el ahorro de batería activado"

(El ahorro de batería debe estar activado)

Cómo cambiar el brillo de la pantalla con un atajo del teclado

La mayoría de los teclados tienen atajos para disminuir o aumentar el brillo de la pantalla, especialmente si estás utilizando una laptop (o portátil),

Las dos teclas usualmente tienen un ícono de sol con una flecha apuntando hacia abajo para disminuir el brillo, y otra flecha apuntando hacia arriba para aumentar el brillo. Algunos no tienen flechas, sino que solo en ícono de sol.

Las combinaciones más comunes de atajos del teclado son la "tecla de función" (fn) + la tecla designada para aumentar o disminuir el brillo.

Aparte de los 5 métodos que comparto arriba, puedes automáticamente ajustar el brillo según la luz ambiental, pero no todas las computadoras Windows 10 pueden hacer esto.

Para tener acceso a esta opción, abre Configuración, haz clic en Sistema, y después en Pantalla. Si eres capaz de ver "Ajustar el brillo automáticamente según luz ambiental", entonces tu computador tiene el sensor que detecta la luz ambiental. Si no lo ves, entonces tu computador no tiene acceso a esta cualidad.

En conclusión

Espero que este artículo te ayude a familiarizarte con las varias maneras en las que puedes disminuir el brillo de tu computador con Windows 10. Esto te ayudará a proteger tus ojos y a desempeñarte mejor en tu trabajo.

Gracias por leer y que tengas un buen rato.

Cómo generar un Reporte de Excel en una API REST de Spring Boot con Apache POI y Kotlin

Josué Leiva — Tue, 21 Feb 2023 14:31:57 +0000

Artículo original: How to Generate an Excel Report in a Spring Boot REST API with Apache POI and Kotlin

En este artículo, me gustaría mostrarte cómo generar reportes Excel en los formatos .xls y .xlsx (también conocidos como Open XML) en una API REST de Spring Boot con Apache POI y Kotlin.

Después del término de esta guía, tendrás un entendimiento fundamental sobre cómo crear de forma personalizada, formatos de celdas, estilos y fuentes. Al final, te mostraré cómo crear endpoints para que así puedas descargar los archivos generados fácilmente.

Para visualizar mejor lo que aprenderemos, revisa la vista previa del resultado final.

Paso 1: Añadir las dependencias necesarias.

Como primer paso, vamos a crear un proyecto Spring Boot (Recomiendo altamente, utilizar la página Spring Initializr) e importar las siguientes dependencias.

implementation("org.springframework.boot:spring-boot-starter-web")
implementation("org.apache.poi:poi:4.1.2")
implementation("org.apache.poi:poi-ooxml:4.1.2")

Déjame explicar el propósito de cada librería.

El Spring Boot Starter Web es necesario para crear la API REST en nuestra aplicación.
Apache POI es una librería compleja de Java para trabajar con archivos Excel. Si quisiéramos trabajar solo con el formato .xls, entonces la dependencia poi sería suficiente. En nuestro caso, queremos añadir soporte para el formato .xlsx, por lo que el componente poi-ooxml, también es necesario.

Paso 2: Crear los modelos

Como siguiente paso, vamos a crear una clase tipo enum llamada CustomCellStyle con 4 constantes:

enum class CustomCellStyle {
    GREY_CENTERED_BOLD_ARIAL_WITH_BORDER,
    RIGHT_ALIGNED,
    RED_BOLD_ARIAL_WITH_BORDER,
    RIGHT_ALIGNED_DATE_FORMAT
}

Si bien el propósito de esta clase enum pueda verse un tanto enigmática al momento, se volverá clara en las siguientes secciones.

Paso 3: Preparar los estilos de celdas

La librería Apache POI viene con la interfaz CellStyle, la cual podemos utilizar para definir estilos y formatos personalizados entre filas, columnas y celdas.

Vamos a crear un componente StylesGenerator, el cual será responsable de preparar un mapa que contenga nuestros estilos personalizados.

@Component
class StylesGenerator {

    fun prepareStyles(wb: Workbook): Map {
        val boldArial = createBoldArialFont(wb)
        val redBoldArial = createRedBoldArialFont(wb)

        val rightAlignedStyle = createRightAlignedStyle(wb)
        val greyCenteredBoldArialWithBorderStyle =
            createGreyCenteredBoldArialWithBorderStyle(wb, boldArial)
        val redBoldArialWithBorderStyle =
            createRedBoldArialWithBorderStyle(wb, redBoldArial)
        val rightAlignedDateFormatStyle =
            createRightAlignedDateFormatStyle(wb)

        return mapOf(
            CustomCellStyle.RIGHT_ALIGNED to rightAlignedStyle,
            CustomCellStyle.GREY_CENTERED_BOLD_ARIAL_WITH_BORDER to greyCenteredBoldArialWithBorderStyle,
            CustomCellStyle.RED_BOLD_ARIAL_WITH_BORDER to redBoldArialWithBorderStyle,
            CustomCellStyle.RIGHT_ALIGNED_DATE_FORMAT to rightAlignedDateFormatStyle
        )
    }
}

Como puedes ver, con este acercamiento, creamos cada estilo una vez y lo ponemos dentro de un mapa para que así lo podamos referenciar después.

Hay bastantes técnicas de diseño que podríamos utilizar aquí, pero creo que utilizando un mapa y constantes enum es una de las mejores maneras para mantener el código más limpio y más fácil de modificar.

Dicho esto, añadamos algunas funciones faltantes dentro de la clase generadora. Comencemos primero con las fuentes personalizadas:

private fun createBoldArialFont(wb: Workbook): Font {
    val font = wb.createFont()
    font.fontName = "Arial"
    font.bold = true
    return font
}

La función createBoldArialFont crea una nueva instancia en negrita de la fuente Arial, la cual la usaremos más tarde.

Similarmente, vamos a implementar una función createRedBoldArialFont y establecer el color de la fuente a rojo:

private fun createRedBoldArialFont(wb: Workbook): Font {
    val font = wb.createFont()
    font.fontName = "Arial"
    font.bold = true
    font.color = IndexedColors.RED.index
    return font
}

Después de eso, podemos añadir otras funciones responsables de crear instancias CellStyle individuales.

private fun createRightAlignedStyle(wb: Workbook): CellStyle {
    val style: CellStyle = wb.createCellStyle()
    style.alignment = HorizontalAlignment.RIGHT
    return style
}

private fun createBorderedStyle(wb: Workbook): CellStyle {
    val thin = BorderStyle.THIN
    val black = IndexedColors.BLACK.getIndex()
    val style = wb.createCellStyle()
    style.borderRight = thin
    style.rightBorderColor = black
    style.borderBottom = thin
    style.bottomBorderColor = black
    style.borderLeft = thin
    style.leftBorderColor = black
    style.borderTop = thin
    style.topBorderColor = black
    return style
}

private fun createGreyCenteredBoldArialWithBorderStyle(wb: Workbook, boldArial: Font): CellStyle {
    val style = createBorderedStyle(wb)
    style.alignment = HorizontalAlignment.CENTER
    style.setFont(boldArial)
    style.fillForegroundColor = IndexedColors.GREY_25_PERCENT.getIndex();
    style.fillPattern = FillPatternType.SOLID_FOREGROUND;
    return style
}

private fun createRedBoldArialWithBorderStyle(wb: Workbook, redBoldArial: Font): CellStyle {
    val style = createBorderedStyle(wb)
    style.setFont(redBoldArial)
    return style
}

private fun createRightAlignedDateFormatStyle(wb: Workbook): CellStyle {
    val style = wb.createCellStyle()
    style.alignment = HorizontalAlignment.RIGHT
    style.dataFormat = 14
    return style
}

Por favor hay que tener en mente que los ejemplos de arriba son solo una parte pequeña de las posibilidades de CellStyle (estilo de celda). Si te gustaría ver una lista completa, por favor refiérate a la documentación aquí (artículo en inglés).

Paso 4: Crear la clase ReportService

Como siguiente paso vamos a implementar la clase ReportService responsable de crear los archivos .xlsx y .xls y retornarlos como instancias ByteArray:

@Service
class ReportService(
    private val stylesGenerator: StylesGenerator
) {
    fun generateXlsxReport(): ByteArray {
        val wb = XSSFWorkbook()

        return generateReport(wb)
    }

    fun generateXlsReport(): ByteArray {
        val wb = HSSFWorkbook()

        return generateReport(wb)
    }
 }

Como puedes ver, la única diferencia entre la generación de estos dos formatos es el tipo de implementación del Workbook (libro de trabajo) que hemos utilizado. Para el formato .xlsx vamos a utilizar la clase XSSFWorkbook, y para el .xls utilizaremos HSSFWorkbook.

Vamos a añadir el resto del código a ReportService:

private fun generateReport(wb: Workbook): ByteArray {
    val styles = stylesGenerator.prepareStyles(wb)
    val sheet: Sheet = wb.createSheet("Example sheet name")

    setColumnsWidth(sheet)

    createHeaderRow(sheet, styles)
    createStringsRow(sheet, styles)
    createDoublesRow(sheet, styles)
    createDatesRow(sheet, styles)

    val out = ByteArrayOutputStream()
    wb.write(out)

    out.close()
    wb.close()

    return out.toByteArray()
}

private fun setColumnsWidth(sheet: Sheet) {
    sheet.setColumnWidth(0, 256 * 20)

    for (columnIndex in 1 until 5) {
        sheet.setColumnWidth(columnIndex, 256 * 15)
    }
}

private fun createHeaderRow(sheet: Sheet, styles: Map) {
    val row = sheet.createRow(0)

    for (columnNumber in 1 until 5) {
        val cell = row.createCell(columnNumber)

        cell.setCellValue("Column $columnNumber")
        cell.cellStyle = styles[CustomCellStyle.GREY_CENTERED_BOLD_ARIAL_WITH_BORDER]
    }
}

private fun createRowLabelCell(row: Row, styles: Map, label: String) {
    val rowLabel = row.createCell(0)
    rowLabel.setCellValue(label)
    rowLabel.cellStyle = styles[CustomCellStyle.RED_BOLD_ARIAL_WITH_BORDER]
}

private fun createStringsRow(sheet: Sheet, styles: Map) {
    val row = sheet.createRow(1)
    createRowLabelCell(row, styles, "Strings row")

    for (columnNumber in 1 until 5) {
        val cell = row.createCell(columnNumber)

        cell.setCellValue("String $columnNumber")
        cell.cellStyle = styles[CustomCellStyle.RIGHT_ALIGNED]
    }
}

private fun createDoublesRow(sheet: Sheet, styles: Map) {
    val row = sheet.createRow(2)
    createRowLabelCell(row, styles, "Doubles row")

    for (columnNumber in 1 until 5) {
        val cell = row.createCell(columnNumber)

        cell.setCellValue(BigDecimal("${columnNumber}.99").toDouble())
        cell.cellStyle = styles[CustomCellStyle.RIGHT_ALIGNED]
    }
}

private fun createDatesRow(sheet: Sheet, styles: Map) {
    val row = sheet.createRow(3)
    createRowLabelCell(row, styles, "Dates row")

    for (columnNumber in 1 until 5) {
        val cell = row.createCell(columnNumber)

        cell.setCellValue((LocalDate.now()))
        cell.cellStyle = styles[CustomCellStyle.RIGHT_ALIGNED_DATE_FORMAT]
    }
}

Como puedes ver, la primera cosa que la función generateReport hace, es que estiliza la inicialización. Pasamos la instancia Workbook al StylesGenerator (generador de estilos) y en retorno, obtenemos un mapa, el cual utilizaremos más tarde para obtener CellStyles (estilos de celda) apropiados.

Después de esto, crea una nueva hoja dentro de nuestro libro de trabajo y le entrega un nombre para este (el libro).

Después, invoca las funciones responsables de configurar el ancho de las columnas y operar nuestra hoja fila por fila.

Finalmente, escribe nuestro libro de trabajo a un ByteArrayOutputStream.

Tomemos un minuto y analicemos que hace exactamente cada función:

private fun setColumnsWidth(sheet: Sheet) {
    sheet.setColumnWidth(0, 256 * 20)

    for (columnIndex in 1 until 5) {
        sheet.setColumnWidth(columnIndex, 256 * 15)
    }
}

Como el nombre sugiere, setColumnsWidth (establecerAnchoColumnas) es responsable de configurar los anchos de las columnas en nuestra hoja. El primer parámetro pasado a setColumnsWidth indica el columnIndex (indiceColumna), y el segundo establece el ancho (en unidades de 1/256 de ancho de carácter).

private fun createRowLabelCell(row: Row, styles: Map, label: String) {
    val rowLabel = row.createCell(0)
    rowLabel.setCellValue(label)
    rowLabel.cellStyle = styles[CustomCellStyle.RED_BOLD_ARIAL_WITH_BORDER]
}

La función createRowLabelCell (crearEtiquetaFilaCelda) es responsable de añadir una celda en la primera columna de la fila entregada, paralelamente configura su valor a la etiqueta especificada y configura su estilo. He decidido añadir esta función para reducir un poco la redundacia del código.

Todas las funciones de abajo son bastante similares. Su propósito es crear una nueva fila, invocar la función createRowLabelCell (a excepción de createHeaderRow) y añadir cinco columnas con información a nuestra hoja.

private fun createHeaderRow(sheet: Sheet, styles: Map) {
    val row = sheet.createRow(0)

    for (columnNumber in 1 until 5) {
        val cell = row.createCell(columnNumber)

        cell.setCellValue("Column $columnNumber")
        cell.cellStyle = styles[CustomCellStyle.GREY_CENTERED_BOLD_ARIAL_WITH_BORDER]
    }
}

private fun createStringsRow(sheet: Sheet, styles: Map) {
    val row = sheet.createRow(1)
    createRowLabelCell(row, styles, "Strings row")

    for (columnNumber in 1 until 5) {
        val cell = row.createCell(columnNumber)

        cell.setCellValue("String $columnNumber")
        cell.cellStyle = styles[CustomCellStyle.RIGHT_ALIGNED]
    }
}

private fun createDoublesRow(sheet: Sheet, styles: Map) {
    val row = sheet.createRow(2)
    createRowLabelCell(row, styles, "Doubles row")

    for (columnNumber in 1 until 5) {
        val cell = row.createCell(columnNumber)

        cell.setCellValue(BigDecimal("${columnNumber}.99").toDouble())
        cell.cellStyle = styles[CustomCellStyle.RIGHT_ALIGNED]
    }
}

private fun createDatesRow(sheet: Sheet, styles: Map) {
    val row = sheet.createRow(3)
    createRowLabelCell(row, styles, "Dates row")

    for (columnNumber in 1 until 5) {
        val cell = row.createCell(columnNumber)

        cell.setCellValue((LocalDate.now()))
        cell.cellStyle = styles[CustomCellStyle.RIGHT_ALIGNED_DATE_FORMAT]
    }
}

Paso 5: Implementar el ReportController REST

Como último paso, vamos a implementar una clase llamada ReportController. Será responsable de manejar las peticiones POST entrantes a nuestros dos endpoints REST:

/api/report/xlsx - crear un reporte en formato .xlsx
/api/report/xls - lo mismo de arriba, pero en formato .xls

@RestController
@RequestMapping("/api/report")
class ReportController(
    private val reportService: ReportService
) {

    @PostMapping("/xlsx")
    fun generateXlsxReport(): ResponseEntity {
        val report = reportService.generateXlsxReport()

        return createResponseEntity(report, "report.xlsx")
    }

    @PostMapping("/xls")
    fun generateXlsReport(): ResponseEntity {
        val report = reportService.generateXlsReport()

        return createResponseEntity(report, "report.xls")
    }

    private fun createResponseEntity(
        report: ByteArray,
        fileName: String
    ): ResponseEntity =
        ResponseEntity.ok()
            .contentType(MediaType.APPLICATION_OCTET_STREAM)
            .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"$fileName\"")
            .body(report)

}

La parte más interesante del código de arriba es la función createResponseEntity (crearEntidadRespuesta), la cual establece el ByteArray (Arreglo de Bytes) entregado con su reporte generado como un cuerpo de respuesta.

Adicionalmente, establecemos el encabezado Content-Type de la respuesta como application/octet-stream, y la disposición de contenido (Content-Disposition) como el archivo adjunto attachment; filename =

Paso 6: Testear tódo con Postman

Finalmente, podemos correr y probar nuetra aplicación Spring Boot, por ejemplo con el commando gradlew:

./gradlew bootRun

Por defecto, la aplicación Spring Boot estará corriendo en el puerto 8080, así que vamos a abrir Postman (o cualquier otra herramienta), especificar la petición POST a localhost:8080/api/report/xls y presionar el botón Send and Download (enviar y descargar):

Si tódo estuvo bien , tendríamos que ver una ventana que nos permita guardar el archivo .xls.

Similarmente, vamos a probar el segundo endpoint:

Esta vez, la extensión del archivo tendría que ser .xlsx.

Resumen

¡Eso es todo por este artículo! Hemos cubierto el proceso de generar reportes Excel en una API REST de Spring Boot con Apache POI y Kotlin.

Si lo disfrutaste y te gustaría aprender otros temas a través de artículo similares, porfavor visita my blog Codersee (blog en inglés).

Y la última cosa: para el código fuente, o un proyecto completamente funcional, porfavor consulte este repositorio GitHub (en inglés).

Josué Leiva - freeCodeCamp.org

%.2f en Python – ¿Que significa?

Cómo usar el formateador %f en Python

Cómo usar el formateador %d en Python

Resumen

Cómo crear APIs seguras con Flask y Auth0

¿Por qué no construir tu propia autenticación y autorización?

Cómo Configurar una Cuenta Gratuita de Administración de Identidades en Auth0

Crear una nueva API Auth0

Cómo impulsar nuestra aplicación

Instalar las dependencias

Construir los endpoints

Cómo asegurar los endpoints

Variables de Configuración Auth0

Métodos de error

Cómo capturar el token JWT

Cómo validar el token

Cómo requerir una petición autenticada para un endpoint

Cómo probarlo

Control de acceso basado en roles

Conclusión

Tutorial de Spring Boot: Cómo crear Apps Java modernas y rápidas

Requisitos previos

¿Qué estamos construyendo?

Lista de características para la App

Tecnologías que usaremos

¿Por qué Spring Boot?

Cómo crear el proyecto con Bootify

Cómo probar y explorar el código generado

¡Probemos la API!

Cómo Ajustar el Código para Nuestro Caso Particular

Como crear los Archivos de Controladores y Vistas para Mostrar Información

Cómo Definir Distintos Tipos de Servicios

Como Mostrar las Reservaciones de un Usuario

Como Crear Vistas con Thymeleaf

Reservation management made easy.

Welcome

Cómo Crear una Reservación

Welcome

Welcome

Cómo Añadir Autenticación y Autorización a la App

Cómo Mostrar las Reservaciones de los Usuarios Conectados

Cómo Evaluar la Capacidad

Conclusión

Cómo cambiar el brillo de la pantalla en Windows 10: Ajustes de brillo y cómo reducirlo

Cómo cambiar el ajuste del brillo en el centro de acciones de Windows 10

Cómo cambiar los ajustes del brillo en el centro de movilidad de Windows

Cómo cambiar el brillo en los ajustes de Windows 10

Cómo cambiar el ajuste de brillo automáticamente según la vida útil de tu batería

Cómo cambiar el brillo de la pantalla con un atajo del teclado

En conclusión

Cómo generar un Reporte de Excel en una API REST de Spring Boot con Apache POI y Kotlin

Paso 1: Añadir las dependencias necesarias.

Paso 2: Crear los modelos

Paso 3: Preparar los estilos de celdas

Paso 4: Crear la clase ReportService

Paso 5: Implementar el ReportController REST

Paso 6: Testear tódo con Postman

Resumen

Cómo usar el formateador `%f` en Python

Cómo usar el formateador `%d` en Python