use chrono::{DateTime, Utc};
use uuid::Uuid;{% for import in imports %}
use {{ import }};{% endfor %}
use crate::errores::Error{{ pascal }};
/// El id de cada `{{ pascal }}`: un `Uuid` que no se puede pasar donde se espera el id de otra
/// entidad.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct Id{{ pascal }}(Uuid);
impl Id{{ pascal }} {
/// Un id nuevo y aleatorio — para una entidad 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: cualquier `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 Id{{ pascal }} {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
self.0.fmt(f)
}
}
#[derive(Debug, Clone)]
pub struct Props{{ pascal }} {
{% for f in fields %} pub {{ f.name }}: {{ f.rust_type }},
{% endfor %}}
#[derive(Debug, Clone)]
pub struct {{ pascal }} {
pub id: Id{{ pascal }},
pub creado_en: DateTime<Utc>,
pub actualizado_en: DateTime<Utc>,
pub borrado: bool,
pub borrado_en: Option<DateTime<Utc>>,
{% for f in fields %} pub {{ f.name }}: {{ f.rust_type }},
{% endfor %}}
impl {{ pascal }} {
pub fn new(props: Props{{ pascal }}) -> Result<Self, Error{{ pascal }}> {
Self::validar(&props)?;
let ahora = chrono::Utc::now();
Ok(Self {
id: Id{{ pascal }}::generar(),
creado_en: ahora,
actualizado_en: ahora,
borrado: false,
borrado_en: None,
{% for f in fields %} {{ f.name }}: props.{{ f.name }},
{% endfor %} })
}
/// Cambia los campos propios, con las mismas reglas que `new`.
pub fn actualizar(&mut self, props: Props{{ pascal }}) -> Result<(), Error{{ pascal }}> {
Self::validar(&props)?;
{% for f in fields %} self.{{ f.name }} = props.{{ f.name }};
{% endfor %} self.actualizado_en = chrono::Utc::now();
Ok(())
}
pub fn from_repositorio(datos: {{ pascal }}) -> Self {
datos
}
/// Las reglas de los campos propios: las comprueban `new` y `actualizar`, así que una regla nueva
/// se escribe solo aquí.
fn validar({% if fields | filter(attribute="required_string", value=true) %}props{% else %}_props{% endif %}: &Props{{ pascal }}) -> Result<(), Error{{ pascal }}> {
{% for f in fields | filter(attribute="required_string", value=true) %} if props.{{ f.name }}.trim().is_empty() {
return Err(Error{{ pascal }}::Validacion("{{ f.name }}_vacio".into()));
}
{% endfor %} Ok(())
}
}
{% set required = fields | filter(attribute="required_string", value=true) %}{% set string_vos = fields | filter(attribute="string_vo", value=true) %}{% set enum_vos = fields | filter(attribute="is_enum_vo", value=true) %}
#[cfg(test)]
mod tests {
use super::*;
use crate::pruebas::madres::Madre{{ pascal }};
#[test]
fn deberia_crear_{{ snake }}_cuando_{% if fields | length == 1 and required | length == 1 and fields.0.name == "nombre" %}el_nombre_es_valido{% else %}los_campos_son_validos{% endif %}() {
let resultado = {{ pascal }}::new(Madre{{ pascal }}::new().construir_props());{% if required | length > 0 %}
assert_eq!(
resultado.unwrap().{{ required.0.name }},
Madre{{ pascal }}::new().construir_props().{{ required.0.name }}
);{% else %}
assert!(resultado.is_ok());{% endif %}
}{% if required or string_vos or enum_vos %}
{% endif %}{% for sf in required %}
#[test]
fn deberia_rechazar_{{ snake }}_cuando_{{ sf.name }}_es_una_cadena_vacia() {
let resultado = {{ pascal }}::new(Madre{{ pascal }}::new().con_{{ sf.name }}_vacio().construir_props());
assert!(resultado.is_err());
assert_eq!(
resultado.unwrap_err().to_string(),
"{{ snake }}.validacion.{{ sf.name }}_vacio"
);
}
#[test]
fn deberia_rechazar_{{ snake }}_cuando_{{ sf.name }}_solo_tiene_espacios() {
let resultado = {{ pascal }}::new(Madre{{ pascal }}::new().con_{{ sf.name }}(" ").construir_props());
assert!(resultado.is_err());
}{% endfor %}{% if required %}
#[test]
fn deberia_rechazar_actualizar_{{ snake }}_cuando_{{ required.0.name }}_es_una_cadena_vacia() {
let mut entidad = Madre{{ pascal }}::aleatorio();
let resultado = entidad.actualizar(Madre{{ pascal }}::new().con_{{ required.0.name }}_vacio().construir_props());
assert_eq!(
resultado.unwrap_err().to_string(),
"{{ snake }}.validacion.{{ required.0.name }}_vacio"
);
}{% endif %}{% for f in string_vos %}
#[test]
fn deberia_rechazar_{{ snake }}_cuando_{{ f.vo_snake }}_es_una_cadena_vacia() {
let resultado = {{ f.vo }}::new("".to_string());
assert!(resultado.is_err());
assert_eq!(
resultado.unwrap_err().to_string(),
"{% if f.is_shared_vo %}nucleo.{{ f.vo_snake }}_invalido{% else %}{{ snake }}.{{ f.vo_snake }}_invalido{% endif %}"
);
}{% endfor %}{% for f in enum_vos %}
#[test]
fn deberia_rechazar_{{ snake }}_cuando_{{ f.vo_snake }}_no_es_una_variante_conocida() {
let resultado = "VarianteInvalida".parse::<{{ f.vo }}>();
assert!(resultado.is_err());
assert_eq!(
resultado.unwrap_err().to_string(),
"{% if f.is_shared_vo %}nucleo.{{ f.vo_snake }}_invalido{% else %}{{ snake }}.{{ f.vo_snake }}_invalido{% endif %}"
);
}{% endfor %}
}