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 }}> {
{% 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 %} 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 %} })
}
pub fn from_repositorio(datos: {{ pascal }}) -> Self {
datos
}
}
{% 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::*;
#[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(Props{{ pascal }} {
{% for f in fields %} {{ f.name }}: {{ f.props_literal }},
{% endfor %} });{% if required | length > 0 %}
assert_eq!(resultado.unwrap().{{ required.0.name }}, "example");{% 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(Props{{ pascal }} {
{% for f in fields %} {{ f.name }}: {% if f.name == sf.name %}"".into(){% else %}{{ f.props_literal }}{% endif %},
{% endfor %} });
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(Props{{ pascal }} {
{% for f in fields %} {{ f.name }}: {% if f.name == sf.name %}" ".into(){% else %}{{ f.props_literal }}{% endif %},
{% endfor %} });
assert!(resultado.is_err());
}{% endfor %}{% 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 %}
}