//! Lo escribe una vez `puerto nuevo --auth`; desde entonces es tuyo. Todo el que llama con sesión
//! iniciada es una fila `Usuario` (ADR-0021 § 3 de Puerto): lo que referencian otras entidades
//! (`owner: IdUsuario`), sea cual sea el proveedor con el que inició sesión.
use chrono::{DateTime, Utc};
use uuid::Uuid;
{%- if local %}
use crate::errores::ErrorUsuario;
/// El emisor de las cuentas que guarda la propia API (`POST /auth/registro`).
pub const EMISOR_LOCAL: &str = "local";
{%- endif %}
/// El id de cada `Usuario`: un `Uuid` que no se puede pasar donde se espera el id de otra entidad.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct IdUsuario(Uuid);
impl IdUsuario {
/// Un id nuevo y aleatorio, para un usuario que se está creando.
pub fn generar() -> Self {
Self(Uuid::new_v4())
}
/// Un id leído de fuera (un parámetro de ruta, una fila), sin validar: todo `Uuid` es un id.
pub fn from_uuid(valor: Uuid) -> Self {
Self(valor)
}
pub fn valor(&self) -> Uuid {
self.0
}
}
impl std::fmt::Display for IdUsuario {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
self.0.fmt(f)
}
}
/// Quien inició sesión, tal como lo conoce este proyecto. `(emisor, sujeto)` es el nombre que da
/// el proveedor a la persona y es único; `email` y `name` son lo que dijo el proveedor la primera
/// vez.
#[derive(Debug, Clone, PartialEq)]
pub struct Usuario {
pub id: IdUsuario,
pub emisor: String,
pub sujeto: String,
pub email: Option<String>,
pub nombre: Option<String>,
/// No se lee en un proyecto OIDC: allí los roles vienen solo del token, para que decida un
/// único sitio.
pub roles: Vec<String>,
pub creado_en: DateTime<Utc>,
pub actualizado_en: DateTime<Utc>,
}
impl Usuario {
/// El usuario que crea la primera petición de `(emisor, sujeto)` (alta just-in-time).
pub fn aprovisionar(
emisor: impl Into<String>,
sujeto: impl Into<String>,
email: Option<String>,
nombre: Option<String>,
) -> Self {
let ahora = Utc::now();
Self {
id: IdUsuario::generar(),
emisor: emisor.into(),
sujeto: sujeto.into(),
email,
nombre,
roles: vec![],
creado_en: ahora,
actualizado_en: ahora,
}
}
{% if local %} /// Una cuenta local nueva (`registrar_usuario`). Su sujeto es el email tal como lo escribe
/// [`Usuario::sujeto_local`], así que `UNIQUE (emisor, sujeto)` hace único el email.
pub fn registrar(email: &str, nombre: Option<String>) -> Result<Self, ErrorUsuario> {
let email = Self::sujeto_local(email);
if !es_email(&email) {
return Err(ErrorUsuario::Validacion("email_invalido".into()));
}
let nombre = nombre
.map(|n| n.trim().to_string())
.filter(|n| !n.is_empty());
Ok(Self::aprovisionar(EMISOR_LOCAL, email.clone(), Some(email), nombre))
}
/// Cómo se compara el email de una cuenta local: sin espacios alrededor y en minúsculas.
pub fn sujeto_local(email: &str) -> String {
email.trim().to_lowercase()
}
{% endif %} /// Reconstruye desde la persistencia, sin validar. SOLO lo usa la infraestructura.
pub fn from_repositorio(datos: Usuario) -> Self {
datos
}
}
{% if local %}/// Una `@` entre un nombre no vacío y un dominio con punto, sin espacios. Si la dirección existe lo
/// averiguará un correo de confirmación, no esta comprobación.
fn es_email(email: &str) -> bool {
let Some((nombre, domain)) = email.split_once('@') else {
return false;
};
!nombre.is_empty()
&& !domain.contains('@')
&& domain.contains('.')
&& !domain.starts_with('.')
&& !domain.ends_with('.')
&& !email.chars().any(char::is_whitespace)
}
{% endif %}#[cfg(test)]
mod tests {
use super::*;
#[test]
fn deberia_guardar_lo_que_dijo_el_proveedor_cuando_se_da_de_alta() {
// Actuar
let usuario = Usuario::aprovisionar(
"http://localhost:8180/realms/shop",
"f81d4fae",
Some("ada@example.com".into()),
Some("Ada Lovelace".into()),
);
// Comprobar
assert_eq!(usuario.emisor, "http://localhost:8180/realms/shop");
assert_eq!(usuario.sujeto, "f81d4fae");
assert_eq!(usuario.email.as_deref(), Some("ada@example.com"));
assert_eq!(usuario.nombre.as_deref(), Some("Ada Lovelace"));
assert!(usuario.roles.is_empty());
assert_eq!(usuario.creado_en, usuario.actualizado_en);
}
#[test]
fn deberia_recibir_un_id_nuevo_cuando_se_dan_de_alta_dos_usuarios() {
// Actuar
let ada = Usuario::aprovisionar("issuer", "ada", None, None);
let bob = Usuario::aprovisionar("issuer", "bob", None, None);
// Comprobar
assert_ne!(ada.id, bob.id);
}
{%- if local %}
#[test]
fn deberia_registrar_una_cuenta_local_con_su_email_en_minusculas() {
// Actuar
let usuario = Usuario::registrar(" Ada@Example.COM ", Some(" Ada ".into())).expect("cuenta válida");
// Comprobar
assert_eq!(usuario.emisor, EMISOR_LOCAL);
assert_eq!(usuario.sujeto, "ada@example.com");
assert_eq!(usuario.email.as_deref(), Some("ada@example.com"));
assert_eq!(usuario.nombre.as_deref(), Some("Ada"));
assert!(usuario.roles.is_empty());
}
#[test]
fn no_deberia_guardar_nombre_cuando_esta_en_blanco() {
let usuario = Usuario::registrar("ada@example.com", Some(" ".into())).expect("cuenta válida");
assert_eq!(usuario.nombre, None);
}
#[test]
fn deberia_rechazar_una_cuenta_cuando_el_email_no_es_valido() {
for email in ["", "ada", "ada@", "@example.com", "ada@example", "a da@example.com", "a@b@c.com", "ada@.com"] {
let err = Usuario::registrar(email, None).expect_err(email);
assert_eq!(err.to_string(), "usuario.validacion.email_invalido", "{email}");
}
}
{%- endif %}
}